code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 1
101M
|
|---|---|---|---|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
#define LLINF 9223372036854775807
#define MOD ll(1e9+7)
int main(){
ll n, k;
cin >> n >> k;
int max_bit = 31;
vector<ll> a(n);
vector<ll> b(n);
for(int i = 0; i < n; i++){
cin >> a[i] >> b[i];
}
vector<ll> candidates;
candidates.push_back(k);
for(int i = 1; i < max_bit; i++){
if(k&(1<<i)){
ll tmp = k;
tmp -= 1<<i;
tmp |= (1<<i)-1;
candidates.push_back(tmp);
}
}
ll ans = -1;
for(int i = 0; i < candidates.size(); i++){
ll tmpsum = 0;
for(int j = 0; j < n; j++){
bool isOK = true;
for(int bit = 0; bit < max_bit; bit++){
if(!(candidates[i]&(1<<bit)) && a[j]&(1<<bit)){
isOK = false;
break;
}
}
if(isOK){
tmpsum += b[j];
}
}
ans = max(ans,tmpsum);
}
cout << ans << endl;
}
|
#include <algorithm>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cmath>
#include <cstring>
#include <list>
#include <cassert>
#include <climits>
#include <bitset>
#include <chrono>
#include <random>
using namespace std;
#define PB push_back
#define MP make_pair
#define SZ(v) ((int)(v).size())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORE(i,a,b) for(int i=(a);i<=(b);++i)
#define REPE(i,n) FORE(i,0,n)
#define FORSZ(i,a,v) FOR(i,a,SZ(v))
#define REPSZ(i,v) REP(i,SZ(v))
std::mt19937 rnd((int)std::chrono::steady_clock::now().time_since_epoch().count());
typedef long long ll;
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 200000;
int n, nop;
int a[MAXN];
int ans[MAXN];
int cur[MAXN];
int nxt[MAXN + 1];
void solve() {
REP(i, n) cur[i] = a[i];
REP(op, nop) {
bool done = true; REP(i, n) if (cur[i] != n) done = false; if (done) break;
REPE(i, n) nxt[i] = 0;
REP(i, n) {
int d = cur[i], l = max(0, i - d), r = min(n - 1, i + d);
++nxt[l], --nxt[r + 1];
}
REP(i, n) nxt[i + 1] += nxt[i];
REP(i, n) cur[i] = nxt[i];
}
REP(i, n) ans[i] = cur[i];
}
void run() {
scanf("%d%d", &n, &nop);
REP(i, n) scanf("%d", &a[i]);
solve();
REP(i, n) { if (i != 0) printf(" "); printf("%d", ans[i]); } puts("");
}
int main() {
run();
return 0;
}
| 0
| 46,261,452
|
#include<iostream>
#include<stdio.h>
#include<queue>
#include<string.h>
using namespace std;
int mp[1002][1002],mp2[1002][1002];
int main()
{
char a;
int t, j, h, w, k, i;
pair<int, int> s, m[10];
queue<pair<int, int> > u;
queue<int> e;
cin >> h >> w >> k;
for (i = 0; i <= h; i++)
{
mp[i][0] = 1;
mp[i][w + 1] = 1;
mp2[i][0] = 1;
mp2[i][w + 1] = 1;
}
for (i = 0; i <= w; i++)
{
mp[0][i] = 1;
mp[h + 1][i] = 1;
mp2[0][i] = 1;
mp2[h + 1][i] = 1;
}
for (i = 1; i <= h; i++)
{
for (j = 1; j <= w; j++)
{
cin >> a;
if (a == 'X')
{
mp[i][j] = 1;
}
if (a == 'S')
{
mp[i][j] = 10;
s.first = i;
s.second = j;
}
if (a == '1')
{
mp[i][j] = 11;
m[1].first = i;
m[1].second = j;
}
if (a == '2')
{
mp[i][j] = 12;
m[2].first = i;
m[2].second = j;
}
if (a == '3')
{
mp[i][j] = 13;
m[3].first = i;
m[3].second = j;
}
if (a == '4')
{
mp[i][j] = 14;
m[4].first = i;
m[4].second = j;
}
if (a == '5')
{
mp[i][j] = 15;
m[5].first = i;
m[5].second = j;
}
if (a == '6')
{
mp[i][j] = 16;
m[6].first = i;
m[6].second = j;
}
if (a == '7')
{
mp[i][j] = 17;
m[7].first = i;
m[7].second = j;
}
if (a == '8')
{
mp[i][j] = 18;
m[8].first = i;
m[8].second = j;
}
if (a == '9')
{
mp[i][j] = 19;
m[9].first = i;
m[9].second = j;
}
}
}
t = 0;
e.push(0);
i = 1;
u.push(s);
while (i <= k)
{
t = e.front();
e.pop();
s = u.front();
u.pop();
if (s == m[i])
{
i++;
memset(mp2, 0, sizeof(mp2));
while (!u.empty())
{
u.pop();
}
while (!e.empty())
{
e.pop();
}
e.push(t);
u.push(s);
continue;
}
if (mp[s.first + 1][s.second] != 1 && mp2[s.first + 1][s.second] != 1)
{
mp2[s.first + 1][s.second] = 1;
s.first++;
u.push(s);
t++;
e.push(t);
t--;
s.first--;
}
if (mp[s.first][s.second + 1] != 1 && mp2[s.first][s.second + 1] != 1)
{
mp2[s.first][s.second + 1] = 1;
s.second++;
u.push(s);
t++;
e.push(t);
t--;
s.second--;
}
if (mp[s.first - 1][s.second] != 1 && mp2[s.first - 1][s.second] != 1)
{
mp2[s.first - 1][s.second] = 1;
s.first--;
u.push(s);
t++;
e.push(t);
t--;
s.first++;
}
if (mp[s.first][s.second - 1] != 1 && mp2[s.first][s.second - 1] != 1)
{
mp2[s.first][s.second - 1] = 1;
s.second--;
u.push(s);
t++;
e.push(t);
t--;
s.second++;
}
}
cout << t << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define REP(i,n) for (ll i = 0; i < (n); ++i)
#define RREP(i, n) for (ll i = (n) - 1; i >= 0; --i)
#define ALL(v) (v).begin(), (v).end()
int main(){
ll h, w;
cin >> h >> w;
vector<string> s(h);
REP(i, h){
cin >> s.at(i);
}
const bool start_is_black = s.at(0).at(0) == '#';
const bool end_is_black = s.at(h - 1).at(w - 1) == '#';
if(start_is_black){
REP(i, h){
REP(j, w){
if(s.at(i).at(j) == '#'){
s.at(i).at(j) = '.';
}else{
s.at(i).at(j) = '#';
}
}
}
}
vector<vector<ll>> dist(h, vector<ll>(w, numeric_limits<ll>::max()));
dist.at(0).at(0) = 0;
REP(i, h){
REP(j, w){
if(i > 0){
if(s.at(i - 1).at(j) == '.' && s.at(i).at(j) == '#'){
dist.at(i).at(j) = min(
dist.at(i).at(j), dist.at(i - 1).at(j) + 1);
}else{
dist.at(i).at(j) = min(
dist.at(i).at(j), dist.at(i - 1).at(j));
}
}
if(j > 0){
if(s.at(i).at(j - 1) == '.' && s.at(i).at(j) == '#'){
dist.at(i).at(j) = min(
dist.at(i).at(j), dist.at(i).at(j - 1) + 1);
}else{
dist.at(i).at(j) = min(
dist.at(i).at(j), dist.at(i).at(j - 1));
}
}
}
}
cout << dist.at(h - 1).at(w - 1) + (end_is_black && start_is_black) << endl;
return 0;
}
| 0
| 6,771,520
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <limits>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <functional>
using namespace std;
using ll = long long;
using ui = unsigned int;
const ll MOD = 1000000007;
const ll INF = 9223372036854775807;
int main() {
ll N;
scanf("%lld", &N);
char s[101010];
scanf("%s", s);
vector<vector<char>> dp(N + 1, vector<char>(4, 0));
dp[0][0] = 'S';
dp[0][1] = 'S';
dp[0][2] = 'W';
dp[0][3] = 'W';
dp[1][0] = 'S';
dp[1][1] = 'W';
dp[1][2] = 'S';
dp[1][3] = 'W';
for (ll i = 2; i < N + 1; i++) {
for (ll j = 0; j < 4; j++) {
ll count = 0;
if (dp[i - 2][j] == 'S') {
count++;
}
if (dp[i - 1][j] == 'S') {
count++;
}
if (s[i - 1] == 'o') {
count++;
}
dp[i][j] = (count % 2 == 0) ? 'W' : 'S';
}
}
for (ll j = 0; j < 4; j++) {
if (dp[N][j] == dp[0][j]) {
ll count = 0;
if (dp[N - 1][j] == 'S') {
count++;
}
if (dp[0][j] == 'S') {
count++;
}
if (dp[1][j] == 'S') {
count++;
}
if (s[0] == 'o') {
count++;
}
if (count % 2 == 0) {
for (ll i = 0; i < N; i++) {
printf("%c", dp[i][j]);
}
printf("\n");
return 0;
}
}
}
ll result = -1;
printf("%lld\n", result);
}
|
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <deque>
#include <queue>
#include <fstream>
#include <iomanip>
#include <stack>
#include <algorithm>
#include <set>
#include <map>
#include <list>
#define endl "\n"
typedef long long ll;
using namespace std;
void Lancer() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); }
bool isPrime(ll n){
if (n == 2 || n == 3 || n == 5)
return true;
else if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n == 1)
return false;
else {
for (int i = 5; i <= sqrt(n); i += 2){
if (n%i == 0)
return false;
}
return true;
}
}
char arr[107][107];
int main(){
Lancer();
ll r, c, t;
cin >> r >> c;
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++)
cin >> arr[i][j];
for (int i = 0; i < r; i++){
t = 0;
for (int j = 0; j < c; j++){
if (arr[i][j] == '.')
t++;
}
if (t == c){
for (int j = 0; j < c; j++){
arr[i][j] = 'w';
}
}
}
for (int i = 0; i < c; i++){
t = 0;
for (int j = 0; j < r; j++){
if (arr[j][i] == '.' || arr[j][i] == 'w')
t++;
}
if (t == r){
for (int j = 0; j < r; j++)
arr[j][i] = 'w';
}
}
for (int i = 0; i < r; i++){
bool ch = false;
for (int j = 0; j < c; j++){
if (arr[i][j] != 'w'){
cout << arr[i][j];
ch = true;
}
}
if(ch) cout << endl;
}
return 0;
}
| 0
| 27,425,683
|
#include <iostream>
#include <cstring>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <set>
#include <utility>
#include <cstdlib>
#include <queue>
#include <stack>
#include <iomanip>
#include <cstdio>
#include <map>
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
#define rep(i,x) for(ll i = 0; i < (ll)(x); i++)
#define rrep(i,x) for(ll i = ((ll)(x) - 1); i >= 0; i--)
#define _upgrade ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define all(x) (x).begin(), (x).end()
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );
template<class T1, class T2> void chmin(T1 &a, T2 b){if(a>b)a=b;}
template<class T1, class T2> void chmax(T1 &a, T2 b){if(a<b)a=b;}
int dx[4] = {1,0,-1,0};
int dy[4] = {0,1,0,-1};
const ll mod = 1e9 + 7;
const ll IMF = 1LL<<29;
const double PI = 3.14159265358979323846;
int a,b;
char mp[101][105];
int main(){
cin >> a >> b;
for(int i = 1; i <= 50; i++)
{
for(int j = 1; j <= 100; j++)
{
mp[i][j] = '.';
}
}
for(int i = 51; i <= 100; i++)
{
for(int j = 1; j <= 100; j++)
{
mp[i][j] = '#';
}
}
b--;
for(int i = 1; i <= 50 && b; i += 2)
{
for(int j = 1; j <= 100 && b; j += 2)
{
mp[i][j] = '#';
b--;
}
}
a--;
for(int i = 100; i > 50 && a; i -= 2)
{
for(int j = 1; j <= 100 && a; j += 2)
{
mp[i][j] = '.';
a--;
}
}
cout << "100 100" << endl;
for(int i = 1; i <= 100; i++){
for(int j = 1; j <= 100; j++){
cout << mp[i][j];
}
cout << endl;
}
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <vector>
#include <string>
#include <sstream>
#include <utility>
#include <deque>
#include <numeric>
#include <map>
#include <stack>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define INF 1000000000000
using namespace std;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef long long ll;
int G[101][101];
int main () {
int N, K;
cin >> N >> K;
if (K > (N-1)*(N-2)/2) {
cout << -1 << endl;
return 0;
}
vector<pii> ans;
rep(i,N-1) ans.push_back(pii(i+1, N));
vector<pii> edges;
rep(i,N-1)
rep(j,i)
edges.push_back(pii(j+1,i+1));
rep(i,(N-1)*(N-2)/2 - K) ans.push_back(edges[i]);
cout << ans.size() << endl;
rep (i,ans.size()) {
cout << ans[i].first << " " << ans[i].second << endl;
}
return 0;
}
| 0
| 27,298,002
|
#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
using namespace std;
int main(){
int n;
while(true){
cin >> n;
if(n == 0){
break;
}
vector< pair<int, int> > train;
train.push_back(make_pair(0, 0));
vector< pair<int, int> > time;
int hs, ms, ss, he, me, se;
char tmp;
for(int i=0; i<n; i++){
cin >> hs >> tmp >> ms >> tmp >> ss;
cin >> he >> tmp >> me >> tmp >> se;
time.push_back(make_pair(hs*3600 + ms*60 + ss, he*3600 + me*60 + se));
}
sort(time.begin(), time.end());
int ans = 1;
for(int i=0; i<n; i++){
int sz = train.size();
for(int j=0; j<sz; j++){
if(train[j].second <= time[i].first){
train[j].second = time[i].second;
break;
}
if(j == sz-1){
train.push_back(make_pair(time[i].first, time[i].second));
ans++;
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
#include <tuple>
class A
{
public:
A()
{
int n;
std::cin >> n;
std::vector<int> a(n);
for(int i = 0; i < n; ++i)
{
std::cin >> a[i];
}
int cnt = bubbleSort(a, n);
show(a);
std::cout << cnt << std::endl;
}
const int bubbleSort(std::vector<int>& a, const int n)
{
int cnt = 0;
bool flag = true;
while(flag)
{
flag = false;
for(int i = n - 1; i >= 1; --i)
{
if(a[i] < a[i - 1])
{
int v = a[i];
a[i] = a[i - 1];
a[i - 1] = v;
flag = true;
cnt++;
}
}
}
return cnt;
}
void show(const std::vector<int>& a)
{
for(int i = 0; i < a.size(); ++i)
{
std::cout << a[i] << (i + 1 == a.size() ? "\n" : " ");
}
}
};
class B
{
public:
B()
{
int n;
std::cin >> n;
std::vector<int> a(n);
for(int i = 0; i < n; ++i)
{
std::cin >> a[i];
}
const int cnt = selectionSort(a, n);
for(int i = 0; i < n; ++i)
{
std::cout << a[i] << (i + 1 == n ? "\n" : " ");
}
std::cout << cnt << std::endl;
}
const int selectionSort(std::vector<int>& a, const int n)
{
int cnt = 0;
for(int i = 0; i < n; ++i)
{
int min_j = i;
for(int j = i; j < n; ++j)
{
if(a[j] < a[min_j])
{
min_j = j;
}
}
int v = a[i];
a[i] = a[min_j];
a[min_j] = v;
if(i != min_j)
{
cnt++;
}
}
return cnt;
}
};
class C
{
public:
C()
{
int n;
std::cin >> n;
std::vector<std::pair<std::string, int>> v(n);
for(int i = 0; i < n; ++i)
{
std::cin >> v[i].first;
v[i].second = (int)(v[i].first[1] - '0');
v[i].first.pop_back();
}
bubbleSort(v);
selectionSort(v);
output(bubble_v);
output(select_v);
}
private:
std::vector<std::pair<std::string, int>> bubble_v;
std::vector<std::pair<std::string, int>> select_v;
void output(const std::vector<std::pair<std::string, int>>& v)
{
for(int i = 0; i < v.size(); ++i)
{
std::cout << v[i].first << v[i].second << (i + 1 == v.size() ? "\n" : " ");
}
std::cout << (judgeStable(v) ? "Stable" : "Not stable") << std::endl;
}
const bool judgeStable(const std::vector<std::pair<std::string, int>>& v)
{
for(int i = 0; i < v.size(); ++i)
{
if(v[i] != bubble_v[i])
{
return false;
}
}
return true;
}
void bubbleSort(const std::vector<std::pair<std::string, int>>& v)
{
bubble_v = v;
bool flag = true;
while(flag)
{
flag = false;
for(int i = bubble_v.size() - 1; i > 0; --i)
{
if(bubble_v[i].second < bubble_v[i - 1].second)
{
std::swap(bubble_v[i], bubble_v[i - 1]);
flag = true;
}
}
}
}
void selectionSort(const std::vector<std::pair<std::string, int>>& v)
{
select_v = v;
for(int i = 0; i < select_v.size(); ++i)
{
int min_j = i;
for(int j = i; j < select_v.size(); ++j)
{
if(select_v[min_j].second > select_v[j].second)
{
min_j = j;
}
}
std::swap(select_v[i], select_v[min_j]);
}
}
};
int main(void)
{
C c;
return 0;
}
| 0
| 72,776,801
|
#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 main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int N; cin >> N;
string S[310];
rep(i, N) cin >> S[i];
int ans = 0;
rep(A, N) {
bool ok = true;
rep(i, N) {
rep(j, N) {
int i1 = (i + A) % N;
int j1 = j;
int i2 = (j + A) % N;
int j2 = i;
if(S[i1][j1] != S[i2][j2]) ok = false;
}
}
ans += ok;
}
cout << ans * N << endl;
return 0;
}
|
#include<iostream>
#include<cstdio>
#include <cstring>
using namespace std;
int main()
{
int n;
bool a[1000001];
memset(a,0,sizeof(a));
for(int i=2;i<=1000;++i)
{
for(int j=2;j*i<=1000000;++j)
{
a[i*j]=1;
}
}
while(cin>>n)
{
int count=0;
for(int k=2;k<=n;k++)
{
if(!a[k])
count++;
}
cout<<count<<endl;
}
return 0;
}
| 0
| 20,410,514
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <sstream>
#include <algorithm>
#include <math.h>
#include <map>
#include <functional>
#include <iomanip>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <typeinfo>
#define PI 3.14159265359
#define INF 99999999;
#define rep(i, n) for(int i=0; i<n; i++)
#define REP(n) rep(i, n)
#define EPS 1e-10
typedef long long ll;
using namespace std;
typedef pair<int, int> P;
double distanceAB(double xa, double ya, double xb, double yb);
void trace(int A[], int N);
static const int N = 100;
int main()
{
int M[N][N];
int n, u, k, v;
cin >> n;
rep(i, n) rep(j, n) M[i][j] = 0;
rep(i, n)
{
cin >> u >> k;
u--;
rep(j, k)
{
cin >> v;
v--;
M[u][v] = 1;
}
}
rep(i, n)
{
rep(j, n)
{
if (j) cout << " ";
cout << M[i][j];
}
cout << endl;
}
return 0;
}
void trace(int A[], int N)
{
REP(N)
{
if (i > 0) cout << " ";
cout << A[i];
}
cout << endl;
}
double distanceAB(double xa, double ya, double xb, double yb)
{
return sqrt((xb-xa)*(xb-xa) + (yb-ya)*(yb-ya));
}
|
#include <bits/stdc++.h>
using namespace std;
string s;
unordered_map<int, int>cnt;
int main(){
cin>>s;
int cur = 0, x;
cnt[cur] = 1;
for(int i = 0; i < s.size(); ++i){
cur ^= (1 << (s[i] - 'a'));
if(cur == 0){
continue;
}
else{
x = 1e8;
if(cnt[cur] > 0){
x= min(x, cnt[cur]);
}
for(int j = 0; j < 26; ++j){
if((cur ^ (1 << j)) == 0){ x = 1; break;}
else{
if(cnt[cur ^ (1 << j)] > 0) x = min(x, cnt[cur ^ (1 << j)] + 1);
else{
x = min(x, cnt[cur ^ (1 << (s[i] - 'a'))] + 1);
}
}
}
cnt[cur] = x;
}
}
cout << cnt[cur] << endl;
}
| 0
| 77,643,838
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(x)(x).begin(), (x).end()
#define rall(v)(v).rbegin(), (v).rend()
#define INF 1LL << 60
typedef long long int LL;
typedef long long int ll;
#define pll pair < ll, ll >
#define F first
#define S second
const int MOD = 1000000007;
template < class T > bool chmax(T & a,const T & b) { if (a < b) { a = b; return true; } return false; }
template < class T > bool chmin(T & a,const T & b) { if (a > b) { a = b; return true; } return false; }
int main() {
string S;cin >> S;
if(S[2] == S[3]){
if(S[4] == S[5]){
cout << "Yes" << endl;
}
else cout << "No" << endl;
}
else{
cout << "No" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
template<class T> inline T sqr(T x) {return x*x;}
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> P;
typedef long long ll;
#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 FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
const double EPS = 1e-10;
const double PI = acos(-1.0);
#define CLR(a) memset((a), 0 ,sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << 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; }
int main(void){
int N;
cin >> N;
int P[N];
REP(i,N) cin >> P[i];
int idx[N];
REP(i,N) idx[P[i]-1] = i+1;
set<int> s;
ll ans = 0;
for(int x=N; x>0; x--){
ll c;
int i = idx[x-1];
s.insert(i);
int l[2] = {0,0}, r[2] = {N+1,N+1};
auto itr = s.find(i);
REP(j,2){
if(itr == s.begin()) break;
itr--;
l[j] = *itr;
}
itr = s.find(i);
REP(j,2){
itr++;
if(itr == s.end()) break;
r[j] = *itr;
}
c = (ll)(i-l[0])*(r[1]-r[0]) + (ll)(r[0]-i)*(l[0]-l[1]);
ans += c*x;
}
cout << ans << endl;
return 0;
}
| 0
| 10,837,104
|
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
constexpr char ln = '\n';
constexpr long long MOD = 1000000007LL;
constexpr long long INF = 1001001001LL;
constexpr long long LINF = 1001001001001001001;
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define rept(i, j, n) for(int i=(j); i<(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; }
int main(){
double L; cin >> L;
double num = L / 3;
cout << fixed << setprecision(12);
cout << num * num * num << ln;
}
|
#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;
int main(){
int n;
while(cin>>n,n){
int state=0,cnt=0;
for(string step;n>0;--n){
cin>>step;
if(step=="lu"||step=="ru"){
if(state==1) cnt++;
state=1;
}else{
if(state==0) cnt++;
state=0;
}
}
cout<<cnt<<endl;
}
return EXIT_SUCCESS;
}
| 0
| 66,635,454
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <bitset>
#include <math.h>
#include <iomanip>
#include <map>
#include <queue>
#include <tuple>
#include <math.h>
#include <iomanip>
using namespace std;
typedef long long ll;
typedef tuple<int,int,int> P;
int main(){
string S;
cin >> S;
if(S[0]!=S[1] || S[1]!=S[2]) cout << "Yes";
else cout << "No";
return 0;
}
|
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <string>
#include <math.h>
#include <iomanip>
#include <limits>
#include <list>
#include <queue>
#include <tuple>
#include <map>
#include <stack>
#include <set>
using namespace std;
#define MOD (long long int)(1e9+7)
#define ll long long int
#define rep(i,n) for(int i=0; i<(int)(n); i++)
#define reps(i,n) for(int i=1; i<=(int)(n); i++)
#define REP(i,n) for(int i=n-1; i>=0; i--)
#define REPS(i,n) for(int i=n; i>0; i--)
#define INF (int)(1123456789)
#define LINF (long long int)(112345678901234567)
#define chmax(a, b) a = (((a)<(b)) ? (b) : (a))
#define chmin(a, b) a = (((a)>(b)) ? (b) : (a))
#define all(v) v.begin(), v.end()
const int N = (int)3e5;
ll mpow(ll a, ll b){
if(b==0) return 1;
else if(b%2==0){ll memo = mpow(a,b/2); return memo*memo%MOD;}
else return mpow(a,b-1) * a % MOD;
}
ll lpow(ll a, ll b){
if(b==0) return 1;
else if(b%2==0){ll memo = lpow(a,b/2); return memo*memo;}
else return lpow(a,b-1) * a;
}
ll gcd(ll a, ll b){
if(b==0) return a;
else return gcd(b, a%b);
}
vector<ll> kaijo_memo;
ll kaijo(ll n){
if(kaijo_memo.size() > n) return kaijo_memo[n];
if(kaijo_memo.size() == 0) kaijo_memo.push_back(1);
while(kaijo_memo.size() <= n) kaijo_memo.push_back(kaijo_memo[kaijo_memo.size()-1] * kaijo_memo.size() % MOD);
return kaijo_memo[n];
}
vector<ll> gyaku_kaijo_memo;
ll gyaku_kaijo(ll n){
if(gyaku_kaijo_memo.size() > n) return gyaku_kaijo_memo[n];
if(gyaku_kaijo_memo.size() == 0) gyaku_kaijo_memo.push_back(1);
while(gyaku_kaijo_memo.size() <= n) gyaku_kaijo_memo.push_back(gyaku_kaijo_memo[gyaku_kaijo_memo.size()-1] * mpow(gyaku_kaijo_memo.size(), MOD-2) % MOD);
return gyaku_kaijo_memo[n];
}
ll nCr(ll n, ll r){
if(n == r) return 1;
if(n < r || r < 0) return 0;
ll ret = 1;
ret *= kaijo(n); ret %= MOD;
ret *= gyaku_kaijo(r); ret %= MOD;
ret *= gyaku_kaijo(n-r); ret %= MOD;
return ret;
}
int main(void){
int n;cin>>n;
vector<ll> P;
rep(i,n){
ll p;cin>>p;p--;
P.push_back(p);
}
vector<ll> A,B;
ll base = 4e4;
rep(i,n){
A.push_back(i*base);
B.push_back(i*base);
}
reverse(all(B));
rep(i,n){
ll p = P[i];
A[p] += i+1;
B[p] += i+1;
}
rep(i,n){
cout<<A[i]<<" ";
}
cout<<endl;
rep(i,n){
cout<<B[i]<<" ";
}
cout<<endl;
return 0;
}
| 0
| 36,696,588
|
#include "bits/stdc++.h"
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
#define int long long
signed main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, m, d;
cin >> n >> m >> d;
if (d == 0) {
cout << fixed << setprecision(12) << (m - 1.0)/n << endl;
} else {
cout << fixed << setprecision(12) << (m - 1.0) * ((n - d) * 2)/(n * n)<< endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int n,m,need;
int a[15][15];
int cost[20];
int dp[20][1<<15];
int func(int pos,int mask)
{
if(pos>n)
{
int tcost=0;
for(int i=1; i<=m; i++)
{
int sm=0;
for(int j=1; j<=n; j++)
{
if(mask&(1<<(j-1)))
{
sm+=a[j][i];
if(i==1)
tcost+=cost[j];
}
}
if(sm<need) return INT_MAX;
}
return tcost;
}
int &r=dp[pos][mask];
if(r!=-1) return r;
int x=func(pos+1,mask|(1<<pos));
int y=func(pos+1,mask);
r=min(x,y);
return dp[pos][mask]=r;
}
int main()
{
cin>>n>>m>>need;
for(int i=1; i<=n; i++)
{
int c;
cin>>c;
cost[i]=c;
for(int j=1; j<=m; j++)
{
cin>>a[i][j];
}
}
memset(dp,-1,sizeof dp);
int ans=func(0,0);
if(ans==INT_MAX) cout<<-1;
else cout<<ans<<endl;
}
| 0
| 9,052,437
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, Y;
cin >> N >> Y;
int x = -1, y = -1, z = -1;
for (int i = 0; i <= N; i++){
for (int j = 0; j <= N - i; j++){
if (1000 * (N - i - j) == Y - 10000 * i - 5000 * j){
x = i;
y = j;
z = N - i - j;
break;
}
}
if (x > -1){
break;
}
}
cout << x << " " << y << " " << z << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int64_t N,M;
cin >> N >> M;
vector<int64_t> A(N),B(N);
for ( int64_t i = 0; i < N; ++i){
cin >> A[i] >> B[i];
}
vector<vector<int64_t>> AB(N,vector<int64_t>(2));
for ( int64_t i = 0; i < N; ++i){
AB[i][0] = A[i];
AB[i][1] = B[i];
}
sort(AB.begin(),AB.end());
int64_t count = 0;
int64_t ans = 0;
for ( int64_t i = 0; i < N; ++i){
int64_t cost = AB[i][0];
int64_t num = AB[i][1];
if ( count + num <= M ){
count = count + num;
ans = ans + cost * num;
} else {
ans = ans + cost * ( M - count );
break;
}
}
cout << ans << endl;
return 0;
}
| 0
| 18,635,503
|
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
constexpr int DEBUG = 0;
template<typename T> ostream& operator<<(ostream& s, const vector<T>& v) {
int len = v.size();
s << "[";
for (int i = 0; i < len; i++) {
if (i > 0) s << ", ";
s << v[i];
}
s << "]";
return s;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<pair<int, int64>> xs;
int64 total_sum = 0;
for (int i = 0; i < n; i++) {
int64 x;
cin >> x;
xs.push_back({i, x});
total_sum += x;
}
sort(xs.begin(), xs.end(), [](const auto& p1, const auto& p2) {
if (p1.second != p2.second) return p1.second > p2.second;
return p1.first < p2.first;
});
vector<int64> rs(n);
int index = xs[0].first;
if (index == 0) {
rs[0] = total_sum;
} else {
int64 sum = xs[0].second;
int64 used = 0;
for (int i = 1; i < n; i++) {
const auto& p = xs[i];
if (DEBUG) cout << p.first << " " << p.second << endl;
if (p.first < index) {
rs[index] = sum - (p.second * i) - used;
used += rs[index];
index = p.first;
if (index == 0) {
rs[0] = total_sum - used;
break;
}
}
sum += p.second;
}
}
for (int i = 0; i < n; i++) {
cout << rs[i] << "\n";
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define arep(i,x,n) for(int i=int(x);i<(int)(n);i++)
#define rep(i,n) for(long long i = 0;i < n;++i)
#define rrep(i,n) for(int i=int(n-1);i>=0;i--)
#define fs first
#define sc second
#define all(x) (x).begin(), (x).end()
#define pi 3.141592653589793
#define eps 0.00000001
#define INF 1e9+7
using ll = long long;
using P=pair<int,int>;
using lP=pair<ll,ll>;
using fP=pair<double,double>;
using PPI=pair<P,int>;
ll const mod=1e9+7;
const ll MAX=1000005;
using vi=vector<int>;
using vl=vector<ll>;
using vc=vector<char>;
using vd=vector<double>;
using vs=vector<string>;
using vp=vector<P>;
using vb=vector<bool>;
using vvi =vector<vector<int>>;
using vvl =vector<vector<ll>>;
using vvd=vector<vector<double>>;
using vvc=vector<vector<char>>;
using vvp =vector<vector<P>>;
using vvb=vector<vector<bool>>;
template <typename T>
bool chmax(T &a, const T b){if(a < b){a = b; return true;} return false;}
template <typename T>
bool chmin(T &a, const T b){if(a > b){a = b; return true;} return false;}
ll dp[100005][2];
int main(){
string s;
cin>>s;
int n=s.size();
dp[0][1]=1;
dp[1][0]=1;
rep(i,n){
dp[i+1][0]+=dp[i][0]*3%mod;
if(s[i]=='1'){
dp[i+1][0]+=dp[i][1];
dp[i+1][0]%=mod;
dp[i+1][1]=dp[i][1]*2%mod;
}
if(s[i]=='0'){
dp[i+1][1]=dp[i][1];
dp[i+1][1]%=mod;
}
if(i==0)dp[1][0]=1;
}
ll ans=dp[n][0]+dp[n][1];
ans%=mod;
cout<<ans<<endl;
return 0;
}
| 0
| 47,086,443
|
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <complex>
#include <utility>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <tuple>
#include <cmath>
#include <bitset>
#include <cctype>
#include <set>
#include <map>
#include <unordered_map>
#include <numeric>
#include <functional>
#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(ll i=ll(a);i<ll(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define PRINT(V) cout << V << "\n"
#define SORT(V) sort((V).begin(),(V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
using namespace std;
using ll = long long;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
inline void Yes(bool condition){ if(condition) PRINT("Yes"); else PRINT("No"); }
template<class itr> void cins(itr first,itr last){
for (auto i = first;i != last;i++){
cin >> (*i);
}
}
template<class itr> void array_output(itr start,itr goal){
string ans = "",k = " ";
for (auto i = start;i != goal;i++) ans += to_string(*i)+k;
if (!ans.empty()) ans.pop_back();
PRINT(ans);
}
ll gcd(ll a, ll b) {
return a ? gcd(b%a,a) : b;
}
const ll INF = 1e15;
const ll MOD = 100000000;
const ll MOD2 = 998244353;
typedef pair<ll,ll> P;
const ll MAX = 200010;
constexpr ll nx[8] = {1,0,-1,0,-1,-1,1,1};
constexpr ll ny[8] = {0,1,0,-1,-1,1,-1,1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll h,w,d;
cin >> h >> w >> d;
vector<P> place(h*w+1);
ll a;
rep(i,h){
rep(j,w){
cin >> a;
place[a] = P(i,j);
}
}
vector<vector<ll>> power(d);
rep(i,d) power[i].push_back(0);
rep(i,d,h*w+1){
ll x,y,nx,ny;
tie(x,y) = place[i-d];
tie(nx,ny) = place[i];
power[i%d].push_back(abs(nx-x)+abs(ny-y));
}
rep(i,d){
rep(j,power[i].size()-1){
power[i][j+1] += power[i][j];
}
}
ll q;
cin >> q;
ll l,r;
rep(i,q){
cin >> l >> r;
PRINT(power[l%d][r/d]-power[l%d][l/d]);
}
}
|
#pragma region template
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vld = vector<ld>;
using vvld = vector<vld>;
using vvvld = vector<vvld>;
using vs = vector<string>;
using pll = pair<ll, ll>;
using vp = vector<pll>;
template <typename T>
using pqrev = priority_queue<T, vector<T>, greater<T>>;
#define rep(i, n) for (ll i = 0, i##_end = (n); i < i##_end; i++)
#define repb(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repr(i, a, b) for (ll i = (a), i##_end = (b); i < i##_end; i++)
#define reprb(i, a, b) for (ll i = (b)-1, i##_end = (a); i >= i##_end; i--)
#define ALL(a) (a).begin(), (a).end()
#define SZ(x) ((ll)(x).size())
constexpr ll MOD = 1e9 + 7;
/*/
constexpr ll MOD = 998244353;
constexpr ll INF = 1e+18;
constexpr ld EPS = 1e-12L;
constexpr ld PI = 3.14159265358979323846L;
constexpr ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
constexpr ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
template <typename S, typename T>
constexpr bool chmax(S &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename S, typename T>
constexpr bool chmin(S &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#ifdef OJ_LOCAL
#include "dump.hpp"
#else
#define dump(...) ((void)0)
#endif
template <typename T>
bool print_(const T &a) {
cout << a;
return true;
}
template <typename T>
bool print_(const vector<T> &vec) {
for (auto &a : vec) {
cout << a;
if (&a != &vec.back()) {
cout << " ";
}
}
return false;
}
template <typename T>
bool print_(const vector<vector<T>> &vv) {
for (auto &v : vv) {
for (auto &a : v) {
cout << a;
if (&a != &v.back()) {
cout << " ";
}
}
if (&v != &vv.back()) {
cout << "\n";
}
}
return false;
}
void print() { cout << "\n"; }
template <typename Head, typename... Tail>
void print(Head &&head, Tail &&... tail) {
bool f = print_(head);
if (sizeof...(tail) != 0) {
cout << (f ? " " : "\n");
}
print(forward<Tail>(tail)...);
}
#pragma endregion
void Pr(bool f){
cout << (f ? "Yes" : "No") << "\n";
exit(0);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll w, h, x, y;
cin >> w >> h >> x >> y;
ll b = 0;
if(x*2==w&&y*2==h) b = 1;
print((ld)w*h/2, b);
}
| 0
| 40,942,808
|
#include <iostream>
using namespace std;
int main(){
int track[10], c, num;
while(1){
cin >> num;
if(!num){
if(!c) break;
else cout << track[c--] <<endl;
}
else{
if(c==10) cout << "Already Full" <<endl;
else track[++c] = num;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
using P = pair<ll,ll>;
constexpr ll mod = 1e9+7;
#define ALL(x) (x).begin(),(x).end()
#define REP(i,n) for(ll (i)=0;(i)<(n);(i)++)
#define REPS(i,n) for(ll (i)=1;(i)<=(n);(i)++)
#define RREP(i,n) for(ll (i)=(n-1);(i)>=0;(i)--)
#define RREPS(i,n) for(ll (i)=(n);(i)>0;(i)--)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define F first
#define S second
#define UNIQUE(v) v.erase(unique(ALL(v)),v.end());
template<class T> inline void chmin(T& a, T b){
if (a > b){
a = b;
}
}
template<class T> inline void chmax(T& a, T b){
if (a < b){
a = b;
}
}
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(12);
ll K,S;
cin >> K >> S;
ll ans = 0;
REP(i,K+1){
REP(l,K+1){
if(S-l-i<=K&&S-l-i>=0)ans++;
}
}
cout << ans << "\n";
}
| 0
| 31,447,803
|
#include <iostream>
#include <vector>
using namespace std;
int main(){
vector<int> h,w;
int _h,_w;
while(1){
cin >> _h >> _w;
if(_h == 0 && _w == 0){
break;
}
h.push_back(_h);
w.push_back(_w);
}
for(int i=0;i<h.size();i++){
for(int h_i=0;h_i<h[i];h_i++){
for(int w_i=0;w_i<w[i];w_i++){
cout << "#";
}
cout << endl;
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#include <iostream>
#include <vector>
#include <cstdlib>
#include <cmath>
#include <math.h>
#include <sstream>
#include <numeric>
#include <cctype>
#include <bitset>
#include <cassert>
#include<algorithm>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define SIZE 100005
#define INF 1e18
#define all(x) x.begin(),x.end()
#define fi first
#define se second
#define vec vector
using pint = pair<int,int>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const double pi = acos(-1);
int main() {
ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
ll n;
cin>>n;
vector<int> dp(100000,0);
rep(i,n+1){
dp[i]=i;
}
int b=6; int q=9;
for(int i=0;i<=n+1;i++){
if(i>=b*6)b*=6;
if(i>=q*9)q*=9;
if(i<6) dp[i]=i;
else if(i<9) dp[i]=min(dp[i-1]+1,dp[i-b]+1);
else dp[i] = min({dp[i-1]+1,dp[i-b]+1,dp[i-q]+1});
}
cout<<dp[n]<<endl;
return 0;
}
| 0
| 5,691,313
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll,ll> P;
typedef pair<int,int> Pi;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define fi first
#define se second
#define endl "\n"
template<typename T> inline bool chmax(T &a, T b){if(a<b){a=b;return true;}return false;}
template<typename T> inline bool chmin(T &a, T b){if(a>b){a=b;return true;}return false;}
template<typename T> ostream& operator<<(ostream& s,const complex<T>& d) {return s<<"("<<d.real()<<", "<<d.imag()<< ")";}
template<typename T1, typename T2> ostream& operator<<(ostream& s,const pair<T1,T2>& d) {return s<<"("<<d.first<<", "<<d.second<<")";}
template<typename T> ostream& operator<<(ostream& s, const vector<T>& d){
int len=d.size();
rep(i,len){
s<<d[i];if(i<len-1) s<<" ";
}
return s;
}
template<typename T> ostream& operator<<(ostream& s,const vector<vector<T>>& d){
int len=d.size();
rep(i,len){
s<<d[i]<<endl;
}
return s;
}
template<typename T> ostream& operator<<(ostream& s,const set<T>& v){
s<<"{ ";
for(auto itr=v.begin();itr!=v.end();++itr) {
if (itr!=v.begin()) {s<< ", ";}
s<<(*itr);
}
s<<" }";
return s;
}
template<typename T1, typename T2> ostream& operator<<(ostream& s,const map<T1,T2>& m){
s<<"{"<<endl;
for(auto itr=m.begin();itr!=m.end();++itr){
s<<" "<<(*itr).first<<" : "<<(*itr).second<<endl;
}
s<<"}"<<endl;
return s;
}
const ll mod=1e9+7;
const ll inf=1e17;
const int INF=1e9;
const double PI=acos(-1);
const double EPS=1e-10;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin>>n;
map<int,int> mp;
vector<ll> b;
rep(i,n){
int a;
cin>>a;
mp[a]++;
}
for(auto itr:mp){
b.push_back(itr.se);
}
sort(begin(b),end(b));
int m=b.size();
vector<ll> sum(m+1,0);
rep(i,m){
sum[i+1]=sum[i]+b[i];
}
auto solve=[&](ll x,ll k){
auto itr=lower_bound(begin(b),end(b),x);
ll ret=sum[itr-begin(b)]+x*(end(b)-itr);
return ret>=k*x;
};
FOR(k,1,n+1){
ll ok=0,ng=INF,mid;
while(ng-ok>1){
mid=(ok+ng)/2;
if(solve(mid,k)) ok=mid;
else ng=mid;
}
cout<<ok<<endl;
}
}
|
#include<bits/stdc++.h>
#define forr(i, a, b) for(int i = (a); i < (b); i++)
#define rep(i,n) for(int i = 0; i < (n); i++)
#define rrep(i,n) for(int i = 1; i <= (n); i++)
#define ALL(a) (a.begin()),(a.end())
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef pair<ll, ll> LP;
const ll LINF = 1LL<<60;
const int INF = 1001001001;
const int MOD = 1000000007;
using Gragh = vector<vector<int>>;
int main() {
int n, m;
cin >> n >> m;
Gragh to(n);
rep(i, m) {
int a, b;
cin >> a >> b;
a--; b--;
to[a].push_back(b);
to[b].push_back(a);
}
vector<int> order(n);
rep(i, n) order[i] = i;
int ans = 0;
do {
if(order[0] != 0) continue;
bool check;
int cnt = 0;
rep(i, n - 1) {
check = true;
for(auto x : to[order[i]]) {
if(x == order[i + 1]) check = false;
}
if(check) break;
cnt++;
}
if(cnt == n - 1) ans++;
} while(next_permutation(ALL(order)));
cout << ans << endl;
return 0;
}
| 0
| 60,021,161
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1e16;
const ll mod = 1000000007;
#define rep(i, n) for (int i = 0; i < (ll)(n); i++)
int main() {
ll h, w, d; cin >> h >> w >> d;
vector <pair <ll, ll>> v(h*w, pair <ll, ll> ());
rep(i, h) {
rep(j, w) {
ll a; cin >> a;
v.at(a-1) = make_pair(i, j);
}
}
vector <ll> imos(h*w, 0);
rep(i, d) {
ll tmp = i;
while (tmp+d < h*w) {
imos.at(tmp+d) = imos.at(tmp)+abs(v.at(tmp+d).first-v.at(tmp).first)+abs(v.at(tmp+d).second-v.at(tmp).second);
tmp += d;
}
}
ll q; cin >> q;
rep(i, q) {
ll l, r; cin >> l >> r;
l--; r--;
cout << imos.at(r) - imos.at(l) << endl;
}
}
|
#include<iostream>
#include<string>
#include<algorithm>
#include<queue>
#include<vector>
#include<cstdlib>
#include<set>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
#include<iostream>
int const MAX_N = 100000;
int par[MAX_N];
int depth[MAX_N];
void init(int n){
for(int i = 0; i < n; i++){
par[i] = i;
depth[i] = 0;
}
}
int find(int x){
if (par[x] == x) {
return x;
}else{
return par[x] = find(par[x]);
}
}
void unite(int x, int y){
x = find(x);
y = find(y);
if (x == y) return;
if (depth[x] < depth[y]) {
par[x] = y;
}else{
par[y] = x;
if (depth[x] == depth[y]) depth[x]++;
}
}
bool same(int x, int y){
return find(x) == find(y);
}
int main(){
int n, m;
cin >> n >> m;
int p[n];
rep(i, n){cin >> p[i]; p[i]--;}
init(n);
int x, y;
rep(i, m) {
cin >> x >> y;
x--; y--;
unite(x, y);
}
int ans = 0;
rep(i, n){
if (i != p[i]){
if (same(i, p[i])){
ans++;
}
}else{
ans++;
}
}
cout << ans << endl;
}
| 0
| 15,442,002
|
#include <bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ordered_set tree <ll, null_type, less_equal <ll>, rb_tree_tag, tree_order_statistics_node_update>
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
const double pi=3.1415926535897932384626433832;
long long mod= 1e9+7;
typedef complex<double> cd;
typedef long long ll;
typedef double ld;
cd fast_exp(cd a, long long b)
{
if (b == 0)
return 1;
cd res = fast_exp(a, b / 2);
res = res *res;
if (b % 2 == 1)
{
res = res * a;
}
return res;
}
long long fastexpon(long long a,long long b,long long mod)
{
if(b==0)
return 1LL;
long long res=fastexpon(a,b/2,mod);
res=(res*res)%mod;
if(b%2==1)
res= (res * a)%mod;
return res;
}
struct custom
{
bool operator()(ll a, ll b)
{
return a > b;
}
};
double findangle(double x, double y)
{
if(x>=0 && y>=0)
{
if(x!=0)
return atan(y/x);
else
return pi/2;
}
else if(x<0 && y>=0)
{
x = abs(x);
y = abs(y);
return pi - atan(y/x);
}
else if(x<=0 && y<0)
{
x = abs(x);
y = abs(y);
if(x==0)
return 3*pi/2;
else
return pi + atan(y/x);
}
else
{
x = abs(x);
y = abs(y);
return 2*pi - atan(y/x);
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout.precision(30);
vector<pair<ll,ll>> v;
ll x,y;
int n;
cin>>n;
for(int i = 0; i<n ;i++)
{
cin>>x>>y;
v.pb(mp(x,y));
}
sort(v.begin(),v.end(),[](pair<ll,ll> a , pair<ll,ll> b){ return atan2(a.ff,a.ss) < atan2(b.ff,b.ss);} );
ll cumulx[n+1]={} , cumuly[n+1]={};
for(int i = 1 ; i<=n ;i++)
{
cumulx[i]=v[i-1].ff + cumulx[i-1];
cumuly[i]=v[i-1].ss + cumuly[i-1];
}
double truans = 0;
double res = 0, store;
for(ll len=1;len<=n;len++)
{
for(ll j=0;j<n;j++)
{
ll xsum=0;
ll ysum=0;
ll curridx=j;
for(ll k=0;k<len;k++)
{
xsum+=v[curridx].first;
ysum+=v[curridx].second;
curridx=(curridx+1);
if(curridx>=n)
{
curridx-=n;
}
}
store=double(xsum*xsum);
store+=(double)(ysum*ysum);
store=sqrt(store);
if(res<=store)
{
res=store;
}
}
}
cout << fixed << setprecision(20) << res << endl;
return 0;
}
|
#include<algorithm>
#include<iostream>
#include<cstring>
#define rep(i,a) for(int i=0;i<(a);++i)
#define repd(i,a) for(int i=(a);i>=0;--i)
#define clr(a,v) memset((a),(v),sizeof(a))
const int MAX_X = 1000, MAX_Y = 1000;
int q;
std::string X, Y;
int dp[MAX_X+1][MAX_Y+1];
int main()
{
std::cin >> q;
while( q-- )
{
std::cin >> X >> Y;
clr( dp, 0 );
repd( i, X.size()-1 ) repd( j, Y.size()-1 )
{
if( X[i] == Y[j] )
dp[i][j] = dp[i+1][j+1]+1;
else
dp[i][j] = std::max( dp[i+1][j], dp[i][j+1] );
}
printf( "%d\n", dp[0][0] );
}
return 0;
}
| 0
| 41,411,974
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,a,b,x[200];
while(1){
cin>>n>>a>>b;
if(n==0 && a==0 && b==0) break;
for(int i =0;i<n;i++){
cin>>x[i];
}
int j=0,k=a;
for(int i=a-1;i<b;i++){
if(x[i]-x[i+1]>=j){
j=x[i]-x[i+1];
k=i+1;
}
}
cout<<k<<endl;
}
return 0;
}
|
#include <iostream>
#include <cctype>
#include <cstring>
#include <cstdio>
#include <cmath>
#define PI 3.1415926535
using namespace std;
int main()
{
int a,b,arg;
scanf("%d %d %d",&a,&b,&arg);
double rad = (arg / 180.0) * PI;
printf("%5lf\n",(a * b * sin(rad)) / 2);
printf("%5lf\n",a + b + sqrt(a*a + b*b - 2*a*b*cos(rad)));
printf("%5lf\n",b*sin(rad));
return 0;
}
| 0
| 79,357,356
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <cstdio>
#include <string>
#include <set>
#include <queue>
#include <stack>
using namespace std;
typedef vector<int> vi;
typedef vector< vi > vvi;
int a[6];
int main() {
int L,N=0,M=0;
while (cin >> N) {
L = 1000 - N;
if (N == 0) {
break;
}
if (L >= 500) {
a[0]++;
L = L - 500;
}
while (L >= 100) {
a[1]++;
L = L - 100;
}
while (L >= 50) {
a[2]++;
L = L - 50;
}
while (L >= 10) {
a[3]++;
L = L - 10;
}
while (L >= 5) {
a[4]++;
L = L - 5;
}
a[5] = L;
M = a[0] + a[1] + a[2] + a[3] + a[4] + a[5];
cout << M << endl;
M = 0;
for (int i = 0; i < 6; i++) {
a[i] = 0;
}
}
}
|
#include <iostream>
#include <string>
using namespace std;
const int cnMaxAry = 1000033;
long long fnStrToLL(string sKey)
{
int iElm;
int iBase = 1;
long long llKey = 0;
for (int i = sKey.size() - 1; i >= 0; i--)
{
switch (sKey[i])
{
case 'A': iElm = 1;
break;
case 'C': iElm = 2;
break;
case 'G': iElm = 3;
break;
case 'T': iElm = 4;
break;
default: iElm = 0;
}
llKey += iBase * iElm;
iBase *= 5;
}
return llKey;
}
int fnHash1(long long a_llKey) { return (a_llKey % cnMaxAry); }
int fnHash2(long long a_llKey) { return (1 + (a_llKey % (cnMaxAry - 1))); }
void fnDic(string stasDic[])
{
int iCmdCnt;
cin >> iCmdCnt;
for (int i = 0; i < iCmdCnt; i++)
{
string sCmd;
string sKey;
cin >> sCmd >> sKey;
long long llKey = fnStrToLL(sKey);
int iCnt = 0;
for (iCnt = 0; ;iCnt++)
{
int ix = (fnHash1(llKey) + iCnt * fnHash2(llKey)) % cnMaxAry;
if (stasDic[ix] == sKey)
{
if (sCmd[0] == 'i')
break;
else if (sCmd[0] == 'f')
{
cout << "yes" << endl;
break;
}
}
else if (stasDic[ix].size() == 0)
{
if (sCmd[0] == 'i')
{
stasDic[ix] = sKey;
break;
}
else if (sCmd[0] == 'f')
{
cout << "no" << endl;
break;
}
}
}
}
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
static string stasDic[cnMaxAry];
fnDic(stasDic);
return 0;
}
| 0
| 71,966,343
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
typedef long double ld;
const int inf=1e9+7;
const ll longinf=1LL<<60;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
#define F first
#define S second
const int mx=100010;
const ll mod=1e9+7;
int main(){
int n;
cin >> n;
if(n<1200){cout << "ABC" << endl; return 0;}
if(n<2800){cout << "ARC" << endl; return 0;}
cout << "AGC" << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define FASTIO ios::sync_with_stdio(false);cin.tie(0);
#define ADD +
#define SUBTRACT -
#define MULTIPLY *
#define DIVIDE /
#define MOD %
#define INCREMENT(x) ++x
#define DECREMENT(x) --x
#define in(a,b) cin>>a>>b;
#define out(a,b) cout<<a<<endl<<b<<endl;
#define scan(a) scanf("%d",&a);
#define print(a) printf("%d\n",a);
#define scanii(a,b) scanf("%d %d",&a,&b);
#define printii(a,b) printf("%d\n%d\n",a,b);
#define scaniii(a,b,c) scanf("%d %d %d",&a,&b,&c);
#define pub push_back
#define pob pop_back
#define puf push_front
#define pof pop_front
#define ll long long
#define ull unsigned long long
#define sll signed long long
#define pi acos(-1)
#define mod 1000000007
#define TRUE 1
#define FALSE 0
#define ZERO 0
#define MP make_pair
#define F first
#define S second
#define f1(i,a) for(int i=0;i<a;++i)
#define f2(i,a) for(int i=a-1;i>=0;--i)
#define en puts("");
#define elif else if
typedef ll int lli;
typedef sll int slli;
typedef ull int ulli;
const int sz=10000;
using namespace std;
int clue();
int result();
void show();
bool check();
bool cmp(pair<int,int>p,pair<int,int>q) {
return p.second<q.second;
}
int main() {
int t;
t=1;
while(t-->0) {
clue();
}
return 0;
}
int clue() {
int a[50]={1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
int k;
cin>>k;
cout<<a[k-1]<<endl;
return 0;
}
| 0
| 91,288,127
|
#include<bits/stdc++.h>
using namespace std;
void test()
{
int a,b,c;
map<int,int>mp;
int res=0;
cin>>a>>b>>c;
mp[a]++;
mp[b]++;
mp[c]++;
for(int i=1;i<=100;i++)
{
if(mp[i])
res++;
}
cout<<res<<"\n";
}
int main()
{
ios::sync_with_stdio(NULL);
cin.tie(0);
cout.tie(0);
test();
return 0;
}
|
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
long long n;
cin >> n;
vector<long long> a(n);
for(long long i = 0; i < n; i++) cin >> a[i];
sort(a.begin(), a.end());
vector<bool> divide(1000001, false);
vector<bool> seen(1000001, false);
for(long long i = 0; i < n; i++){
if(seen[a[i]] == true){
divide[a[i]] = true;
continue;
}
seen[a[i]] = true;
for(long long j = 2 * a[i]; j <= 1000000; j += a[i]){
seen[j] = true;
divide[j] = true;
}
}
long long cnt = 0;
for(long long i = 0; i < n; i++){
if(divide[a[i]] == false) cnt++;
}
cout << cnt << endl;
return 0;
}
| 0
| 57,962,373
|
#include<iostream>
#include<vector>
using namespace std;
vector<int> ans;
int main(){
while(1){
int n,a,b,c,x;
cin >> n >> a >> b >> c >> x;
if(n + a + b + c + x == 0) break;
int y[100];
int count = -1;
int reel = 0;
for(int i = 0;i < n;i++){
cin >> y[i];
}
for(int i = 0;i <= 10000;i++){
if(x == y[reel]) reel++;
if(reel == n){
count = i;
break;
}
x = (a*x + b) % c;
}
ans.push_back(count);
}
for(int i = 0;i < ans.size();i++) cout << ans[i] << endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <queue>
using namespace std;
int main(){
int K;
cin>>K;
queue<long long> q;
for(int i=1;i<10;i++){
q.push(i);
}
int cnt=0;
long long node;
while(!q.empty()){
node=q.front();q.pop();
cnt++;
if(cnt==K){
cout<<node<<endl;
break;
}
int tmp=node%10;
if(tmp!=0){
q.push(node*10+tmp-1);
}
q.push(node*10+tmp);
if(tmp!=9){
q.push(node*10+tmp+1);
}
}
return 0;
}
| 0
| 15,042,691
|
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, N) for(int i = 0; i < N; i++)
#define rep2(i, N, a, b) for(int i = a; i < N; i += b)
int main(){
string A, B;
cin >> A >> B;
if (A.size() == B.size()){
if (A > B) cout << "GREATER" << endl;
else if (A < B) cout << "LESS" << endl;
else cout << "EQUAL" << endl;
}
else {
if (A.size() > B.size()) cout << "GREATER" << endl;
else cout << "LESS" << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define arep(i,x,n) for(int i=int(x);i<(int)(n);i++)
#define rep(i,n) for(long long i = 0;i < n;++i)
#define pi 3.141592653589793
#define eps 0.00000001
#define INF 1e9+7
using ll = long long;
using P=pair<int,int>;
using lP=pair<ll,ll>;
using fP=pair<double,double>;
int main(){
int n,m;
cin>>n>>m;
vector<int>a(m);
rep(i,m)cin>>a[i];
sort(a.rbegin(),a.rend());
vector<int>nd(10);
vector<int>dp(n+1,-1);
vector<int>cnt(n+1);
dp[0]=0;
nd[1]=2;
nd[2]=5;
nd[3]=5;
nd[4]=4;
nd[5]=5;
nd[6]=6;
nd[7]=3;
nd[8]=7;
nd[9]=6;
rep(i,n+1){
rep(j,m){
if(i>=nd[a[j]]&&dp[i-nd[a[j]]]>=0){
dp[i]=max(dp[i],dp[i-nd[a[j]]]+1);
}
}
}
int num=dp[n];
while(num>0){
rep(j,m){
if(n>=nd[a[j]]&&dp[n-nd[a[j]]]+1==dp[n]){
cout<<a[j];
num--;
n-=nd[a[j]];
break;
}
}
}
cout<<endl;
return 0;
}
| 0
| 39,144,713
|
#include<bits/stdc++.h>
using namespace std;
#define int long long int
int32_t main()
{
int n;
cin>>n;
int m;
cin>>m;
if(m<2*n)
cout<<m/2<<endl;
else
{
int ans=n;
m=m-n*2;
cout<<ans+(m/4)<<endl;
}
}
|
#include <bits/stdc++.h>
typedef long long int ll;
typedef long double ld;
using namespace std;
const long long int INF = 1e18;
const long long int mod = 1e9+7;
typedef pair<ll, ll> pairs;
typedef vector<pairs> p;
struct Edge{
ll to, weight;
Edge(ll t, ll w) : to(t), weight(w){}
};
using graph = vector<vector<ll>>;
using Graph = vector<vector<Edge>>;
ll gcd(ll a,ll b){
if(b == 0){
return a;
}else{
return gcd(b, a%b);
}
}
ll lcm(ll a, ll b){
return a / gcd(a, b) * b;
}
ll keta(ll N){
ll M = 1;
while( N > 0 ){
if(N / 10 == 0){
break;
}
N /= 10;
M++;
}
return M;
}
bool kai(string S){
bool flag = true;
for(ll i=0;i<S.size()/2;++i){
if(S[i] != S[S.size()-i-1]){
flag = false;
break;
}
}
return flag;
}
int main(){
ll n, m;
cin>>n>>m;
ll g[n][n];
for(ll i=0;i<n;++i){
for(ll j=0;j<n;++j){
if(i == j){
g[i][j] = 0;
}else{
g[i][j] = INF;
}
}
}
vector<ll> a(m), b(m), c(m);
for(ll i=0;i<m;++i){
cin>>a[i]>>b[i]>>c[i];
a[i]--;
b[i]--;
g[a[i]][b[i]] = min(g[a[i]][b[i]], c[i]);
g[b[i]][a[i]] = min(g[b[i]][a[i]], c[i]);
}
for(ll k=0;k<n;++k){
for(ll i=0;i<n;++i){
for(ll j=0;j<n;++j){
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
}
}
ll ans = m;
for(ll i=0;i<m;++i){
bool flag = false;
for(ll j=0;j<n;++j){
if(g[j][a[i]] + c[i] == g[j][b[i]]){
flag = true;
}
}
if(flag){
ans--;
}
}
cout<<ans<<endl;
return 0;
}
| 0
| 60,389,856
|
#include <iostream>
#include <vector>
#define ll long long
using namespace std;
ll stone[100010];
bool ch[100010];
ll dfs(int key, vector<vector<int>> &g){
ch[key]=1;
ll sum=0, mx=0;
int cnt=0;
for(int i=0; i<g[key].size(); ++i){
if(!ch[g[key][i]]){
++cnt;
ll p=dfs(g[key][i], g);
if(p<0) return -1;
sum += p;
mx=max(mx, p);
}
}
if(cnt==0) return stone[key];
if(cnt==1){
if(sum==stone[key]) return stone[key];
else return -1;
}
ll num_pair=sum-stone[key];
if(num_pair<0 || min(sum/2, sum-mx)<num_pair) return -1;
stone[key] -= num_pair;
return stone[key];
}
int main() {
int N;
cin >> N;
for(int i=1; i<=N; ++i) cin >> stone[i];
vector<vector<int>> v(N+1);
for(int i=1; i<N; ++i){
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
if(N==2){
cout << (stone[1]==stone[2] ? "YES" : "NO") << endl;
return 0;
}
int t=1;
while(v[t].size()==1) ++t;
if(dfs(t, v)==0) cout << "YES" << endl;
else cout << "NO" << endl;
return 0;
}
|
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <queue>
#include <numeric>
#include <string>
#include <string.h>
#include <map>
#include <set>
#include <functional>
#include <complex>
using namespace std;
const int INF = (1<<30) - 1;
const int T = 24 * 60 * 60;
int d[T];
int to_int(string s){
int res = 0;
res += ((s[0]-'0')*10 + s[1]-'0') * 3600;
res += ((s[3]-'0')*10 + s[4]-'0') * 60;
res += ((s[6]-'0')*10 + s[7]-'0');
return res;
}
int main(){
int N;
while(cin>>N, N){
memset(d, 0, sizeof(d));
while(N--){
string s, e;
cin >> s >> e;
d[to_int(s)]++;
d[to_int(e)]--;
}
for(int i=1; i<T; i++)
d[i] += d[i-1];
int ans = 0;
for(int i=0; i<T; i++)
ans = max(ans, d[i]);
cout << ans << endl;
}
return 0;
}
| 0
| 25,635,214
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pint = pair<int, int>;
using pll = pair<ll, ll>;
using edge = pair<int, ll>;
using Graph = vector<vector<int>>;
using WeightedGraph = vector<vector<edge>>;
const ll INF = 1LL << 60;
const int INF32 = 1 << 29;
const ll MOD = 1000000007;
int main(){
char c; cin >> c;
string ans = "consonant";
if(c=='a'||c=='e'||c=='i'||c=='o'||c=='u')ans = "vowel";
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MD=1e9+7;
long long n,dp[100005],pre[100005],ans;
vector<int> v;
string str;
long long qpow(long long b,long long exp) {
long long ret=1;
while (exp!=0) {
if (exp%2==1) {ret*=b; ret%=MD;}
b*=b; b%=MD;
exp/=2;
}
return ret;
}
int main() {
cin>>str; n=str.size();
for (int i=0; i<n; i++) {
if (str[i]=='1') v.push_back(n-i-1);
}
v.push_back(0);
dp[0]=1;
for (int i=1; i<=n; i++) dp[i]=qpow(3,i-1);
for (int i=1; i<=n; i++) {pre[i]=pre[i-1]+dp[i]; pre[i]%=MD;}
ans+=pre[n-1];
for (int i=0; i<v.size()-1; i++) {
ans+=((dp[v[i+1]+1]*qpow(2,i))%MD); ans%=MD;
}
cout<<(1+(2*ans)%MD)%MD<<'\n';
}
| 0
| 96,304,185
|
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <complex>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vP = vector<P>;
using vT = vector<T>;
using vvll = vector<vector<ll>>;
using vvP = vector<vector<P>>;
using dqll = deque<ll>;
ll dx[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
ll dy[9] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
const ll INF = 1LL << 50;
static const long long mod = 1000000007;
ll n, a, b, c;
vll ls;
ll dfs(ll d, ll an, ll bn, ll cn, ll ac, ll bc, ll cc){
if (d == n) {
if (ac == 0 || bc == 0 || cc == 0) return INF;
return abs(a - an) + abs(b - bn) + abs(c - cn) + 10*(ac-1) + 10*(bc-1) + 10*(cc-1);
}
ll ans = INF;
chmin(ans, dfs(d + 1, an + ls[d], bn, cn, ac+1, bc, cc));
chmin(ans, dfs(d + 1, an, bn + ls[d], cn, ac, bc+1, cc));
chmin(ans, dfs(d + 1, an, bn, cn + ls[d], ac, bc, cc+1));
chmin(ans, dfs(d + 1, an, bn, cn, ac, bc, cc));
return ans;
}
int main() {
cin >> n >> a >> b >> c;
ls.resize(n);
rep(i, n) cin >> ls[i];
ll ans = dfs(0, 0, 0, 0, 0, 0, 0);
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define ALL(v) (v).begin(), (v).end()
using ll = long long;
using P = pair<int, int>;
const int INF = 1e9;
const long long LINF = 1e18;
const long long MOD = 1e9 + 7;
signed main() {
int n;
cin >> n;
int mx = 0;
int a[n];
rep(i, n) {
cin >> a[i];
mx = max(mx, a[i]);
}
int mn = (mx + 1) / 2;
sort(a, a + n);
if (mx % 2 == 0) {
if (a[0] != mn || a[1] == mn) {
cout << "Impossible" << endl;
return 0;
}
} else {
if (a[0] != mn || a[1] != mn || a[2] == mn) {
cout << "Impossible" << endl;
return 0;
}
}
int cnt[mx + 1] = {};
for (int i = (mx % 2 == 0 ? 1 : 2); i < n; i++) {
cnt[a[i]]++;
}
for (int i = mn + 1; i <= mx; i++){
if(cnt[i] < 2){
cout << "Impossible" << endl;
return 0;
}
}
cout << "Possible" << endl;
return 0;
}
| 0
| 40,434,293
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n, m, k; cin >> n >> m >> k;
for (int i = 0; i <= n; i++) for (int j = 0; j <= m; j++) {
if (i * m + j * n - 2 * i * j == k) {
cout << "Yes\n";
return 0;
}
}
cout << "No\n";
return 0;
}
|
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
#include<vector>
#include<bitset>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
using namespace std;
template<class T>inline void read(T &res)
{
char c;T flag=1;
while((c=getchar())<'0'|c>'9')if(c=='-')flag=-1;res=c-'0';
while((c=getchar())>='0'&&c<='9')res=res*10+c-'0';res*=flag;
}
bitset<50>bit;
#define _for(i,a,b) for( int i=(a); i<(b); ++i)
#define rof(i,a,b) for( int i=b-1;i>=a;i--)
#define rep(i,a,b) for( int i=(a); i<=(b); ++i)
#define per(i,a,b) for( int i=(b); i>=a; --i)
#define sd(n) scanf("%d",&n)
#define sdd(n,m) scanf("%d %d",&n,&m)
#define sddd(n,m,k) scanf("%d %d %d",&n,&m,&k)
#define pd(n) printf("%d\n",n)
#define pd_(n) printf("%d ",n)
#define pdd(n,m) printf("%d %d",n,m)
#define pddd(n,m,k) printf("%d %d %d",n,m,k)
#define pld(n) printf("%lld\n",n)
#define pldd(n,m) printf("%lld %lld\n",n,m)
#define sld(n) scanf("%lld",&n)
#define sldd(n,m) scanf("%lld %lld",&n,&m)
#define slddd(n,m,k) scanf("%lld %lld %lld",&n,&m,&k)
#define sf(n) scanf("%lf",&n)
#define sff(n,m) scanf("lf",&n,&m)
#define sfff(n,m,k) scanf("%lf %lf %lf",&n,&m,&k)
#define ss(str) scanf("%s",str)
#define mm(a,n) memset(a, n, sizeof(a))
#define debug(x) cout << #x << ": " << x << endl
#define pb push_back
#define fi first
#define se second
#define mod(x) ((x)%MOD)
typedef long long ll;
typedef pair<int,int> PII;
typedef unsigned long long ull;
typedef long double ld;
const int N=1e9+7;
const int MOD = 1e9 + 7;
const double PI=atan(1.0)*4;
const int maxn=3e5+5;
int main()
{
ll n;
sld(n);
ll ans=0;
for(ll i=1;i*i<n;i++)
{
if(n%i==0)
{
ll m=n/i-1;
if(n%(m)==n/m)
ans+=m;
}
}
pld(ans);
return 0;
}
| 0
| 94,534,462
|
#include <iostream>
#include <queue>
using namespace std;
int main() {
priority_queue<int> A;
string command;
int target;
while(true) {
cin >> command;
if (command == "insert") {
cin >> target;
A.push(target);
} else if (command == "extract") {
cout << A.top() << endl;
A.pop();
} else {
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
long x;
cin >> n >> m >> x;
long c[n], a[n][m];
for (int i = 0; i < n; i++) {
cin >> c[i];
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
long min = -1;
int b = 0b0;
while (b++ < pow(2, n)) {
long total_price = 0;
vector<long> skills(m);
bool satisfied = true;
for (int i = 0; i < n; i++) {
total_price += ((b >> i) & 1)*c[i];
for (int j = 0; j < m; j++) {
skills[j] += ((b >> i) & 1)*a[i][j];
}
}
for (int j = 0; j < m; j++) {
if (skills[j] < x) {
satisfied = false;
break;
}
}
if (satisfied && (total_price < min || min == -1)) min = total_price;
}
cout << min;
return 0;
}
| 0
| 34,033,140
|
#include <algorithm>
#include <iostream>
using namespace std;
long long count(long long n) {
return n < 5 ? 0 : count(n / 5) + n / 5;
}
int main() {
long long n; cin >> n;
cout << (n % 2 == 0 ? count(n / 2) : 0) << '\n';
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main() {
int N; cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) cin >> A[i];
long long res = A[0] - 1;
int ma = 1;
for (int i = 1; i < N; i++) {
if (A[i] == ma + 1) ma++;
if (A[i] <= ma) continue;
res += (A[i]-1) / (ma+1);
}
cout << res << endl;
}
| 0
| 60,950,016
|
#include <cstdio>
#include <cstring>
#include <cctype>
int main () {
char c;
int ans[150];
for (int i=0; i< 150; i++) ans[i] = 0;
while (scanf("%c", &c) != EOF) {
char lower = tolower(c);
ans[lower] += 1;
}
for (int i=97; i<123; i++) {
printf("%c : %d\n", i, ans[i]);
}
return 0;
}
|
# include <cstdio>
# include <cmath>
#define M_PI 3.14159265358979323846
int n;
struct PointPair {
double x, y;
};
void koch(int k, PointPair p1, PointPair p2) {
if (k == 0)
return;
PointPair s, u, t;
double th = M_PI * 60.0 / 180.0;
s.x = (2.0 * p1.x + 1.0 * p2.x) / 3.0;
s.y = (2.0 * p1.y + 1.0 * p2.y) / 3.0;
t.x = (1.0 * p1.x + 2.0 * p2.x) / 3.0;
t.y = (1.0 * p1.y + 2.0 * p2.y) / 3.0;
u.x = (t.x - s.x) * cos(th) - (t.y - s.y) * sin(th) + s.x;
u.y = (t.x - s.x) * sin(th) + (t.y - s.y) * cos(th) + s.y;
koch(k - 1, p1, s);
printf("%.8f %.8f\n", s.x, s.y);
koch(k - 1, s, u);
printf("%.8f %.8f\n", u.x, u.y);
koch(k - 1, u, t);
printf("%.8f %.8f\n", t.x, t.y);
koch(k - 1, t, p2);
}
int main() {
scanf("%d", &n);
PointPair p1, p2;
p1.x = 0.0;
p1.y = 0.0;
p2.x = 100.0;
p2.y = 0.0;
printf("%.8f %.8f\n", p1.x, p1.y);
koch(n, p1, p2);
printf("%.8f %.8f\n", p2.x, p2.y);
return 0;
}
| 0
| 40,708,361
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 60;
const ll mod = 1e9 + 7;
vector<ll> a;
ll N;
bool isOK(ll start, ll goal) {
for(ll i = 0; i < N; i++) {
start -= (start % a[i]);
}
if(start >= goal)
return true;
else
return false;
}
ll binary_search(ll key) {
ll left = 1;
ll right = longinf;
while(right - left > 1) {
ll mid = left + (right - left) / 2;
if(isOK(mid, key))
right = mid;
else
left = mid;
}
return right;
}
int main() {
cin >> N;
a.resize(N);
for(int i = 0; i < N; i++) cin >> a[i];
ll under = binary_search(2);
ll upper = binary_search(3);
if(under >= upper)
cout << -1 << "\n";
else
cout << under << " " << upper - 1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
#define SS " "
#define endl "\n"
#define EPS 1e-9
#define gcd __gcd
#define pb push_back
#define pi acos(-1.0)
#define Ars greater<int>()
#define vi vector<int>
#define vvi vector<vector<int> >
#define flush cin.ignore(numeric_limits<streamsize>::max(),'\n');
#define wow ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
typedef long long ll;
typedef double dbl;
typedef unsigned long long ull;
ll lcm(ll a, ll b)
{
return (a/gcd(a, b))*b;
}
void solve()
{
int a, b, cnt=0;
cin>>a>>b;
for(int i=a; i<=b; i++)
{
string s, t;
s = to_string(i);
t = s;
reverse(s.begin(), s.end());
if(s == t)
cnt++;
}
cout<<cnt<<endl;
}
int main()
{
wow
int t=1;
while(t--)
solve();
return 0;
}
| 0
| 90,153,268
|
#include <bits/stdc++.h>
#define PI 3.1415926535897
using namespace std;
typedef long long ll;
const int INF = 1000000000;
const ll LINF = 1000000000000000000;
const double EPS = 1e-10;
int main(void)
{
string S;
cin >> S;
ll K;
cin >> K;
char ans;
for (int i = 0; i < K; i++)
{
if (S[i] == '1' && K == i + 1)
{
ans = '1';
}
else
{
if (S[i] != '1')
{
ans = S[i];
break;
}
}
}
cout << ans << endl;
return (0);
}
|
# include <iostream>
# include <string>
using namespace std;
typedef long long ll;
bool allCharSame(string s){
char c = s[0];
for(int i=1; i<s.size(); i++) if(s[i] != c) return false;
return true;
}
int main(){
string s;
ll k;
cin >> s >> k;
if(allCharSame(s)){
cout << s.size() * k / 2 << endl;
}
else{
ll front = 0;
while(s[front] == s[front+1]) front++;
front++;
ll back = s.size()-1;
while(s[back] == s[back-1]) back--;
back = s.size()-back;
ll ans = 0;
if(s[0] == s[s.size()-1]) {
ans += (front+back)/2 * (k-1);
}
else {
ans += ((front/2) + (back/2)) * (k-1);
}
ans += (front/2) + (back/2);
ll left = front;
ll right = left;
while(left < s.size()-back){
while(right + 1 < s.size()-back && s[left] == s[right+1]) right++;
ans += ((right-left+1)/2)*k;
left = right+1;
right = left;
}
cout << ans << endl;
}
return 0;
}
| 0
| 90,060,585
|
#include "bits/stdc++.h"
using namespace std;
int main() {
int N;
cin >> N;
map<string, int>mp;
for (int n = 0; n < N; ++n) {
string S;
cin >> S;
sort(S.begin(),S.end());
mp[S]++;
}
long long ans = 0;
auto begin = mp.begin(), end = mp.end();
for (auto iter = begin; iter != end; iter++) {
ans += (long long)iter->second*(iter->second-1)/2;
}
cout << ans <<endl;
return 0;
}
|
#define rep(i, n) for(int i = 0; i < (int)n; i++)
#define repi(i, a, b) for(int i = int(a); i < int(b); ++i)
#include <bits/stdc++.h>
#define M_PI 3.14159265358979323846
using namespace std;
typedef long long ll;
ll gcd(ll a, ll b) {
return b ? gcd(b, a % b) : a;
}
vector<pair<ll, int>> factorize(ll n) {
vector<pair<ll, int>> res;
for(ll i = 2; i * i <= n; i++) {
if(n % i)
continue;
res.emplace_back(i, 0);
while(n % i == 0) {
n /= i;
res.back().second++;
}
}
if(n != 1)
res.emplace_back(n, 1);
return res;
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b;
}
ll ceil(ll a, ll b) { return (a + b - 1) / b; }
const ll INF = LONG_MAX;
template <class T> inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return 1;
}
return 0;
}
const int dx[] = {1, 0};
const int dy[] = {0, 1};
template <typename T> struct BIT {
private:
vector<T> array;
const int n;
public:
BIT(int _n) : array(_n + 1, 0), n(_n) {}
T sum(int i) {
T s = 0;
while(i > 0) {
s += array[i];
i -= i & -i;
}
}
T sum(int i, int j) {
T ret_i = sum(i - 1);
T ret_j = sum(j);
return ret_j - ret_i;
}
void add(int i, T x) {
while(i <= n) {
array[i] += x;
i += i & -i;
}
}
};
int main() {
#ifdef LOCAL
std::ifstream in("code.txt");
std::cin.rdbuf(in.rdbuf());
#endif
int n, m, X, Y;
cin >> n >> m >> X >> Y;
vector<int> x(n), y(m);
rep(i, n) cin >> x[i];
sort(x.begin(), x.end());
rep(i, m) cin >> y[i];
sort(y.begin(), y.end());
for(int i = -100; i <= 100; i++) {
if(X < i && i <= Y) {
if(x.back() < i && i <= y.front()) {
cout << "No War";
return 0;
}
}
}
cout << "War";
return 0;
}
#if 0
struct node {
int to, weight;
};
using Edge = vector<node>;
void addEdge(bool directed, Edge *edges, int u, int v, int wt) {
edges[u].push_back({v, wt});
if(!directed) {
edges[v].push_back({u, wt});
}
}
int pre_node[100000];
void zeroOneBFS(Edge *edges, vector<int> &dist, int src) {
for(int i = 0; i < dist.size(); i++)
dist[i] = INT_MAX;
deque<int> Q;
dist[src] = 0;
Q.push_back(src);
while(!Q.empty()) {
int v = Q.front();
Q.pop_front();
for(int i = 0; i < edges[v].size(); i++) {
if(dist[edges[v][i].to] > dist[v] + edges[v][i].weight) {
dist[edges[v][i].to] = dist[v] + edges[v][i].weight;
pre_node[edges[v][i].to] = v;
if(edges[v][i].weight == 0)
Q.push_front(edges[v][i].to);
else
Q.push_back(edges[v][i].to);
}
}
}
for(int i = 0; i < dist.size(); i++)
cout << dist[i] << " ";
}
#endif
| 0
| 81,534,923
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N;
cin >> N;
long long res = 0;
for(long long a = 1; a <N; a++){
res += (N-1)/a;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int convert(char c) {
if (c == 'R') return 0;
if (c == 'G') return 1;
return 2;
}
int remain(char c1, char c2) {
if ((c1 == 'R' && c2 == 'G') || (c1 == 'G' && c2 == 'R')) return 2;
if ((c1 == 'R' && c2 == 'B') || (c1 == 'B' && c2 == 'R')) return 1;
return 0;
}
int main() {
int N; cin >> N;
string S; cin >> S;
long long cums[N][3] = {};
long long ans = 0;
cums[N-1][convert(S[N-1])] = 1;
for (int i = N - 2; i >= 0; i--) {
for (int j = 0; j < 3; j++) cums[i][j] = cums[i+1][j];
cums[i][convert(S[i])]++;
}
for (int i = 0; i < N - 2; i++) {
for (int j = i + 1; j < N - 1; j++) {
if (S[i] == S[j]) continue;
ans += cums[j+1][remain(S[i], S[j])];
int k = 2 * j - i;
if (k < N && convert(S[k]) == remain(S[i], S[j])) ans--;
}
}
cout << ans << endl;
}
| 0
| 87,931,186
|
#include <bits/stdc++.h>
using namespace std;
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; }
using ll = long long;
using P = pair<ll,ll>;
using grid = vector<vector<int>>;
const int dx[2] = {1, 0};
const int dy[2] = {0, 1};
const int INF = 1<<30;
const ll mod = 998244353LL;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int N,R;
cin>>N>>R;
if(N>=10) cout<<R<<endl;
else cout<<R+100*(10-N)<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
const ll INF=1LL<<60;
const double EPS = 1e-10;
const ll mod=1000000007;
int main(void){
ll k,a,b;
cin>>k>>a>>b;
if(b-a<=2){
cout<<k+1<<endl;
}
else{
ll x=k-(a-1);
ll ans=a;
if(x%2==1){
x--;
ans++;
}
ans+=(b-a)*x/2;
cout<<ans<<endl;
}
}
| 0
| 33,872,360
|
#include <bits/stdc++.h>
#define rep(i, n) for (long long i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair <int, int>;
const double PI = acos(-1);
const ll MOD = 1000000007;
int main() {
ll N;
cin >> N;
vector<ll> B(N);
rep(i,N){
ll x;
cin >> x;
B[i] = x - i - 1;
}
sort(B.begin(), B.end());
ll base = B[N/2];
ll ans = 0;
rep(i, N) ans += abs(B[i]-base);
cout << ans << endl;
}
|
#include<iostream>
#include<vector>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
vector<vector<char> >v(n,vector<char>(m));
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
cin>>v[i][j];
}
}
bool no=false;
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++){
if(v[i][j]=='#')
{
int count=0;
if(i>0&&v[i-1][j]=='#'){
count++;
}
if(i<n-1&&v[i+1][j]=='#'){
count++;
}
if(j>0&&v[i][j-1]=='#'){
count++;
}
if(j<m-1&&v[i][j+1]=='#'){
count++;
}
if(count==0)
{
no=true;
break;
}
}
if(no)
{
break;
}
}
}
if(no){
cout<<"No"<<endl;
}
else
{
cout<<"Yes"<<endl;
}
}
| 0
| 58,634,781
|
#include <bits/stdc++.h>
#define REP(i, n) for (int (i) = 0; (i) < (int)(n); i++)
#define FOR(i, a, b) for(int (i) = a; (i) < (int)b; i++)
#define RREP(i, n) for(int (i)=((int)(n)-1); (i)>=0; i--)
#define RFOR(i, a, b) for(int (i) =((int)(b)-1); (i)>=(int)a; i--)
#define ALL(v) (v).begin(),(v).end()
#define MOD 1000000007
#define FI first
#define SE second
#define MP make_pair
#define PB push_back
#define SZ(x) (int)x.size()
#define SP(x) setprecision((int)x)
using namespace std ;
typedef long long ll;
typedef vector<int> vint;
typedef vector<vint> vvint;
typedef vector<string> vstr;
typedef pair<int, int> pii;
const int INF = 1e9;
const ll LINF = 1e18;
const double EPS = 1e-9;
ll gcd(ll a, ll b) {return b ? gcd(b, a % b) : a;}
ll lcm(ll a, ll b) {return a / gcd(a, b) * b;}
int main()
{
int n ;
cin >> n ;
int cnt = 0 ;
ll h, w ;
cin >> h >> w ;
REP(i,n){
ll a, b ;
cin >> a >> b ;
if(a>=h && b>=w){
cnt++ ;
}
}
cout << cnt <<endl ;
return 0 ;
}
|
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
int n,q[40003];
long long ans,c[50];
int main(){
cin>>n;
char _a;
for(int i=1,_n=n+1;i<_n;i++){
cin>>_a;
switch(_a){
case 'R':
q[i]=1;
break;
case 'G':
q[i]=2;
break;
case 'B':
q[i]=4;
break;
}
c[q[i]]++;
}
ans=1ll*c[1]*c[2]*c[4];
for(int i=1,_m=n-1;i<_m;i++){
for(int j=i+1,_n=n+1;j<_n;j++){
ans-=((q[i]|q[j]|q[j+j-i])==7);
}
}
cout<<ans;
return 0;
}
| 0
| 2,105,256
|
#include <iostream>
using namespace std;
#define rep(i, n) for(int i=1;i<n;i++)
int main(){
int num;
cin >> num;
int count=0, ans=0;
rep(i, num+1){
if(i%2 == 1){
rep(j, i+1){
if(i%j == 0){
count++;
}
}
if(count == 8){
ans++;
}
count=0;
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
#include <set>
#include <queue>
#include <map>
#include <string>
#define rep(i, a, b) for ( int i = (a); i < (b); i++ )
#define per(i, a, b) for ( int i = (b)-1; i >= (a); i--)
#define pb push_back
#define mp make_pair
#define bg begin()
#define en end()
#define all(v) (v).begin(), (v).end()
#define sz(v) (int)(v).size()
using namespace std;
typedef long long ll;
typedef long double ld;
using P = pair<int, int>;
static const long long MOD = 1000000007;
static const long long LINF = (ll)(1e18+99);
static const int INF = 1e9+99;
int dist[105][105];
int A[1005], B[1005], C[1005];
int ans;
int main(void) {
int n, m;
cin >> n >> m;
rep(i, 0, 105) rep(j, 0, 105) {
if (i==j) dist[i][j] = 0;
else dist[i][j] = INF;
}
rep(i, 0, m) {
int a, b, c;
cin >> a >> b >> c;
a--; b--;
dist[a][b] = dist[b][a] = c;
A[i] = a;
B[i] = b;
C[i] = c;
}
for (int k=0; k<n; k++) {
for (int i=0; i<n; i++) {
for (int j=0; j<n; j++) {
dist[i][j] = min(dist[i][j], dist[i][k]+dist[k][j]);
}
}
}
for (int k=0; k<m; k++) {
bool flag = false;
int a = A[k], b = B[k], c = C[k];
for (int i=0; i<n; i++) {
for (int j=0; j<n; j++) {
if (dist[i][j]==dist[i][a]+dist[b][j]+c) flag = true;
}
}
if (!flag) ans++;
}
cout << ans << endl;
return 0;
}
| 0
| 8,716,698
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, s, e) for (int i = (int)(s); i < (int)(e); i++)
#define _rep(i, n) for (int i = (int)(n - 1); i >= 0; i--)
#define _REP(i, e, s) for (int i = (int)(e - 1); i >= (int)(s); i--)
#define yes cout << "yes" << endl;
#define Yes cout << "Yes" << endl;
#define YES cout << "YES" << endl;
#define no cout << "no" << endl;
#define No cout << "No" << endl;
#define NO cout << "NO" << endl;
#define AC cout << "AC" << endl;
#define WA cout << "WA" << endl;
#define out(s) cout << s << endl;
#define ll long long
#define ull unsigned long long
const unsigned int BIT_FLAG_0 = (1 << 0);
const unsigned int BIT_FLAG_1 = (1 << 1);
const unsigned int BIT_FLAG_2 = (1 << 2);
const unsigned int BIT_FLAG_3 = (1 << 3);
const unsigned int BIT_FLAG_4 = (1 << 4);
const unsigned int BIT_FLAG_5 = (1 << 5);
const unsigned int BIT_FLAG_6 = (1 << 6);
const unsigned int BIT_FLAG_7 = (1 << 7);
const double PI = 3.14159265358979323846;
const int dy[4] = {0, 1, 0, -1};
const int dx[4] = {1, 0, -1, 0};
#define H_MAX 500
#define W_MAX 500
#define INF 1e9 + 7
const ll mod = 1000000007;
int main() {
char al;
cin >> al;
if (isupper(al)) {
cout << "A" << endl;
} else {
cout << "a" << endl;
}
}
|
#include <iostream>
#include <string>
#include <utility>
#include <stack>
#include <vector>
#include <queue>
#include <algorithm>
#include <map>
#include <climits>
#include <set>
#include <cmath>
#include <numeric>
using namespace std;
string S[300];
int main(){
int N;
cin >> N;
for(int i = 0; i < N; i++){
cin >> S[i];
}
int ans = 0;
for(int i = 0; i < N; i++){
bool is_good_grid = true;
for(int j = 0; j < N; j++){
for(int k = 0; k < N; k++){
if(S[(j - i + N) % N][k] != S[(k - i + N) % N][j]){
is_good_grid = false;
break;
}
}
if(!is_good_grid){
break;
}
}
if(is_good_grid){
ans += N;
}
}
cout << ans << endl;
return 0;
}
| 0
| 72,001,031
|
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
vector<int> a(n);
REP(i, n) cin >> a[i];
if (n == k) cout << 1 << '\n';
else {
int ans = 1;
int tmp = n - k;
int div = tmp / (k - 1);
int mod = tmp % (k - 1);
if (mod) cout << ans + div + 1 << '\n';
else cout << ans + div << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#include <string>
#include <algorithm>
#include <string.h>
#include <ctype.h>
#include <math.h>
#include <float.h>
#include <iomanip>
#include <iostream>
using namespace std;
int gcd(int x,int y){
if(y==0)return x;
return gcd(y,x%y);
}
int lcm(int x,int y){
return x*y/gcd(x,y);
}
int main(){
int N[4]={};
for(int i=0;i<4;i++){
cin>>N[i];
}
sort(N,N+4);
if(N[0]==1
&&N[1]==4
&&N[2]==7
&&N[3]==9){
cout<<"YES"<<endl;
}else{
cout<<"NO"<<endl;
}
return 0;
}
| 0
| 74,849,817
|
#include<iostream>
using namespace std;
int main(){
int n;
while(cin>>n){
bool array[1000500];
for(int i=0;i<=n;i++){
array[i]=true;
}
int count=0;
array[0]=array[1]=false;
for(int i=1;i<=n;i++){
if(array[i]){
count++;
for(int j=i*2;j<=n;j+=i){
array[j]=false;
}
}
}
cout<<count<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void){
int W,H,N;
cin >> W >> H >> N;
int x[N],y[N],a[N];
for(int i = 0 ; i < N ; i++){
cin >> x[i] >> y[i] >> a[i];
}
bool judge[H][W];
for(int i = 0 ; i < H ; i++){
for(int j = 0 ; j < W ; j++){
judge[i][j] = true;
}
}
for(int k = 0 ; k < N ; k++){
if(a[k] == 1){
for(int i = 0 ; i < H ; i++){
for(int j = 0 ; j < x[k] ; j++){
judge[i][j] = false;
}
}
}else if(a[k] == 2){
for(int i = 0 ; i < H ; i++){
for(int j = x[k] ; j < W ; j++){
judge[i][j] = false;
}
}
}else if(a[k] == 3){
for(int i = 0 ; i < y[k] ; i++){
for(int j = 0 ; j < W ; j++){
judge[i][j] = false;
}
}
}else if(a[k] == 4){
for(int i = y[k] ; i < H ; i++){
for(int j = 0 ; j < W ; j++){
judge[i][j] = false;
}
}
}
}
int counter = 0;
for(int i = 0 ; i < H ; i++){
for(int j = 0 ; j < W ; j++){
if(judge[i][j] == true){
counter++;
}
}
}
cout << counter << endl;
return 0;
}
| 0
| 69,024,302
|
#include<iostream>
#include<map>
using namespace std;
#define repa(i,a,n) for(int i=(a);i<(n);i++)
#define rep(i,n) for(int i=0;i<(n);i++)
#define df 0
typedef long int li;
int main(){
string s; cin >> s;
rep(i,4) cout << s[i];
cout << " ";
repa(i,4,s.size()) cout << s[i];
cout << "\n";
}
|
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <iostream>
#include <istream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <tuple>
#include <iomanip>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define rep(i, n) for(ll i = 0; i < (n); i++)
#define revrep(i, n) for(ll i = (n)-1; i >= 0; i--)
#define pb push_back
#define f first
#define s second
#define chmin(x, y) x = min(x, y);
#define chmax(x, y) x = max(x, y);
const ll INFL = 1LL << 60;
const ll INF = INFL;
ll MOD = 998244353;
vector<ll> dy = {0, -1, 0, 1, 1, 1, -1, -1, 0};
vector<ll> dx = {1, 0, -1, 0, 1, -1, 1, -1, 0};
void pres(double A, ll x = 10){cout << fixed << setprecision(x) << A << endl;}
void BinarySay(ll x, ll y = 60){rep(i, y) cout << (x>>(y-1-i) & 1); cout << endl;}
ll get_bit(ll x){return __builtin_popcountll(x);}
ll pow_long(ll x, ll k){
ll res = 1;
while(k > 0){
if(k % 2) res *= x;
x *= x;
k /= 2;
}
return res;
}
ll pow_mod(ll x, ll k){
ll res = 1;
while(k > 0){
if(k % 2){
res *= x; res %= MOD;
}
x *= x; x %= MOD;
k /= 2;
}
return res;
}
ll inverse(ll x){return pow_mod(x, MOD - 2);};
ll gcd(ll a, ll b){
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll x, ll y){return x / gcd(x, y) * y;};
ll kai_mod(ll x){
if(x == 0) return 1;
return x * kai_mod(x-1) % MOD;
}
vector<ll> divisor(ll n){
vector<ll> res(0);
for(ll i = 1; i * i <= n; i++){
if(n % i == 0){
res.push_back(i);
if(i != n/i) res.push_back(n/i);
}
}
sort(res.begin(), res.end());
return res;
}
vector<ll> MakePrimeList(ll x) {
vector<ll> res;
for(ll k=2; k*k<=x; k++) {
if(x % k == 0) {
res.pb(k);
while(x % k == 0) x /= k;
}
}
if(x > 1) res.push_back(x);
return res;
}
const int MAXcomb = 2000100;
ll fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];
void COMinit(){
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(int i = 2; i < MAXcomb; i++){
fac[i] = fac[i-1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD/i) % MOD;
finv[i] = finv[i-1] * inv[i] % MOD;
}
}
ll comb(int n, int k){
if(n < k) return 0;
if(n < 0 || k < 0) return 0;
return fac[n] * finv[k] % MOD * finv[n-k] % MOD;
}
ll disit(ll x, ll d = 10){
ll res = 0;
while(x){
res++;
x /= d;
}
return res;
}
void solve(){
ll N;
cin >> N;
vector<ll> A(N, 0);
rep(i, N){
ll a;
cin >> a;
A[a-1]++;
}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
ll canuse = N, erased_num = 0;
ll s = 0;
vector<ll> ok(N+1, 0);
for(ll ans = N; ans >= 1; ans--){
while(ans < A[s]){
canuse -= (A[s] - ans);
erased_num++;
s++;
}
chmax(ok[canuse / ans], ans);
canuse -= erased_num;
}
revrep(i, N){
if(ok[i] == 0) ok[i] = ok[i+1];
}
rep(i, N){
cout << ok[i+1] << endl;
}
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
solve();
}
| 0
| 29,428,882
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <deque>
#include <queue>
#include <list>
#include <stack>
#include <string>
#include <tuple>
#include <functional>
#include <numeric>
#include <cmath>
#include <iomanip>
#include <map>
#include <random>
#include <cstdlib>
#define INT_MAX 2147483647
#define INT_MIN -2147483646
#define Loop(i, n) for(int i = 0; i < (int)n; i++)
#define Loop1(i, n) for(int i = 1; i <= (int)n; i++)
#define Loopr(i, n) for(int i = (int)n - 1; i >= 0; i--)
#define Loopr1(i, n) for(int i = (int)n; i >= 1; i--)
using namespace std;
typedef long long int ll;
int memo[105][105];
int r[105], c[105];
int func(int a, int b) {
if (memo[a][b] != INT_MIN) return memo[a][b];
if (b - a == 0) {
memo[a][b] = 0;
}
else {
int m = INT_MAX;
for (int k = a;k < b;k++) {
m = min(m, func(a, k) + func(k + 1, b) + r[a] * c[k] * c[b]);
}
memo[a][b] = m;
}
return memo[a][b];
}
int main() {
int n;
cin >> n;
Loop(i, n) {
Loop(j, n) {
memo[i][j] = INT_MIN;
}
}
Loop(i, n) {
cin >> r[i] >> c[i];
}
cout << func(0, n - 1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define FR first
#define SE second
using namespace std;
typedef pair<int,int> pr;
int num[200005];
pr st[400005];
bool check(int n,int d) {
int top=0;
for(int i=1;i<=n;i++)
if (num[i]>num[i-1]) st[++top]=pr(1,num[i]-num[i-1]);
else {
int len=num[i-1];
while (len>num[i])
if (len-st[top].SE>=num[i]) len-=st[top--].SE;
else {
st[top].SE-=len-num[i];
break;
}
while (top&&st[top].FR==d) len-=st[top--].SE;
if (!top) return 0;
if (st[top].SE>1) {
st[top].SE--;
st[++top]=pr(1,1);
}
st[top].FR++;
if (len<num[i]) st[++top]=pr(1,num[i]-len);
}
return 1;
}
int main() {
int n;
scanf("%d",&n);
bool v=1;
for(int i=1;i<=n;i++) {
scanf("%d",&num[i]);
if (num[i]<=num[i-1]) v=0;
}
if (v) {
puts("1");
return 0;
}
int l=2,r=n;
while (l<r) {
int m=((l+r)>>1);
if (check(n,m)) r=m; else l=m+1;
}
printf("%d\n",l);
return 0;
}
| 0
| 12,022,336
|
#include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
#define rep(i,a,b) for (int i = (a); i < (b); i++ )
typedef pair<int,int> P;
typedef long long ll;
const int INF = 100000000;
const double PI=3.14159265358979323846;
int main () {
ll X,Y;
cin >> X >> Y;
ll ans = 0;
ll tmp = X;
while(tmp<=Y) {
tmp*=2;
ans++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
char s[4];
scanf("%s", s);
map <char, int> freq;
for(int i = 0; i < 4; i++){
freq[s[i]]++;
if(freq[s[i]] >= 3)
return puts("No"), 0;
}
for(auto x : freq){
if(x.second != 2)
return puts("No"), 0;
}
puts("Yes");
return 0;
}
| 0
| 37,347,743
|
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <deque>
#include <queue>
#include <fstream>
#include <iomanip>
#include <stack>
#include <algorithm>
#include <set>
#include <map>
#include <list>
#define endl "\n"
typedef long long ll;
using namespace std;
void Lancer() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); }
bool isPrime(ll n){
if (n == 2 || n == 3 || n == 5)
return true;
else if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n == 1)
return false;
else {
for (int i = 5; i <= sqrt(n); i += 2){
if (n%i == 0)
return false;
}
return true;
}
}
int arr[100007];
int main(){
Lancer();
ll t, res = 0;
string str;
cin >> str;
for (int i = str.length() - 2; i >= 0; i--){
if (i % 2 != 0){
bool ch = true;
int k = i;
for (int j = i / 2; j >= 0; j--){
if (str[j] != str[k--]){
ch = false;
break;
}
}
if (ch){
res = i + 1;
break;
}
}
}
cout << res;
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
#define MODV 1000000007
#define INFLL (1LL<<62)
#define EPS 1e-9
#define rep(i, n) for(ll i=0, i##_len=(ll)(n); i<i##_len; i++)
#define repf(i, n) for(ll i=1, i##_len=(ll)(n+1); i<i##_len; i++)
#define all(v) v.begin(), v.end()
#define endl "\n"
#define vi vector<ll>
#define vvi vector<vector<ll>>
#define Yes() cout << "Yes" << endl
#define YES() cout << "YES" << endl
#define No() cout << "No" << endl
#define NO() cout << "NO" << endl
#define Init() std::ios::sync_with_stdio(false); std::cin.tie(0); std::cout<<fixed<<setprecision(15);
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; }
using namespace std;
void count(map<ll, ll> &cnt, ll num){
for(ll i=0; i<=40; i++) if(num & (1LL << i)) cnt[i]++;
}
int main(){
Init();
ll n, k;
cin >> n >> k;
vi a(n), cand;
rep(i, n) cin >> a[i];
for(ll i=0; i<n; i++){
ll pre = 0;
for(ll j=i; j<n; j++){
pre += a[j];
cand.emplace_back(pre);
}
}
ll ans = 0;
for(ll i=40; i>=0; i--){
ll cnt = 0;
ans += (1LL << i);
for(ll c=0; c<cand.size(); c++) if((ans&cand[c]) == ans) cnt++;
if(cnt < k) ans -= (1LL << i);
}
cout << ans << endl;
}
| 0
| 88,623,919
|
#include <bits/stdc++.h>
#include <vector>
# include <cstdint>
#define FOR(i,l,r) for(int i=(l);i<(r);++i)
#define RFOR(i,l,r) for(int i=(l);i>=(int)(r);i--)
#define rep(i,n) FOR(i,0,n)
#define rrep(i,n) RFOR(i,n-1,0)
#define int long long
using namespace std;
const int MX = 1e6;
const int inf = 1e9;
const int mod = 1e9+7;
#define ll long long
signed main() {
int n;
cin >> n;
int a[n];
rep(i,n) cin >> a[i];
if(n%2==0) {
rep(i,n/2) cout << a[n-1-i*2]<<" " << flush;
rep(i,n/2) cout << a[i*2]<<" " << flush;
}else {
rep(i,n/2+1) cout << a[n-1-i*2]<<" " << flush;
rep(i,n/2) cout << a[i*2+1]<<" " << flush;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 1e5+5;
int n, t[MAXN], v;
vector<int> g[MAXN];
int s[MAXN];
void dfs(int v, int f = -1) {
s[v] = 1;
int ct = 0;
for (int u : g[v]) {
if (u != f) {
dfs(u, v);
s[v] += s[u];
ct += s[u]%2;
}
}
ct += (n-s[v])%2;
if (ct >= 2) {
cout << "First\n";
exit(0);
}
}
int main() {
cin >> n;
for (int i = 0; i < n-1; ++i) {
int a, b;
cin >> a >> b;
a--; b--;
g[a].push_back(b);
g[b].push_back(a);
}
dfs(0);
cout << "Second\n";
return 0;
}
| 0
| 99,454,943
|
#include <bits/stdc++.h>
using namespace std;
const string color = "RYGB";
int H,W,d;
int main() {
cin>>H>>W>>d;
for (int h=0;h<H;h++) {
for (int w=0;w<W;w++) {
int d1 = h+w;
int d2 = h-w+W-1;
int num = d1/d % 2 * 2 + d2/d % 2 * 3;
cout << color[num%4];
}
cout<<endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int a[100000];
int main(){
int n;
scanf("%d",&n);
memset(a,0x3f,sizeof(a));
for(int i=0,x;i<n;i++){
scanf("%d",&x);
*lower_bound(a,a+n,x)=x;
}
printf("%d\n",lower_bound(a,a+n,0x3f3f3f3f)-a);
return 0;
}
| 0
| 22,160,922
|
#include <bits/stdc++.h>
#define int long long int
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n,k;
cin>>k>>n;
int t,t2;
int s=0;
int maxi=INT_MIN;
int f;
cin>>s;
f=s;
int sum=0;
for(int i=0;i<n-1;i++)
{
cin>>t;
t2=t;
t = t-s;
sum +=t;
maxi = max(maxi,t);
s=t2;
}
maxi = max(maxi,k-sum);
cout<<k-maxi;
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#define rep(i, n) for(int i = 0; i < (int)(n); ++i)
#define REP(i, n) for(int i = 1; i < (int)(n); ++i)
using namespace std;
int main() {
int N;
string s, t;
cin >> N >> s >> t;
reverse(s.begin(), s.end());
for (int i = N; i >= 0; --i) {
string str = s.substr(0, i);
reverse(str.begin(), str.end());
if (str == t.substr(0, i)) {
cout << 2 * N - i << endl;
return 0;
}
}
return 0;
}
| 0
| 66,057,561
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll n, m, x, y;
cin >> n >> m >> x >> y;
ll mx = x;
ll my = y;
for (ll i = 0; i < n; ++i) {
ll u;
cin >> u;
mx = max(mx, u);
}
for (ll i = 0; i < m; ++i) {
ll u;
cin >> u;
my = min(my, u);
}
if (mx < my) {
cout << "No War" << endl;
} else {
cout << "War" << endl;
}
}
|
#include <iostream>
using namespace std;
int main(void) {
string s;
int m, h, c, n, i;
while (1) {
cin >> s;
if (s == "-") break;
cin >> m;
n = s.size();
c = 0;
for (i = 0; i < m; i++) {
cin >> h;
c = (c + h) % n;
}
cout << s.substr(c) << s.substr(0, c) << endl;
}
return 0;
}
| 0
| 26,055,200
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pi 3.141592653589793238
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
int main(){
fast;
ll a,b;
cin>>a>>b;
cout<<2*b-a;
return 0;
}
|
#include<bits/stdc++.h>
#include <iostream>
using namespace std;
int main()
{
#ifdef LOCAL_EXEC
#else
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#endif
vector<long long int>vt;
long long int i,n,j;
cin>>n;
long long int A[n+1];
bool ok=true;
vt.push_back(1);
for(i=0;i<=n;i++){
cin>>A[i];
if(A[i]>vt[vt.size()-1])
ok=false;
if((vt[i]-A[i])*2<1e18)
vt.push_back(max(0ll,(vt[i]-A[i])*2));
else
vt.push_back(1e18);
}
if(n==0&&A[0]!=1)
ok=false;
if(ok==false)
cout<<-1;
else{
long long int sum=0,dp[n+1];
dp[n]=A[n];
for(i=n-1;i>=0;i--){
dp[i]=A[i]+dp[i+1];
dp[i]=min(vt[i],dp[i]);
}
for(i=0;i<=n;i++){
sum+=dp[i];
}
cout<<sum;
}
return 0;
}
| 0
| 65,913,196
|
#include<bits/stdc++.h>
#define MAX 1000000
using namespace std;
int main(){
vector<int> prime(MAX,1);
vector<int> ans;
prime[0] = 0;
prime[1] = 0;
prime[2] = 1;
for(int i=4;i<MAX;i+=2)
prime[i] = 0;
for(int i=3;i<sqrt(MAX);i+=2)
for(int j=i+i;j<MAX;j+=i)
prime[j] = 0;
int n;
while(cin>>n){
int cnt = 0;
for(int i=0;i<=n;++i)
if(prime[i]==1)
cnt++;
cout<<cnt<<endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int a[101];
float avg(int * a, int n) {
float mean = 0;
for (int i = 0; i < n; i++) {
mean += a[i];
}
mean /= n;
return mean;
}
int main() {
int n;
cin >> n;
int int_mean = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
float mean = avg(a, n);
if (mean < 0) {
int_mean = mean - 0.5;
}
else {
int_mean = mean + 0.5;
}
long long result = 0;
for (int i = 0; i < n; i++) {
result += (a[i] - int_mean) * (a[i] - int_mean);
}
cout << result << endl;
return 0;
}
| 0
| 34,769,935
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll Q, H, S, D, N;
cin >> Q >> H >> S >> D >> N;
ll P = 0;
ll m = min (D, S * 2);
m = min(m, H * 4);
m = min(m, Q * 8);
if (m == D) {
ll PD = N / 2 * D;
ll m2 = min(S, H * 2);
m2 = min(m2, Q * 4);
ll PS = (N % 2) * m2;
P = PD + PS;
}
else P = N * m / 2;
cout << P << endl;
}
|
#include <bits/stdc++.h>
#include <numeric>
using namespace std;
#define ll long long
#define mod107 1000000007
#define rep(i, n) for (int i = 0; i < n; ++i)
using Graph = vector<vector<int>>;
#define grepq priority_queue<double, std::vector<double>, std::greater<double>>
#define all(v) v.begin(), v.end()
#define PI acos(-1)
const ll INF = 10010001010;
const int inf = 1000034000;
typedef vector<ll> vecl;
typedef vector<int> veci;
typedef tuple<string, int, int> TUP;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
int main()
{
string S;
cin >> S;
string ans;
for (int i = 0; i < S.size(); i++)
{
if(S[i] == '0'){
ans += '0';
}
else if(S[i] == '1'){
ans += '1';
}
else{
if(ans.size() != 0){
ans.erase(ans.size()-1);
}
}
}
cout << ans << endl;
}
| 0
| 18,018,867
|
#include <stdio.h>
int main(){
int A;
scanf("%d", &A);
int B;
scanf("%d", &B);
if(A==1 && B==3){
printf("2");
}
else if(A==1 && B==2){
printf("3");
}
else if(A==2 && B==3){
printf("1");
}
else if(A==3 && B==1){
printf("2");
}
else if(A==2 && B==1){
printf("3");
}
else if(A==3 && B==2){
printf("1");
return 0;
}
}
|
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
using namespace std;
typedef long long ll;
int dfs(int h,int n, int sum,int s){
if(h==10){
if(sum == s && n == 0) return 1;
return 0;
}
return dfs(h+1,n-1,sum+h,s)+dfs(h+1,n,sum,s);
}
int main(){
int n,s;
while(1){
scanf("%d%d",&n,&s);
if(n==0) break;
printf("%d\n",dfs(0,n,0,s));
}
return 0;
}
| 0
| 51,258,318
|
#include<bits/stdc++.h>
using namespace std;
#define arep(i,x,n) for(int i=int(x);i<(int)(n);i++)
#define rep(i,n) for(long long i = 0;i < n;++i)
#define pi 3.141592653589793
#define eps 0.00000001
#define INF 1e9+7
using ll = long long;
using P=pair<int,int>;
using lP=pair<ll,ll>;
using fP=pair<double,double>;
ll const mod=998244353;
const ll MAX=300000;
using vi=vector<int>;
using vc=vector<char>;
using vs=vector<string>;
using vvi =vector<vector<int>>;
using vvc=vector<vector<char>>;
using vvp =vector<vector<P>>;
int main(){
int n;
cin>>n;
vvi c(n,vi(26));
rep(i,n){
string s;
cin>>s;
rep(j,s.size()){
c[i][s[j]-'a']++;
}
}
vc ans;
rep(i,26){
bool ok=true;
int cnt=INF;
rep(j,n){
if(c[j][i]==0){
ok=false;
break;
}
else cnt=min(cnt,c[j][i]);
}
if(ok){
rep(j,cnt)ans.push_back((char)(i+'a'));
}
}
rep(i,ans.size())cout<<ans[i];
cout<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define optimize() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define file() freopen("input.txt","r",stdin);freopen("output.txt","w",stdout);
#define tt int t; cin>>t; while(t--)
#define nl cout<<"\n";
#define sp cout<<" ";
#define rep(i, a, b) for(long long i=a; i<b; i++)
const int INF = 1e9 + 7;
const int MOD = 1e9 + 7;
double PI = 4*atan(1);
int main()
{
optimize();
int a[3], k;
cin>> a[0]>> a[1]>> a[2]>> k;
int i=0, sum=0;
while(k!=0)
{
if(i==2)
sum-= min(k, a[i]);
else if(i== 0)
sum+= min(k, a[i]);
k-=(min(k, a[i]));
i++;
}
cout<< sum;
nl;
return 0;
}
| 0
| 53,275,542
|
#include<bits/stdc++.h>
using namespace std;
#define endl "\n"
#define for(i,a,b) for(int i = a;i<b;i++)
int main()
{
int n,l;
cin>>n>>l;
string a[n];
for(i,0,n) cin>>a[i];
for(i,0,n-1){
for(j,i+1,n){
if(a[i]>a[j]){
swap(a[i],a[j]);
}
}
}
for(i,0,n) cout<<a[i];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> Pii;
typedef pair<ll,ll> Pll;
#define rep(i,n) for (ll i=0;i<n;++i)
#define rep2(i,a,b) for (ll i=a;i<b;++i)
const ll MOD=1000000007;
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;
vector<ll> a(N),b(N);
rep(i,N){
a[i]=N*i+1;
b[N-1-i]=N*i+1;
}
rep(i,N){
ll p;
cin >> p;
p--;
a[p]+=i;
b[p]+=i;
}
rep(i,N){
cout << a[i];
if (i!=N-1){
cout << ' ';
}
else {
cout << endl;
}
}
rep(i,N){
cout << b[i];
if (i!=N-1){
cout << ' ';
}
else {
cout << endl;
}
}
}
| 0
| 78,385,250
|
#include <cstdio>
#include <cstring>
#include <string>
#include <iostream>
#include <cmath>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <algorithm>
using namespace std;
typedef long long int ll;
typedef pair<ll, int> P;
int main()
{
int w, h;
scanf("%d %d", &w, &h);
vector<P> v;
for(int i=0; i<w; i++){
ll p;
scanf("%lld", &p);
v.push_back(P(p, 0));
}
for(int i=0; i<h; i++){
ll q;
scanf("%lld", &q);
v.push_back(P(q, 1));
}
ll c0=0, c1=0;
sort(v.begin(), v.end());
ll ans=0;
for(auto p:v){
int t=p.second;
ll x=p.first;
if(t==0){
ans+=(x*((ll)h+1-c1));
c0++;
}else{
ans+=(x*((ll)w+1-c0));
c1++;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod=1000000007;
const int N=100005;
vector<int> v[N];
array<ll,2> dfs(int a,int p=-1)
{
array<ll,2> now={1,1};
for(int to:v[a])
{
if(to==p) continue;
array<ll,2> nxt=dfs(to,a);
now[0]=(now[0]*(nxt[0]+nxt[1]))%mod;
now[1]=(now[1]*nxt[0])%mod;
}
return now;
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for(int i=0;i<n-1;i++)
{
int a,b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
array<ll,2> a=dfs(1);
cout << (a[0]+a[1])%mod << "\n";
return 0;
}
| 0
| 23,601,949
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
using P = pair<string,int>;
const double PI = acos(-1);
int main() {
int n;
cin >> n;
vector<int> h(n);
rep(i,n) cin >> h.at(i);
if(n == 1){
cout << 0 << endl;
return 0;
}
vector<int> a(n-1);
rep(i,n-1){
a.at(i) = h.at(i)-h.at(i+1);
}
vector<int> b;
int x = 0;
rep(i,n-1){
if(a.at(i) >= 0){
x++;
if(i == n-2) b.push_back(x);
}
else{
b.push_back(x);
x = 0;
}
}
sort(b.begin(),b.end());
cout << b.back() << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef double db;
typedef string str;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
#define pb push_back
#define f first
#define s second
#define all(x) x.begin(), x.end()
#define endl '\n'
const ll MOD = 1000000007;
int main() {
int H, W, M; scanf("%d%d%d", &H, &W, &M);
vector<int> rowCnt(H), colCnt(W);
set<pi> m;
for (int i = 0; i < M; i++) {
int h, w; scanf("%d%d", &h, &w);
m.insert({h - 1, w - 1});
rowCnt[h - 1]++;
colCnt[w - 1]++;
}
int maxRow = 0, maxCol = 0;
for (int i : rowCnt)
maxRow = max(maxRow, i);
for (int i : colCnt)
maxCol = max(maxCol, i);
vector<int> maxRowIdx;
for (int i = 0; i < H; i++)
if (rowCnt[i] == maxRow) maxRowIdx.pb(i);
vector<int> maxColIdx;
for (int i = 0; i < W; i++)
if (colCnt[i] == maxCol) maxColIdx.pb(i);
int ans = maxRow + maxCol - 1;
if (maxRowIdx.size() * maxColIdx.size() <= M) {
for (int i : maxRowIdx) {
for (int j : maxColIdx)
if (m.find({i, j}) == m.end()) ans = maxRow + maxCol;
}
} else {
ans += 1;
}
printf("%d", ans);
return 0;
}
| 0
| 53,006,621
|
#include<stdio.h>
#include<queue>
#include<math.h>
#include<time.h>
#include<string.h>
#include<vector>
#include<algorithm>
#include<iostream>
#include<set>
#include<map>
#include<stack>
#define LL long long
#define mem(a,b) memset(a,b,sizeof(a))
#define lowbit(a) a&(-a)
#define PI acos(-1)
#define shortime(a) std::ios::sync_with_stdio(a);
using namespace std;
LL quick(LL x,LL n,LL mod){ LL ans=1,temp=x; while(n){if(n%2==1){ ans=(ans*temp)%mod;} n/=2;temp=temp*temp%mod;}return ans%mod;}
int maxn (int a,int b,int c){return max(max(a,b),max(b,c));}
LL min(LL a,LL b) {return a<b?a:b;}
int gcd (int a,int b){return b==0?a:gcd(b,a%b);}
typedef pair <int ,int >node;
deque<node> Q;
int main()
{
int n;
scanf("%d",&n);
node x;
int vis[100005]={0};
x.first=1;x.second=1;
Q.push_front(x);
while (!Q.empty())
{
node x=Q.front();
Q.pop_front();
if(vis[x.first]) continue;
vis[x.first]=1;
if(x.first==0) {
printf("%d\n",x.second);
return 0;
}
node temp=x;
temp.first=(x.first*10)%n;
Q.push_front(temp);
temp=x;
temp.first=(x.first+1)%n;
temp.second++;
Q.push_back(temp);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define INF 1001000100010001000
#define MOD 1000000007
#define EPS 1e-10
#define int long long
#define rep(i, N) for (int i = 0; i < N; i++)
#define Rep(i, N) for (int i = 1; i < N; i++)
#define For(i, a, b) for (int i = (a); i < (b); i++)
#define pb push_back
#define eb emplece_back
#define mp make_pair
#define i_i pair<int, int>
#define vi vector<int>
#define vvi vector<vi >
#define vb vector<bool>
#define vvb vector<vb >
#define vp vector< i_i >
#define Edge pair< i_i, int>
#define all(a) (a).begin(), (a).end()
#define Int(x) int x; scanf("%lld", &x);
#define int2(x, y) int x, y; scanf("%lld %lld", &x, &y);
#define fir first
#define sec second
#define ffir first.first
#define fsec first.second
#define sfir second.first
#define ssec second.second
signed main()
{
int2(b, a);
while (a) {
Int(n);
vvi dp(a+1, vi(b+1, 0));
vvb state(a, vb(b, true));
rep(i, n) {
int2(c, d);
state[d-1][c-1] = false;
}
dp[0][0] = 1;
rep(i, a) {
rep(j, b) {
if (state[i][j]) {
dp[i+1][j] += dp[i][j];
dp[i][j+1] += dp[i][j];
}
}
}
cout << dp[a-1][b-1] << endl;
cin >> b >> a;
}
return 0;
}
| 0
| 30,554,281
|
#include<bits/stdc++.h>
#include<limits.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
static const int N = 100;
int main(){
int n;
vector<int> p(N+1);
vector<vector<int>> m(N+1, vector<int>(N+1, 0));
cin >> n;
for(int i = 1; i <= n; i++){
cin >> p.at(i - 1) >> p.at(i);
}
for(int l = 2; l <= n; l++){
for(int i = 1; i <= n - l + 1; i++){
int j = i + l - 1;
m.at(i).at(j) = (1 << 21);
for(int k = i; k <= j - 1; k++){
m.at(i).at(j) = min(m.at(i).at(j), m.at(i).at(k) + m.at(k + 1).at(j) + p.at(i - 1) * p.at(k) * p.at(j));
}
}
}
cout << m.at(1).at(n) << endl;
}
|
#include <iostream>
using namespace std;
const int big_month = 20;
const int small_month = 19;
const int ordinal_year = big_month * 5 + small_month * 5;
const int special_year = big_month * 10;
const int three_years = ordinal_year * 2 + special_year;
const int millennium = three_years * 333 + 1;
int count_day_from_first(int y, int m, int d) {
int day = 0;
if (y % 3 == 0) {
day += three_years * ((y-1) / 3);
day += ordinal_year * ((y-1) % 3);
day += big_month * (m-1);
day += d;
} else {
day += three_years * ((y-1) / 3);
day += ordinal_year * ((y-1) % 3);
day += (big_month + small_month) * ((m-1) / 2);
if ((m-1) % 2 == 1) {
day += big_month;
}
day += d;
}
return day;
}
int main() {
int n; cin >> n;
for (int i = 0; i < n; i++) {
int y, m, d; cin >> y >> m >> d;
cout << millennium - count_day_from_first(y, m, d) << endl;
}
return 0;
}
| 0
| 26,500,421
|
#include <bits/stdc++.h>
#define f(i,j,k) for(int i=j;i<k;i++)
using namespace std;
int main(){
long long n;
cin>>n;
vector<long long> a;
for(long long i=1;i*i<=n;i++){
if(n%i==0){
a.push_back(i+n/i-2);
}
}
sort(a.begin(),a.end());
cout<<a[0]<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int H,W;
int dh[4] = {1,0,-1,0};
int dw[4] = {0,1,0,-1};
cin >> H >> W;
vector<vector<char>>c(H,vector<char>(W,' '));
vector<vector<int>>dist(H,vector<int>(W,-1));
queue<pair<int,int>>que;
for(int i = 0; i < H; i++)
{
for(int j = 0; j < W; j++)
{
cin >> c[i][j];
if(c[i][j] == '#') dist[i][j] = 0,que.push(pair(i,j));
}
}
int ans = 0;
while(!que.empty())
{
pair<int,int>p = que.front();
que.pop();
for(int i = 0; i < 4; i++)
{
pair<int,int> np = pair(p.first + dh[i], p.second + dw[i]);
if((np.first < 0)||(np.first >= H)||(np.second < 0)||(np.second >= W)) continue;
if(dist[np.first][np.second] != -1) continue;
dist[np.first][np.second] = dist[p.first][p.second] + 1;
ans = max(ans,dist[np.first][np.second]);
que.push(np);
}
}
cout << ans << endl;
}
| 0
| 56,940,635
|
#include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> sticks(n);
for (size_t i = 0; i < n; ++i) cin >> sticks[i];
sort(sticks.begin(), sticks.end(), greater<int>());
cout << accumulate(sticks.begin(), sticks.begin() + k, 0) << endl;
return EXIT_SUCCESS;
}
|
#include<bits/stdc++.h>
using namespace std;
long long N;
long long x[1005];
long long y[1005];
int main(){
cin >> N;
bool ok = true;
for(long long i = 0; i < N; i++){
cin >> x[i] >> y[i];
if(i != 0){
if((abs(x[0]) + abs(y[0]))%2 != (abs(x[i]) + abs(y[i]))%2){
ok = false;
}
}
}
if(!ok){
cout << -1 << endl;
return 0;
}
vector<long long> arm;
for(long long len = pow(2, 32); len>=1; len/=2){
arm.push_back(len);
}
if((abs(x[0]) + abs(y[0]))%2 == 0){
arm.push_back(1);
}
cout << arm.size() << endl;
for(long long i = 0; i < arm.size(); i++){
cout << arm[i];
if(i == arm.size() - 1){
cout << endl;
}else{
cout << " ";
}
}
for(long long i = 0; i < N; i++){
long long tarx = x[i];
long long tary = y[i];
long long curx = 0;
long long cury = 0;
string ans = "";
for(long long j = 0; j < arm.size(); j++){
long long diffx = tarx - curx;
long long diffy = tary - cury;
if(abs(diffx) > abs(diffy)){
if(diffx >= 0){
ans+="R";
curx += arm[j];
}else{
ans+="L";
curx -= arm[j];
}
}else{
if(diffy >= 0){
ans+="U";
cury += arm[j];
}else{
ans+="D";
cury -= arm[j];
}
}
}
cout << ans << endl;
}
}
| 0
| 40,134,606
|
#include <iostream>
int main()
{
int a,b;
std::cin >> a >> b;
if (a>b){
std::cout << "a" << " > " << "b" << std::endl;
}else if (a<b){
std::cout << "a" << " < " << "b" << std::endl;
}else{
std::cout << "a" << " == " << "b" << std::endl;
}
return 0;
}
|
#include <cstdio>
void printFrame(int x, int y) {
int i, j;
for(i=0;i<y;i++) printf("#");
printf("\n");
for(i=2;i<x;i++) {
printf("#");
for(j=2;j<y;j++) printf(".");
printf("#\n");
}
for(i=0;i<y;i++) printf("#");
printf("\n\n");
}
int main() {
int x=-1, y=-1;
for(;;) {
scanf("%d %d", &x, &y);
if (x==0 && y==0) break;
printFrame(x, y);
}
return 0;
}
| 0
| 23,626,986
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair< ll, ll > Pi;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep2(i,n) for(int i=1;i<=(n);i++)
#define rep3(i,i0,n) for(int i=i0;i<(n);i++)
#define pb push_back
#define mod 1000000007
const ll INF = 1LL << 60;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
ll gcd(ll a, ll b) {return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) {return a/gcd(a,b)*b;}
#define all(x) x.begin(), x.end()
#define mp make_pair
bool compare(Pi a, Pi b) {
if(a.first != b.first){
return a.first < b.first;
}else{
return a.second < b.second;
}
}
bool In_map(ll y,ll x,ll h,ll w){
if(y<0 || x<0 || y>=h || x>=w){
return 0;
}else{
return 1;
}
}
const vector<ll> dx{1,0,-1,0};
const vector<ll> dy{0,1,0,-1};
int main() {
string S;
ll N;
cin >>S;
N=S.size();
map<char,bool>m;
rep(i,N){
m[S[i]]=1;
}
for(char i='a';i<='z';i++){
if(m[i]==0){
cout<<i<<endl;
return 0;
}
}
cout << "None" << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
struct UnionFind {
vector< int > data;
UnionFind(int sz) {
data.assign(sz, -1);
}
bool unite(int x, int y) {
x = find(x), y = find(y);
if(x == y) return (false);
if(data[x] > data[y]) swap(x, y);
data[x] += data[y];
data[y] = x;
return (true);
}
int find(int k) {
if(data[k] < 0) return (k);
return (data[k] = find(data[k]));
}
int size(int k) {
return (-data[find(k)]);
}
};
int main() {
int N, M, U[200000], V[200000];
cin >> N >> M;
UnionFind latte(N + N), malta(N);
for(int i = 0; i < M; i++) {
int x, y;
cin >> x >> y;
--x, --y;
latte.unite(x + N, y);
latte.unite(y + N, x);
malta.unite(x, y);
}
int64 uku = 0, one = 0, two = 0;
for(int i = 0; i < N; i++) {
if(malta.find(i) != i) continue;
if(malta.size(i) == 1) ++uku;
else if(latte.find(i) != latte.find(i + N)) ++two;
else ++one;
}
cout << (uku * N + two * (one + two)) * 2 - uku * uku + one * one << endl;
}
| 0
| 49,013,196
|
#include<iostream>
#include<cstdio>
#include<cstring>
#include <fstream>
#include<string>
#include<sstream>
#include<algorithm>
#include<bitset>
#include<vector>
#include<deque>
#include<queue>
#include<list>
#include<map>
#include<set>
#include<stack>
#include<cmath>
#include<iomanip>
#include <functional>
#include <math.h>
#include <assert.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const long long int MOD = 1000000007;
const int INF = 1000000007;
const double EPS = 1e-10;
const double PI = 3.14159265359;
const int N = 100005;
ll dp[N][2];
vector<int> edge[N];
int n, u, v;
void dfs(int x, int last)
{
dp[x][0] = dp[x][1] = 1;
for (auto to : edge[x]) {
if (to == last) continue;
dfs(to, x);
dp[x][0] = dp[x][0] * ((dp[to][0] + dp[to][1]) % MOD) % MOD;
dp[x][1] = dp[x][1] * dp[to][0] % MOD;
}
}
int main()
{
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
edge[u].push_back(v);
edge[v].push_back(u);
}
dfs(1, -1);
cout << (dp[1][0] + dp[1][1]) % MOD << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#define fo(i, n) for(int i=0; i<n; i++)
#define Fo(i, k, n) for(int i=k; i<n; i++)
#define w(x) int x; cin>>x; while(x--)
#define watch(x) cout << (#x) << " is " << (x) << "\n"
#define watch2(x,y) cout <<(#x)<<" is "<<(x)<<" and "<<(#y)<<" is "<<(y)<<"\n"
#define watch3(x,y,z) cout <<(#x)<<" is "<<(x)<<" and "<<(#y)<<" is "<<(y)<<" and "<<(#z)<<" is "<<(z)<<"\n"
#define watch4(x,y,z,q) cout <<(#x)<<" is "<<(x)<<" and "<<(#y)<<" is "<<(y)<<" and "<<(#z)<<" is "<<(z)<<" and "<<(#q)<<" is "<<(q)<<"\n"
#define MOD 1000000007
#define INF 1000000007;
#define F first
#define S second
#define pb(x) push_back(x);
#define ll long long
#define all(c) (c).begin(),(c).end()
#define endl "\n"
typedef vector<int> vl;
typedef vector< vl > vvl;
typedef pair< int, int> pll;
typedef map< int, int> mll;
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
void c_p_c()
{
#ifndef ONLINE_JUDGE
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
void parray(int a[],int n){
for(int i=0;i<n;i++){
cout<<a[i]<<" ";
}
cout<<endl;
}
int main() {
int i,n,m,k,c=0,sum=0;
c_p_c();
string s;
cin>>s;
n = (int)s.size();
int ans =753;
int mini=INF;
for (int i = 0,j=2; i <=n-3; i++)
{
string str=s.substr(i,3);
int x = stoi(str);
mini=min(mini,abs(ans-x));
}
cout<<mini<<endl;
return 0;
}
| 0
| 86,464,896
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,P;
cin>>N>>P;
int64_t Z=0,E=1,O=0;
for(int i=0;i<N;i++){
int a;
cin>>a;
if(a%2==0){
E*=2;
}
else{
O++;
}
}
int64_t Q=E;
for(int64_t i=1;i<=O+1;i++){
P=(P^1);
if(P){
Z+=Q;
}
Q*=O+1-i;
Q/=i;
}
cout<<Z<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for(int i=0; i<N; i++)
typedef long long ll;
#define dump(x) cerr<<#x<<"="<<x<<endl
using P = pair<int, int>;
int main() {
ll h, w; cin >> h >> w;
if(h%3==0 || w%3==0){
cout << 0 << endl;
return 0;
}
dump(h);
ll ht = h/3LL;
ll ht1 = (h+2)/3LL;
ll tmp = max(w*ht, (h-ht)*((w+1)/2LL)) - min(w*ht, (h-ht)*(w/2LL));
dump(tmp);
tmp = min(tmp, max(w*ht1, (h-ht1)*((w+1)/2LL)) - min(w*ht1, (h-ht1)*(w/2LL)));
dump(tmp);
ll wt = w/3LL;
ll wt1 = (w+2)/3LL;
ll tmp2 = max(h*wt, (w-wt)*((h+1)/2LL)) - min(h*wt, (w-wt)*(h/2LL));
dump(tmp2);
tmp2 = min(tmp2, max(h*wt1, (w-wt1)*((h+1)/2LL)) - min(h*wt1, (w-wt1)*(h/2LL)));
dump(tmp2);
ll ans = min(tmp, tmp2);
ans = min(w, min(h, ans));
cout << ans << endl;
return 0;
}
| 0
| 30,699,164
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll INF = 1LL << 60;
ll N, H, W;
vector<ll> A, B;
int main() {
cin >> N >> H >> W;
A.resize(N); B.reserve(N);
rep(i, N) cin >> A[i] >> B[i];
ll ans = 0;
rep(i, N) {
if (A[i] < H) continue;
if (B[i] < W) continue;
ans++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define SPEED ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define int long long
#define ld long double
#define fi first
#define se second
#define all(uiet) uiet.begin(),uiet.end()
#define read(UIET) for(int i = 0; i < n; ++i) cin >> UIET[i]
#define out(UIET) for(int i = 0; i < n; ++i) cout << UIET[i]
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define vpp vector<pair< int, int > >
#define pll pair<int , int >
#define ppll pair < pll , pll >
#define debug(n1) cout << n1 << endl
#define len(a) ((int) (a).size())
#define endl "\n"
#define mod 1000000007
const int INF=(1LL<<60)-1;
const int MAXN = 1000001;
string extractStringAtKey(string str, int key){
char *s = strtok((char *)str.c_str(), " ");
while(key > 1){
s = strtok(NULL, " ");
key--;
}
return (string)s;
}
int32_t main(){
SPEED;
int a[3];
cin >> a[0] >> a[1] >> a[2];
int odd = 0, even = 0;
for(int i = 0; i < 3; ++i){
if(a[i] & 1) odd++;
else even++;
}
if(odd == 3 || even == 3){
sort(a, a + 3);
if(a[0] == a[1] && a[1] == a[2]){
cout << 0;
return 0;
}
if(odd == 3){
cout << (a[2] - a[0])/2 + (a[2] - a[1])/2;
}
else cout << (a[2] - a[0])/2 + (a[2] - a[1])/2;
}
else{
if(odd > even){
int ans = 1;
for(int i = 0; i < 3; ++i){
if(a[i] & 1) a[i]++;
}
if(a[0] == a[1] && a[1] == a[2]){
cout << 1;
return 0;
}
sort(a, a + 3);
cout << ans + (a[2] - a[0])/2 + (a[2] - a[1])/2;
}
else{
int ans = 1;
for(int i = 0; i < 3; ++i){
if(a[i] % 2 == 0) a[i]++;
}
sort(a, a + 3);
if(a[0] == a[1] && a[1] == a[2]){
cout << 1;
return 0;
}
cout << ans + (a[2] - a[0])/2 + (a[2] - a[1])/2;
}
}
}
| 0
| 83,848,774
|
#include <bits/stdc++.h>
#define REP(i,n) for (int i = 0; i <(n); ++i)
#define ALL(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int,int>;
static const double PI = acos(-1);
int f(int x){
if(x%2 == 0) return x/2;
else return 3*x + 1;
}
int main(){
int s;
cin >> s;
const int INF = 1000005;
vector<int> a(INF);
REP(i,INF){
if(i == 0){
a[i] = s;
continue;
}
a[i] = f(a[i-1]);
}
vector<int> b(INF);
REP(i,INF) b[i] = 0;
REP(i,INF){
++b[a[i]];
if(b[a[i]] > 1){
cout << i + 1 << endl;
return 0;
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
vector< int >apply(const vector< int >&v) {
int n = v.size();
vector< int >cu(n, 0);
for (int i = 0; i < n; i++) {
int l = max(i-v[i], 0);
int r = min(i+v[i], n-1);
cu[l]++;
if (r+1 < n) cu[r+1]--;
}
for (int i = 1; i < n; i++) cu[i] += cu[i-1];
return cu;
}
int main() {
int n, k;
cin >> n >> k;
vector< int >a(n);
for (int &x : a) cin >> x;
while (k--) {
vector< int >r = apply(a);
if (a == r) break;
swap(a, r);
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
return 0;
}
| 0
| 38,196,329
|
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=15;
char s[N+9];
int n;
void into(){
scanf("%s",s+1);
n=strlen(s+1);
}
int ans;
void Get_ans(){
ans+=15-n;
for (int i=1;i<=n;++i) ans+=s[i]=='o';
}
void work(){
Get_ans();
}
void outo(){
puts(ans>=8?"YES":"NO");
}
int main(){
into();
work();
outo();
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <numeric>
#include <cmath>
#include <iomanip>
#include <cassert>
using namespace std;
typedef long long ll;
#define pb push_back
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
#define P pair<int,int>
int mx8[] = {0,0,1,-1,-1,1,-1,1};
int my8[] = {-1,1,0,0,-1,-1,1,1};
int mx4[] = {1,-1,0,0};
int my4[] = {0,0,-1,1};
const int MAX = 510000;
const int MOD = 1000000007;
class UnionFind {
public:
std::vector<int> RANK;
std::vector<int> par;
public:
UnionFind(int n)
{
RANK.resize(n);
par.resize(n);
for(int i = 0; i < n; ++i) par[i] = i;
}
int FindRoot(int x)
{
if (par[x] == x) return x;
par[x] = FindRoot(par[x]);
return par[x];
}
bool IsSame(int x, int y)
{
return FindRoot(x) == FindRoot(y);
}
void Union(int x, int y)
{
x = FindRoot(x);
y = FindRoot(y);
if (x == y) return;
else{
if(RANK[x] > RANK[y]){
par[y] = x;
}
else{
par[x] = y;
if(RANK[x] == RANK[y]){
RANK[x]++;
}
}
}
}
};
int main() {
ios::sync_with_stdio(false);
ll h, w; cin >> h >> w;
if(h%3==0 || w%3==0){cout<<0<<endl;return 0;}
ll ans = 10000000009;
for(ll i = 1; i < h; ++i)
{
ll s1 = i * w;
ll s2 = (h-i) * (w / 2);
ll s3 = h*w - s1 - s2;
ll L = max(s1,max(s2,s3));
ll M = min(s1,min(s2,s3));
ans = min(ans,L-M);
}
for(ll i = 1; i < w; ++i)
{
ll s1 = i * h;
ll s2 = (w-i) * (h / 2);
ll s3 = h*w - s1 - s2;
ll L = max(s1,max(s2,s3));
ll M = min(s1,min(s2,s3));
ans = min(ans,L-M);
}
for(ll i = 1; i < w; ++i)
{
ll s1 = i * h;
ll s2 = ((w-i) /2) * h;
ll s3 = h*w - s1 - s2;
ll L = max(s1,max(s2,s3));
ll M = min(s1,min(s2,s3));
ans = min(ans,L-M);
}
for(ll i = 1; i < h; ++i)
{
ll s1 = i * w;
ll s2 = ((h-i)/2) * w;
ll s3 = h*w - s1 - s2;
ll L = max(s1,max(s2,s3));
ll M = min(s1,min(s2,s3));
ans = min(ans,L-M);
}
cout << ans << endl;
}
| 0
| 40,408,419
|
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int n,count = 0,ans = -1,flag;
cin>>n;
for(int i = 1;i<=n;i++)
{
count = 0;
int temp = i;
while(temp%2 == 0 && temp != 0)
{
count++;
temp = temp/2;
}
if(count > ans)
flag = i;
ans = max(count,ans);
}
cout<<flag<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#include <math.h>
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 int64_t INF = 1LL << 60;
int main() {
int64_t A,B,K;
cin>>A>>B>>K;
for(int i=0;i<K;i++){
if(i%2==0){
if(A%2!=0){A-=1;}
A/=2;B+=A;
}
if(i%2!=0){
if(B%2!=0){B-=1;}
B/=2;A+=B;
}
}
cout<<A<<" "<<B<<endl;
return 0;
}
| 0
| 54,580,222
|
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
int A, B, K;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> A >> B >> K;
for (int i = 0; i < K; i++) {
if (i % 2 == 0) {
A /= 2;
B += A;
} else {
B /= 2;
A += B;
}
}
cout << A << " " << B << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long lol;
#define REP(i,n) for(lol i=0;i<lol(n);i++)
#define REPD(i,n) for(lol i=n-1;i>=0;i--)
#define FOR(i,a,b) for(lol i=a;i<=lol(b);i++)
#define FORD(i,a,b) for(lol i=a;i>=lol(b);i--)
#define VL vector<lol>
#define ALL(x) x.begin(),x.end()
#define SIZE(x) lol(x.size())
#define PI 3.1415926535897932385
#define INF 1000000000000
#define MOD 1000000007
#define MAXR 100000
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; }
int gcd(int a,int b){return b?gcd(b,a%b):a;}
int main()
{
lol result{0};
lol n, r; cin >> n >> r;
if(n < 10)
{
result = r + 100*(10-n);
}
else
{
result = r;
}
cout << result << endl;
return 0;
}
| 0
| 48,756,824
|
#include <iostream>
#include <vector>
#include <climits>
using namespace std;
typedef long long ll;
vector<int> v;
ll dfs(ll i, ll N, ll K, ll *a, ll m) {
if (i == N) {
if (v.size() < K)
return 999999999999;
return 0;
}
ll ans;
if (a[i] <= m) {
v.push_back(i);
ans = m+1-a[i]+dfs(i+1, N, K, a, m+1);
v.pop_back();
ans = min(ans, dfs(i+1, N, K, a, m));
return ans;
}
else {
v.push_back(i);
ans = dfs(i+1, N, K, a, a[i]);
v.pop_back();
return ans;
}
}
int main() {
ll N, K; cin >> N >> K;
ll *a = new ll[N];
for (int i = 0; i < N; i++)
cin >> a[i];
cout << dfs(0, N, K, a, 0) << endl;
return 0;
}
|
#include<iostream>
#include<cstring>
using namespace std;
int data[10][6]={
{5,'.',',','!','?',' '},
{3,'a','b','c',0,0},
{3,'d','e','f',0,0},
{3,'g','h','i',0,0},
{3,'j','k','l',0,0},
{3,'m','n','o',0,0},
{4,'p','q','r','s',0},
{3,'t','u','v',0,0},
{4,'w','x','y','z',0}
};
int main(){
int n;
cin>>n;
string s;
for(int i=0;i<n;i++){
cin>>s;
for(int j=0;j<s.length();j++){
if(s[j]=='0')continue;
int tmp=j;
while(s[j]!='0')j++;
int button=s[j-1]-'0'-1;
int cnt=(j-tmp-1)%data[button][0] + 1;
cout << (char)data[button][cnt];
}
cout << endl;
}
return 0;
}
| 0
| 30,793,808
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define reps(i,s,n) for (int i = (s); i <= (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
int n[3];
cin >> n[0];
cin >> n[1];
cin >> n[2];
sort(n, n + 3);
int diff = 2 * n[2] - n[1] - n[0];
if(diff % 2 == 0){
cout << diff / 2 << endl;
} else {
cout << ((diff + 1) / 2 ) + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i=0; i<n; i++)
#define pb push_back
int N, K;
long long a[5010];
bool dp1[5010][5010], dp2[5010][5010];
vector<int> acc[5010];
int main() {
cin.tie(0); ios::sync_with_stdio(false);
cin >> N >> K;
rep(i, N) cin >> a[i];
dp1[0][0] = true;
rep(i, N) rep(j, K) {
dp1[i+1][j] |= dp1[i][j];
if (j+a[i]<K) dp1[i+1][j+a[i]] |= dp1[i][j];
}
dp2[0][0] = true;
rep(i, N) rep(j, K) {
dp2[i+1][j] |= dp2[i][j];
if (j+a[N-1-i]<K) dp2[i+1][j+a[N-1-i]] |= dp2[i][j];
}
rep(i, N) {
acc[i].pb(0);
rep(j, K) acc[i].pb(acc[i].back()+dp2[i][j]);
}
int ans = 0;
rep(i, N) {
bool need = false;
rep(j, K) {
if (dp1[i][j]==0) continue;
int l = max(0ll, K-a[i]-j);
int h = K-j;
if (acc[N-i-1][h]-acc[N-i-1][l]>0) need = true;
}
if (!need) ans++;
}
cout << ans << endl;
}
| 0
| 79,225,028
|
#include<bits/stdc++.h>
using namespace std;
using lint = long long;
typedef pair<lint, lint> P;
vector<lint> dist;
const lint INF = 1e18;
struct edge{lint to, cost;};
vector<edge> G[100010];
void dij(lint start){
priority_queue<P, vector<P>, greater<P> > que;
for(lint i = 0; i < dist.size(); i++) dist[i] = INF;
dist[start] = 0;
que.push(P(0, start));
while(!que.empty()){
P p = que.top(); que.pop();
lint next = p.second;
if(dist[next] < p.first) continue;
for(lint i = 0; i < G[next].size(); i++){
edge e = G[next][i];
if(dist[next] + e.cost < dist[e.to]){
dist[e.to] = dist[next] + e.cost;
que.push(P(dist[e.to], e.to));
}
}
}
}
signed main(){
lint N; cin >> N;
for(lint i = 0; i < N - 1; i++){
lint a, b, c; cin >> a >> b >> c;
edge e = {b - 1, c}, e1 = {a - 1, c};
G[a - 1].push_back(e); G[b - 1].push_back(e1);
}
dist.resize(N);
lint Q, K; cin >> Q >> K;
dij(K - 1);
for(lint i = 0; i < Q; i++){
lint x, y; cin >> x >> y;
lint ans = dist[x - 1] + dist[y - 1];
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define P pair<int,int>
#define fi first
#define se second
#define rep(i,n) for(int i=0;i<n;i++)
#define INF 1000000000
#define MOD 1000000007
#define all(v) v.begin(),v.end()
int dx[]={0,1,0,-1},dy[]={1,0,-1,0};
int kaijo[222222];
struct edge{int to,cost;};
int gcd(int a,int b){
if(b==0)return a;
return gcd(b,a%b);
}
int lcm(int a,int b){
return a/gcd(a,b)*b;
}
bool prime(int a){
if(a==1)return false;
for(int i=2;i*i<=a;i++){
if(a%i==0)return false;
}
return true;
}
bool kosa(double ax,double ay,double bx,double by,double cx,double cy,double dx,double dy){
double ta=(cx-dx)*(ay-cy)+(cy-dy)*(cx-ax);
double tb=(cx-dx)*(by-cy)+(cy-dy)*(cx-bx);
double tc=(ax-bx)*(cy-ay)+(ay-by)*(ax-cx);
double td=(ax-bx)*(dy-ay)+(ay-by)*(ax-dx);
return tc*td<0&&ta*tb<0;
}
void init_fact(int n){
kaijo[0]=1;
for(int i=1;i<=n;i++){
kaijo[i]=kaijo[i-1]*i;
kaijo[i]%=MOD;
}
}
int modpow(int a,int b){
if(b==0)return 1;
if(b%2)return modpow(a,b-1)*a%MOD;
int memo=modpow(a,b/2);
return memo*memo%MOD;
}
int comb(int a,int b){
return kaijo[a]*modpow(kaijo[a-b],MOD-2)%MOD*modpow(kaijo[b],MOD-2)%MOD;
}
int g(int x){
x=modpow(x,MOD-2);
return x;
}
int n,ans;
priority_queue<int>q;
signed main(){
cin>>n;
rep(i,n){
int a;
cin>>a;
q.push(a);
}
while(q.top()>=n){
int p=q.top();
q.pop();
int memo=p-(n-1);
int cnt=(memo-1)/n+1;
int a[55];
rep(i,n-1){
a[i]=q.top();
q.pop();
}
q.push(p-(cnt*n));
rep(i,n-1){
a[i]+=cnt;
q.push(a[i]);
}
ans+=cnt;
}
cout<<ans<<endl;
return 0;
}
| 0
| 16,030,770
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define reps(i, f, n) for (ll i = (f); i < (n); i++)
#define repr(i, n) for (ll i = n; i >= 0; i--)
#define repv(v) for (auto it = (v).begin(); it != (v).end(); it++)
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define pb push_back
#define INIT \
cin.tie(0); \
ios::sync_with_stdio(false);
template <class T>
inline bool chmax(T& a, T b) {
return a = (a < b) ? b : a;
}
template <class T>
inline bool chmin(T& a, T b) {
return a = (a > b) ? b : a;
}
ll const INF = 1LL << 60;
ll const MOD = 1000000007;
vector<ll> find_all(const string str, const string subStr) {
vector<ll> result;
int subStrSize = subStr.size();
int pos = str.find(subStr);
while (pos != std::string::npos) {
result.push_back(pos);
pos = str.find(subStr, pos + subStrSize);
}
return result;
}
int main() {
INIT;
ll N;
cin >> N;
vector<string> s(N);
rep(i, N) cin >> s[i];
ll ans = 0;
vector<ll> find_vec;
rep(i, N) {
find_vec = find_all(s[i], "AB");
ans += SZ(find_vec);
find_vec.clear();
}
ll c1 = 0, c2 = 0, c3 = 0;
rep(i, N) {
ll len = SZ(s[i]);
if (s[i][0] == 'B' && s[i][len - 1] == 'A') {
c1++;
} else if (s[i][0] == 'B') {
c2++;
} else if (s[i][len - 1] == 'A') {
c3++;
}
}
if (c1 == 0) {
ans += min(c2, c3);
} else {
if (c2 + c3 == 0) {
ans += c1 - 1;
} else {
ans += c1 + min(c2, c3);
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <queue>
using namespace std;
int c[101][102],ch[101];
queue<int> q;
int main(){
int a,b,e,d,n,k;
cin>>a;
for(int i=1;i<=a;i++)ch[i]=-1;
for(int i=0;i<a;i++){
cin>>b>>e;
c[b][0]=e;
for(int j=1;j<=e;j++){
cin>>d;
c[b][j]=d;
}
}
q.push(1);
ch[1]=0;
while(q.size()){
n=q.front();q.pop();
for(int i=1;i<=c[n][0];i++){
if(ch[c[n][i]]==-1){
q.push(c[n][i]);
ch[c[n][i]]=ch[n]+1;
}
}
}
for(int i=1;i<=a;i++)cout<<i<<" "<<ch[i]<<endl;
return 0;
}
| 0
| 15,330,675
|
#include <iostream>
#include <ctime>
#define ESP 1e-10
using namespace std;
int main() {
bool flag = false;
time_t c1;
while (true) {
int H, W; cin >> H >> W;
if (!flag) { c1 = clock(); flag = true; }
if (H == 0 && W == 0) break;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W;j++) {
cout << "#";
}
cout << endl;
}
cout << endl;
}
time_t c2;
while (true) {
c2 = clock();
if (c2 - c1 > 999) break;
}
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define FOR(i,n,m) for(int i=(int)(n); i<=(int)(m); i++)
#define RFOR(i,n,m) for(int i=(int)(n); i>=(int)(m); i--)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define RITR(x,c) for(__typeof(c.rbegin()) x=c.rbegin();x!=c.rend();x++)
#define setp(n) fixed << setprecision(n)
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
#define ld long double
#define ll long long
#define vll vector<ll>
#define vi vector<int>
#define pll pair<ll,ll>
#define pi pair<int,int>
#define all(a) (a.begin()),(a.end())
#define rall(a) (a.rbegin()),(a.rend())
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define ins insert
using namespace std;
#define INF LONG_LONG_MAX
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int n,k; cin>>n>>k;
vll x(n),y(n);
rep(i,n) cin>>x[i]>>y[i];
vll sx, sy;
sx = x, sy = y;
sort(all(sx));
sort(all(sy));
ll ans=INF;
rep(a,n)rep(b,n)rep(c,n)rep(d,n){
if (a>b || c>d) continue;
int cnt=0;
rep(i,n)if(sx[a]<=x[i]&&x[i]<=sx[b]&&sy[c]<=y[i]&&y[i]<=sy[d]){
cnt++;
}
if (cnt>=k) chmin(ans,(sx[b]-sx[a])*(sy[d]-sy[c]));
}
cout<<ans<<endl;
return 0;
}
| 0
| 53,350,308
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("unroll-loops")
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define int long long
#define fr(i,a,b) for(int i = a ; i <= b ; ++i)
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) (int)(x).size()
#define pb push_back
#define fst first
#define snd second
using namespace __gnu_pbds;
using ordered_set =
tree<int, null_type,less<int>,
rb_tree_tag,tree_order_statistics_node_update>;
typedef long long ll;typedef pair<int, int> pii;
typedef vector<int> vi;typedef long double ld;
template<class T>
using min_heap = priority_queue<T,vector<T>,greater<T>>;
template<typename T> T gcd(T a, T b){return(b?__gcd(a,b):a);}
template<typename T> T lcm(T a, T b){return(a*(b/gcd(a,b)));}
template<typename T>
void remdup(vector<T>& v) {
sort(all(v)); v.erase(unique(all(v)), v.end());
}
template<typename T> void re(vector<T> &v) {trav(i,v) cin >> i;}
void unsyncIO() { ios_base::sync_with_stdio(0); cin.tie(0); }
#ifdef np
#include "C:\Users\navodit\Desktop\mycodes\pr.h"
#else
#define trace(...)
#endif
#define MOD 1000000007
void solve(){
int a , b ;
cin >> a >> b;
cout << (a*3 + b )/2;
}
signed main() {
unsyncIO();
int tt =1 ;
rep(i,0,tt) solve();
#ifdef np
cout <<endl<<endl<< "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define reps(i, f, n) for (ll i = (f); i < (n); i++)
#define repv(v) for (auto it = (v).begin(); it != (v).end(); it++)
ll const INF = 1LL << 60;
ll const MAX_N = 510000;
ll const MOD = 1000000007;
int main() {
ll N;
cin >> N;
vector<ll> A(N);
vector<ll> B(N);
rep(i, N) { cin >> A[i]; }
rep(i, N) { cin >> B[i]; }
ll sumA = 0;
ll sumB = 0;
rep(i, N) {
sumA += A[i];
sumB += B[i];
}
if (sumA < sumB) {
cout << "-1" << endl;
return 0;
}
vector<ll> D(N);
rep(i, N) { D[i] = A[i] - B[i]; }
sort(D.begin(), D.end(), greater<ll>());
ll cnt = 0;
ll diff = 0;
for (ll i = N - 1; i >= 0; i--) {
if (D[i] < 0) {
diff += D[i];
cnt++;
} else {
break;
}
}
for (ll i = 0; i < N; i++) {
if (D[i] > 0 && diff < 0) {
diff += D[i];
cnt++;
} else {
break;
}
}
cout << cnt << endl;
return 0;
}
| 0
| 5,417,080
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N;
vector<string> s(N);
for (int i=0; i<N; i++){
cin >> s.at(i);
}
cin >> M;
vector<string> t(M);
for (int i=0; i<M; i++){
cin >> t.at(i);
}
vector<int> count(N);
for (int i=0; i<N; i++){
for (int j=i; j<N; j++){
if(s.at(i)==s.at(j)) count.at(i)++;
}
for (int j=0; j<M; j++){
if(s.at(i)==t.at(j)) count.at(i)--;
}
}
int ans=0;
for (int i=0; i<N; i++){
ans = count.at(i) > ans ? count.at(i) : ans;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll N = 0;
cin >> N;
vector<ll> A(N,0);
for(ll i = 0; i < N; i++) {
cin >> A.at(i);
}
map<int, int> m;
int ans = 0;
for(int i = 0; i < N; i++) {
for(int j = -1; j < 2; j++) {
if(!m.count(A.at(i) + j)) {
m[A.at(i) + j] = 0;
}
m.at(A.at(i) + j)++;
ans = max(ans, m.at(A.at(i) + j));
}
}
cout << ans << endl;
return 0;
}
| 0
| 3,637,009
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int d1,d2,d3,d4,d5,d6;
int x1,x2,x3,x4,x5,x6;
cin>>x1>>x2>>x3>>x4>>x5>>x6;
d1=x1,d2=x2,d3=x3,d4=x4,d5=x5,d6=x6;
int m1,m2,m3,m4,m5,m6;
int a,x,y;
cin>>a;
for(int i=0;i<a;i++)
{
d1=x1;d2=x2;d3=x3;d4=x4;d5=x5;d6=x6;
m1=d1;m2=d2;m3=d3;m4=d4;m5=d5;m6=d6;
cin>>x>>y;
for(int i3=0; i3<6 ; i3++)
{
for(int i2=0;i2<4;i2++)
{
m1=d1;m2=d2;m3=d3;m4=d4;m5=d5;m6=d6;
m1=d2;m2=d6;m6=d5;m5=d1;
d1=m1;d2=m2;d3=m3;d4=m4;d5=m5;d6=m6;
if(d1==x && d2==y) {cout<<d3<<endl; break;}
}
if(d1==x && d2==y) break;
if(i3<3)
{m1=d1;m2=d2;m3=d3;m4=d4;m5=d5;m6=d6;
m3=d6;m6=d4;m4=d1;m1=d3;
d1=m1;d2=m2;d3=m3;d4=m4;d5=m5;d6=m6;}
if(i3==3)
{m1=d1;m2=d2;m3=d3;m4=d4;m5=d5;m6=d6;
m1=d2;m2=d6;m6=d5;m5=d1;
d1=m1;d2=m2;d3=m3;d4=m4;d5=m5;d6=m6;
m1=d1;m2=d2;m3=d3;m4=d4;m5=d5;m6=d6;
m3=d6;m6=d4;m4=d1;m1=d3;
d1=m1;d2=m2;d3=m3;d4=m4;d5=m5;d6=m6;}
if(i3==4)
{m1=d1;m2=d2;m3=d3;m4=d4;m5=d5;m6=d6;
m3=d6;m6=d4;m4=d1;m1=d3;
d1=m1;d2=m2;d3=m3;d4=m4;d5=m5;d6=m6;
m1=d1;m2=d2;m3=d3;m4=d4;m5=d5;m6=d6;
m3=d6;m6=d4;m4=d1;m1=d3;
d1=m1;d2=m2;d3=m3;d4=m4;d5=m5;d6=m6;}
}
}
return 0;
}
|
#include <cstdio>
#include <algorithm>
#include <numeric>
#include <map>
#define fail return puts("-1"), 0
const int N = 1e5 + 5, M = 2e5 + 5;
int n, tot, lnk[N], ter[M], nxt[M], sz[N], fa[N];
long long dep[N], d[N], D[N];
std::map<long long, int> mp;
void add(int u, int v) {
ter[++tot] = v, nxt[tot] = lnk[u], lnk[u] = tot;
}
void dfs1(int u, int p) {
sz[u] = 1;
for (int i = lnk[u]; i; i = nxt[i]) {
int v = ter[i];
if (v == p) continue;
dep[v] = dep[u] + 1;
dfs1(v, u);
sz[u] += sz[v];
}
}
void dfs2(int u, int p) {
for (int i = lnk[u]; i; i = nxt[i]) {
int v = ter[i];
if (v == p) continue;
D[v] = D[u] - 2 * sz[v] + n;
dfs2(v, u);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &d[i]);
mp[d[i]] = i;
sz[i] = 1;
}
int cnt = 0;
for (auto it = mp.rbegin(); it != mp.rend(); it++) {
int v = it->second;
long long now = it->first;
long long s = now + 2 * sz[v] - n;
if (!mp.count(s)) fail;
int u = mp[s];
if (u == v) fail;
fa[v] = u, sz[u] += sz[v];
add(u, v), add(v, u);
if (++cnt == n - 1) break;
}
dfs1(1, 0);
D[1] = std::accumulate(dep + 1, dep + n + 1, 0LL);
dfs2(1, 0);
for (int i = 1; i <= n; i++) {
if (D[i] != d[i]) fail;
}
for (int i = 1; i <= n; i++) {
if (fa[i]) printf("%d %d\n", i, fa[i]);
}
return 0;
}
| 0
| 34,299,771
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
int main(){
double a,b;
cin >> a >> b;
ll ans=0;
if(a==1||b==1){
cout <<"1" <<endl;
return 0;
}
double calc =floor(a/2)*b;
ans = calc;
if(fmod(a,2) != 0){
ans += ceil(b/2);
}
cout << ans <<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template<typename T> T combination(int n, int r) {
T ans = 1;
for (int i = 0; i < r; i++) {
ans *= n - i;
}
for (int i = 1; i <= r; i++) {
ans /= i;
}
return ans;
}
int main() {
int N;
map<string, int> M;
cin >> N;
for (int i = 0; i < N; i++) {
string s;
cin >> s;
sort(s.begin(), s.end());
M[s]++;
}
long long ans = 0;
for (auto it = M.begin(); it != M.end(); it++) {
ans += combination<long long>((*it).second, 2);
}
cout << ans << endl;
return 0;
}
| 0
| 37,955,048
|
#include <bits/stdc++.h>
using namespace std;
#define froop1(a,n) for(int i = a;i < n;i++)
#define froop2(a,n) for(int i = a;i > n;i--)
int main(){
long long N,tickets;
cin >> N >> tickets;
priority_queue<long long> pq;
froop1(0,N){
long long a;
cin >> a;
pq.push(a);
}
froop1(0,tickets){
long long b = pq.top();
pq.pop();
pq.push(b / 2);
}
long long sum = 0;
while(!pq.empty()){
sum += pq.top();
pq.pop();
}
cout << sum << endl;
}
|
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main(){
int N;
cin >> N;
vector<ll> A(N),cnt(60);
ll x = 0;
for(int i=0;i<N;i++){
cin >> A[i];
x ^= A[i];
}
for(int i=0;i<N;i++) A[i] &= ~x;
int r = 0;
for(int j=59;j>=0;j--){
bool ok = false;
for(int i=r;i<N;i++){
if(A[i]&(1LL<<j)){
swap(A[i],A[r]);
ok = true;
break;
}
}
if(ok){
for(int i=0;i<N;i++){
if((i!=r) && (A[i]&(1LL<<j))) A[i] ^= A[r];
}
r++;
}
}
ll ans = 0;
for(int i=0;i<N;i++) ans = max(ans,ans^A[i]);
cout << 2*ans+x << endl;
}
| 0
| 8,176,216
|
#include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const LL INF = 0x3f3f3f3f3f3f3f3fLL;
const LL MOD = 1e9 + 7;
void solve(int u, int p, auto &G, auto &dp) {
for (auto &v : G[u]) {
if (v == p)
continue;
solve(v, u, G, dp);
(dp[u][0] *= (dp[v][0] + dp[v][1]) % MOD) %= MOD;
(dp[u][1] *= dp[v][0]) %= MOD;
}
}
void marmot0814() {
int n; cin >> n;
vector<vector<int>> G(n);
for (int i = 1 ; i < n ; i++) {
int u, v; cin >> u >> v; u--, v--;
G[u].push_back(v);
G[v].push_back(u);
}
vector<vector<LL>> dp(n, vector<LL>(2, 1));
solve(0, 0, G, dp);
cout << (dp[0][0] + dp[0][1]) % MOD << '\n';
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
int t = 1, kase = 0;
while (t--) {
marmot0814();
}
}
|
#include<bits/stdc++.h>
#define ll long long int
using namespace std;
int main()
{
ll n,k,x=-2,y=2000000,m;map<ll,ll>ml;
cin>>n>>m;
vector<pair<ll,ll>>v;
for(int i=1;i<=m;i++){
ll a,b;
cin>>a>>b;
v.push_back(make_pair(a,b));
}
sort(v.begin(),v.end());
for(int i=0;i<v.size();i++){
if(v[i].first==1)ml[v[i].second]=1;
else if(v[i].second==n&&ml[v[i].first]){
cout<<"POSSIBLE";return 0;
}
}
cout<<"IMPOSSIBLE";
return 0;
}
| 0
| 36,726,260
|
#include <bits/stdc++.h>
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef long long LL;
typedef pair<int,int> PI;
typedef vector<LL> VL;
typedef vector<VL> VVL;
typedef pair<LL,LL> PLL;
typedef unsigned long long ULL;
typedef pair<double,double> PD;
#define FOR(x, b, e) for(int x = b; x<= (e); x++)
#define FORD(x, b, e) for(int x = b; x>= (e); x--)
#define REP(x, n) for(int x = 0; x<(n); ++x)
#define ALL(c) (c).begin(), (c).end()
#define SIZE(x) ((int)(x).size())
#define PB push_back
#define IN insert
#define ST first
#define ND second
#define INF 2000000011
#define MOD 1000000007
#define MAXS
LL n,m,v,p;
VL zb;
bool mozna(int p1){
if(p1<0)
return false;
LL nad=m*(v-1);
int mks=p-1,prog=zb[p1]+m;
REP(i,n){
if(zb[i]>prog)
mks--;
}
if(mks<0)
return false;
mks=p-1;
FORD(i,n-1,0){
if(i==p1)
continue;
if(mks){
nad-=m;
mks--;
}
else
nad-=min(m,prog-zb[i]);
}
return nad<=0;
}
int main(){
ios::sync_with_stdio(0); cin.tie(0);
cin>>n>>m>>v>>p;
zb.resize(n);
REP(i,n)
cin>>zb[i];
sort(ALL(zb));
int k=n-1;
for(int p1=n/2;p1>=1;p1/=2){
while(mozna(k-p1))
k-=p1;
}
cout<<n-k;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int A,B,K;
cin >> A >> B >> K;
int count = 0;
while(true){
if (A%2 == 1){
A = A - 1;
B = B + A / 2;
A = A / 2;
}
else{
B = B + A / 2;
A = A / 2;
}
count++;
if (count >= K){
break;
}
if (B%2 == 1){
B = B - 1;
A = A + B / 2;
B = B / 2;
}
else{
A = A + B / 2;
B = B / 2;
}
count++;
if (count >= K){
break;
}
}
cout << A << " " << B << endl;
}
| 0
| 60,681,777
|
#include<iostream>
#include<vector>
#include<string>
using namespace std;
signed main() {
string a;
cin >> a;
for (int b = a.length() - 1; b != -1; b--)cout << a[b];
cout << endl;
}
|
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int main() {
int n;
cin >> n;
vector<ll> a(n);
for (int i = 0; i < n; ++i) {
ll x;
cin >> x;
x -= i + 1;
a[i] = x;
}
sort(a.begin(), a.end());
ll b = a[(n % 2 == 1 ? (n - 1) / 2 : n / 2 - 1)];
ll ans = 0;
for (int i : a) {
ans += abs(i - b);
}
cout << ans << endl;
}
| 0
| 68,067,887
|
#include<iostream>
#include<cmath>
#include<vector>
#include<set>
#include<algorithm>
#include<tuple>
#include<utility>
#include<cctype>
#include<climits>
#include<map>
#include<queue>
#include<functional>
#include<stack>
#include<iomanip>
#include<sstream>
#include<bitset>
using namespace std;
#define REP(i,a,n) for(int i=a;i<n;++i)
#define REPL(i,a,n) for(ll i=a;i<n;++i)
#define RUP(a,b) ((a+b-1)/(b))
#define ENT "\n"
#define SORTVG(v) sort(v.begin(),v.end(),greater<>())
#define SORTV(v) sort(v.begin(),v.end())
#define ALL(v) (v).begin(),(v).end()
#define MOD 1000000007
#define INF LLONG_MAX/2
typedef long long ll;
typedef tuple<int,int,bool> Tb;
typedef pair<int,int> Pii;
typedef vector<int> Vi;
template<class T> void chmax(T& a, T b) {if(a < b){a=b;}}
template<class T> void chmin(T& a, T b) {if(a > b){a=b;}}
template<class T> void YesNo(T& a) {if(a){cout << "Yes" << ENT;}else{cout << "No" << ENT;}}
template<class T> void YESNO(T& a) {if(a){cout << "YES" << ENT;}else{cout << "NO" << ENT;}}
int atcoder(){
ll n,k;
cin>>n>>k;
vector<ll> a(n),b(n);
REPL(i,0,n) cin>>a[i]>>b[i];
stringstream ss;
ss << bitset<30>(k);
string s = ss.str();
vector<ll> check;
check.push_back(k);
REP(i,0,s.length()){
if(s[i]=='1'){
string t=s;
t[i]='0';
REP(j,i+1,s.length()) t[j]='1';
ll tmp=stoll(t,0,2);
check.push_back(tmp);
}
}
ll ans=0;
REP(i,0,check.size()){
ll tmp=0;
REP(j,0,n) if((check[i] | a[j]) == check[i]) tmp+=b[j];
chmax(ans,tmp);
}
cout<<ans<<ENT;
return 0;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
atcoder();
return 0;
}
|
#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() {
int n,m;cin>>n>>m;
vector<vector<char>> a(n,vector<char>(n)),b(m,vector<char>(m));
rep(i,n)rep(j,n)cin>>a[i][j];
rep(i,m)rep(j,m)cin>>b[i][j];
rep(i,n-m+1)rep(j,n-m+1){
bool ans=true;
if(a[i][j]==b[0][0]){
rep(k,m)rep(l,m){
if(a[i+k][j+l]!=b[k][l])ans=false;
}
}
else continue;
if(ans){
cout<<"Yes"<<endl;
return 0;
}
}
cout<<"No"<<endl;
}
| 0
| 76,736,453
|
#include <iostream>
#include <cstdlib>
#include <queue>
#include <cstring>
using namespace std;
typedef long long ll;
const int N=500010;
char c[N];
int ru[N],ans[N],hed[N],ver[N],nex[N],tot;
ll sum;
queue<int> q;
void add(int x,int y)
{
tot++;
ver[tot]=y;
nex[tot]=hed[x];
hed[x]=tot;
}
int main()
{
int i,x,y;
cin>>c;
int n=strlen(c);
for(i=0;i<n;i++)
{
if(c[i]=='<')
{
add(i,i+1);
ru[i+1]++;
}
else
{
add(i+1,i);
ru[i]++;
}
}
for(i=0;i<=n;i++)
{
if(ru[i]==0)
{
ans[i]=0;
q.push(i);
}
}
while(!q.empty())
{
x=q.front();
q.pop();
for(i=hed[x];i;i=nex[i])
{
y=ver[i];
ru[y]--;
ans[y]=max(ans[y],ans[x]+1);
if(ru[y]==0) q.push(y);
}
}
for(i=0;i<=n;i++) sum+=ans[i];
cout<<sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define println(msg) cout << msg << endl
#define yes_or_no(flag) if (flag) { println("Yes"); } else { println("No"); }
#define sort_vec(vec) sort(vec.begin(), vec.end())
#define rsort_vec(vec) sort(vec.rbegin(), vec.rend())
int main() {
int N;
cin >> N;
vector<string> s(N);
for (int i = 0; i < N; i++) {
cin >> s.at(i);
}
int M;
cin >> M;
vector<string> t(M);
for (int i = 0; i < M; i++) {
cin >> t.at(i);
}
map<string, int> ag;
for (auto x : s) {
if (ag.count(x)) {
ag[x]++;
} else {
ag[x] = 1;
}
}
for (auto x : t) {
if (ag.count(x)) {
ag[x]--;
} else {
ag[x] = -1;
}
}
int m = INT_MIN;
for (auto p : ag) {
if (m < p.second) {
m = p.second;
}
}
println(max(0, m));
}
| 0
| 31,442,175
|
#include <bits/stdc++.h>
using namespace std;
#define dump(x) cout << (x) << endl
#define Int int64_t
#define fi first
#define se second
Int INF = 1e18;
Int mod = 1e9+7;
int main() {
Int n, l;
cin >> n >> l;
vector<Int> a(n + 1);
for (Int i = 1; i <= n; i++) {
cin >> a[i];
}
Int index = -1;
for (Int i = 1; i <= n - 1; i++) {
if (a[i] + a[i + 1] >= l) {
index = i;
}
}
if (index == -1) {
dump("Impossible");
return 0;
}
dump("Possible");
for (Int i = 1; i < index; i++) {
dump(i);
}
for (Int i = n - 1; i >= index; i--) {
dump(i);
}
return 0;
}
|
#include <bits/stdc++.h>
int main(){
int N;
std::cin >> N;
std::vector< int > A(N);
for(int i=0; i<N; i++){
std::cin >> A[i];
}
std::vector< bool > b(N, false);
std::vector< bool > s(N, false);
int best = 1e9;
bool up = false;
for(int i=0; i<N; i++){
if(!up && best > A[i]){
best = A[i];
}else if(!up && best < A[i]){
b[i-1] = true;
up = true;
best = A[i];
}else if(up && best < A[i]){
best = A[i];
}else if(up && best > A[i]){
s[i-1] = true;
up = false;
best = A[i];
}
}
if(up){
s[N-1] = true;
}
int buy;
long long money = 1000;
for(int i=0; i<N; i++){
if(b[i]){
buy = A[i];
}else if(s[i]){
money = (money / buy) * A[i] + (money % buy);
}
}
std::cout << money << std::endl;
return 0;
}
| 0
| 70,138,237
|
#include <cstdio>
main(){
int a[4],b[4],ar,br;
scanf("%d%d%d%d",a,a+1,a+2,a+3);
scanf("%d%d%d%d",b,b+1,b+2,b+3);
ar=*a+a[1]+a[2]+a[3],br=*b+b[1]+b[2]+b[3];
printf("%d\n",ar>br?ar:br);
}
|
#include <array>
#include <cstdint>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
void dfs(int32_t H, int32_t W, array<array<char, 20>, 20> &tiles, array<array<bool, 20>, 20> &visited, int32_t i, int32_t j, char index)
{
visited[i][j] = true;
tiles[i][j] = index;
for (int32_t l = -1; l <= 1; l++) {
if (0 <= j + l && j + l < W) {
if (tiles[i][j + l] == '.') {
dfs(H, W, tiles, visited, i, j + l, index);
}
}
}
for (int32_t k = -1; k <= 1; k++) {
if (0 <= i + k && i + k < H) {
if (tiles[i + k][j] == '.') {
dfs(H, W, tiles, visited, i + k, j, index);
}
}
}
}
int32_t main()
{
while (true) {
int32_t W, H;
cin >> W >> H;
if (W == 0) break;
array<array<char, 20>, 20> tiles;
array<array<bool, 20>, 20> visited;
uint32_t start_x = 0;
uint32_t start_y = 0;
for (int32_t i = 0; i < H; i++) {
for (int32_t j = 0; j < W; j++) {
cin >> tiles[i][j];
if (tiles[i][j] == '@') {
start_x = i;
start_y = j;
tiles[i][j] = '.';
}
}
}
char index = 0;
for (int32_t i = 0; i < H; i++) {
for (int32_t j = 0; j < W; j++) {
if (tiles[i][j] == '.') {
dfs(H, W, tiles, visited, i, j, index);
index++;
}
}
}
char start_index = tiles[start_x][start_y];
uint32_t count = 0;
for (int32_t i = 0; i < H; i++) {
for (int32_t j = 0; j < W; j++) {
if (tiles[i][j] == start_index) {
count++;
}
}
}
cout << count << endl;
}
return 0;
}
| 0
| 87,926,194
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ii pair<int,int>
#define fi first
#define sc second
#define all(x) (x).begin(),(x).end()
signed main() {
#ifdef _DEBUG
#endif
ios::sync_with_stdio(0); cin.tie(0);
int n;
cin >> n;
string o;
set<string> d;
for (int i = 1; i <= n; i++) {
string s;
cin >> s;
if ((i > 1 && o.back() != s.front()) || d.count(s)) {
cout << "No" << '\n';
return 0;
}
o = s;
d.insert(s);
}
cout << "Yes" << '\n';
}
|
#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
#define fi first
#define se second
#define pb push_back
#define mod(n,k) ( ( ((n) % (k)) + (k) ) % (k))
#define forn(i,a,b) for(int i = a; i < b; i++)
#define forr(i,a,b) for(int i = a; i >= b; i--)
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef long double ld;
typedef pair<int,int> ii;
typedef vector<int> vi;
typedef vector<ii> vii;
#define MAX 100000+10
#define MOD 1000000007
ll fac[MAX],caf[MAX];
ll deg(ll x,ll d){
d %= MOD - 1;
if(d < 0)d += MOD - 1;
ll y = 1;
while (d) {
if (d & 1) y *= x, y %= MOD;
x *= x, x %= MOD;
d /= 2;
}
return y;
}
ll coeff(int n,int k){
return fac[n] * caf[k] % MOD * caf[n - k] % MOD;
}
int main(){
ios_base::sync_with_stdio(0); cin.tie(0);
fac[0] = caf[0] = 1;
forn(i,1,MAX)fac[i] = i * fac[i - 1] % MOD, caf[i] = deg(fac[i], -1);
int S; cin >> S;
ll res = 0;
forn(i,1,2000){
int Sp = S-3*i;
if(Sp < 0)break;
ll add = coeff(i+Sp-1,i-1);
res = ((res%MOD)+(add%MOD))%MOD;
}
if(res < 0)res += MOD;
cout << res << '\n';
return 0;
}
| 0
| 3,452,430
|
#include "bits/stdc++.h"
using namespace std;
class HandV {
private:
int h, w, k;
int black = 0;
int ans = 0;
vector<string> board;
vector<int> hBlack;
vector<bool> hDrawn;
public:
HandV(int _h, int _w, int _k) {
h = _h;
w = _w;
k = _k;
board = vector<string>(h);
hBlack = vector<int>(h, 0);
hDrawn = vector<bool>(h, false);
}
void setBoard() {
for (int i = 0; i < h; i++) {
cin >> board.at(i);
for (auto e : board.at(i)) {
if (e == '#') {
black++;
hBlack.at(i)++;
}
}
}
if (black == k) ans++;
}
void drawH(int _h) {
if (black - hBlack.at(_h) < k || _h >= h) return;
else if (black - hBlack.at(_h) == k) ans++;
black -= hBlack.at(_h);
hDrawn.at(_h) = true;
for (int i = _h + 1; i < h; i++) {
drawH(i);
}
for (int i = 0; i < w; i++) {
drawW(i);
}
hDrawn.at(_h) = false;
black += hBlack.at(_h);
}
void drawW(int _w) {
int wBlack = 0;
for (int i = 0; i < h; i++) {
if (hDrawn.at(i) == false && board.at(i).at(_w) == '#') {
wBlack++;
}
}
if (black - wBlack < k) return;
else if (black - wBlack == k) ans++;
black -= wBlack;
for (int i = _w + 1; i < w; i++) {
drawW(i);
}
black += wBlack;
}
void solve() {
setBoard();
for (int i = 0; i < h; i++) {
drawH(i);
}
for (int i = 0; i < w; i++) {
drawW(i);
}
cout << ans << endl;
}
};
int main() {
int h, w, k;
cin >> h >> w >> k;
HandV hv(h, w, k);
hv.solve();
}
|
#include <iostream>
#include<cmath>
using namespace std;
int main()
{
double a, b, k;
cin >> a >> b >> k;
double vol = a * a * b;
double pi = acos(-1);
double d = atan(b / a);
if (vol / 2 < k) {
int amari = vol - k;
double ans = atan(amari*2.0 / (a * a * a));
printf("%.10f", ans*180/pi);
}
else if (vol / 2 == k) {
printf("%.10f", d*180/pi);
}
else {
double ans = pi/2- atan(2.0 * k / (a * b * b));
printf("%.10f", ans*180/pi);
}
return 0;
}
| 0
| 49,220,127
|
#include <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
#define rep(i,a,b) for(ll i=a;i<b;i++)
#define rrep(i,b,a) for(int i=b;i>=a;i--)
#define fori(a) for(auto i : a )
#define all(a) begin(a), end(a)
#define set(a,b) memset(a,b,sizeof(a))
#define sz(a) a.size()
double pi=acos(-1);
#define ll long long
#define ull unsigned long long
#define pb push_back
#define PF push_front
#define pq priority_queue
const ll mod=1000000007;
#define f first
#define s second
#define pii pair< ll, ll >
#define vi vector<int>
#define vpii vector<pii>
#define debug(v) for(auto i:v) cout<<i<<" ";
#define tc int t; cin >> t; while(t--)
using namespace boost::multiprecision;
using namespace std;
void optimizeIO(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int N=1000005;
ll fact[N],invfact[N];
ll power(ll x,ll y){
if(y<=0) return 1LL;
ll z=power(x,y/2);
if(y%2) return (((z*z)%mod)*x)%mod;
return (z*z)%mod;
}
void pre(){
fact[0]=invfact[0]=invfact[1]=fact[1]=1;
rep(i,2,N) fact[i]=(i*fact[i-1])%mod;
rep(i,2,N) invfact[i]=(invfact[i-1]*power(i,mod-2))%mod;
}
ll nCr(ll n,ll k){ return (((fact[n]*invfact[n-k])%mod)*invfact[k])%mod; }
const int N1=1e6+1;
vector<int> isprime(N1,1),prime;
void seive(){
rep(i,2,sqrt(N1)+1){
if(isprime[i]){
for(int j=i*i;j<N1;j+=i) isprime[j]=0;
prime.pb(i);
}
}
rep(i,sqrt(N1)+1,N1) if(isprime[i]) prime.pb(i);
}
struct dsu {
vector<int> par, rank;
dsu(int n): par(n+1), rank(n+1) {
for (int i = 0; i <= n; i++) {
par[i] = i;
rank[i]= 1;
}
}
int root(int a) {
if (a == par[a]) return a;
return par[a] = root(par[a]);
}
void merge(int a, int b) {
a = root(a);
b = root(b);
if (a == b) return;
if (rank[a] > rank[b]) swap(a, b);
par[b] = a;
}
set<int> parent(int n){
set<int> s;
for(int i=1;i<=n;i++){
s.insert(root(i));
}
return s;
}
};
void solve(){
int n,y;
cin>>n>>y;
y/=1000;
rep(i,0,n+1){
rep(j,0,n+1){
int z=y-i*10-j*5;
if((i+j+z)==n && z>=0){
cout<<i<<" "<<j<<" "<<z<<endl;
return;
}
}
}
cout<<"-1 -1 -1"<<endl;
}
int main(){
optimizeIO();
int r=1;
{solve();}
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define P pair<ll, ll>
#define Graph vector<vector<ll>>
#define fi first
#define se second
constexpr ll mod = 1000000007;
constexpr ll INF = (1ll << 60);
constexpr double pi = 3.14159265358979323846;
template <typename T>
inline bool chmax(T &a, T b){if (a < b){a = b;return 1;}return 0;}
template <typename T>
inline bool chmin(T &a, T b){if (a > b){a = b;return 1;}return 0;}
int main(){
string s;cin>>s;
bool yes=true;
if(s[0]!='A') yes=false;
ll cnt = 0;
bool BIG=false;
ll key=-1;
for(ll i=2;i<=s.size()-2;i++){
if(s[i]=='C'){
cnt++;
key=i;
}
}
rep(i,s.size()){
if(i==0 || i==key) continue;
if(!('a'<=s[i] && s[i]<='z')) BIG=true;
}
if (cnt != 1)
yes = false;
if (BIG)
yes = false;
if(yes) cout<<"AC"<<endl;
else cout<<"WA"<<endl;
return 0;
}
| 0
| 43,784,403
|
#include <iostream>
using namespace std;
int main() {
int n,t_p=0,h_p=0;
string taro,hanako;
cin>>n;
while (n!=0){
cin>>taro>>hanako;
if(taro==hanako){t_p++;h_p++;}
else taro>hanako? t_p+=3 : h_p+=3;
n--;
}
cout<<t_p<<" "<<h_p<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int K;
string S;
cin>>K;
cin>>S;
for(int i= 0; i < S.length(); i++){
if(i>=K){
cout<<"...";
break;
}else{
cout<<S[i];
}
}
}
| 0
| 39,492,384
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,N) for(int i=0;i<int(N);++i)
#define rep1(i,N) for(int i=1;i<int(N);++i)
#define all(a) (a).begin(),(a).end()
#define print(v) { cerr<<#v<<": [ "; for(auto _ : v) cerr<<_<<", "; cerr<<"]"<<endl; }
#define printpair(v) { cerr<<#v<<": [ "; for(auto _ : v) cerr<<"{"<<_.first<<","<<_.second<<"}"<<", "; cerr<<"]"<<endl; }
#define dump(x) cerr<<#x<<": "<<x<<endl;
#define bit(k) (1LL<<(k))
#define Yes "Yes"
#define No "No"
#define YES "YES"
#define NO "NO"
typedef long long ll;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
const int INF = (ll)1e9;
const ll INFLL = (ll)1e18+1;
const ll MOD = (ll)1e9+7;
const double PI = acos(-1.0);
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll N,K;
cin >> N >> K;
vector<ll> A(N);
rep(i,N){
cin>>A[i];
A[i]--;
A[i] %= K;
}
vec<ll> cum(N+1, 0);
rep(i,N){
cum[i+1] = cum[i] + A[i];
cum[i+1] %= K;
}
map<ll, int> mp;
ll ans = 0;
rep(i,N+1){
if(i >= K){
mp[cum[i - K]]--;
}
ans += mp[cum[i]];
mp[cum[i]]++;
}
cout << ans << endl;
}
|
#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <cmath>
#include <map>
#include <climits>
#include <cassert>
#include <algorithm>
#include <utility>
using namespace std;
using Int = long long int;
using UInt = unsigned long long int;
using VI = vector<long long int>;
using VVI = vector<vector<long long int> >;
int main(void) {
string s;
cin >> s;
string result = "";
for (Int i = 0; i < (Int)s.length(); ++i) {
if (s[i] == '0' || s[i] == '1') {
result += s[i];
} else if (s[i] == 'B' && result != "") {
result.pop_back();
}
}
cout << result << endl;
return 0;
}
| 0
| 57,405,458
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1 << 30;
int fr[100002];
int main() {
int n;
cin >> n;
rep(i, n) {
int a; cin >> a;
a--;
fr[i] = a;
}
ll cnt = 0;
rep(i, n) {
int j = fr[i];
if (fr[j] == i) cnt++;
}
cnt /= 2;
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORR(x, arr) for (auto& x : arr)
#define ITR(x, c) for (__typeof(c.begin()) x = c.begin(); x != c.end(); x++)
#define ALL(a) (a.begin()), (a.end())
#define ZERO(a) memset(a, 0, sizeof(a))
#define MINUS(a) memset(a, 0xff, sizeof(a))
string s1, s2;
int dp[1145][1145];
int rec(int i, int j) {
if (i > s1.size() || j > s2.size()) {
return 1 << 20;
}
if (j == 0) {
return i;
}
if (i == 0) {
return j;
}
if (dp[i][j] >= 0) {
return dp[i][j];
} else {
int x = 1 << 20;
if (s1[i - 1] == s2[j - 1]) {
x = min(x, rec(i - 1, j - 1));
}
x = min(x, rec(i - 1, j) + 1);
x = min(x, rec(i, j - 1) + 1);
x = min(x, rec(i - 1, j - 1) + 1);
dp[i][j] = x;
return x;
}
}
void solve() {
cin >> s1 >> s2;
fill(dp[0], dp[1145], 1 << 20);
REP(i, 1145) dp[i][0] = i;
REP(i, 1145) dp[0][i] = i;
FOR(i, 1, s1.size() + 1) {
FOR(j, 1, s2.size() + 1) {
if (s1[i - 1] == s2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1];
}
dp[i][j] = min(dp[i][j], dp[i - 1][j] + 1);
dp[i][j] = min(dp[i][j], dp[i][j - 1] + 1);
dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] + 1);
}
}
cout << dp[s1.size()][s2.size()] << endl;
}
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 0
| 65,649,368
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int X, Y;
cin >> X >> Y;
bool flag = false;
int legs = 0;
for(int i=0; i<=X; i++){
int j = X-i;
legs = 2*i + 4*j;
if(legs == Y){
flag = true;
break;
}
}
if(flag)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define REPR(i,n) for(int i=n; i>-1; --i)
#define ALL(a) (a).begin(),(a).end()
#define FILL(a,n,x); REP(i,(n)){ (a)[i]=(x); }
#define CINA(a,n); REP(i,(n)){ cin >> (a)[i]; }
#define FILL2(a,n,m,x); REP(i,(n)){ REP(j,(m)){(a)[i][j]=(x);} }
#define CINA2(a,n,m); REP(i,(n)){ REP(j,(m)){cin >> (a)[i][j];} }
#define Liny "Yes\n"
#define Linn "No\n"
#define LINY "YES\n"
#define LINN "NO\n"
int keta(ll x){ if(x<10){return 1;} else{return keta(x/10) + 1;}}
int keta_wa(ll x){ if(x<10){return x;} else{return keta_wa(x/10) + x%10;} }
int ctoi(char c){ return ( (c>='0' && c<='9')? c - '0': 0 );}
int __stoi(string s){ return atoi(s.c_str()); }
ll sum(ll a[],ll N){ return accumulate(a,a+N,0LL);}
ll gcd(ll a,ll b){if(a<b)swap(a,b); return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b){if(a<b){swap(a,b);} return a/gcd(a,b)*b;}
template<class T> void chmax(T& a, T b){ if(a<b){a=b;} }
template<class T> void chmin(T& a, T b){ if(a>b){a=b;} }
template<class T> bool isIn(T a,vector<T> v){ for(T x:v){ if(a==x){return true;}} return false;}
string strReplace(string s,string target, string replacement){
if (!target.empty()) {
std::string::size_type pos = 0;
while ((pos = s.find(target, pos)) != std::string::npos) {
s.replace(pos, target.length(), replacement);
pos += replacement.length();
}
}
return s;
}
const ll MOD = 1e9+7;
#define pii pair<int,int>
#define pll pair<ll,ll>
#define MP make_pair
int main(){
int N,K; cin>>N>>K;
int a[N]; CINA(a,N);
REP(count,min(K,50)){
int b[N+1] = {0};
REP(i,N){
int left = max(0,i-a[i]);
int right = min(N-1,i+a[i]);
++b[left];
--b[right+1];
}
for(int i=1;i<N;++i){
b[i] += b[i-1];
}
REP(i,N){
a[i] = b[i];
}
}
REP(i,N){
if(i<N-1){ cout << a[i] << " ";}
else{ cout << a[i] << "\n";}
}
}
| 0
| 55,117,104
|
#include<iostream>
#include<iomanip>
#include<string>
#include<algorithm>
#include<vector>
#include<utility>
#include<tuple>
#include<map>
#include<queue>
#include<stack>
#include<deque>
#include<bitset>
#include<math.h>
using namespace std;
using intl = int64_t;
using graph = vector<vector<int> >;
int main(){
int n,k;
cin >> n >> k;
vector<intl> h;
for(int i=0;i<n;i++){
intl f;
cin >> f;
h.push_back(f);
}
if(n<=k) {
cout << 0 << endl;
return 0;
}
sort(h.begin(),h.end());
reverse(h.begin(),h.end());
intl sum=0;
for(int i=k;i<n;i++){
sum += h.at(i);
}
cout << sum << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
#endif
ll n,m;
cin>>n>>m;
vector<ll> a(n);
for(int i=0;i<n;i++)
{
cin>>a[i];
a[i]=a[i]/2;
}
ll lcm=a[0];
ll prev;
for(int i=1;i<n;i++)
{
prev=lcm;
lcm=(lcm*a[i])/(__gcd(lcm,a[i]));
if(lcm<prev)
{
cout<<0<<endl;
return 0;
}
if((lcm/a[i])%2==0)
{
cout<<0<<endl;
return 0;
}
}
ll ans=(m/(lcm));
long double div=2;
ans=ceil(ans/div);
cout<<ans;
return 0;
}
| 0
| 19,988,911
|
#include <bits/stdc++.h>
#include <iostream>
#include <utility>
#include <string>
#include <vector>
#define MAX_N 100001
#define MOD 1000000007
#define FOR(i, a, b) for(ll i=a; i<b; i++)
#define REP(i, n) for(ll i=0; i<n; i++)
#define RER(i, n) for(ll i=n-1; i>=0; i--)
#define ALL(v) v.begin() v.end()
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
ll n;
string s;
bool d[2*MAX_N];
signed main(){
cin >> n >> s;
d[0] = 1;
for(ll i=1; i<2*n; i++){
if(s[i] == s[i-1]) d[i] = 1 - d[i-1];
else d[i] = d[i-1];
}
ll ret = 1;
ll num_l = 1;
for(ll i=1; i<2*n; i++){
if(d[i]) num_l++;
else{
ret *= num_l--;
ret %= MOD;
}
}
if(num_l != 0) ret = 0;
if(s[0] == 'W') ret = 0;
ret %= MOD;
for(ll i=1; i<=n; i++){
ret *= i;
ret %= MOD;
}
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <string>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <bitset>
typedef long long ll;
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
const int MAX = 510000;
const int MOD = 1000000007;
const int MAX_N = 200000;
int ctoi(const char c){
switch(c){
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
default : return -1;
}
}
long long modpow(long long a, long long n) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % MOD;
a = a * a % MOD;
n >>= 1;
}
return res;
}
int main(int argc, const char * argv[]) {
ll N; cin >> N ;
vector< bitset<61> > A;
for(ll i=0;i<N;i++){
ll temp; cin >> temp;
bitset<61> B(temp);
A.push_back(B);
}
ll ans = 0;
for(ll i=0; i<61; i++){
ll one_num = 0;
for(ll j=0; j<N;j++){
if(A[j][i]) one_num++;
}
ans = ( ans + ((one_num * (N - one_num)) % MOD ) * modpow(2,i) ) % MOD;
}
cout << ans % MOD << endl;
return 0;
}
| 0
| 66,191,046
|
#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() {
double n, m;
cin >> n >> m;
vector<double> a(n);
rep(i, n) cin >> a[i];
sort(a.begin(), a.end(), greater<int>());
double s = accumulate(a.begin(), a.end(), 0);
rep(i, m) {
if(s / (4 * m) > a[i]) {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << 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 repl(i, l, r) for(int i = (l); i < (r); i++)
#define per(i, n) for(int i = ((n)-1); i >= 0; i--)
#define perl(i, l, r) for(int i = ((r)-1); i >= (l); i--)
#define all(x) (x).begin(),(x).end()
#define MOD9 998244353
#define MOD1 1000000007
#define IINF 1000000000
#define LINF 1000000000000000000
#define SP <<" "<<
#define CYES cout<<"Yes"<<endl
#define CNO cout<<"No"<<endl
#define CFS cin.tie(0);ios::sync_with_stdio(false)
#define CST(x) cout<<fixed<<setprecision(x)
using ll = long long;
using ld = long double;
using vi = vector<int>;
using mti = vector<vector<int>>;
using vl = vector<ll>;
using mtl = vector<vector<ll>>;
using pi = pair<int, int>;
using pl = pair<ll, ll>;
template<typename T>
using heap = priority_queue<T, vector<T>, function<bool(const T, const T)>>;
int main() {
int n, q;
cin >> n >> q;
dsu d(n);
rep(i, q) {
int c, a, b;
cin >> c >> a >> b;
if (c == 0) {
d.merge(a, b);
} else {
cout << (d.same(a, b) ? 1 : 0) << endl;
}
}
return 0;
}
| 0
| 68,927,590
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.