code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include<stdio.h>
int main()
{
int A,B,C;
scanf("%d%d",&A,&B);
C=A*B;
printf("%d",C);
return 0;
} | #include <bits/stdc++.h>
#define sz(arr) (int)arr.size()
#define all(arr) arr.begin(), arr.end()
using namespace std;
void _cin() {}
template <class Head, class... Tail>
void _cin(Head&& head, Tail&&... tail) {
cin >> head;
_cin(forward<Tail>(tail)...);
}
#define Cin(T, ...) \
T __VA_ARGS__; \
_cin(__VA_ARGS__)
int main() {
Cin(int, n, k);
cout << n - k + 1 << endl;
return 0;
} | 0 |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<vector>
int cnt;
int l;
int A[1000000];
int n;
std::vector<int> G;
void insertionSort(int A[], int n, int g) {
for (int i = g; i < n; i++) {
int v = A[i];
int j = i - g;
while (j >= 0 && A[j] > v) {
A[j + g] = A[j];
j -= g;
cnt++;
}
A[j + g] = v;
}
}
void shellSort(int A[], int n) {
for (int h=1; ; ) {
if (h > n) {
break;
}
G.push_back(h);
h = 3*h + 1;
}
for (int i = G.size()-1; i >=0; i--) {
insertionSort(A, n, G[i]);
}
}
int main() {
std::cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
cnt = 0;
shellSort(A, n);
std::cout << G.size() << std::endl;
for (int i = G.size() - 1; i >= 0; i--) {
printf("%d", G[i]);
if (i) printf(" ");
}
printf("\n");
printf("%d\n", cnt);
for (int i = 0; i < n; i++) {
printf("%d\n", A[i]);
}
return 0;
}
| #include <iostream>
#include <algorithm>
#include <string>
#define N 50
using namespace std;
struct data{
string l;
int p,a,b,c,d,e,f,s,m;
double cal;
};
int main(){
int n,i,j,time;
struct data d[N];
while(1){
cin >> n;
if(n==0) break;
for(i=0;i<n;i++){
cin >> d[i].l >> d[i].p >> d[i].a >> d[i].b >> d[i].c;
cin >> d[i].d >> d[i].e >> d[i].f >> d[i].s >> d[i].m;
time=(d[i].a+d[i].b+d[i].c+d[i].d+d[i].e);
d[i].m--;
time+=(d[i].d+d[i].e)*d[i].m;
d[i].cal=((double)d[i].f*d[i].s*(d[i].m+1)-d[i].p)/time;
}
for(i=0;i<n;i++){
for(j=1;j<n;j++){
if(d[j].l<d[j-1].l) swap(d[j],d[j-1]);
}
}
for(i=0;i<n;i++){
for(j=1;j<n;j++){
if(d[j].cal>d[j-1].cal) swap(d[j],d[j-1]);
}
}
for(i=0;i<n;i++) cout << d[i].l << endl;
cout << '#' << endl;
}
return 0;
} | 0 |
//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx,avx2,fma")
#pragma GCC optimize("O3")
#include<iostream>
#include<algorithm>
#include<string>
#include<cmath>
#include<cstdlib>
#include<set>
#include<vector>
#include<sstream>
#include<queue>
#include <iomanip>
#include<unordered_set>
#include <stack>
#include <unordered_map>
#include <map>
#include<numeric>
#include<chrono>
#include <fstream>
constexpr auto INF = 9223372036854775807;
typedef long long int ll;
typedef unsigned long long int ull;
typedef unsigned long int ul;
#define f(i,a,b) for(ll i=(ll)a;i<(ll)b;i+=1)
#define rf(i,a,b) for(ll i=(ll)a;i>=(ll)b;i-=1)
#define endl '\n'
#define N 1000000007 // prime modulo value
#define M 998244353
#define all(x) x.begin(),x.end()
#define mkp(a,b) make_pair(a,b)
using namespace std;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
inline int mex(unordered_set<int> st)
{
int m = 0;
while (st.find(m) != st.end())
{
m += 1;
}
return m;
}
inline int calculateGrundy(int n)
{
if (n == 1)
return 0;
unordered_set<int> mexi;
for (int i = 1; i <= sqrt(n); i += 1)
{
if (n % i == 0)
{
if (n / i != n)
mexi.insert(calculateGrundy(n / i));
mexi.insert(calculateGrundy(i));
}
}
return mex(mexi);
}
inline ll gcd(ll a, ll b)
{
// This is code taken from geeksforgeek
if (b == 0)
return a;
return gcd(b, a % b);
}
/*ll power(ll x, ll y)
{
// This is code taken from geeksforgeek
ll res = 1;
x = x % N;
if (x == 0) return 0;
while (y > 0)
{
if (y & 1)
res = (res * x) % N;
y = y >> 1;
x = (x * x) % N;
}
return res;
}*/
ll power(ll x, ll y)
{
ll res = 1;
x = x;
while (y > 0)
{
if (y & 1)
res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
/*ll modInverse(ll n, ll p)
{
return power(n, p - 2, p);
}*/
ll sum(ll n)
{
return (n * (n + 1)) / 2;
}
ll sum_digit(ll n)
{
ll ans = 0;
while (n)
{
ans += n % 10;
n /= 10;
}
return ans;
}
ll gp(ll r, ll n)
{
return (pow(r, n) - 1) / (r - 1);
}
int main()
{
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
ll n;
cin>>n;
vector<ll> arr(n,0);
f(i,0,n)
{
cin>>arr[i];
}
ll ans=0;
f(i,1,n)
{
if(arr[i]<arr[i-1])
{
ans+=arr[i-1]-arr[i];
arr[i]=arr[i-1];
}
}
cout<<ans;
return 0;
} | #include <iostream>
#include <cmath>
using namespace std;
void sort(int *val, int n) {
for (int i = n - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (val[i] < val[j]) swap(val[i], val[j]);
}
}
}
bool judge(int *val, int n, int num) {
for (int i = 0; i < n; i++) {
if (val[i] % num != 0) return false;
}
return true;
}
int main() {
int n, i, k, harf, count;
int val[3], div[10000];
cin >> n;
for (i = 0; i < n; i++) cin >> val[i];
sort(val, n);
harf = (int)sqrt(val[0]);
div[0] = count = 1;
for (i = 2; i <= harf; i++) {
if (val[0] % i == 0) div[count++] = i;
}
cout << 1 << endl;
for (i = 1; i < count; i++) {
if (judge(&val[1], n - 1, div[i])) cout << div[i] << endl;
}
if (div[count - 1] == harf) count--;
for (i = count - 1; i >= 0; i--) {
k = (int)(val[0] / div[i]);
if (judge(&val[1], n - 1, k)) cout << k << endl;
}
return 0;
}
| 0 |
#include "bits//stdc++.h"
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
const ll MOD = 1e9 + 7;
#define ALL(v) v.begin(), v.end()
typedef pair<int, int> P;
ll mod_pow(ll a, ll n) {
if (n == 0) return 1;
if (n % 2 == 0) {
ll tmp = mod_pow(a, n / 2);
return (tmp * tmp) % MOD;
}
return (a * mod_pow(a, n - 1)) % MOD;
}
int A[500001];
int zero[500001];
int pre[1 << 20];
vector<P> v[1 << 20];
ll dp[500001][2];
void solve(int k) {
for (int i = 0; i <= v[k].size(); i++) dp[i][0] = dp[i][1] = 0;
dp[1][0] = 1;
for (int i = 1; i < v[k].size(); i++) {
dp[i + 1][0] = dp[i][0];
dp[i + 1][1] = dp[i][1];
if (v[k][i].first == 0) {
(dp[i + 1][0] += dp[i][1] * v[k][i].second) %= MOD;
}
else {
(dp[i + 1][1] += dp[i][0] * v[k][i].second) %= MOD;
}
}
return;
}
int main() {
int N;
cin >> N;
for (int i = 1; i <= N; i++) cin >> A[i];
for (int i = 1; i <= N; i++) A[i] ^= A[i - 1];
memset(pre, -1, sizeof(pre));
zero[0] = 1;
for (int i = 1; i <= N; i++) {
zero[i] = zero[i - 1];
if (A[i] != 0) {
int cnt = zero[i];
if (pre[A[i]] != -1) cnt -= zero[pre[A[i]]];
if (cnt > 0) v[A[i]].emplace_back(0, cnt);
v[A[i]].emplace_back(A[i], 1);
pre[A[i]] = i;
}
else {
zero[i]++;
}
}
for (int i = 1; i < (1 << 20); i++) {
if (pre[i] == -1) continue;
int cnt = zero[N];
cnt -= zero[pre[i]];
if (cnt > 0) v[i].emplace_back(0, cnt);
}
int X = A[N];
if (X != 0) {
solve(X);
cout << dp[v[X].size() - 1][0] << endl;
return 0;
}
ll ans = 0;
for (int i = 1; i < (1 << 20); i++) {
if (v[i].empty()) continue;
solve(i);
(ans += dp[v[i].size() - 1][1]) %= MOD;
}
(ans += mod_pow(2, zero[N] - 2)) %= MOD;
cout << ans << endl;
}
| #include <bits/stdc++.h>
#include <boost/range/irange.hpp>
using namespace std;
using namespace boost;
main() {
int64_t n;
cin >> n;
int64_t x = 0;
vector<int64_t> xx(n);
for (auto i : irange(0L, n)) {
int64_t aa;
cin >> aa;
x ^= aa;
xx[i] = x;
}
constexpr auto M = 1000000007;
auto last_x = xx.back();
cerr << last_x << endl;
if (last_x > 0) {
int64_t count = 0;
int64_t count0 = 0;
for (auto x : xx) {
if (x == 0) {
count0 += count;
count0 %= M;
} else if (x == last_x) {
count += count0 + 1;
count %= M;
}
}
cout << count0 + 1 << endl;
} else {
unordered_map<int64_t, int64_t> count0;
unordered_map<int64_t, int64_t> count;
unordered_map<int64_t, int64_t> last_num0;
int64_t num0 = 0;
for (auto i : irange(0L, n)) {
auto x = xx[i];
if (x == 0) {
++num0;
} else {
count0[x] += (count[x] * ((num0 - last_num0[x]) % M)) % M;
count[x] += count0[x] + 1;
count[x] %= M;
last_num0[x] = num0;
}
}
int64_t ans = 0;
for (auto kv : count) {
ans += kv.second;
ans %= M;
}
int64_t p0 = 1;
for (auto i : irange(0L, num0 - 1)) {
p0 *= 2;
p0 %= M;
}
cerr << ans << endl;
cerr << p0 << endl;
cout << (ans + p0) % M << endl;
}
} | 1 |
using namespace std;
#include <bits/stdc++.h>
int main()
{
int a,b,c,d;
cin>>a>>b>>c>>d;
if(a+b==c+d)std::cout << "Balanced" << std::endl;
else if(a+b<c+d)std::cout << "Right" << std::endl;
else std::cout << "Left" << std::endl;
} | #include<iostream>
using namespace std;
int main()
{
char S[3];
cin>>S;
if(S[0]=='7'||S[1]=='7'||S[2]=='7')
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return 0;
}
| 0 |
#include <iostream>
using namespace std;
#define N 8
#define FREE 0
#define NOT_FREE -1
bool BOARD[N][N] = { false };
int C_COL[N], C_ROW[N], C_DIAGONAL_L[2*N], C_DIAGONAL_R[2*N];
void printBoard() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (BOARD[i][j])
if (C_ROW[i] != j) return;
}
}
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
cout << (C_ROW[i] == j ? 'Q' : '.');
}
cout << endl;
}
}
void solve(int i) {
if (i == N) {
printBoard();
return;
}
for (int j = 0; j < N; j++) {
if (C_COL[j] == NOT_FREE ||
C_DIAGONAL_L[i+j] == NOT_FREE ||
C_DIAGONAL_R[i-j+N-1] == NOT_FREE
) continue;
C_ROW[i] = j;
C_COL[j] = C_DIAGONAL_L[i+j] = C_DIAGONAL_R[i-j+N-1] = NOT_FREE;
solve(i+1);
C_ROW[i] = C_COL[j] = C_DIAGONAL_L[i+j] = C_DIAGONAL_R[i-j+N-1] = FREE;
}
//cout << "no solution for input" << endl;
}
int main() {
for (int i = 0; i < N; i++) {
C_COL[i] = C_ROW[i] = FREE;
C_DIAGONAL_L[i] = C_DIAGONAL_R[i] = FREE;
C_DIAGONAL_L[2*i] = C_DIAGONAL_R[2*i] = FREE;
}
int k; cin >> k;
while (k--) {
int r, c; cin >> r >> c;
BOARD[r][c] = true;
}
solve(0);
} | #include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 1e5+5;
ll minnx[N];
int n;
struct node {
ll l,r;
}a[N],s[N];
bool cmp(node a,node b){
return a.l>b.l;
}
int main(){
cin>>n;
ll maxx=0,minn=1e17,maxlen=0;
for(int i=1;i<=n;i++){
cin>>a[i].l>>a[i].r;
maxx=max(maxx,a[i].l);
minn=min(minn,a[i].r);
maxlen=max(maxlen,a[i].r-a[i].l+1);
}
ll ans1=maxlen+max(minn-maxx+1,0ll);
for(int i=1;i<=n;i++){
s[i].l=max(minn-a[i].l+1,0ll);
s[i].r=max(a[i].r-maxx+1,0ll);
}
sort(s+1,s+n+1,cmp);
minnx[n+1]=1e18;
for(int i=n;i>=1;i--) minnx[i]=min(minnx[i+1],s[i].r);
ll ans2=0;
for(int i=1;i<=n-1;i++){
// cout<<s[i].l<<" "<<s[i].r<<endl;
ans2=max(ans2,s[i].l+minnx[i+1]);
// cout<<ans2<<endl;
}
// cout<<ans1<<" "<<ans2<<endl;
cout<<max(ans1,ans2)<<endl;
return 0;
} | 0 |
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;
bool includes_keyword(const char *str) {
const static char *keywords[] = { "the", "this", "that" };
for (const auto keyword : keywords) {
const char *pos = strstr(str, keyword);
if (pos == NULL) { continue; }
if (pos != str && isalpha(pos[-1])) { continue; }
if (isalpha(pos[strlen(keyword)])) { continue; }
return true;
}
return false;
}
int main() {
char *cipher = NULL;
size_t buffer_size = 0;
ssize_t len;
while ((len = getline(&cipher, &buffer_size, stdin)) > 0) {
if (cipher[len - 1] == '\n') {
cipher[len - 1] = '\0';
len -= 1;
}
char decoded[81];
for (int i = 0; i < 26; ++i) {
strcpy(decoded, cipher);
for (int j = 0; j < len; ++j) {
if (islower(decoded[j])) {
decoded[j] += i;
if (!islower(decoded[j])) { decoded[j] -= 26; }
}
}
if (includes_keyword(decoded)) { break; }
}
puts(decoded);
}
free(cipher);
return 0;
} | #include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
long long int nums[10000];
bool flags[10000];
int index[10000];
int main(){
while(true){
int n;
cin >> n;
if(n == 0){
break;
}
for(int i = 0; i < 10000; i++){
nums[i] = 0;
flags[i] = true;
}
for(int i = 0; i < n; i++){
long long int e, p, q;
cin >> e >> p >> q;
nums[e] += p * q;
index[i] = e;
}
bool check = false;
for(int i = 0; i < n; i++){
if(nums[index[i]] >= 1000000 && flags[index[i]]){
cout << index[i] << endl;
check = true;
flags[index[i]] = false;
}
}
if(!check){
cout << "NA" << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
//#define int long long
//signed main(){
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int h,w;
cin >> h >> w;
vector<int> a(h*w);
for(int i = 0; i < h; i++) {
for(int j = 0; j < w; j++) {
if(i%2) cin >> a[i*w+w-1-j];
else cin >> a[i*w+j];
}
}
vector<string> ans;
for(int i = 0; i < h*w-1; i++) {
if(a[i]%2){
a[i]--;
a[i+1]++;
int r=i/w;
int c=i%w;
int nr=(i+1)/w;
int nc=(i+1)%w;
if(r%2) c=w-1-c;
if(nr%2) nc=w-1-nc;
string tmp=to_string(r+1)+" "+to_string(c+1)+" "+to_string(nr+1)+" "+to_string(nc+1);
ans.emplace_back(tmp);
}
}
cout << ans.size() << "\n";
for(int i = 0; i < ans.size(); i++) cout << ans[i] << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, m, n) for(int(i) = (int)(m); i < (int)(n); ++i)
#define rep2(i, m, n) for(int(i) = (int)(n)-1; i >= (int)(m); --i)
#define REP(i, n) rep(i, 0, n)
#define REP2(i, n) rep2(i, 0, n)
#define all(hoge) (hoge).begin(), (hoge).end()
#define en '\n'
using ll = long long;
using ull = unsigned long long;
template <class T>
using vec = vector<T>;
template <class T>
using vvec = vector<vec<T>>;
typedef pair<ll, ll> P;
using tp = tuple<ll, ll, ll>;
constexpr long long INF = 1LL << 60;
constexpr int INF_INT = 1 << 25;
//constexpr long long MOD = (ll)1e9 + 7;
constexpr long long MOD = 998244353LL;
using ld = long double;
static const ld pi = 3.141592653589793L;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
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;
}
//グラフ関連
struct Edge {
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to;
cap = _cap;
rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph &G, ll from, ll to, ll cap, bool revFlag, ll revCap) {
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if(revFlag)
G[to].push_back(Edge(from, revCap, (ll)G[from].size() - 1));
}
void solve() {
ll n;
cin >> n;
vec<ll> a(n), b(n), c(n + 1, 0), d(n + 1, 0);
REP(i, n) {
cin >> a[i];
c[a[i]]++;
}
REP(i, n) {
cin >> b[i];
d[b[i]]++;
}
REP(i, n) {
if(c[i + 1] + d[i + 1] >= n + 1) {
cout << "No" << en;
return;
}
c[i + 1] += c[i];
d[i + 1] += d[i];
}
ll x = -INF;
rep(i, 1, n + 1) {
chmax(x, c[i] - d[i - 1]);
}
cout << "Yes" << en;
vec<ll> ans(n);
REP(i, n) {
ans[(i + x) % n] = b[i];
}
for(auto i : ans)
cout << i << " ";
cout << en;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
/*
ll t;
cin >> t;
while(t--)*/
solve();
return 0;
}
| 0 |
// C
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
#endif
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#ifdef __GXX_EXPERIMENTAL_CXX0X__
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#endif
//#include <bits/stdc++.h>
#define all(v) v.begin(), v.end()
typedef long long ll;
#define rep(i, z, n) for(ll i = z; i < n; i++)
//const int INF = 1<<29;
//const ll MOD = 1000000007;
using namespace std;
int main(){
int A, B;
cin >> A >> B;
int ans = (B + A - 3) / (A - 1);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define INF 1e12
#define PB push_back
#define PF push_front
#define fi first
#define se second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vpi vector<pii>
#define vll vector<ll>
#define vpl vector<pll>
#define vvi vector<vector<int>>
#define vvl vector<vector<ll>>
#define MX(x) *max_element(all(x))
#define MN(x) *min_element(all(x))
#define ios ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define pr_d(x) cout << fixed << setprecision(15) << x << endl
#define ud(c, x) distance(c.begin(), upper_bound(all(c), x))
#define ld(c, x) distance(c.begin(), lower_bound(all(c), x))
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
#define rep3(i, n) for (int i = (n - 1); i >= 0; --i)
#define rep4(i, a, b) for (int i = (a); i > (b); --i)
#define pb push_back
#define out(x) cout << x << "\n"
bool odd(int i) { return i % 2; }
#define all(v) v.begin(), v.end()
#define size(x) int(x.size())
int gcd(int a, int b) { return __gcd(a, b); }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
void Yes_No(bool f) {
if (f)
printf("Yes\n");
else
printf("No\n");
}
void deb_p(pii p) { printf("pair = %d %d\n", p.fi, p.se); }
void deb_i(int i) { printf("i = %d\n", i); }
void deb_v(vector<int> v) {
printf("v = ");
for (auto i : v) printf("%d ", i);
printf("\n");
}
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;
}
//-------------------ここから回答する-----------------------
void solve(void) {
int n, x;
cin >> n >> x;
vector<ll> a(n);
rep(i, n) cin >> a[i];
vector<ll> sum(n - 1);
rep(i, n - 1) sum[i] = a[i] + a[i + 1];
ll ans = 0;
for (int i = 0; i < n - 1; ++i) {
if (sum[i] <= x)
continue;
else {
int d = min(a[i + 1], sum[i] - x);
ans += d;
sum[i] -= d;
sum[i + 1] -= d;
}
}
if (sum[0] > x) {
int d = sum[0] - x;
sum[0] -= d;
ans += d;
}
if (sum[n - 2] > x) {
int d = sum[n - 2] - x;
sum[n - 2] -= d;
ans += d;
}
cout << ans << endl;
}
int main(void) { solve(); } | 0 |
#include<bits/stdc++.h>
#define fast ios::sync_with_stdio(false);cin.tie(NULL)
using namespace std;
#define int long long
#define MOD 1000000007
typedef vector<int> vi;
typedef pair<int,int> pi;
#define inf 1e18
#define For(i,a,b) for (int i = a; i < b; i++)
#define Rep(i,a,b) for (int i = a; i <= b; i++)
#define ps(x,y) fixed << setprecision(y) << x
#define pb push_back
#define mp make_pair
int a[200005];
int32_t main()
{
fast;
int n, t, ans = 0; cin >> n >> t;
For(i, 0, n) cin >> a[i];
ans += t;
For(i, 1, n) {
ans += t;
if(a[i] < a[i-1] + t) ans -= (a[i-1] + t - a[i]);
}
cout << ans;
return 0;
} | #include <iostream>
#include <algorithm>
#include <deque>
using namespace std;
int H, W;
string S[2020];
int pt[2020][2020];
deque<pair<int, int> > st;
int main(int argc, const char * argv[]) {
cin >> H >> W;
for (int i = 0; i < H; ++i)
cin >> S[i];
for (int i = 0; i < H - 1; ++i) {
string r0 = S[i];
string r1 = S[i + 1];
bool p = (r0[0] == r1[0]);
pt[i][0] = 1;
int c = 1;
for (int j = 1; j < W; ++j) {
if (p == (r0[j] == r1[j])) {
c += 1;
} else {
p = !p;
c = 1;
}
pt[i][j] = c;
}
}
int max_area = (H < W) ? W : H;
for (int j = 0; j < W; ++j) {
st.push_back(make_pair(0, pt[0][j]));
for (int i = 1; i < H - 1; ++i) {
int w = pt[i][j];
int li = i;
while (!st.empty() && w < st.back().second) {
pair<int, int> p = st.back();
st.pop_back();
li = p.first;
int area = p.second * (i - (st.empty() ? 0 : li) + 1);
max_area = (max_area < area) ? area : max_area;
}
if (st.empty() || st.back().second < w) {
st.push_back(make_pair(li, w));
}
}
while (!st.empty()) {
pair<int, int> p = st.back();
st.pop_back();
int area = p.second * (H - (st.empty() ? 0 : p.first));
max_area = (max_area < area) ? area : max_area;
}
}
cout << max_area << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define bp __builtin_popcountll
#define pb push_back
#define in(s) freopen(s, "r", stdin);
#define out(s) freopen(s, "w", stdout);
#define inout(s, end1, end2) freopen((string(s) + "." + end1).c_str(), "r", stdin),\
freopen((string(s) + "." + end2).c_str(), "w", stdout);
#define fi first
#define se second
#define bw(i, r, l) for (int i = r - 1; i >= l; i--)
#define fw(i, l, r) for (int i = l; i < r; i++)
#define fa(i, x) for (auto i: x)
using namespace std;
const int mod = 1e9 + 7, inf = 1061109567;
const long long infll = 4557430888798830399;
const int N = 2e5 + 5;
int n, k, a[N], cnt[N];
signed main() {
#ifdef BLU
in("blu.inp");
#endif
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin >> n >> k;
fw (i, 0, n) cin >> a[i];
// fw (i, 0, n) cout << a[i] << " "; cout << "\n";
int steps = 0;
fw (i, 0, k) {
fw (j, 0, n) cnt[j] = 0;
fw (j, 0, n) {
cnt[max(0, j - a[j])]++;
cnt[min(n, j + a[j] + 1)]--;
}
int tmp = 0;
fw (j, 0, n) {
tmp += cnt[j];
a[j] = tmp;
}
bool done = 1;
fw (j, 0, n) if (a[j] != n) done = 0;
if (done) break;
}
fw (i, 0, n) cout << a[i] << " ";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using llong = long long;
using ldbl = long double;
using lpair = pair<llong, llong>;
#define ALL(x) x.begin(), x.end()
constexpr llong mod = 1e9+7;
constexpr llong inf = mod * mod;
int main() {
llong N;
vector<vector<lpair>> A;
cin >> N;
A.resize(N + 1);
for (int i = 1; i <= N; i++) {
llong n;
cin >> n;
A[i].resize(n);
for (auto &in: A[i]) {
cin >> in.first >> in.second;
}
}
int ans = 0;
for (int i = 0; i < (1<<N); i++) {
vector<int> res(N + 1);
for (int j = 0; j < N; j++) {
res[j + 1] = (i>>j)&1;
}
bool check = true;
for (int j = 0; j < N; j++) {
if (!((i>>j)&1)) continue;
for (auto a: A[j + 1]) {
check &= res[a.first] == a.second;
}
}
if (check) {
ans = max(ans, __builtin_popcount(i));
}
}
cout << ans << endl;
return 0;
} | 0 |
#include <iostream>
#include <string>
using namespace std;
int main(){
int i,j,n,k[100],l,len,h;
string s,out;
char data[52]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
while(1){
out="";
cin >> n;
if(n==0) break;
for(i=0;i<n;i++){
cin >> k[i];
}
cin >> s;
len=s.size();
for(i=0,l=0;i<len;i++,l++){
if(l==n) l=0;
for(j=0;j<52;j++){
if(s[i]==data[j]){
if(j-k[l]<0){
h=k[l]-j;
out+=data[52-h];
}
else out+=data[j-k[l]];
}
}
}
cout << out << endl;
}
return 0;
} | #pragma GCC target ("avx2")
#pragma GCC optimize ("unroll-loops")
#pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include <unordered_set>
#include <unordered_map>
#include <random>
using namespace std;
typedef long long ll;
const ll MOD = /*1'000'000'007LL;*/ 998'244'353LL;
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for(int (i)=0; (i)<(n); (i)++)
const int dx[4]={ 1,0,-1,0 };
const int dy[4]={ 0,1,0,-1 };
int N;
int L[100000], R[100000]; // [L,R)
pair<int, int> sec[100000];
vector<pair<int, int>> v;
signed main(){
cin >> N;
rep(i, N){
cin >> L[i] >> R[i];
L[i]--;
sec[i] ={ L[i],-R[i] };
}
sort(sec, sec+N);
rep(i, N){
while(v.size() > 0 && v.back().second >= -sec[i].second){
v.pop_back();
}
v.pb({ sec[i].first,-sec[i].second });
}
if(v.size() == 1){
int ans = 0;
rep(i, N-1){
ans = max(ans, -sec[i].second - sec[i].first);
}
cout << ans + -sec[N-1].second - sec[N-1].first << endl;
exit(0);
}
int ans = 0;
for(int i=1; i<v.size(); i++){
ans = max(ans, max(0, v[0].second-v[i-1].first) + max(0, v[i].second-v[v.size()-1].first));
}
set<pair<int,int>> l, r;
rep(i, N){
l.insert({ L[i],i });
r.insert({ R[i],i });
}
rep(i, N){
l.erase({ L[i],i });
r.erase({ R[i],i });
ans = max(ans, R[i]-L[i] + max(0, r.begin()->first-prev(l.end())->first));
l.insert({ L[i],i });
r.insert({ R[i],i });
}
cout << ans << endl;
} | 0 |
#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 graph = vector<vector<int>>;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll INF = 1LL<<60;
const ll mod = 1000000007LL;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int dp[3005][3005];
int subdp[3005][3005];
int main(){
int N,T;
cin>>N>>T;
vector<vector<int>> v(N,vector<int>(2));
rep(i,N) cin>>v[i][1]>>v[i][0];
sort(v.begin(),v.end());
rep(i,N){
rep(j,T){
chmax(dp[i+1][j],dp[i][j]);
if(j+v[i][1]<T) chmax(dp[i+1][j+v[i][1]],dp[i][j]+v[i][0]);
}
}
int time = T-1;
vector<bool> use(N);
int ans = 0;
for(int i = N-1; i >= 0; i--){
if(time>=v[i][1]){
if(dp[i+1][time]==dp[i][time - v[i][1]] + v[i][0]){
time -= v[i][1];
use[i]=true;
continue;
}
}
}
vector<vector<int>> nouse;
rep(i,N){
if(!use[i]) nouse.push_back({v[i][0],v[i][1]});
}
rep(i,N){
rep(j,T){
chmax(dp[i+1][j],dp[i][j]);
if(j+v[i][1]<T) chmax(dp[i+1][j+v[i][1]],dp[i][j]+v[i][0]);
}
}
int m = nouse.size();
rep(i,m){
rep(j,T){
chmax(subdp[i+1][j],subdp[i][j]);
if(j+nouse[i][1]<T) chmax(subdp[i+1][j+nouse[i][1]],subdp[i][j]+nouse[i][0]);
}
}
vector<int> exceptmax(N);
rep(i,N){
if(use[i]) exceptmax[i] = dp[N][T-1]-v[i][0]+subdp[m][v[i][1]];
else exceptmax[i] = dp[N][T-1];
}
rep(i,N) chmax(ans,exceptmax[i]+v[i][0]);
cout<<ans<<endl;
} | #include <bits/stdc++.h>
int main(){
int N, T;
std::cin >> N >> T;
std::vector< std::pair< int, int > > AB(N);
for(int i=0; i<N; i++){
std::cin >> AB[i].first >> AB[i].second;
}
std::sort(AB.begin(), AB.end());
std::vector< std::vector< int > > dp(N + 1, std::vector< int >(T));
dp[0].assign(T, 0);
int max = 0;
for(int i=1; i<N+1; i++){
if(max < dp[i-1][T-1] + AB[i-1].second){
max = dp[i-1][T-1] + AB[i-1].second;
}
for(int j=0; j<T; j++){
if(j < AB[i-1].first){
dp[i][j] = dp[i-1][j];
}else{
dp[i][j] = std::max(dp[i-1][j], dp[i-1][j-AB[i-1].first] + AB[i-1].second);
}
}
}
std::cout << max << std::endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
int k;
vector<P> d;
char table[8][8];
vector<int> row;
vector<int> col;
void show_vec(vector<int>);
void solve(){
sort(col.begin(), col.end());
do{
vector<P> v;
for (auto &e: d) v.push_back(e);
for (int i = 0 ; i < (int)row.size(); i++)
{
P p;
p.first = row[i];
p.second = col[i];
v.push_back(p);
}
bool ok = true;
for (int i = 0; i < (int)v.size() && ok; i++)
{
for (int j = 0; j < (int)v.size(); j++)
{
if(i == j) continue;
int dx = v[i].first - v[j].first;
int dy = v[i].second - v[j].second;
if(abs(dx) == abs(dy)){
ok = false;
break;
}
}
}
if(ok){
for(auto &e: v){
//cout << "(" << e.first << ", " << e.second << ")";
table[e.first][e.second] = 'Q';
}
break;
}
}while(next_permutation(col.begin(), col.end()));
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
cout << table[i][j];
}
cout << endl;
}
}
int main(){
cin >> k;
for (int i = 0; i < 8; i++)
{
row.push_back(i);
col.push_back(i);
}
for (int i = 0; i < k; i++)
{
P p;
cin >> p.first >> p.second;
row.erase(find(row.begin(), row.end(), p.first));
col.erase(find(col.begin(), col.end(), p.second));
d.push_back(p);
}
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
table[i][j] = '.';
}
}
solve();
return 0;
}
void show_vec(vector<int> v){
cout << "[";
for (int i = 0; i < (int)v.size(); i++)
{
cout << v[i] << ", ";
}
cout << "\b\b]" << endl;
}
| #include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <stack>
#define N 8
using namespace std;
stack<char> s[N][N];
char map[N][N];
int kazu;
void post(int a,int b){
for(int i=0;i<N;i++){
s[i][b].push(1);
if(i!=b) s[a][i].push(1);
}
for(int i=1;i+a<N&&i+b<N;i++){
s[a+i][b+i].push(1);
}
for(int i=1;a-i>=0&&b-i>=0;i++){
s[a-i][b-i].push(1);
}
for(int i=1;a+i<N&&b-i>=0;i++){
s[a+i][b-i].push(1);
}
for(int i=1;a-i>=0&&b+i<N;i++){
s[a-i][b+i].push(1);
}
}
void receive(int a,int b){
for(int i=0;i<N;i++){
s[i][b].pop();
if(i!=b)s[a][i].pop();
}
for(int i=1;i+a<N&&i+b<N;i++){
s[a+i][b+i].pop();
}
for(int i=1;a-i>=0&&b-i>=0;i++){
s[a-i][b-i].pop();
}
for(int i=1;a+i<N&&b-i>=0;i++){
s[a+i][b-i].pop();
}
for(int i=1;a-i>=0&&b+i<N;i++){
s[a-i][b+i].pop();
}
}
void view(){
for(int i=0;i<N;i++){
for(int j=0;j<N;j++){
printf("%c",map[i][j]);
}
printf("\n");
}
}
void rop(int a,int b){
map[a][b]='Q';
post(a,b);
kazu++;
if(kazu>=8){
view();
exit(0);
}
for(int i=a+1;i<N;i++){
for(int j=0;j<N;j++){
if(s[i][j].empty()) rop(i,j);
}
}
receive(a,b);
map[a][b]='.';
kazu--;
}
int main(void){
int n;
int a,b;
kazu=0;
for(int i=0;i<N;i++){
for(int j=0;j<N;j++){
map[i][j]='.';
}
}
cin>>n;
while(n--){
cin>>a>>b;
map[a][b]='Q';
post(a,b);
kazu++;
}
if(kazu==8){
view();
exit(0);
}
for(int i=0;i<N;i++){
for(int j=0;j<N;j++){
if(s[i][j].empty()){
rop(i,j);
}
}
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
char s[1500];
int i,n;
cin>>s;
n=strlen(s);
for(i=0;i<n-8;i++){
cout<<s[i];
}
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define REP(i, n) for(ll i = 1; i < n + 1; i++)
#define PI 3.14159265359
#define EPS 0.0000000001
#define MOD 1000000007
//cout << std::fixed << std::setprecision(15) << y << endl;
int main(){
string S;
cin >> S;
bool check1 = false, check2 = false, check3 = true;
ll Ccount = 0;
if(S[0] == 'A'){
check1 = true;
}
if(S[1] < 'a'){
check3 = false;
}
for(ll i = 2; i < S.size() - 1; i++){
if(S[i] == 'C' && Ccount == 0){
check2 = true;
Ccount++;
}else if(S[i] < 'a'){
check3 = false;
}
}
if(S[S.size() - 1] < 'a'){
check3 = false;
}
if(check1 && check2 && check3){
cout << "AC" << endl;
}else{
cout << "WA" << endl;
}
return 0;
} | 0 |
#include<bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int) (n); i++)
using namespace std;
int main(){
int A[55] = {2, 7, 17, 37, 47,
67, 97, 107, 127, 137,
157, 167, 197, 227, 257,
277, 307, 317, 337, 347,
367, 397, 457, 467, 487,
547, 557, 577, 587, 607,
617, 647, 677, 727, 757,
787, 797, 827, 857, 877,
887, 937, 947, 967, 977,
997, 1087, 1097, 1117, 1187,
1217, 1237, 1277, 1297, 1307,
};
int N;
cin >> N;
rep(i, N){
if(i) cout << " ";
cout << A[i];
}
cout << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
int main(){
int n; cin >> n;
vector<int> sosu, ans;
int cnt = 0;
for(int i = 2; i <= 555555; i++){
int j;
for(j = 0; j < sosu.size(); j++){
if(i % sosu[j] == 0){
break;
}
}
if(j == sosu.size()){
sosu.push_back(i);
if(i % 5 == 1){
ans.push_back(i);
cnt++;
if(cnt == n){
break;
}
}
}
}
rep(i, n){
if(i == 0) cout << ans[i];
else cout << " " << ans[i];
}
cout << endl;
return 0;
}
| 1 |
#include<cstdio>
int main() {
while (1) {
int m, nmin, nmax, p[201], maxg = 0, n;
scanf("%d %d %d", &m, &nmin, &nmax);
for (int i = 1; i <= m; i++) {
scanf("%d", &p[i]);
}
for (int j = nmin; j <= nmax; j++) {
if (p[j] - p[j+1] >= maxg) {
maxg = p[j] - p[j+1];
n = j;
}
}
if (m == 0 && nmin == 0 && nmax == 0) {
return 0;
}
else {
printf("%d\n", n);
}
}
}
| #include <stdio.h>
char buf[100];
int l[10], v[2];
int main() {
while (scanf("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d", l, l + 1, l + 2, l + 3, l + 4, l + 5, l + 6, l + 7, l + 8, l + 9, v, v + 1) != -1) {
int total = 0;
int i;
for (i = 0; i < 10; i++) total += l[i];
int now = 0;
for (i = 0; i < 10; i++) {
now += l[i];
if (now * v[1] >= (total - now) * v[0]) {
break;
}
}
printf("%d\n", i + 1);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
int ans = 1;
cin >> n >> k;
for (int i = 0; i < n; i++) {
ans = min(ans*2, ans+k);
}
cout << ans << endl;
} | #include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
#include "ctime"
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(begin, i, end) for (int i = begin; i < (int)(end); i++)
#define all(v) v.begin(), v.end()
const int MOD = 1000000007;
ll N, K;
ll solve(ll N);
int main()
{
cin >> N >> K;
cout << solve(N) << endl;
}
ll solve(ll N)
{
if (N == 1)
{
return 2;
}
return min(solve(N - 1) * 2, solve(N - 1) + K);
} | 1 |
#include<iostream>
using namespace std;
int main() {
int n, a[100], i, j, flag, hoge, counta = 0;
cin >> n;
for (i = 0; i < n; i++)cin >> a[i];
flag = 1;
while (flag) {
flag = 0;
i = 0;
for (j = n - 1; j > i; j--) {
if (a[j] < a[j - 1]) {
hoge = a[j];
a[j] = a[j - 1];
a[j - 1] = hoge;
flag = 1;
counta++;
}
}
i++;
}
for (i = 0; i < n; i++) {
if (i > 0)cout << " ";
cout << a[i];
}
cout << endl << counta << endl;
}
| #include <iostream>
#include <vector>
using namespace std;
bool linearSearch(const vector<int>& ary, int key) {
for (auto i = 0; i < ary.size(); i++) {
if (ary[i] == key) {
return true;
}
}
return false;
}
int main(void) {
int n;
cin >> n;
vector<int> S(n);
for (int i = 0; i < n; i++) {
cin >> S[i];
}
int q;
cin >> q;
int cnt = 0;
for (int i = 0; i < q; i++) {
int key;
cin >> key;
if (linearSearch(S, key)) cnt++;
}
cout << cnt << endl;
return 0;
} | 0 |
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#include <cmath>
#include <string.h>
using namespace std;
#define FOR(i,s,e) for (int i = int(s); i != int(e); i++)
#define REP(i,e) for (int i = 0; i != int(e); i++)
#define FORIT(i, A) for (auto i : A)
#define ISEQ(c) (c).begin(), (c).end()
#define PRINT(x) cout << (x) << endl
#define SZ(x) ((int)(x).size())
int compare(const std::string& buf, const std::string& str)
{
}
int main(int argc, char const *argv[])
{
int n;
std::string s;
std::getline(std::cin, s);
std::stringstream ss(s);
ss >> n;
REP(i, n)
{
std::getline(std::cin, s);
int k = 0;
int l = s.length();
while(k+7 <= l)
{
if (s.substr(k, 7) == "Hoshino")
s.at(k+6) = 'a';
k++;
}
std::cout << s << std::endl;
}
return 0;
} | #include<iostream>
#include<string>
using namespace std;
int main(){
int n;
int i;
while(cin >> n){
i=n;
string s[n];
cin.ignore();
while(n--){
getline(cin,s[n]);
int ix=0;
while( ( ix =s[n].find("Hoshino") ) >=0 ){
s[n].replace(ix,7,"Hoshina");
}
}
while(i--){
cout << s[i] << endl;
}
}
return 0;
} | 1 |
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <complex>
#include <ctime>
#include <cstdlib>
using namespace std;
inline int to_int(string s) {int v; istringstream sin(s); sin >> v; return v;}
template<class T> inline string to_str(T x) {ostringstream sout; sout << x; return sout.str();}
typedef long long ll;
int main()
{
int L[16];
int sum;
int v1, v2;
double crush;
int ans;
while(scanf("%d",&L[0]) != EOF)
{
sum = L[0];
for(int i = 1; i < 10; i++)
{
scanf(",%d",&L[i]);
sum += L[i];
}
scanf(",%d,%d", &v1, &v2);
crush = sum * (v1 * 1.0/(v1+v2) );
for(int i = 0; i < 10; i++)
{
crush -= L[i];
if(crush <= 0)
{
ans = i+1;
break;
}
}
cout << ans << endl;
}
} | #include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int main(){
int l[10];
char c;
while(1){
for(int i = 0 ; i < 10 ; i++){
cin >> l[i] >> c;
if(cin.eof()) return 0;
}
int a, b;
cin >> a >> c >> b;
int n = 0;
for(int i = 0 ; i < 10 ; i++){
n += l[i];
}
double h = (double)n/(a+b);
double d = (double)a*h;
n = 0;
for(int i = 0 ; i < 10 ; i++){
n += l[i];
if(d <= n){
cout << i+1 << endl;
break;
}
}
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define PI 3.141592653589793
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
typedef long double ld;
ll modpow(ll a, ll p, ll M){
ll ret = 1;
while(p){
if(p & 1) ret = ret * a % M;
a = a * a % M;
p >>= 1;
}
return ret;
}
int main() {
ll N, M;
M = 998244353;
cin >> N;
vector<ll> D(N);
rep(i, N) cin >> D[i];
vector<ll> num(N,0);
rep(i,N) num[D[i]]++;
ll ans = 1;
for(int i = 1; i < N; i++){
ans *= modpow(num[i-1], num[i],M);
ans %= M;
}
if(num[0] != 1 || D[0] != 0) ans = 0;
cout << ans << endl;
} | //product of pairs
#include<bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
int main()
{
long long int tt;
tt = 1;
while (tt--)
{
long long int n, i, count = 0;
cin >> n;
long long int a[n + 1], p[n + 1];
for (i = 1; i <= n; i++)
{
cin >> a[i];
}
p[n] = a[n];
for (i = n - 1; i >= 1; i--)
{
p[i] = (p[i + 1] + a[i]) % mod;
}
for (i = 1; i <= n - 1; i++)
{
count = (count + (a[i] * p[i + 1]) % mod) % mod;
}
cout << count << " " << endl;
}
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <utility>
#include <queue>
#include <string>
#include <set>
#include <bitset>
#include <unordered_map>
#include <cmath>
#include <functional>
#include <map>
#include <cstdlib>
using namespace std;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template <class T>
using Vvec = vector<vector<T> >;
template <class T>
void debug(T& v)
{
for(auto& x: v) cout << x << " ";
cout << endl;
}
int main()
{
const ll push = 0;
const ll pop = 1;
const ll get = 2;
struct Data{
ll key, qid, val;
Data(): key(0), qid(0), val(0){}
Data(ll k, ll q, ll v): key(k), qid(q), val(v){}
bool operator<(const Data& e) const{
if(key == e.key){
if(qid == e.qid) return val < e.val;
return qid < e.qid;
}
return key < e.key;
}
};
int N, Q;
cin >> N >> Q;
vector<ll> S(N), T(N), X(N), D(Q), ans(Q);
for(int i=0; i<N; i++) cin >> S[i] >> T[i] >> X[i];
for(auto& x: D) cin >> x;
multimap<ll, Pll> mp;
vector<Data> ds(2*N+Q);
for(int i=0; i<N; i++){
ds[2*i] = Data(S[i]-X[i], push, X[i]);
ds[2*i+1] = Data(T[i]-X[i], pop, X[i]);
}
for(int i=0; i<Q; i++) ds[2*N+i] = Data(D[i], get, i);
sort(ds.begin(), ds.end());
multiset<ll> Xs;
for(auto& d: ds){
ll qid = d.qid;
ll val = d.val;
// cout << d.key << " " << qid << " " << val << "\n";
if(qid == push) Xs.insert(val);
else if(qid == pop){
auto itr = Xs.find(val);
Xs.erase(itr);
}else{
if(Xs.empty()) ans[val] = -1;
else ans[val] = *Xs.begin();
}
}
for(auto& x: ans) cout << x << "\n";
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (int)n; i++)
using ll = long long;
const ll INF = 1e17;
template<typename T, typename E, typename F, typename G, typename H>
class LazySegmentTree {
int n, height;
F f; G g; H h; const T ti; const E ei;
vector<T> dat; vector<E> laz; vector<int> highest;
void propagate(int k) {
if(laz[k] != ei) {
laz[2*k] = h(laz[2*k],laz[k]); laz[2*k+1] = h(laz[2*k+1],laz[k]);
dat[k] = g(dat[k],laz[k],n/highest[k]);
laz[k] = ei;
}
}
inline void recalc(int k) {
while(k >>= 1) dat[k] = f(g(dat[2*k],laz[2*k],n/highest[2*k]),g(dat[2*k+1],laz[2*k+1],n/highest[2*k+1]));
}
inline void thrust(int k) {
for(int i = height; i > 0; i--) propagate(k >> i);
}
public:
LazySegmentTree(int _n, F f, G g, H h, T ti, E ei): f(f), g(g), h(h), ti(ti), ei(ei) {
n = 1; height = 0;
while(n < _n) n <<= 1, height++;
dat.assign(2*n,ti); laz.assign(2*n,ei); highest.assign(2*n,0);
int c = 1;
for(int i = 1; i < 2*n; i++) {
if(c*2 <= i) c <<= 1;
highest[i] = c;
}
}
void set(int k, T x) {
dat[k+n] = x;
}
void build() {
for(int i = n-1; i >= 0; i--) {
dat[i] = f(dat[2*i],dat[2*i+1]);
}
}
void update(int a, int b, const E x) {
thrust(a += n); thrust(b += n-1);
for(int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if(l & 1) laz[l] = h(laz[l],x), ++l;
if(r & 1) --r, laz[r] = h(laz[r],x);
}
recalc(a); recalc(b);
}
T query(int a, int b) {
thrust(a += n); thrust(b += n-1);
T l = ti, r = ti; b++;
while(a < b) {
if(a & 1) l = f(l,g(dat[a],laz[a],n/highest[a])), a++;
if(b & 1) b--, r = f(g(dat[b],laz[b],n/highest[b]),r);
a >>= 1; b >>= 1;
}
return f(l,r);
}
};
int main(){
int n, q;
cin >> n >> q;
auto f = [](ll a, ll b){return a+b;};
auto g = [](ll a, ll b, int l){return b == INF ? a : b*l;};
auto h = [&](ll a, ll b) {return b;};
LazySegmentTree<ll,ll,decltype(f),decltype(g),decltype(h)> lst(n,f,g,h,0,INF);
rep(i,n) lst.set(i,((ll)1<<31)-1);
lst.build();
vector<ll> ans;
rep(i,q) {
int t;
cin >> t;
if(t == 0) {
int l, r; ll x;
cin >> l >> r >> x;
lst.update(l,r+1,x);
} else {
int p;
cin >> p;
ans.push_back(lst.query(p,p+1));
}
}
for(auto x : ans) cout << x << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
//#include <boost/multiprecision/cpp_int.hpp>
//namespace mp = boost::multiprecision;
using namespace std;
const double PI = 3.14159265358979323846;
typedef long long ll;
const double EPS = 1e-9;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef pair<ll, ll> P;
const ll INF = 10e17;
#define cmin(x, y) x = min(x, y)
#define cmax(x, y) x = max(x, y)
#define ret() return 0;
double equal(double a, double b) {
return fabs(a - b) < DBL_EPSILON;
}
std::istream &operator>>(std::istream &in, set<int> &o) {
int a;
in >> a;
o.insert(a);
return in;
}
std::istream &operator>>(std::istream &in, queue<int> &o) {
ll a;
in >> a;
o.push(a);
return in;
}
bool contain(set<int> &s, int a) { return s.find(a) != s.end(); }
typedef priority_queue<ll, vector<ll>, greater<ll> > PQ_ASK;
class Match {
multiset<ll> l, r;
public:
void add(P p) {
this->l.insert(p.first);
this->r.insert(p.second);
}
ll point() {
auto itl = l.end();
itl--;
ll lr = *itl;
auto itr = r.begin();
ll rl = *itr;
return max<ll>(rl - lr + 1, 0);
}
void pop(P p) {
l.erase(l.find(p.first));
r.erase(r.find(p.second));
}
};
int main() {
int n;
cin >> n;
vector<P> v(n);
for (P &p:v)cin >> p.first >> p.second;
ll ans_one = [&] {
Match a, b;
rep(i, n) {
b.add(v[i]);
}
ll ans = 0;
rep(i, n) {
b.pop(v[i]);
a.add(v[i]);
ll now = b.point() + a.point();
cmax(ans, now);
a.pop(v[i]);
b.add(v[i]);
}
return ans;
}();
ll ans_split = [&]() -> ll {
sort(v.begin(), v.end(), [](P p1, P p2) {
return p1.second < p2.second;
});
Match a, b;
for (P p : v) b.add(p);
ll ans = 0;
rep(i, n - 1) {
P p = v[i];
a.add(p);
b.pop(p);
ll now = a.point() + b.point();
cmax(ans, now);
}
return ans;
}();
ll ans = max(ans_split, ans_one);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using i64 = long long;
const i64 MOD = 1e9 + 7;
const i64 INF = i64(1e18) + 7;
template <typename T>
bool chmin(T& x, T y){
if(x > y){
x = y;
return true;
}
return false;
}
template <typename T>
bool chmax(T& x, T y){
if(x < y){
x = y;
return true;
}
return false;
}
template <typename T>
struct DisjointSparseTable{
function<T(T, T)> f;
vector<vector<T>> v;
DisjointSparseTable(vector<T>& inp, function<T(T, T)> f) : f(f){
int n = inp.size();
int b;
for(b = 0; (1 << b) <= inp.size(); ++b);
v.assign(b, vector<T>(n));
for(int i = 0; i < n; ++i)
v[0][i] = inp[i];
for(int i = 1; i < b; ++i){
int siz = 1 << i;
for(int j = 0; j < n; j += siz << 1){
int t = min(j + siz, n);
v[i][t - 1] = inp[t - 1];
for(int k = t - 2; k >= j; --k)
v[i][k] = f(inp[k], v[i][k + 1]);
if(t >= n)
break;
v[i][t] = inp[t];
int r = min(t + siz, n);
for(int k = t + 1; k < r; ++k)
v[i][k] = f(v[i][k - 1], inp[k]);
}
}
}
T get(int l, int r){
if(l >=r)
return MOD;
if(l >= --r)
return v[0][l];
int p = 31 - __builtin_clz(l ^ r);
return f(v[p][l], v[p][r]);
}
};
signed main(){
int n;
cin >> n;
vector<int> l(n), r(n);
for(int i = 0; i < n; ++i){
cin >> l[i] >> r[i];
--l[i];
}
int l_ma = 0, l_ma_idx = 0;
int r_mi = MOD, r_mi_idx = 0;
for(int i = 0; i < n; ++i){
if(chmax(l_ma, l[i]))
l_ma_idx = i;
if(chmin(r_mi, r[i]))
r_mi_idx = i;
}
int ans = 0;
for(int i = 0; i < n; ++i){
if(i != l_ma_idx && i != r_mi_idx)
chmax(ans, max(r_mi - l_ma, 0) + r[i] - l[i]);
}
if(l_ma_idx != r_mi_idx){
vector<pair<int,int>> v;
for(int i = 0; i < n; ++i){
if(i != l_ma_idx && i != r_mi_idx){
// 一定までfirstを、それ以降はsecondを見て、総和の最大化をする
v.emplace_back(max(0, r[i] - l_ma), max(0, r_mi - l[i]));
}
}
sort(v.begin(), v.end(), greater<>());
int m = v.size();
vector<int> v1, v2;
for(int i = 0; i < m; ++i){
v1.push_back(v[i].first);
v2.push_back(v[i].second);
}
DisjointSparseTable<int> d1(v1, [](auto x, auto y){return min(x, y);});
DisjointSparseTable<int> d2(v2, [](auto x, auto y){return min(x, y);});
for(int i = 0; i <= m; ++i){
chmax(ans, min(d1.get(0, i), r[l_ma_idx] - l[l_ma_idx]) + min(d2.get(i, m), r[r_mi_idx] - l[r_mi_idx]));
}
}
cout << ans << endl;
}
| 1 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <cmath>
#include <string>
#include <sstream>
#include <iomanip>
#include <complex>
using namespace std;
#define ll long long
#define vvi vector< vector<int> >
#define vi vector<int>
#define All(X) X.begin(),X.end()
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define pb push_back
#define pii pair<int,int>
#define mp make_pair
#define pi 3.14159265359
#define shosu(X) fixed << setprecision(X)
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(){
const int intmax = 1000010;
ll int e;
while(cin >> e,e){
ll int ans = 9999999;
FOR(y,0,sqrt((double)e)+2){
FOR(z,0,cbrt((double)e)+2){
if(e-y*y-z*z*z>=0) ans = min(ans,y+z+(e-y*y-z*z*z));
}
}
cout << ans << endl;
}
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
int main(void){
int n;
while (cin >> n, n) {
vector<pair<double, string> > list;
for (int i = 0; i < n; i++) {
string l;
int p, a, b, c, d, e, f, s, m;
cin >> l >> p >> a >> b >> c >> d >> e >> f >> s >> m;
double cost = (-1.0)*(m*s*f-p)/((a+b+c)+m*(d+e));
list.push_back(make_pair(cost, l));
}
sort(list.begin(), list.end());
for (int i = 0; i < list.size(); i++) {
cout << list[i].second << endl;
}
cout << "#" << endl;
}
return 0;
} | 0 |
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <cmath>
using namespace std;
const int MAXN = 100 + 5;
int n, m;
char gra[MAXN][MAXN];
short sum[MAXN][MAXN];
int ex, ey;
short f[MAXN][MAXN][MAXN][MAXN];
int get_sum(int x1, int y1, int x2, int y2)
{
if(x1 > x2 || y1 > y2)
return 0;
return sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1];
}
int dp(int x1, int y1, int x2, int y2)
{
if(x1 > x2 || y1 > y2)
return 0;
if(f[x1][y1][x2][y2] != -1)
return f[x1][y1][x2][y2];
int ret = 0, tot = get_sum(x1, y1, x2, y2);
// cut left
if(ret < tot)
ret = max(ret, dp(x1, y1 + 1, x2, y2) +
(y1 + m - y2 < ey ? 0 : get_sum(max(x1, ex - n + x2), y1, min(x2, ex + x1 - 1), y1)));
// cut right
if(ret < tot)
ret = max(ret, dp(x1, y1, x2, y2 - 1) +
(y2 + 1 - y1 > ey ? 0 : get_sum(max(x1, ex - n + x2), y2, min(x2, ex + x1 - 1), y2)));
// cut up
if(ret < tot)
ret = max(ret, dp(x1 + 1, y1, x2, y2) +
(x1 + n - x2 < ex ? 0 : get_sum(x1, max(y1, ey - m + y2), x1, min(y2, ey + y1 - 1))));
// cut up
if(ret < tot)
ret = max(ret, dp(x1, y1, x2 - 1, y2) +
(x2 + 1 - x1 > ex ? 0 : get_sum(x2, max(y1, ey - m + y2), x2, min(y2, ey + y1 - 1))));
// cout << x1 << ' ' << y1 << ' ' << x2 << ' ' << y2 << ' ' << ret << endl;
return f[x1][y1][x2][y2] = ret;
}
int main()
{
ios::sync_with_stdio(false);
// freopen("1.in", "r", stdin);
// freopen("1.out", "w", stdout);
cin >> n >> m;
for(int i = 1; i <= n; i++)
cin >> (gra[i] + 1);
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++)
{
sum[i][j] = sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + (gra[i][j] == 'o');
if(gra[i][j] == 'E')
ex = i, ey = j;
}
// cout << sum[n][m] << endl;
memset(f, -1, sizeof(f));
int ans = dp(1, 1, n, m);
cout << ans << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int line[110][110],col[110][110];
short dp[101][101][101][101];
int main()
{
int n,m,x,y;scanf("%d%d\n",&n,&m);
for (int i=1;i<=n;i++)
for (int j=1;j<=m;j++)
{
line[i][j]=line[i][j-1];col[i][j]=col[i-1][j];
char ch=getchar();
if (ch=='E') {x=i;y=j;}
else if (ch=='o') {line[i][j]++;col[i][j]++;}
if (j==m) scanf("\n");
}
int all=0;
for (int i=x;i>=1;i--)
for (int j=y;j>=1;j--)
for (int k=x;k<=n;k++)
for (int l=y;l<=m;l++)
{
all=max(all,(int)dp[i][j][k][l]);
if ((1<i)&&(k+1<x+i)) dp[i-1][j][k][l]=max((int)dp[i-1][j][k][l],dp[i][j][k][l]+line[i-1][min(l,m-y+j)]-line[i-1][max(j-1,l-y)]);
if ((k<n)&&(x+k<n+i)) dp[i][j][k+1][l]=max((int)dp[i][j][k+1][l],dp[i][j][k][l]+line[k+1][min(l,m-y+j)]-line[k+1][max(j-1,l-y)]);
if ((1<j)&&(l+1<y+j)) dp[i][j-1][k][l]=max((int)dp[i][j-1][k][l],dp[i][j][k][l]+col[min(k,n-x+i)][j-1]-col[max(i-1,k-x)][j-1]);
if ((l<m)&&(y+l<m+j)) dp[i][j][k][l+1]=max((int)dp[i][j][k][l+1],dp[i][j][k][l]+col[min(k,n-x+i)][l+1]-col[max(i-1,k-x)][l+1]);
}
cout<<all<<endl;
} | 1 |
#include <stdio.h>
int main() {
int N=0, K= 0, z= 1;
scanf("%d\n%d", &N, &K);
for (int i = 0; i < N; i++) {
if (2 * z <= z + K) {
z *= 2;
} else {
z += K;
}
}
printf("%d\n", z);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
#define all(x) (x).begin(), (x).end()
#define endl '\n'
#define fsp(x) cout << fixed << setprecision(x)
const ll inf = LLONG_MAX;
const long double pi = M_PI;
void Yes() {cout << "Yes" << endl;}
void No() {cout << "No" << endl;}
void YES() {cout << "YES" << endl;}
void NO() {cout << "NO" << endl;}
int main() {
ll n, k;
cin >> n >> k;
cout << n - k + 1 << endl;
} | 0 |
#include <bits/stdc++.h>
typedef long long ll;
#define pb push_back
using namespace std;
typedef pair<ll,ll> pll;
ll n;
string s;
ll a[200005];
ll b[200005];
const ll mod = 1e9 + 7;
ll ans;
ll suf[200005];
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
cin >> n; n+=n;
cin >> s;
if(s[0] == 'W' || s[n-1] == 'W'){
cout << "0\n"; return 0;
}
a[0]=1;
ll cnt = 1;
ll tc=1;
b[0]=1;
ll L = 1;
ll R = 0;
for(ll i=1;i<n;i++) {
if(s[i] == s[i-1]){
b[i] =1-b[i-1];
}else b[i] = b[i-1];
if(b[i]) L++;
else R++;
}
if(L != R){
cout << "0\n"; return 0;
}
ans=1LL;
for(ll i=n-1;i>=0;i--) {
suf[i] = suf[i+1] + b[i];
}
ll l=0;
ll r=0;
for(ll i=0;i<n;i++) {
if(b[i] == 0){
ans = (ans * (l-r))%mod;
r++;
}else l++;
}
for(ll i=1;i<=(n/2);i++) ans = (ans * i)%mod;
cout << ans << endl;
return 0;
}
| //#include <bits/stdc++.h>
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
//#include "boost/multiprecision/cpp_int.hpp"
//typedef boost::multiprecision::cpp_int LL;
typedef long double dd;
#define i_7 (ll)(1E9+7)
//#define i_7 998244353
#define i_5 i_7-2
ll mod(ll a){
ll c=a%i_7;
if(c>=0)return c;
return c+i_7;
}
typedef pair<ll,ll> l_l;
typedef pair<dd,dd> d_d;
ll inf=(ll)1E16;
#define rep(i,l,r) for(ll i=l;i<=r;i++)
#define pb push_back
ll max(ll a,ll b){if(a<b)return b;else return a;}
ll min(ll a,ll b){if(a>b)return b;else return a;}
void Max(ll &pos,ll val){pos=max(pos,val);}//Max(dp[n],dp[n-1]);
void Min(ll &pos,ll val){pos=min(pos,val);}
void Add(ll &pos,ll val){pos=mod(pos+val);}
dd EPS=1E-9;
#define fastio ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define fi first
#define se second
#define endl "\n"
#define SORT(v) sort(v.begin(),v.end())
#define ERASE(v) v.erase(unique(v.begin(),v.end()),v.end())
#define POSL(v,x) (lower_bound(v.begin(),v.end(),x)-v.begin())
#define POSU(v,x) (upper_bound(v.begin(),v.end(),x)-v.begin())
//template<class T>void max(T a,T b){if(a<b)return b;else return a;}
//template<class T>void min(T a,T b){if(a>b)return b;else return a;}
//template<class T>bool Max(T&a, T b){if(a < b){a = b;return 1;}return 0;}
//template<class T>bool Min(T&a, T b){if(a > b){a = b;return 1;}return 0;}
//////////////////////////
int main(){fastio
ll n;cin>>n;
string s;cin>>s;
ll ans=1;
rep(i,1,n)ans=mod(ans*i);
ll cnt=0;
rep(i,0,2*n-1){
if((s[i]=='B')^(cnt%2==0)){
ans=mod(ans*cnt);
cnt--;
if(cnt<0){
cout<<0<<endl;return 0;
}
}else{
cnt++;
}
//cout<<cnt<<" ";
}
if(cnt!=0)ans=0;
cout<<mod(ans)<<endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define REPP(i,a,b,c) for(int i=a; i<=b; i+=c)
#define REP(i,a,b) REPP(i,a,b,1)
#define REVV(i,a,b,c) for(int i=a; i>=b; i-=c)
#define REV(i,a,b) REVV(i,a,b,1)
#define FOR(i,a) REP(i,0,(int)a-1)
#define FORD(i,a) REV(i,(int)a-1,0)
#define MP make_pair
#define PB push_back
#define POB pop_back
#define FI first
#define SE second
typedef long long ll;
typedef unsigned long long ull;
typedef pair < int , int > pii;
typedef vector < int > vi;
typedef vector < pii > vii;
typedef vector < ll > vl;
const double PI = acos(-1);
const double EPS = 1e-9;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
///////////////////////////////////////////////////////
const int N = 1e5;
ll h,w,a,b;
ll fact[2*N + 5];
ll addMod(ll a, ll b){
return (a +b ) % MOD;
}
ll mulMod(ll a, ll b){
return (a*b) % MOD;
}
ll fast(ll a, ll b){
if(b == 0) return 1;
ll tmp = fast(a,b/2);
tmp = mulMod(tmp,tmp);
if(b % 2 == 1) tmp = mulMod(tmp,a);
return tmp;
}
ll combin(int n, int k){
return mulMod(fact[n], fast(mulMod(fact[n-k], fact[k]), MOD-2));
}
ll solve(){
ll ret = 0;
REP(i,1,h-a){
int y = i;
int x = b;
ll val = combin(y+x-2,y-1);
x++;
val = mulMod(val, combin(h+w-y-x, h-y));
ret = addMod(ret, val);
}
return ret;
}
int main(){
ios_base :: sync_with_stdio(0); cin.tie(0); cout.tie(0);
fact[0] = 1;
REP(i,1,2*N) fact[i] = mulMod(fact[i-1], i);
cin >> h >> w >> a >> b;
cout << solve() << endl;
return 0;
} | #include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const ll mod=1000000007;
ll fac[200007],finv[200007],inv[200007];
void cominit(){
fac[0]=fac[1]=1;
finv[0]=finv[1]=1;
inv[1]=1;
for(int i=2;i<200007;i++){
fac[i]=fac[i-1]*i%mod;
inv[i]=mod-inv[mod%i]*(mod/i)%mod;
finv[i]=finv[i-1]*inv[i]%mod;
}
}
ll com(ll n,ll k){
if(n<k)return 0;
if(n<0 || k<0)return 0;
return fac[n]*(finv[k]*finv[n-k]%mod)%mod;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll h,w,a,b;
cin>>h>>w>>a>>b;
h--;w--;
cominit();
ll ans=com(h+w,w);
for(ll i=0LL;i<a;i++){
ans-=((com(b-1+h-i,b-1))*(com(w-b+i,i)))%mod;
ans%=mod;
}
cout <<(ans+mod)%mod<<endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int N, V, P;
int64_t M;
cin >> N >> M >> V >> P;
vector<int> A(N);
for (int i = 0; i < N; i++)
{
cin >> A.at(i);
}
sort(A.rbegin(), A.rend());
int Ab = A.at(P - 1);
int64_t acc = 0;
vector<int64_t> diff(N);
for (int i = P; i < N; i++)
{
acc += Ab - A.at(i);
diff.at(i) = acc;
}
int res = 0;
for (int i = 0; i < N; i++)
{
if (i < P)
{
res++;
continue;
}
int64_t Ai_mx = A.at(i) + M;
if (Ai_mx >= Ab && V - P <= N - i - 1)
{
res++;
continue;
}
int64_t v = M * (V - P - (N - i - 1));
int64_t d = diff.at(i - 1);
int Ab_mn = Ab;
if (v > d)
{
v -= d;
int n = i - (P - 1);
Ab_mn += (v + n - 1) / n;
}
if (Ai_mx >= Ab_mn)
{
res++;
}
}
cout << res << endl;
} | #include "bits/stdc++.h"
using namespace std;
void Main() {
long long N;
cin >> N;
vector<long long> A(N, 0), B(N, 0), C(N, 0);
for (long long i = 0; i < N; ++i) {
cin >> A[i];
}
for (long long i = 0; i < N; ++i) {
cin >> B[i];
}
for (long long i = 0; i < N; ++i) {
cin >> C[i];
}
sort(A.begin(), A.end());
sort(B.begin(), B.end());
sort(C.begin(), C.end());
vector<long long> fromAtoB(N, -1);
vector<long long> fromBtoC(N, -1);
for (long long i = 0; i < N; ++i) {
fromAtoB[i] = distance(B.begin(), upper_bound(B.begin(), B.end(), A[i]));
}
for (long long i = 0; i < N; ++i) {
fromBtoC[i] = distance(C.begin(), upper_bound(C.begin(), C.end(), B[i]));
}
vector<long long> BC(N, -1);
for (long long i = 0; i < N; ++i) {
BC[i] = N - fromBtoC[i];
}
vector<long long> accumBC(N, -1);
for (long long i = N - 1; i >= 0; --i) {
if (i == N - 1) {
accumBC[i] = BC[i];
}
else {
accumBC[i] = accumBC[i + 1] + BC[i];
}
}
long long ans = 0;
for (long long i = 0; i < N; ++i) {
long long k = fromAtoB[i];
if (k == N) {
break;
}
ans += accumBC[k];
}
cout << ans << endl;
}
int main() {
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
| 0 |
#include <cmath>
#include <cstdio>
#include <vector>
#include <iterator>
#include <iostream>
#include <algorithm>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <map>
#include <stdio.h>
#include <functional>
#include <chrono>
using namespace std;
#define rep(i,s,n) for(ll i=s;i<(n);++i)
using ll = long long;
using pll = pair<ll, ll>;
constexpr ll INF = (1LL << 60);
constexpr ll MAX_INF = 9223372036854775807;
constexpr ll MOD = (1e9 + 7);
//constexpr ll MOD = (998244353);
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
template<class T>
vector<vector<T>> vvt(T init, ll m, ll n) {
vector<vector<T>> ans = vector<vector<T>>(m, vector<T>(n, init));
return move(ans);
}
template<class T>
vector<T> vt(T init, ll n) {
vector<T> ans = vector<T>(n, init);
return move(ans);
}
template<class T>
T maxVec(vector<T>& v) {
T ans = -INF;
rep(i, 0, v.size()) {
ans = max(ans, v[i]);
}
return ans;
}
// 素数判定
bool judge(ll n) {
for (ll i = 2; i * i <= n; i++) if (n %= i)return false;
return true;
}
template <class C>
void print(const C & c, std::ostream & os = std::cout)
{
std::copy(std::begin(c), std::end(c), std::ostream_iterator<typename C::value_type>(os, ", "));
os << std::endl;
}
/*
ll count(ll n,ll r) {
ll ans = 0,check = 1;
rep(i,0, r) {
if ((n & check) > 0) {
ans++;
}
check = check << 1;
}
return ans;
}
*/
bool sortreverse(ll a, ll b) {
return a > b;
}
ll kiriage(ll a, ll b) {
if (a % b == 0)return a / b;
return a / b + 1;
}
ll n, m, x, y, t, q, s,k,h,w;
bool topologicalSort(vector<vector<long long>>& graph, vector<long long>& ans) {
vector<unordered_set<long long>> inGraph(graph.size());
vector<long long> node,check(graph.size(),0);
rep(i, 0, graph.size()) {
rep(j, 0, graph.at(i).size()) {
inGraph.at(graph.at(i).at(j)).insert(i);
}
}
rep(i, 0, graph.size()) {
if (inGraph.at(i).size() == 0)node.push_back(i);
}
while (! node.empty()) {
long long v = node.back();
node.pop_back();
ans.push_back(v);
rep(i, 0, graph.at(v).size()) {
inGraph.at(graph.at(v).at(i)).erase(v);
if (inGraph.at(graph.at(v).at(i)).size() == 0) {
node.push_back(graph.at(v).at(i));
}
}
check.at(v) = 1;
}
for (long long v : check) {
if (v == 0)return false;
}
return true;
}
int main() {
cin >> n >> m;
vvl graph(n);
rep(i, 0, n + m - 1) {
cin >> x >> y;
graph.at(x - 1).push_back(y - 1);
}
vl result;
topologicalSort(graph, result);
vl num(n);
rep(i, 0, n) {
num[result[i]] = i;
}
vvl in(n);
rep(i, 0, n) {
for (ll v : graph[i]) {
in[v].push_back(i);
}
}
rep(i, 0, n) {
ll oya = -1, c = -1;
rep(j, 0, in[i].size()) {
if (c < num[in[i][j]]) {
oya = in[i][j];
c = num[in[i][j]];
}
}
printf("%lld\n", oya + 1);
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll MOD = 1e9+7;
// const ll MOD = 998244353;
const ll INF = 1ll<<60;
#define FOR(i,a,b) for (ll i=(a);i<(ll)(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define DEBUG(x) std::cerr << #x << " : " << (x) << std::endl;
vector<ll> seen, deg, par;
vector<vector<ll>> G;
void dfs(ll v, ll pav)
{
seen[v] = true;
par[v] = pav+1;
for (auto &nv : G[v])
--deg[nv];
for (auto &nv : G[v])
{
if (!deg[nv] && !seen[nv])
dfs(nv, v);
}
}
int main(int argc, char **argv)
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll N, M; cin >> N >> M;
G.resize(N);
par.resize(N);
deg.assign(N, 0);
seen.assign(N, false);
REP(i, N-1+M)
{
ll a, b; cin >> a >> b;
--a, --b;
G[a].push_back(b);
deg[b]++;
}
ll root;
REP(i, N)
if (!deg[i])
root = i;
dfs(root, -1);
REP(i, N)
std::cout << par[i] << std::endl;
return 0;
}
| 1 |
#ifdef __GNUC__
#pragma GCC target("avx2")
#pragma GCC optimize ("O30")
#pragma GCC optimize ("tree-vectorize")
#pragma GCC optimize("unroll-loops")
#define iss std::cin
#endif
#include "bits/stdc++.h"
#define rep(i, times) for(ll i = 0; i < (times); ++i)
#define p(x) (cout << (x) << "\n")
using ll = long long; using ld = long double; using namespace std;
ll N, cnt;
void all( ) {
vector<vector<ll>> A;
iss >> N; A.resize(3, vector<ll>(N));
for (auto &abc : A) {
for (auto &a : abc) iss >> a;
}
sort(begin(A[0]), end(A[0]));
sort(begin(A[2]), end(A[2]));
for (auto &b : A[1]) {
cnt += (end(A[2]) - upper_bound(begin(A[2]), end(A[2]), b))
* (lower_bound(begin(A[0]), end(A[0]), b) - begin(A[0]));
}
p(cnt);
}
int main( ) {
cin.tie(0); ios::sync_with_stdio(0);
all( );
} | #include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); ++i)
#define MOD 1e9+7;
using namespace std;
using ll = long long;
int main() {
ll n, ans = 0;
cin >> n;
vector<ll> a(n), b(n), c(n);
rep(i,n) cin >> a[i];
sort(a.begin(), a.end());
rep(i,n) cin >> b[i];
sort(b.begin(), b.end());
rep(i,n) cin >> c[i];
sort(c.begin(), c.end());
for (int i = 0; i < n; i++) {
ll L = -1 , R = n;
while (abs(L - R) > 1) {
int mid = (L + R) / 2;
if (a[mid] < b[i]) L = mid;
else R = mid;
}
ll down = L;
L = -1; R = n;
while (abs(L - R) > 1) {
int mid = (L + R) / 2;
if (c[mid] > b[i]) R = mid;
else L = mid;
}
ll up = R;
ans += (down + 1) * (n - up);
}
cout << ans << endl;
return 0;
} | 1 |
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <climits>
#include <cstring>
#define rep(i, m, n) for(int i=int(m);i<int(n);i++)
#define all(c) begin(c),end(c)
template<typename T1, typename T2>
inline void chmin(T1 &a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2>
inline void chmax(T1 &a, T2 b) { if (a < b) a = b; }
typedef long long int ll;
using ll = long long int;
using ull = long long unsigned int;
using Int = long long int;
using namespace std;
#define INF (1 << 30) - 1
#define INFl (ll)5e15
#define DEBUG 0
#define dump(x) cerr << #x << " = " << (x) << endl
#define MOD 1000000007
//edit
template<typename T>
class Sum2d {
vector<vector<T> > vv;
unsigned xSize{};
unsigned ySize{};
public:
Sum2d(unsigned xSize, unsigned ySize) {
vector<vector<T> > vv(xSize + 2, vector<T>(ySize + 2));
this->vv = vv;
this->xSize = xSize + 2;
this->ySize = ySize + 2;
}
void add(int x, int y, T value) {
x++;
y++;
this->vv[x][y] += value;
}
void set_sum() {
for (int i = 0; i < xSize - 1; i++) {
for (int j = 0; j < ySize; j++) {
this->vv[i + 1][j] += vv[i][j];
}
}
for (int i = 0; i < xSize; i++) {
for (int j = 0; j < ySize - 1; j++) {
this->vv[i][j + 1] += vv[i][j];
}
}
}
//[sx,tx],[sy,ty]の範囲を求めるZE
T calc(int sx, int sy, int tx, int ty) {
tx++;
ty++;
return this->vv[tx][ty] + this->vv[sx][sy] - this->vv[tx][sy] - this->vv[sx][ty];
}
};
class Solve {
public:
void solve() {
Int N, M, Q;
cin >> N >> M >> Q;
vector<string> S(N);
Sum2d<int> V(2 * N, 2 * M), E(2 * N, 2 * M);
for (int i = 0; i < N; ++i) {
cin >> S[i];
for (int j = 0; j < M; ++j) {
if (S[i][j] == '1') {
V.add(2 * i, 2 * j, 1);
}
}
}
for (int i = 0; i < N; ++i) {
for (int j = 0; j + 1 < M; ++j) {
if (S[i][j] == '1' && S[i][j + 1] == '1') {
E.add(2 * i, 2 * j + 1, 1);
}
}
}
for (int j = 0; j < M; ++j) {
for (int i = 0; i + 1 < N; ++i) {
if (S[i][j] == '1' && S[i + 1][j] == '1') {
E.add(2 * i + 1, 2 * j, 1);
}
}
}
V.set_sum();
E.set_sum();
for (int i = 0; i < Q; ++i) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1--, y1--, x2--, y2--;
int r1 = 2 * x1;
int c1 = 2 * y1;
int r2 = 2 * x2;
int c2 = 2 * y2;
Int v1 = V.calc(r1, c1, r2, c2);
Int e1 = E.calc(r1, c1, r2, c2);
Int tmp = V.calc(r1, c1, r2, c2) - E.calc(r1, c1, r2, c2);
cout << tmp << endl;
}
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
Solve().solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define IOS ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long
bool a[2001][2001];
int res[2001][2001],v2[2001][2001],v1[2001][2001];
int main(){
IOS
int n,m,q;
cin>>n>>m>>q;
for(int i=1;i<=n;i++){
int cnt=0;
string s;
cin>>s;
for(int j=0;j<m;j++){
a[i][j+1]=s[j]-'0';
if(a[i][j+1]==1){
cnt++;
}
res[i][j+1]=cnt;
}
}
for(int i=1;i<=n;i++){
int cnt=0;
for(int j=1;j<=m;j++){
if(a[i][j]==1&&a[i][j-1]==1){
cnt++;
}
v1[i][j]=cnt;
}
}
for(int i=1;i<=m;i++){
int cnt=0;
for(int j=1;j<=n;j++){
if(a[j][i]==1&&a[j-1][i]==1){
cnt++;
}
v2[j][i]=cnt;
}
}
for(int i=1;i<=q;i++){
int x1,y1,x2,y2,r=0,v=0;
cin>>x1>>y1>>x2>>y2;
for(int j=y1;j<=y2;j++){
r+=v2[x2][j]-v2[x1][j];
}
for(int j=x1;j<=x2;j++){
r+=v1[j][y2]-v1[j][y1];
}
for(int j=x1;j<=x2;j++){
v+=res[j][y2]-res[j][y1-1];
}
cout<<v-r<<endl;
}
return 0;
}
/*
*/ | 1 |
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pp pair<int,int>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define ld long double
#define al(a) (a).begin(),(a).end()
#define mk make_pair
#define check cout<<"?"<<endl;
ll MOD=1000000007;
ll mod=998244353;
int inf=1000001000;
ll INF=1e18+5;
int find_(int x,vector<pair<ll,ll>> &v){
if(v[x].first<0) return x;
v[x].first=find_(v[x].first,v);
return v[x].first;
}
int same_(int a,int b,vector<pair<ll,ll>> &v){
if(find_(a,v)==find_(b,v)) return 1;
return 0;
}
void union_(int a,int b,vector<pair<ll,ll>> &v){
if(same_(a,b,v)) return;
int a_p=find_(a,v),b_p=find_(b,v);
if(a_p>b_p) swap(a_p,b_p);
v[a_p].first+=v[b_p].first;
v[a_p].second+=v[b_p].second;
v[b_p].first=a_p;
}
/*
void print_v(vector<pp> v){
rep(i,v.size()) cout<<v[i]<<" ";
cout<<endl;
}
int size_(int a,vector<pp> &v){
return -v[find_(a,v)];
}
*/
int main() {
int h,w; cin>>h>>w;
vector<string> s(h,"");
rep(i,h) cin>>s[i];
vector<pair<ll,ll>> v(h*w,mk(-1,0));
rep(i,h*w){
if(s[i/w][i%w]=='#') v[i].second=-1;
}
rep(i,(h-1)*w) if(s[i/w][i%w]!=s[i/w+1][i%w]) union_(i,i+w,v);
rep(i,h*w){
if(i%w==w-1) continue;
if(s[i/w][i%w]!=s[i/w][i%w+1]) union_(i,i+1,v);
}
ll ans=0;
rep(i,h*w){
if(v[i].first<0)
ans+=(-v[i].second)*(v[i].second-v[i].first);
}
cout<<ans<<endl;
} | #include <bits/stdc++.h>
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define INF 2e9
#define MOD 1000000007
#define ALL(v) v.begin(), v.end()
#define sz(x) int(x.size())
using namespace std;
typedef long long ll;
using P = pair<int,int>;
int dx[4] = {1,0,-1,0};
int dy[4] = {0,1,0,-1};
int main()
{
int H,W;
cin >> H >> W;
vector<string> A(H);
REP(i, H) cin >> A[i];
vector<vector<int>> dist(H,vector<int> (W,-1));
ll ans = 0;
REP(i,H){
REP(j,W){
if(A.at(i).at(j)=='#'&&dist[i][j]==-1){
ll cntblack = 1;
ll cntwhite = 0;
queue<P> que;
que.push(make_pair(i,j));
dist[i][j]=0;
while(!que.empty()){
int vy = que.front().first;
int vx = que.front().second;
que.pop();
REP(k,4){
int nvy = vy+dy[k];
int nvx = vx+dx[k];
if(nvy<0||nvy>H-1||nvx<0||nvx>W-1||dist[nvy][nvx]!=-1||(A[vy][vx]=='#'&&A[nvy][nvx]!='.')||(A[vy][vx]=='.'&&A[nvy][nvx]!='#')) continue;
dist[nvy][nvx]=0;
que.push(make_pair(nvy,nvx));
if(A[nvy][nvx]=='#'){
cntblack++;
}else{
cntwhite++;
}
}
}
ans+=cntblack*cntwhite;
}
}
}
cout << ans << endl;
} | 1 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define fastio ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define ll long long
#define ull unsigned long long
#define ld long double
#define pii pair <int, int>
#define pll pair <ll, ll>
#define pci pair <char, int>
#define pld pair <ld, ld>
#define ppld pair <pld, pld>
#define ppll pair <pll, pll>
#define pldl pair <ld, ll>
#define vll vector <ll>
#define vvll vector <vll>
#define vpll vector <pll>
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define mll map <ll, ll>
#define fastmap gp_hash_table
#define cd complex <double>
#define vcd vector <cd>
#define PI 3.14159265358979
#pragma 03
using namespace std;
using namespace __gnu_pbds;
ll n;
multiset <ll> st;
int main(){
fastio;
ll t, k, ans = 0;
cin >> n;
for (ll i = 0; i < n; i++) cin >> t, st.insert(t);
while (st.size() > 1){
auto it = st.end();
it--; t = *it;
st.erase(it);
for (k = 1; k <= t; k *= 2);
it = st.find(k - t);
if (it != st.end()){
st.erase(it); ans++;
}
}
cout << ans << endl;
} | #include <iostream>
#include <string>
#include <cmath>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<iomanip>
#define _USE_MATH_DEFINES
#include <math.h>
#include <functional>
using namespace std;
#define rep(i,x) for(ll i=0;i<x;i++)
#define repn(i,x) for(ll i=1;i<=x;i++)
typedef long long ll;
const ll INF = 1e17;
const ll MOD = 1000000007;
const ll MAX = 1000001;
ll max(ll a, ll b) {
if (a > b) { return a; }
return b;
}
ll min(ll a, ll b) {
if (a > b) { return b; }
return a;
}
ll gcd(ll a, ll b) {
if (b == 0) { return a; }
if (a < b) { return gcd(b, a); }
return gcd(b, a%b);
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) *b;
}
struct edge {
ll ind;
ll fr;
ll to;
ll d;
};
///////////////////////////
int main() {
ll N;
cin >> N;
vector<ll> A(N + 1,0);
repn(i, N) cin >> A[i];
sort(++A.begin(), A.end());
vector<ll> B(1);
vector<ll> C(1);
ll M = 0;
repn(i, N) {
if (A[i] != A[i - 1]) {
M++;
C.push_back(A[i]);
B.push_back(1);
}
else { B[M]++; }
}
ll ans = 0;
for (ll i = M; i > 0; i--) {
ll p = 1;
while (p <= C[i]) {
p *= 2;
}
ll X = p - C[i];
auto itr = lower_bound(++C.begin(), C.end(), X);
ll j = distance(C.begin(), itr);
if (C[j] != X) { continue; }
if (i == j) { ans += B[i] / 2; }
if (j < i) { ans += min(B[i], B[j]); B[j] -= min(B[i], B[j]); }
}
cout << ans;
system("PAUSE");
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b,x,y,z;
cin>>a>>b;
x=a+b;
y=a-b;
z=a*b;
if(x>=y && x>=z)
{
cout<<x<<endl;
}
else if(y>=x && y>=z)
{
cout<<y<<endl;
}
else
{
cout<<z<<endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
using ll = long long;
using p = pair<int,int>;
using Graph = vector<vector<int>>;
int main(int argc, const char * argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int a,b;
cin>>a>>b;
int ans=-1e9;
ans=max(ans,a+b);
ans=max(ans,a-b);
ans=max(ans,a*b);
cout<<ans<<endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
using vi = vector<int>;
int d[30];
ll f[30][2][2];
int main() {
int D;
cin>>D;
memset(d, 0, sizeof(d));
int i = 0;
while (D>0) {
d[i] = D % 10;
D /= 10;
i++;
}
ll ans = 0;
for (int len = i-1; len <= 20; ++len) {
memset(f,0,sizeof(f));
f[0][0][0] = 1;
for (int i = 0; i<=len/2; i++) {
for (int l0 = 0; l0 <= 1; ++l0)
for (int r0 = 0; r0 <= 1; ++r0)
for (int l1 = 0; l1 <= 1; ++l1)
for (int r1 = 0; r1 <= 1; ++r1)
for (int x = 0+(i==0); x <= 9; ++x)
for (int y = 0; y <= 9; ++y)
if (x+d[len-i]+l1==l0*10+y && y+d[i]+r0==r1*10+x) {
f[i+1][l1][r1] += f[i][l0][r0];
if (i==len/2) {
if (len % 2 == 0) {
if (l1==r0 && l0==r1 && x==y) ans += f[i][l0][r0];
}
else {
if (l1 == r1) ans += f[i][l0][r0];
}
}
}
}
}
cout<<ans<<endl;
}
| #include<bits/stdc++.h>
#define fo(i,a,b) for((i)=(a);i<=(b);i++)
#define rfo(i,a,b) for((i)=(a);i>=(b);i--)
#define inrange(x,y,z) (((x)>=(y))&&((x)<=(z)))
#define ALL(vec) (vec).begin(),(vec).end()
#define SOR(vec) sort(ALL(vec))
#define UNI(vec) (vec).erase(unique(ALL(vec)),(vec).end())
using namespace std;
int n;
double val;
long long a,res;
int two,five;
map<pair<int,int>,int> cnt;
int main(){
#ifdef FILIN
#ifndef DavidDesktop
freopen(FILIN,"r",stdin);
freopen(FILOUT,"w",stdout);
#endif
#endif
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin>>n;
for(int i=1;i<=n;i++){
cin>>val;
a=llround(val*1e9);
two=five=0;
while(a%2==0){
two++;
a/=2;
}
while(a%5==0){
five++;
a/=5;
}
cnt[make_pair(two,five)]++;
}
for(auto p1:cnt){
for(auto p2:cnt){
if((p1.first.first+p2.first.first)>=18&&(p1.first.second+p2.first.second)>=18){
if(p1==p2) res+=(long long)(p1.second)*(long long)(p1.second-1);
else res+=(long long)(p1.second)*(long long)(p2.second);
}
}
}
cout<<res/2LL<<endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
typedef long long ll;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); }
template <typename T> void read(T &x) {
x = 0; int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
int get(int h, int m) {
return h * 60 + m;
}
int main() {
int h1, m1, h2, m2, k;
read(h1), read(m1), read(h2), read(m2), read(k);
cout << get(h2, m2) - get(h1, m1) - k << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
#define initdp(a, b) for (int i = 0; i <= a; i++) for (int j = 0; j <= b; j++) dp[i][j] = -1;
#define pb push_back
#define mpr make_pair
#define pii pair<int, int>
#define ll long long
#define pll pair<ll, ll>
#define all(arr) arr.begin(), arr.end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repd(i, n) for (int i = n - 1; i >= 0; i--)
#define fo(i, l, r) for (int i = l; i <= r; i++)
#define INF 1000000001
#define inf1 1000000000000000001
#define mod 1000000007
#define pie 3.14159265358979323846264338327950L
#define N 1000005
#define mid(l, r) l + (r - l) / 2
#define vec vector<int>
#define vecl vector<ll>
#define umap unordered_map<ll,ll>
#define yes cout << "YES" << endl;
#define no cout << "NO" << endl;
#define endl "\n"
using namespace std;
ll gcd(ll a, ll b) {
if(b==0)
return a;
return gcd(b, a%b);
}
void solve(){
int n,M;
cin>>n>>M;
int a,b;
if(M%2==0){
a=M/2;
b=M/2;
}else{
a=M/2;
b=M-a;
}
for(int i=1;i<=a;++i){
cout<<i<<" "<<2*a+2-i<<endl;
}
for(int i=1;i<=b;++i){
cout<<i+2*a+1<<" "<<M*2+2-i<<endl;
}
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout<<fixed<<setprecision(20);
int t = 1;
// cin >> t;
while (t--)
{
solve();
}
} | 0 |
#include<iostream>
using namespace std;
long long n;
long long a[200003];
long long dp[200003];
long long sumb[200003];
long long ans=-2e18;
long long sum;
long long su;
int main(){
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
dp[1]=a[1];
dp[2]=a[2];
sumb[n]=a[n];
sumb[n-1]=a[n-1];
for(int i=3;i<=n;i++) dp[i]=dp[i-2]+a[i];
for(int i=n-2;i>=1;i--) sumb[i]=sumb[i+2]+a[i];
sum=dp[n];
if(n%2==0){
ans=max(dp[n-1],dp[n]);
for(int i=1;i<=n;i+=2) ans=max(ans,dp[i]+sumb[i+3]);
cout<<ans<<endl;
return 0;
}
for(int i=1;i<=n;i++){
if(i%2==0) su+=a[i];
else{
su=max(su-a[i],-a[i]);
ans=max(ans,sum+su);
}
}
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcountll
#define INF 1e16
#define mod 1000000007
void gauss(vector<ll>& a){
ll n=a.size();
ll rank=0;
for(ll b=(1LL<<60LL);b>=1;b>>=1){
ll p=rank;
while(p<n&&!(a[p]&b))p++;
if(p==n)continue;
swap(a[rank],a[p]);
rep(i,n){
if(i==rank)continue;
if(a[i]&b)a[i]^=a[rank];
}
rank++;
}
a.resize(rank);
sort(all(a));
reverse(all(a));
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
vector<ll> a;
cin>>n;
ll sum=0;
a.resize(n);
rep(i,n){
cin>>a[i];
sum^=a[i];
}
rep(i,n){
rep(j,60){
if((sum>>j)&1LL){
if((a[i]>>j)&1LL){
a[i]^=(1LL<<j);
}
}
}
}
sort(all(a));
gauss(a);
ll mx=0;
rep(i,a.size()){
if(mx<(mx^a[i])){
mx^=a[i];
}
}
cout<<mx*2+sum<<endl;
return 0;
}
| 0 |
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define rep(i,N) for(int i=0;i<(int)N;i++)
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
static inline void PUT(char c)
{
static char buf[1<<15],*ptr=buf;
if(ptr==buf+strlen(buf)||c==0){fwrite(buf,1,ptr-buf,stdout),ptr=buf;}*ptr++=c;
}
static inline int IN(void)
{
int x=0,f=0,c=getchar();while(c<48||c>57){f^=c==45,c=getchar();}
while(c>47&&c<58){x=x*10+c-48,c=getchar();}return f?-x:x;
}
static inline void OUT(int a)
{
if(a<0)PUT('-'),a=-a;
int d[40],i=0;do{d[i++]=a%10;}while(a/=10);
while(i--){PUT(d[i]+48);}PUT('\n');
}
int N=0;
static inline void Add(int *fwt,int i,int v){while(i<N){fwt[i]+=v;i|=i+1;}}
static inline int Sum(int *fwt,int i){int v=0;while(i>=0){v+=fwt[i];i=(i&(i+1))-1;}return v;}
int main()
{
N=IN();int Q=IN(),after[500001],dat[500000],fenwick[500000],id[500001],left[500001],pos[500000],result[500000];
rep(i,N){dat[i]=IN()-1;}
rep(i,Q){left[i+1]=IN()-1;int r=IN()-1;after[i+1]=id[r];id[r]=i+1;}
for(int r=0;r<N;r++)
{
if(pos[dat[r]]){Add(fenwick,pos[dat[r]]-1,-1);}
Add(fenwick,r,1);
for(int i=id[r];i;i=after[i]){result[i-1]=Sum(fenwick,r)-Sum(fenwick,left[i]-1);}
pos[dat[r]]=r+1;
}
rep(i,Q){OUT(result[i]);}
} | #include <bits/stdc++.h>
using namespace std;
#define endl "\n"
#define faster ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
typedef long long ll;
typedef vector<int> vi;;
typedef vector<ll> vll;
#define l() length()
#define sz() size()
#define b() begin()
#define e() end()
#define all(x) x.begin(), x.end()
#define pb(i) push_back(i)
#define PB() pop_back()
typedef pair<int, int> pii;
typedef pair<ll,ll> pll;
#define mp make_pair
#define Fi first
#define Se second
const int maxx=1e6+9;
// Happy Coding!
ll _find(int d,int n){
return n<100 ? pow(100,d)*n : 101*pow(100,d);
}
void solve(){
int n;
cin>>n;
map<string,int> f;
for(int i=0;i<n;i++){
string s;cin>>s;
f[s]++;
}
int m;
cin>>m;
for(int i=0;i<m;i++){
string s;cin>>s;
f[s]--;
}
int ans=0;
for(auto P:f){
ans=max(ans,P.Se);
}
cout<<ans<<endl;
}
int main() {
faster;
int t=1;
// cin>>t;
while(t-->0){
solve();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for (int (i) = 0; (i) < (n); i++)
#define ll long long
using namespace std;
int main() {
ll N = 0, A,B;;
cin >> N >> A >> B;
if(N == 1){
cout << "Hello World";
}
else{
cout << A + B;
}
}
| #include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <algorithm>
#include <numeric>
#include <random>
#include <vector>
#include <array>
#include <bitset>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
int main() {
string a, b ,c;
cin >> a >> b >> c;
if(a.back() == b.front() && b.back() == c.front()){
cout << "YES";
}else{
cout << "NO";
}
return 0;
} | 0 |
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n = 0, tmp0 = 0, tmp1 = 0;
int tmp2 = 0, tmp3, out1 = 0, out2 = 0;
int a[100];
scanf("%d", &n);
while (n) {
for (tmp3=0;tmp3<100;tmp3++) a[tmp3] = 0;
tmp0 = 0, out2 = 0;
while (tmp0 < n) {
tmp1 = 0, out1 = 0;
while (tmp1 < n) {
scanf("%d", &tmp2);
a[tmp1] += tmp2;
printf("%5d", tmp2);
out1 += tmp2;
tmp1++;
}
printf("%5d\n", out1);
a[tmp1] += out1;
tmp0++;
}
tmp0 = 0;
while (tmp0 < n) {
printf("%5d", a[tmp0]);
tmp0++;
}
printf("%5d\n", a[tmp0]);
scanf("%d", &n);
}
return 0;
} | #include <iostream>
#include <cstdio>
using namespace std;
int main(){
int n,field[11][11];
while (cin >> n, n){
for (int i = 0; i < 11; i++){
for (int j = 0; j < 11; j++) field[i][j] = 0;
}
for (int i = 0; i < n; i++){
for (int j = 0; j < n; j++) cin >> field[i][j];
}
for (int i = 0; i < n; i++){
for (int j = 0; j < n; j++) field[n][i] += field[j][i];
}
for (int i = 0; i < n; i++){
for (int j = 0; j < n; j++) field[i][n] += field[i][j];
}
for (int i = 0; i < n; i++) field[n][n] += field[n][i];
for (int i = 0; i <= n; i++){
for (int j = 0; j <= n; j++) printf("%5d",field[i][j]);
puts("");
}
}
return 0;
} | 1 |
// ABC 089 A- Grouping 2
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
cout << N / 3 << endl;
}
| #include<iostream>
using namespace std;
int main(){
int a,b=0;
cin>>a;
if(a%3==0 && a>0){
b=(a/3)+b;
}
else if(a%3==1 && a>1){
a-=4;
b++;
b=(a/3)+b;
}
else if(a%3==2 && a>2){
a-=5;
b++;
b=(a/3)+b;
}
else{
system("pause");
}
cout<<b;
} | 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
//using Graph = vector<vector<edge>>;
using dou =long double;
string yes="yes";
string Yes="Yes";
string YES="YES";
string no="no";
string No="No";
string NO="NO";
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define brep(n) for(int bit=0;bit<(1<<n);bit++)
#define erep(i,container) for (auto i : container)
#define irep(i, n) for(int i = n-1; i >= (int)0; i--)
#define rrep(i,m,n) for(ll i = m; i < (ll)(n); i++)
#define reprep(i,j,h,w) rep(i,h)rep(j,w)
#define all(x) (x).begin(),(x).end()
#define VEC(type,name,n) std::vector<type> name(n);rep(i,n)std::cin >> name[i];
#define pb push_back
#define pf push_front
#define query int qq;std::cin >> qq;rep(qqq,qq)
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define itn int
#define mp make_pair
#define sum(a) accumulate(all(a),0ll)
#define keta fixed<<setprecision
#define vvector(name,typ,m,n,a)vector<vector<typ> > name(m,vector<typ> (n,a))
#define vvvector(name,t,l,m,n,a) vector<vector<vector<t> > > name(l, vector<vector<t> >(m, vector<t>(n,a)));
#define vvvvector(name,t,k,l,m,n,a) vector<vector<vector<vector<t> > > > name(k,vector<vector<vector<t> > >(l, vector<vector<t> >(m, vector<t>(n,a)) ));
#define case std::cout <<"Case #" <<qqq+1<<": "
#define RES(a,i,j) a.resize(i);rep(ii,i)a[ii].resize(j);
#define as assign
#define ffor for(;;)
#define ppri(a,b) std::cout << a<<" "<<b << std::endl
#define pppri(a,b,c) std::cout<<a<<" "<<b<<" "<<c<<std::endl
#define aall(x,n) (x).begin(),(x).begin()+(n)
#define ssum(a) accumulate(a,0ll)
#define gre(n) greater<n>()
typedef long long ll;
//
typedef pair<int,int> P;
typedef pair<ll,ll> PL;
//typedef long long T;
const int INF = 1000000000;
const double dINF = 1000000000;
const ll INF64 = 922337203685477580ll;
const ll MOD = 998244353ll;
//const ll MOD = 67280421310721ll;
const dou pi=3.141592653589793;
//メモ
//二次元配列のresizeのしかた
//vv.resize(n);
//for(size_t i=0; i<n; i++){
// vv[i].resize(n);
//}
//メモ
//負の辺を持つ最短経路問題では到達不可経路でも初期化値より小さくなりうるので注意しよう
int main(){
int n,m,v,p;
std::cin >> n>>m>>v>>p;
VEC(ll,a,n);
std::vector<ll> sa(n+1);
sort(all(a),gre(ll));
rep(i,n){
sa[i+1]=sa[i]+a[i];
}
int ans=p;
int dd=a[p-1];
rrep(i,p,n){
ll can=a[i]+m;
ll need=max(0ll,ll(i-(p-1))-(n-v))*m;
bool b=0;
// ll d=0;
ll dd=(i-p+1)*can-(sa[i]-sa[p-1]);
// pppri(i,p-1,sa[i]-sa[p-1]);
if(can<a[p-1])break;
if(dd>=need)ans++;
/*
rrep(j,p-1,i){
// std::cout << j << std::endl;
if(can<a[j]){
b=1;
break;
}
d+=can-a[j];
//if(d>=need)ans++;
}
*/
if(b)break;
//ppri(d,dd);
}
std::cout << ans << std::endl;
} | #include <cstdio>
#include <algorithm>
const int N = 100000;
int n, m, v, p, a[N];
bool test(int t)
{
t = n - t;
int amt = v - t - 1;
int i;
for (i = n - 1; a[t] + m < a[i]; --i, --amt);
long long to = 0;
for (int j = i; j > t; --j) to += a[t] + m - a[j];
for (; i > t && to < (long long)amt * m; --i) {
--amt;
to -= a[t] + m - a[i];
}
return n - i <= p;
}
int main()
{
scanf("%d%d%d%d", &n, &m, &v, &p);
for (int i = 0; i < n; ++i) scanf("%d", a + i);
std::sort(a, a + n);
int l = p, r = n;
int ans;
while (l <= r) {
int m = (l + r) >> 1;
if (test(m)) {
ans = m;
l = m + 1;
}
else r = m - 1;
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <iostream>
#include <string>
#include <vector>
#include <array>
#include <algorithm>
namespace ABC168
{
class B
{
public:
B() = default;
~B() = default;
void Run()
{
std::string S;
int K= 0;
std::cin >> K;
std::cin >> S;
std::string answer = S;
if (S.length() > K)
{
answer = S.substr(0, K);
answer.append("...");
}
std::cout << answer << std::endl;
}
};
}
int main()
{
ABC168::B prob;
prob.Run();
return 0;
}
| #include<bits/stdc++.h>
#define ll long long
const ll mod = 1000000007 ;
bool isInteger(double n)
{
if(floor(n)==ceil(n))
return true ;
return false ;
}
using namespace std ;
int main()
{
int k;
cin>>k;
string s;
cin>>s;
string s1="" ;
if(s.length()<=k)
cout<<s;
else
{
for(int i=0 ;i<s.length() ;i++)
{
if(i<k)
s1+=s[i];
}
s1+="...";
cout<<s1;
}
}
| 1 |
#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 ll = int64_t;
using Graph = vector<vector<int> >;
const ll M = 1000000007;
int main(){
int h,w;
cin >> h >> w;
char s[h+2][w+2];
for(int i=0;i<h+2;i++){
if(i==0 || i==h+1){
for(int j=0;j<w+2;j++) s[i][j]='.';
}else{
for(int j=0;j<w+2;j++){
if(j==0 || j==w+1){
s[i][j]='.';
}else{
cin >> s[i][j];
}
}
}
}
/*for(int i=0;i<h+2;i++){
for(int j=0;j<w+2;j++){
cout << s[i][j];
}
cout << endl;
}*/
for(int i=1;i<=h;i++){
for(int j=1;j<=w;j++){
if(s[i][j]=='#'){
if(s[i+1][j]=='.' && s[i-1][j]=='.' && s[i][j+1]=='.' && s[i][j-1]=='.'){
cout << "No" << endl;
return 0;
}
}
}
}
cout << "Yes" << endl;
} | #include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
using namespace std;
const int N=2005;
int n,m,t,ans;
int dp[N][N],mp[N][N],st[N],f[N],g[N];
char s[N][N];
bool pd(int x1,int y1,int x2,int y2){
int sum;
sum=mp[x1][y1]+mp[x1][y2]+mp[x2][y1]+mp[x2][y2];
return !(sum&1);
}
void init(){
int i,j,k;
for (i=1;i<n;i++){
for (j=m-1;j;j--){
if (pd(i,j,i+1,j+1)) dp[i][j]=dp[i][j+1]+1;
else dp[i][j]=0;
}
}
}
void work(){
int i,j;
for (i=1;i<m;i++){
t=0;
for (j=1;j<n;j++){
while (t&&dp[j][i]<dp[st[t]][i]){
f[st[t]]=j; t--;
}
st[++t]=j;
}
for (j=1;j<=t;j++) f[st[j]]=n;
t=0;
for (j=n-1;j;j--){
while (t&&dp[j][i]<dp[st[t]][i]){
g[st[t]]=j+1; t--;
}
st[++t]=j;
}
for (j=1;j<=t;j++) g[st[j]]=1;
for (j=1;j<n;j++) ans=max(ans,(f[j]-g[j]+1)*(dp[j][i]+1));
}
}
int main(){
int i,j;
scanf("%d%d",&n,&m); ans=max(n,m);
for (i=1;i<=n;i++){
scanf("%s",s[i]+1);
for (j=1;j<=m;j++) mp[i][j]=s[i][j]=='.';
}
init();
work();
printf("%d\n",ans);
return 0;
} | 0 |
#include<cstdio>
#include<utility>
#include<vector>
#include<queue>
using namespace std;
typedef pair<int, int> P;
const int INF = 1050;
struct vertex {
vector<int> to;
int dist = INF;
};
int n, m;
int sd[1000], prv[1000];
vertex ver[1000];
priority_queue<P, vector<P>, greater<P>> q;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
ver[a - 1].to.emplace_back(b - 1);
}
for (int i = 0; i < n; i++) sd[i] = INF;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) ver[j].dist = INF;
ver[i].dist = 0;
q.emplace(0, i);
while(!q.empty()) {
P p = q.top(); q.pop();
if (p.second != i && ver[p.second].dist != p.first) continue;
if (p.second == i && p.first != 0 && sd[i] != p.first) continue;
for (auto &j : ver[p.second].to) {
if (j != i && p.first + 1 < ver[j].dist) {
ver[j].dist = p.first + 1;
q.emplace(ver[j].dist, j);
}
if (j == i && p.first + 1 < sd[i]) {
sd[i] = p.first + 1;
q.emplace(sd[i], i);
}
}
}
}
int minsd = INF, ind;
for (int i = 0; i < n; i++) {
if (sd[i] < minsd) {
minsd = sd[i];
ind = i;
}
}
if (minsd == INF) {
printf("-1\n");
return 0;
}
for (int i = 0; i < n; i++) ver[i].dist = INF;
ver[ind].dist = 0;
sd[ind] = INF;
q.emplace(0, ind);
while(!q.empty()) {
P p = q.top(); q.pop();
if (p.second != ind && ver[p.second].dist != p.first) continue;
if (p.second == ind && p.first != 0 && sd[ind] != p.first) continue;
for (auto &i : ver[p.second].to) {
if (i != ind && p.first + 1 < ver[i].dist) {
ver[i].dist = p.first + 1;
q.emplace(ver[i].dist, i);
prv[i] = p.second;
}
if (i == ind && p.first + 1 < sd[ind]) {
sd[ind] = p.first + 1;
q.emplace(sd[ind], ind);
prv[i] = p.second;
}
}
}
printf("%d\n", minsd);
for (int i = 0, j = ind; i < minsd; i++) {
printf("%d\n", j + 1);
j = prv[j];
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define MAXN 1005
vector<int> g[MAXN];
vector<vector<int>> cycles;
int par[MAXN];
void dfs(int u) {
//$ cerr << u << endl;
for(int v : g[u]) {
if(par[v] == -1) {
par[v] = u;
dfs(v);
} else {
int cur = u;
vector<int> cyc = {u};
while(cur != v && par[cur] != -2) {
cyc.push_back(par[cur]);
cur = par[cur];
}
if(cyc.back() == v)
cycles.push_back(cyc);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
for(int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].push_back(v);
}
for(int i = 0; i < n; i++) {
memset(par, -1, sizeof par);
par[i] = -2;
dfs(i);
}
for(vector<int> v : cycles) {
set<int> s(v.begin(), v.end());
bool ok = true;
for(int i = 0; i < (int) v.size(); i++) {
int cnt = 0;
for(int nei : g[v[i]]) {
if(s.count(nei)) {
cnt++;
}
}
if(cnt > 1) {
ok = false;
}
//$ cerr << v[i] << " : nei's = " << cnt << endl;
}
//$ cerr << endl;
if(ok) {
cout << v.size() << '\n';
for(int i = 0; i < (int) v.size(); i++) {
cout << v[i]+1 << '\n';
}
return 0;
}
}
cout << -1 << endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
ll n,a,b;
cin>>n;
cout<<50<<endl;
a=n/50;
b=n%50;
for(int i=0;i<b;i++){
cout<<50+a-i<<" ";
}
for(int i=b;i<50;i++){
cout<<max(0LL,49+a-i)<<" ";
}
} | #include <cstdio>
#include <iostream>
#include <cassert>
#include <string>
#include <algorithm>
#include <cstring>
#include <utility>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <cmath>
#include <deque>
#include <unordered_map>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
typedef pair<LL, LL> pll;
LL x[50];
int main() {
LL K;
scanf("%lld", &K);
LL rd = K / 50;
for (int i = 0; i < 50; i++)
x[i] = 50 - 1 + rd;
for (int i = 0; i < (K % 50); i++) {
int idx = 0;
for (int j = 0; j < 50; j++)
if (x[j] <= x[idx]) idx = j;
for (int j = 0; j < 50; j++) {
if (j == idx) x[j] += 50;
else x[j]--;
}
}
printf("%d\n", 50);
for (int i = 0; i < 50; i++)
printf("%lld ", x[i]);
puts("");
return 0;
}
| 1 |
#define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <bitset>
#include <utility>
#include <numeric>
#include <iterator>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ldouble = long double;
const ll inf = 1ll << 60;
const ll mod = (ll)1e9 + 7;
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define print(s) cout << s;
#define println(s) cout << s << endl;
#define printd(s) cout << fixed << setprecision(10) << s << endl;
int main()
{
ll m, n, x, y;
cin >> m >> n >> x >> y;
vector<ll> a(m);
ll a0 = -101;
for (ll i = 0; i < m; i++)
{
cin >> a[i];
a0 = max(a0, a[i]);
}
vector<ll> b(n);
ll b0 = 101;
for (ll i = 0; i < n; i++)
{
cin >> b[i];
b0 = min(b0, b[i]);
}
string res = "No War";
if (a0 >= b0)
{
res = "War";
}
if (b0 <= x)
{
res = "War";
}
if (a0 >= y)
{
res = "War";
}
println(res);
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
#define all(a) (a).begin(), (a).end()
int f(int n)
{
return ((n & 1) ? 3 * n + 1 : n / 2);
}
int main()
{
int n, m;
cin >> n >> m;
vector<int> x(n + 1), y(m + 1);
cin >> x[0] >> y[0];
rep2(i, 1, n + 1) cin >> x[i];
rep2(i, 1, m + 1) cin >> y[i];
sort(all(x));
sort(all(y));
cout << ((x[n] < y[0]) ? "No War" : "War") << '\n';
return 0;
}
| 1 |
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=1e5+5;
const int MAXB=65;
typedef long long ll;
int n;
ll a[MAXN],p[MAXN],sum;
bool vis[MAXB];
void ins(ll x){
for (ll i=60;i>=0;i--){
if (!vis[i]) continue;
if (x&(1ll<<i)){
if (!p[i]) p[i]=x;
x^=p[i];
}
}
}
int main(){
scanf("%d",&n);
for (int i=1;i<=n;i++){
scanf("%lld",&a[i]);
sum^=a[i];
}
for (int i=0;i<=60;i++){
if (!(sum&(1ll<<i))) vis[i]=1;
}
for (int i=1;i<=n;i++) ins(a[i]);
ll res=0;
for (int i=60;i>=0;i--){
if (vis[i]&&(!(res&(1ll<<i)))) res^=p[i];
}
printf("%lld\n",res+(sum^res));
return 0;
}
| #include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <iomanip>
#include <utility>
#include <tuple>
#include <functional>
#include <bitset>
#include <cassert>
#include <complex>
#include <stdio.h>
#include <time.h>
#include <numeric>
#include <unordered_map>
#include <unordered_set>
# define ll int64_t
# define str string
# define rep(i,n) for(ll i=0;i<n;i++)
# define rrep(i,n) for(ll i=1;i<=n;i++)
# define ALL(x) (x).begin(), (x).end()
# define SZ(x) ((int)(x).size())
# define pb push_back
# define mod 1000000007
# define PI 3.141592653589793
# define vec vector
#define dump(x) cerr<<#x<<"="<<x<<endl
using namespace std;
#define INF 2000000000
#define MAX_V 10
bool compare_by_b(pair<string,ll> a,pair<string,ll> b){
if(a.second != b.second) return a.second<b.second;
else return a.first<b.first;
}
bool my_compare(pair<string,ll> a,pair<string,ll> b){
if(a.first != b.first) return a.first<b.first;
if(a.second != b.second) return a.second>b.second;
else return true;
}
ll modpow(ll a,ll n,ll mod1) {
ll res=1;
while(n>0){
if(n&1) res=res*a%mod1;
a = a*a%mod1;
n >>= 1;
}
return res;
}
ll factorial(ll n){
ll x=1;
rrep(i,n) (x*=i)%=mod;
return x;
}
ll gcd(ll a,ll b){
if (a%b == 0) return(b);
else return(gcd(b,a%b));
}
ll lcm(ll a,ll b){
return a/gcd(a,b)*b;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n,sum=0;
cin>>n;
vec<ll> a(n+2);
rrep(i,n) cin>>a[i];
a[n+1]=0;
rrep(i,n+1){
sum+=abs(a[i]-a[i-1]);
}
for(ll i=1;i<=n;i++){
ll num=sum;
if(a[i-1]<a[i] && a[i]>a[i+1]){
num-=(abs(a[i]-a[i-1])+abs(a[i]-a[i+1]));
num+=abs(a[i-1]-a[i+1]);
}else if(a[i-1]>a[i] && a[i]<a[i+1]){
num-=(abs(a[i]-a[i-1])+abs(a[i]-a[i+1]));
num+=abs(a[i-1]-a[i+1]);
}
cout<<num<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N;
M = N;
int sum = 0;
for (int i=8; i>=0; i--) {
int W=1;
for (int j=0; j<i; j++){
W *= 10;
}
int x;
x = N / W;
sum += x;
N = N - x*W;
}
if (M % sum == 0) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, x;
cin >> N;
x = N%10 + (N%100)/10 + (N%1000)/100 + (N%10000)/1000 + (N%100000)/10000 + (N%1000000)/100000 + (N%10000000)/1000000 + (N%100000000)/10000000 + (N%1000000000)/100000000;
if (N / x * x == N)
cout << "Yes" << endl;
else cout << "No" << endl;
} | 1 |
#include <iostream>
#include <string>
#include <vector>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using std::cin;
using std::cout;
using std::endl;
using std::string;
using std::vector;
int main() {
long long x;
cin >> x;
long long count = (x / (5 + 6)) * 2;
if (x % (5 + 6) == 0) {}
else if (x % (5 + 6) <= 6) count++;
else count += 2;
cout << count << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> VI;
typedef vector<vector<int>> VVI;
typedef vector<ll> VLL;
typedef vector<vector<ll>> VVLL;
typedef pair<ll, ll> Pair;
template <class T> T input() {T t; cin>>t; return t;}
#define FOR(i,a,b) for (ll i = a; i < b; i++)
#define REP(i,b) FOR(i,0,b)
#define RFOR(i,a,b) for (ll i = a-1; i >= b; i--)
#define RREP(i,a) RFOR(i,a,0)
#define REPALL(i,x) for (ll i = 0; i < x.size(); i++)
#define RREPALL(i,x) for (ll i = x.size()-1; i >= 0; i--)
#define REPITR(itr,x) for (auto itr = (x).begin(); itr != (x).end(); itr++)
#define ALL(x) (x).begin(), (x).end()
#define SORT(x) sort(ALL(x))
#define MIN_ELEMENT(x) min_element(ALL(x))
#define MAX_ELEMENT(x) max_element(ALL(x))
#define COUNT(x,num) count(ALL(x), num)
#define MEMSET(x,val) memset(x, val, sizeof(x))
#define CHMAX(a,b) a = max(a,b)
#define CHMIN(a,b) a = min(a,b)
#define FIND(x,key) x.find(key) != x.end()
#define IN_RANGE_V2(v,k,x,y) (0<=x+dx[k]&&x+dx[k]<v[y].size()&&0<=y+dy[k]&&y+dy[k]<v.size())
#define debug(x) cerr<<__LINE__<<": "<<(#x)<<" = "<<(x)<<endl;
void YES(bool flag) {cout<<(flag ? "YES" : "NO")<<endl;}
void Yes(bool flag) {cout<<(flag ? "Yes" : "No")<<endl;}
void yes(bool flag) {cout<<(flag ? "yes" : "no")<<endl;}
#define PRINT_ARRAY_H(a) REPALL(__i,a) {cout<<a[__i]<<(__i != a.size()-1 ? " " : "");} newline;
#define PRINT_ARRAY_V(a) REPALL(__i,a) {cout<<a[__i]<<endl;}
#define e1 first
#define e2 second
#define newline putchar('\n')
#define cspace ' '
#define sspace " "
const int INF = 1e7;
const ll MOD = 1e9 + 7;
const double pi = 3.141592653589793;
const VI dx = {1, 0, -1, 0};
const VI dy = {0, 1, 0, -1};
//const VI dx = {1, 1, 0, -1, -1, -1, 0, 1};
//const VI dy = {0, 1, 1, 1, 0, -1, -1, -1};
void solve()
{
ll a, b, c, d, n, m, l, r, k, x, y, z, ans = 0ll;
string s, t;
cin>>n;
l = 0, r = n;
ll mid = (l + r) / 2;;
string s0;
cout<<0<<endl;
cin>>s0;
if (s0 == "Vacant") {
return;
}
while (true) {
mid = (l + r) / 2;
cout<<mid<<endl;
cin>>s;
if (s == "Vacant") {
break;
} else if (s == s0) {
if (l % 2 == mid % 2) {
l = mid;
s0 = s;
} else {
r = mid;
}
} else {
if (l % 2 == mid % 2) {
r = mid;
} else {
l = mid;
s0 = s;
}
}
}
}
int main()
{
cout<<fixed<<setprecision(20);
int __t = 1;
//cin>>__t;
REP(i,__t) {
solve();
}
return 0;
} | 0 |
#include<bits/stdc++.h>
const int N = 5005;
const long long inf = 1e18;
using namespace std;
typedef pair <int, int> ii;
vector <ii> mv;
int n, ans;
long long dp[N][N], Min[N];
int main(){
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++){
int x, y; cin >> x >> y;
x += y;
mv.push_back(ii(x, y));
}
sort(mv.begin(), mv.end());
for (int i = 0; i < N; i++) Min[i] = inf;
Min[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = i; j >= 1; j--){
if (mv[i-1].first - mv[i-1].second >= Min[j-1]) dp[i][j] = Min[j-1] + mv[i-1].second;
else dp[i][j] = inf;
Min[j] = min(Min[j], dp[i][j]);
if (dp[i][j] != inf) ans = max(ans, j);
}
}
cout << ans;
}
| #include "bits/stdc++.h"
using namespace std;
#define fi first
#define se second
#define ll long long
#define dbg(v) cerr<<#v<<" = "<<v<<'\n'
#define vi vector<int>
#define vl vector <ll>
#define pii pair<int,int>
#define mp make_pair
#define db long double
#define pb push_back
#define all(s) s.begin(),s.end()
template < class T > T smin(T &a,T b) {if (a > b) a = b;return a;}
template < class T > T smax(T &a,T b) {if (a < b) a = b;return a;}
ll dp[5555];
int main(void)
{
int n;
cin>>n;
vector < pii > s(n);
for (auto &it : s)
cin>>it.fi>>it.se;
sort(all(s),[&](pii x,pii y)
{
return (x.fi + x.se) < (y.fi + y.se);
});
for (int i = 1;i <= n;++i)
dp[i] = 1e18;
dp[0] = 0;
for (auto it : s)
for (int i = n;i;--i)
if (dp[i - 1] <= it.fi)
smin(dp[i],dp[i - 1] + it.se);
int ans = 0;
for (int i = 0;i <= n;++i)
if (dp[i] < 1e18)
ans = i;
cout << ans << '\n';
return 0;
}
| 1 |
#include<stdio.h>
#include<string.h>
int main(void)
{
int a,s,d[10],f,g,h,j,i;
scanf("%d",&a);
while(a!=0){
for(i=0;i<10;i++){
d[i]=0;
}
for(i=1;i<=a;i++){
scanf("%d",&s);
d[s]++;
}
for(i=0;i<10;i++){
if(d[i]!=0){
for(j=1;j<=d[i];j++){
printf("*");
}
}
if(d[i]==0){
printf("-");
}
printf("\n");
}
scanf("%d",&a);
}
return 0;
} | #include<stdio.h>
char table[12][13];
void del(int i,int j){
table[i][j]='0';
if(i>0&&table[i-1][j]=='1')del(i-1,j);
if(j>0&&table[i][j-1]=='1')del(i,j-1);
if(i<11&&table[i+1][j]=='1')del(i+1,j);
if(j<11&&table[i][j+1]=='1')del(i,j+1);
return ;
}
int main(){
while(~scanf("%s",table[0])){
for(int i=1;i<12;i++)scanf("%s",table[i]);
int ret=0;
for(int i=0;i<12;i++)
for(int j=0;j<12;j++)
if(table[i][j]=='1'){
ret++;
del(i,j);
}
printf("%d\n",ret);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define iinf 2000000000
#define linf 1000000000000000000LL
#define ulinf 10000000000000000000ull
#define MOD1 1000000007LL
#define mpr make_pair
typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned long UL;
typedef unsigned short US;
typedef pair < int , int > pii;
clock_t __stt;
inline void TStart(){__stt=clock();}
inline void TReport(){printf("\nTaken Time : %.3lf sec\n",(double)(clock()-__stt)/CLOCKS_PER_SEC);}
template < typename T > T MIN(T a,T b){return a<b?a:b;}
template < typename T > T MAX(T a,T b){return a>b?a:b;}
template < typename T > T ABS(T a){return a>0?a:(-a);}
template < typename T > void UMIN(T &a,T b){if(b<a) a=b;}
template < typename T > void UMAX(T &a,T b){if(b>a) a=b;}
int n,m,a[20][20],pc[20][1000000],dp[20][1000000],rv[1000000];
int main(){
// inputting start
// 数据结构记得初始化！ n，m别写反！
int i,j,k,u,v,w;
scanf("%d%d",&n,&m);
for(i=0;i<m;++i){
scanf("%d%d%d",&u,&v,&w);
--u;--v;
a[u][v]=a[v][u]=w;
}
#ifdef LOCAL
TStart();
#endif
// calculation start
// 数据结构记得初始化！ n，m别写反！
for(i=0;i<n;++i) rv[1<<i]=i;
for(i=0;i<n;++i){
for(j=0;j<n;++j){
for(k=0;k<(1<<n);++k){
if(k&(1<<j)) pc[i][k]+=a[i][j];
}
}
}
for(i=0;i<n;++i) fill(dp[i],dp[i]+(1<<n),iinf);
dp[0][1]=0;
for(j=0;j<(1<<n);++j){
for(i=0;i<n;++i){
if(!(j&(1<<i)) || dp[i][j]==iinf) continue;
int v=dp[i][j],msk=(((1<<n)-1)^j),cst=0;
for(k=0;k<=msk;){
UMIN(dp[i][j|k],v+cst);
int cp=msk;
while(cp && (cp&(-cp))==(k&(-k))){
int cv=(k&(-k));
cst-=pc[rv[cv]][j^(1<<i)];
k^=cv;
cp^=cv;
}
if(!k && !cp) break;
int cv=cp&(-cp);
cst+=pc[rv[cv]][j^(1<<i)];
k|=cv;
}
for(k=0;k<n;++k){
if(a[i][k] && !(j&(1<<k))){
UMIN(dp[k][j|(1<<k)],v+pc[k][j^(1<<i)]);
}
}
}
}
printf("%d\n",dp[n-1][(1<<n)-1]);
#ifdef LOCAL
TReport();
#endif
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
#define rint register int
#define gc() getchar()
inline int read(){int r=0,s=0,c=gc();for(;!isdigit(c);s=c,c=gc());for(;isdigit(c);(r*=10)+=c-48,c=gc());return s^45?r:-r;}
int f[16][32768], g[32768], w[16][16], n, E;
int main()
{
n = read(), E = 1<<n; for(rint m = read(), a, b; m--; a = read()-1, b = read()-1, w[a][b] = w[b][a] = read()); for(rint i = 0; i < n; fill(f[i],f[i]+E,-INF), i++);
for(rint S = 1, T, i, j; S < E; S&1 ? f[0][S] = g[S] : 0, S++) for(g[S] = g[T=S-(S&-S)], i = ilogb(S&-S), j = 0; j < n; j++) if(T&1<<j) g[S] += w[i][j];
for(rint S = 1, T, i, j; S < E; S++) for(T = ~-S&S; T; --T&=S) for(i = 0; i < n-1; i++) if((S^T)&1<<i&&f[i][S^T]>=0)
for(j = 1; j < n; T&1<<j&&w[i][j] ? f[j][S] = max(f[j][S],f[i][S^T]+g[T]+w[i][j]) : 0, j++); printf("%d\n",g[~-E]-f[~-n][~-E]); return 0;
} | 1 |
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
// Acknowledgement: Special thanks to kyomukyomupurin, who developed this
// template.
template <class T, class U>
std::ostream& operator<<(std::ostream& os, const std::pair<T, U>& p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <class T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& vec) {
int n = 0;
for (auto e : vec) os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T>
std::ostream& operator<<(std::ostream& os, const std::set<T>& st) {
int n = 0;
for (auto e : st) os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T, class U>
std::ostream& operator<<(std::ostream& os, const std::map<T, U>& mp) {
int n = 0;
for (auto e : mp) os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T>
std::istream& operator>>(std::istream& is, std::vector<T>& vec) {
for (T& e : vec) is >> e;
return is;
}
#ifdef LOCAL
#define debug(...) \
std::cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
void debug_out() { std::cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head&& head, Tail&&... tail) {
std::cerr << head;
if (sizeof...(Tail) != 0) std::cerr << ", ";
debug_out(std::forward<Tail>(tail)...);
}
using namespace std;
using int64 = long long;
map<int64, int64> decomposition(int64 N) {
map<int64, int64> result;
int64 tmp = N;
int64 amari;
for (int64 i = 2; i * i <= N; i++) {
if (tmp == 1) {
break;
}
amari = tmp % i;
if (amari == 0) {
result[i] = 0;
while (amari == 0) {
tmp /= i;
result[i]++;
amari = tmp % i;
}
}
}
if (tmp != 1) result[tmp] = 1;
return result;
}
int main() {
int64 A, B;
cin >> A >> B;
int64 gcd = __gcd(A, B);
map<int64, int64> mp = decomposition(gcd);
cout << mp.size() + 1 << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define chmax(x,y) x = max(x,y)
#define chmin(x,y) x = min(x,y)
const int INF = 1e9 + 10;
int A, B;
int main() {
cin >> A >> B;
cout << A * B << endl;
} | 0 |
#include <stdio.h>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;
int base[3] = {0, 0, 0};
void Hit()
{
if (base[2] == 1)
{
base[2] = 0;
}
if (base[1] == 1)
{
base[2] = 1;
}
if (base[0] == 1)
{
base[1] = 1;
}
else if (base[0] == 0)
{
base[0] = 1;
}
}
void Homerun()
{
for (int i = 0; i < 3; i++)
{
base[i] = 0;
}
}
int main()
{
int out = 0;
int score = 0;
int n;
string s;
vector <string> event;
int eventnum = 0;
cin >> n;
int a = 0;
for (int i = 0; i < 3 * n; i++)
{
while (true)
{
cin >> s;
event.push_back(s);
if (event.at(a) == "OUT")
{
a += 1;
eventnum += 1;
break;
}
else
{
a += 1;
eventnum += 1;
}
}
}
for (int i = 0; i < eventnum; i++)
{
if (event.at(i) == "HIT")
{
if (base[2] == 1)
{
score += 1;
}
Hit();
}
else if (event.at(i) == "HOMERUN")
{
score += base[0] + base[1] + base[2] + 1;
Homerun();
}
else
{
out += 1;
if (out == 3)
{
cout << score << endl;
for (int i = 0; i < 3; i++)
{
base[i] = 0;
}
score = 0;
out = 0;
}
}
}
return 0;
} | #include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
int main() {
int n;
cin >> n;
while(n--) {
string s;
int out = 0;
vector<int> rui(3);
int ten = 0;
while(out < 3) {
// FOR(it,rui)
// cout << *it << " ";
// cout << endl;
cin >> s;
if (s == "HIT") {
if (rui[2]) ten++;
rui[2] = rui[1];
rui[1] = rui[0];
rui[0] = 1;
} else if (s == "HOMERUN") {
REP(i,3) {
ten += rui[i];
}
ten++;
rui = vector<int>(3);
} else
out++;
}
cout << ten << endl;
}
} | 1 |
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <sstream>
#include <string>
#include <utility>
#include <map>
#include <memory>
#include <set>
#include <vector>
#include <deque>
#include <list>
#include <stack>
#include <queue>
// #include <array>
using namespace std;
class MSTree
{
public:
int solve();
};
int MSTree::solve()
{
int n;
cin >> n;
vector<vector<int>> adj(n, vector<int>(n));
list<int> t, vt;
for ( auto i = 0; i < n; ++i )
for ( auto j = 0; j < n; ++j )
cin >> adj[i][j];
t.push_back( 0 );
for ( auto i = 1; i < n; ++i )
vt.push_back( i );
int w = 0;
while ( vt.size() )
{
int mw = 4000;
list<int>::iterator itm;
for ( auto ita = t.begin(); ita != t.end(); ++ita )
for ( auto itb = vt.begin(); itb != vt.end(); ++itb )
{
if ( adj[*ita][*itb] >= 0 && mw > adj[*ita][*itb] )
{
itm = itb;
mw = adj[*ita][*itb];
}
}
w += mw;
t.push_back( *itm );
vt.erase( itm );
}
cout << w << endl;
return 0;
}
int main()
{
MSTree m;
m.solve();
return 0;
} | //g++ -std=gnu++14 a.cpp
#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>
#include <random>
#include <math.h>
#include <stdio.h>
using namespace std;
#define ll long long
#define rep(i, n) for(ll i = 0; i < (n); i++)
ll MOD = 1e9 + 7;
int INF = 1 << 30;
ll INFL = 1LL << 60;
ll MODP = 998244353;
ll per(ll a){
ll res = 1;
for(int i = 1;i <= a;i++){
res *= i;
}
return res;
}
int main(){
ll N;
cin >> N;
vector<long double> x(N),y(N);
rep(i,N)cin >> x[i] >> y[i];
vector<vector<int>> kumi;
vector<int> v;
for(int i = 1;i <= N;i++)v.push_back(i);
do{
kumi.push_back(v);
}while(next_permutation(v.begin(), v.end()));
long double ans = 0;
for(auto a : kumi){
rep(i,a.size()-1){
long double t = (x[a[i]-1]-x[a[i+1]-1])*(x[a[i]-1]-x[a[i+1]-1]);
t += (y[a[i]-1]-y[a[i+1]-1])*(y[a[i]-1]-y[a[i+1]-1]);
ans += sqrt(t);
}
}
long double all = kumi.size();
ans /= all;
cout << fixed << setprecision(8) << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template<typename T>
void chmax(T &a,T b){
if(a<b)a=b;
}
struct maxhist{
vector<int> hist;
struct rect{int height,idx;};
void add_hist(int a){
hist.push_back(a);
}
int get_max(){
int res=0;
stack<rect> s;
for(int j=0;j<hist.size();j++){
if((!s.size())||s.top().height<hist[j])s.push({hist[j],j});
else if(s.top().height>hist[j]){
int left;
while(s.top().height>hist[j]){
rect tmp=s.top();s.pop();
left=tmp.idx;
//chmax(res,tmp.height*(j-left));
chmax(res,(tmp.height+1)*(j-left+1));
if(!s.size())break;
}
s.push({hist[j],left});
}
}
while(s.size()){
rect tmp=s.top();s.pop();
//chmax(res,tmp.height*(hist.size()-tmp.idx));
chmax(res,(tmp.height+1)*((int)hist.size()-tmp.idx+1));
}
return res;
}
};
struct maxrect{
vector<vector<bool>> rect;
void add_line(vector<bool> &v){
rect.push_back(v);
}
void add_dot(int h,bool f){
if(rect.size()<=h)rect.resize(h+1);
rect[h].push_back(f);
}
int get_max(){
int res=0;
int h=rect.size();
vector<vector<int>> hist(h);
for(int i=0;i<h;i++)hist[i].resize(rect[i].size());
for(int i=0;i<h;i++){
maxhist mh;
for(int j=0;j<hist[i].size();j++){
if(i){
if(hist[i-1].size()<=j)hist[i][j]=rect[i][j];
else hist[i][j]=(hist[i-1][j]+rect[i][j])*rect[i][j];
}
else hist[i][j]=rect[i][j];
mh.add_hist(hist[i][j]);
}
chmax(res,mh.get_max());
}
return res;
}
};
signed main(){
int h,w;cin>>h>>w;
vector<string> s(h);
for(int i=0;i<h;i++)cin>>s[i];
maxrect m;
vector<bool> f(w-1);
for(int i=1;i<h;i++){
for(int j=0;j<w-1;j++){
int a=(s[i-1][j]=='#')+(s[i-1][j+1]=='#')+(s[i][j]=='#')+(s[i][j+1]=='#');
f[j]=(a&1)^1;
}
m.add_line(f);
}
cout<<max({h,w,m.get_max()})<<endl;
}
/*
解説AC
広義唐草模様の面積求めたくなって、どこがダメな場所かも分かったけど最大長方形のアルゴリズムを知らず
時間かければ自分で思いつきそうな気もするけどコスパ悪いし見ていいでしょ
面白かった
*/
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int mod=998244353;
int dp[4][310*310],a[310];
inline int add_mod(int x){
return x<mod?x:x-mod;
}
int main(){
int n,ret=1,sum=0,minus=1;
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%d",a+i);
ret=(ll)ret*3%mod;
minus=add_mod(minus+minus);
sum+=a[i];
}
ret=add_mod(ret+mod-3);
minus=add_mod(minus+mod-2);
ret=add_mod(ret+mod-(ll)minus*3%mod);
memset(dp,0,sizeof dp);
dp[0][0]=1;
for(int i=1;i<=n;i++){
for(int j=sum;j>=a[i];j--){
for(int s=0;s<4;s++){
dp[s|1][j]=add_mod(dp[s|1][j]+dp[s][j-a[i]]);
dp[s|2][j]=add_mod(dp[s|2][j]+dp[s][j-a[i]]);
}
}
}
for(int i=1;i+i<=sum;i++)
ret=add_mod(ret+mod-(ll)dp[3][i]*3%mod);
printf("%d\n",ret);
return 0;
} | 0 |
#include<cstdio>
#include<vector>
#include<map>
#include<climits>
#include<algorithm>
#include<iostream>
using namespace std;
typedef pair<int,int> Pt;
#define MAX 1000001
#define fr first
#define sc second
int main(){
string s;
int ans = 0;
cin >> s;
for(int i=0;i<s.size();){
int a = 0,b = 0,c = 0;
for(;s[i]=='J';a++) i++;
for(;s[i]=='O';b++) i++;
for(;s[i]=='I';c++) i++;
if(a>=b && b<=c) ans = max(ans,b);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
ll r;
cin >> r;
if(r < 1200) {
cout << "ABC\n";
} else if (r < 2800) {
cout << "ARC\n";
} else {
cout << "AGC\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void chmax(string &a, string b) {
if (a == "-")
a = b;
else if (a.size() < b.size())
a = b;
else if (a.size() == b.size()) {
if (a < b) a = b;
}
}
long long num[10] = {2, 5, 5, 4, 5, 6, 3, 7, 6};
string dp[11000];
int main() {
int N, M;
cin >> N >> M;
vector<int> A(M);
for (int i = 0; i < M; ++i) cin >> A[i];
for (int i = 0; i < 11000; ++i) dp[i] = "-";
dp[0] = "";
for (int i = 0; i <= N; ++i) {
if (dp[i] == "-") continue;
for (auto a : A) {
string b = dp[i] + (char)('0' + a);
chmax(dp[i + num[a - 1]], b);
}
}
cout << dp[N] << endl;
}
| #include <bits/stdc++.h>
#define ll long long
#define sz(x) (int)x.size()
using namespace std;
int main(){
int n,k;
cin>>n>>k;
vector<int> a(n);
for(int&i:a)cin>>i;
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
ll ans=0;
for(int i=0;i<k;i++)ans+=a[i];
cout<<ans;
} | 0 |
#include <iostream>
int main() {
int N;
std::cin >> N;
int abc_in;
if (N % 111 == 0)
abc_in = N;
else
abc_in = ((N / 111) + 1) * 111;
std::cout << abc_in << std::endl;
return 0;
}
| #include <bits/stdc++.h>
#define fast ios_base::sync_with_stdio(0);cin.tie(NULL);cout.tie(NULL)
#define ll long long int
#define ld long double
using namespace std;
const int N = 1e6 + 5;
const int MOD = 1e9 + 7;
int main(){
fast;
string s;
cin >> s;
if(s == "SUN") cout << "7\n";
else if(s == "SAT") cout << "1\n";
else if(s == "FRI") cout << "2\n";
else if(s == "THU") cout << "3\n";
else if(s == "WED") cout << "4\n";
else if(s == "TUE") cout << "5\n";
else if(s == "MON") cout << "6\n";
return 0;
} | 0 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; i++)
#define vi vector<int>
#define all(x) (x).begin(),(x).end()
#define INF (1<<30)-1
using ll = long long;
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; }
int main(){
string sa,sb,sc; cin >> sa >> sb >> sc;
int a = 0, b = 0, c = 0;
char now = 'a';
char winner;
while(true){
if(now == 'a'){
if(a == sa.size()){
winner = 'A';
break;
}
now = sa[a];
a++;
}else if(now == 'b'){
if(b == sb.size()){
winner = 'B';
break;
}
now = sb[b];
b++;
}else if(now == 'c'){
if(c == sc.size()){
winner = 'C';
break;
}
now = sc[c];
c++;
}
}
cout << winner;
cout << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return 1;
}
return 0;
}
#ifdef DEBUG
void debug() { cerr << "\n"; }
template <class T> void debug(const T &x) { cerr << x << "\n"; }
template <class T, class... Args> void debug(const T &x, const Args &... args) {
cerr << x << " ";
debug(args...);
}
template <class T> void debugVector(const vector<T> &v) {
for(const T &x : v) {
cerr << x << " ";
}
cerr << "\n";
}
#else
template <class T, class... Args>
void debug(const T &x, const Args &... args) {}
template <class T> void debugVector(const vector<T> &v) {}
#endif
using ll = long long;
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
const double EPS = 1e-7;
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
constexpr int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
//-------------------------------------
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s[3];
for(int i = 0; i < 3; i++) {
cin >> s[i];
}
int nowTurn = 0;
int nowId[3] = {0, 0, 0};
while(1) {
if(nowId[nowTurn] >= s[nowTurn].size()) {
cout << (char)('A' + nowTurn) << endl;
break;
}
int nxtTurn = s[nowTurn][nowId[nowTurn]] - 'a';
nowId[nowTurn]++;
nowTurn = nxtTurn;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define INF 1000000000000
#define MOD 1000000007
#define MAXR 100000
#define _GLIBCXX_DEBUG
int threemax(int a, int b, int c) {
if (a >= b && a >= c) {
return a;
}
else if (b >= a && b >= c) {
return b;
}
else {
return c;
}
}
int threemin(int a, int b, int c) {
if (a <= b && a <= c) {
return a;
}
else if (b <= a && b <= c) {
return b;
}
else {
return c;
}
}
void chmaxl(ll &a,ll b){
if(a<b){
a=b;
}
return;
}
void chminl(ll &a,ll b){
if(a>b){
a=b;
}
return;
}
void chmaxi(int &a,int b){
if(a<b){
a=b;
}
return;
}
void chmini(int &a,int b){
if(a>b){
a = b;
}
return;
}
int main() {
int N;
cin >> N;
if(N==1){
cout << "Hello World";
}
else{
int A,B;
cin >> A >> B;
cout << A+B;
}
} | #include <bits/stdc++.h>
#define rep(i,a,b) for(int i=int(a);i<int(b);++i)
#define SIZE 200005
#define INF 1000000005LL
#define MOD 1000000007
using namespace std;
typedef long long int ll;
typedef pair <int,int> P;
int main(){
int n;
cin >> n;
string s,t;
cin >> s>>t;
for(int i=n;i>=1;i--){
if(t.substr(0,i)==s.substr(n-i,i)){
cout<<2*n-i<<endl;
return 0;
}
}
cout<<2*n<<endl;
return 0;
} | 0 |
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
using namespace std;
int n,a,b,c,d,jun[101],x;
typedef pair<int,int> P;
P t[101];
bool cmp(const P& a,const P& b){
return a.first == b.first ? a.second < b.second : a.first > b.first;
}
int main()
{
cin>>n;
for(int i=1;i<=n;i++) t[i].second=i;
for(int i=1;i<=n*(n-1)/2;i++){
cin>>a>>b>>c>>d;
if(c>d) t[a].first+=3;
else if(c<d) t[b].first+=3;
else {t[a].first++; t[b].first++;}
}
sort(t+1,t+n+1,cmp);
for(int i=1;i<=n;i++){
if(i>1&&t[i].first==t[i-1].first){
jun[t[i].second]=x;
}
else{
jun[t[i].second]=i;
x=i;
}
}
for(int i=1;i<=n;i++){
cout<<jun[i]<<endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
#define INF 2e18
#define eps 1e-9
#define FastRead ios_base::sync_with_stdio(0);cin.tie(0)
#define fRead freopen("input.txt","r",stdin)
#define fWrite freopen("output.txt","w",stdout)
#define LL long long
#define ull unsigned long long
#define PI acos(-1.0)
#define pb push_back
#define mk make_pair
#define pii pair<int,int>
#define pLL pair<LL,LL>
#define ff first
#define ss second
#define all(a) a.begin(),a.end()
#define SQR(a) ((a)*(a))
#define min3(a,b,c) min(a,min(b,c))
#define max3(a,b,c) max(a,max(b,c))
#define min4(a,b,c,d) min(min(a,b),min(c,d))
#define max4(a,b,c,d) max(max(a,b),max(c,d))
#define max5(a,b,c,d,e) max(max3(a,b,c),max(d,e))
#define min5(a,b,c,d,e) min(min3(a,b,c),min(d,e))
#define vi vector <int>
#define vL vector <LL>
#define LB(a,x) (lower_bound(all(a),x)-a.begin()) // first element in the range [first,last) which does not compare less than val.
#define UB(a,x) (upper_bound(all(a),x)-a.begin()) // first element in the range [first,last) which compares greater than val.
#define prec(n) fixed << setprecision(n)
#define MEM(a,x) memset(a,x,sizeof(a))
#define SORT(v) sort(v.begin(),v.end())
#define REV(v) reverse(v.begin(),v.end())
#define Unique(a) sort(all(a)),a.erase(unique(all(a)),a.end())
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define ROF(i,a,b) for(int i=a;i>=b;i--)
#define REP(i,b) for(int i=0;i<b;i++)
#define IT(it,x) for(it=x.begin();it!=x.end();it++)
vector<pLL>v;
LL n;
double s=0;
void f(vector<pLL>vt)
{
LL x=v[0].ff,y=v[0].ss;
for(LL i=0;i<v.size();i++)
{
s+=sqrtl((v[i].ff-x)*(v[i].ff-x)+(v[i].ss-y)*(v[i].ss-y));
}
}
int main()
{
cin>>n;
for(LL i=0;i<n;i++)
{
LL x,y;
cin>>x>>y;
v.pb({x,y});
}
sort(all(v));
do{
f(v);
} while(next_permutation(all(v)));
LL x=1;
for(LL i=1;i<=n;i++)
x=x*i;
// cout<<s<<" "<<x<<endl;
cout<<prec(10)<<s/x;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int maxn = 1e5 + 10;
int n, a[maxn];
int c0, c1, cnt, GCD;
bool solve() {
c1 = 0, c0 = 0, cnt = 0, GCD = 0;
for (int i = 0; i < n; i++) {
if (a[i] == 1) {
c1++;
cnt++;
continue;
}
if (a[i] % 2) {
c1++;
a[i]--;
}
else
c0++;
GCD = __gcd(GCD, a[i]);
}
if (c0 % 2) return 1;
if (cnt || c1 > 1) return 0;
for (int i = 0; i < n; i++) a[i] /= GCD;
return !solve();
}
int32_t main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
if (solve())
cout << "First";
else
cout << "Second";
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<vector<vector<ll>>> vvvll;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<vector<vector<bool>>> vvvb;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<vpll> vvpll;
typedef vector<double> vd;
typedef vector<vd> vdd;
#define FOR(i,x,y) for(ll i=(ll)x; i<(ll)y; ++i)
#define REP(i,y) FOR(i, 0, y)
#define RFOR(i,x,y) for(ll i=(ll)x; i>=(ll)y; --i)
#define RREP(i,x) RFOR(i, x, 0)
#define ALL(a) a.begin(), a.end()
#define pb push_back
#define debug_print(x...) cerr << "line " << __LINE__ << " : "; debug_print_in(x);
template <typename First>
void debug_print_in(First first){
cerr << first << endl;
return;
}
template <typename First, typename... Rest>
void debug_print_in(First first, Rest... rest){
cerr << first << " ";
debug_print_in(rest...);
return;
}
void IN(void){
return;
}
template <typename First, typename... Rest>
void IN(First& first, Rest&... rest){
cin >> first;
IN(rest...);
return;
}
template <typename First>
void OUT(First first){
cout << first << endl;
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest){
cout << first << " ";
OUT(rest...);
return;
}
template<class t, class u> void chmax(t&a,u b){if(a<b)a=b;};
template<class t, class u> void chmin(t&a,u b){if(a>b)a=b;};
int popcount(int t){return __builtin_popcount(t);} //GCC
int popcount(ll t){return __builtin_popcountll(t);} //GCC
template <typename T>
void vec_print(vector<T> VEC){
REP(i, VEC.size()){
cerr << VEC[i] << " ";
}
cerr << endl;
};
template <typename T>
void mat_print(vector<vector<T> > MAT){
REP(i,MAT.size()){
REP(j,MAT[i].size()){
cerr << MAT[i][j] << " ";
}
cerr << endl;
}
};
constexpr int INF = (1<<30);
constexpr ll INFLL = 1LL<<62;
constexpr long double EPS = 1e-12;
constexpr ll MOD = (ll)((1E+9)+7);
int main(){
ll N;
IN(N);
ll start = 0;
ll end = N-1;
ll start_sex = 0;
string str;
std::cout << 0 << std::endl;
IN(str);
if(str=="Male") start_sex = 0;
else if(str=="Female") start_sex = 1;
else return 0;
while(end-start>1){
ll mid = (start+end)/2;
std::cout << mid << std::endl;
IN(str);
ll sex = 0;
if(str=="Male") sex = 0;
else if(str=="Female") sex = 1;
else return 0;
if((mid-start)&1){
if(start_sex!=sex){
start = mid;
start_sex = sex;
}else{
end = mid;
}
}else{
if(start_sex!=sex){
end = mid;
}else{
start = mid;
start_sex = sex;
}
}
}
std::cout << start << std::endl;
IN(str);
if(str=="Vacant") return 0;
std::cout << end << std::endl;
IN(str);
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define ii pair <int, int>
#define app push_back
#define all(a) a.begin(), a.end()
#define bp __builtin_popcount
#define ll long long
#define mp make_pair
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define Time (double)clock()/CLOCKS_PER_SEC
const int N = 601, C = 2e5 + 7;
int sqr[C];
int n, num[N][N], d[2];
vector <int> g[2][N * N];
bool c[2][N * N], used[N * N];
void dfs(bool t, int u) {
used[u] = 1;
for (int v : g[t][u]) {
if (!used[v]) {
c[t][v] = c[t][u] ^ 1;
dfs(t, v);
}
}
}
vector <ii> ans[2][2];
signed main() {
#ifdef HOME
freopen("input.txt", "r", stdin);
#else
ios_base::sync_with_stdio(0); cin.tie(0);
#endif
for (int i = 0; i < C; ++i) sqr[i] = -1;
for (int i = 0; i < C; ++i) if (i * i < C) sqr[i * i] = i;
cin >> n >> d[0] >> d[1];
int p = 0;
for (int i = 0; i < 2 * n; ++i)
for (int j = 0; j < 2 * n; ++j)
num[i][j] = p++;
for (int t = 0; t < 2; ++t) {
vector <ii> v;
for (int i = 0; i * i <= d[t]; ++i)
if (sqr[d[t] - i * i] != -1) {
v.app(mp(i, sqr[d[t] - i * i]));
v.app(mp(i, -sqr[d[t] - i * i]));
v.app(mp(-i, sqr[d[t] - i * i]));
v.app(mp(-i, -sqr[d[t] - i * i]));
}
for (int i = 0; i < 2 * n; ++i)
for (int j = 0; j < 2 * n; ++j)
for (auto e : v) if (0 <= i + e.f && i + e.f < 2 * n && 0 <= j + e.s && j + e.s < 2 * n)
g[t][num[i][j]].app(num[i + e.f][j + e.s]);
memset(used, 0, sizeof used);
for (int i = 0; i < 4 * n * n; ++i)
if (!used[i]) {
dfs(t, i);
}
}
for (int i = 0; i < 4 * n * n; ++i) ans[c[0][i]][c[1][i]].app(mp(i / (n << 1), i % (n << 1)));
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 2; ++j)
if (ans[i][j].size() >= n) {
cerr << Time << '\n';
for (int k = 0; k < n * n; ++k) cout << ans[i][j][k].f << ' ' << ans[i][j][k].s << '\n';
exit(0);
}
exit(1);
} | #include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define REP(i,n) for(int i=0;i<(n);i++)
#define qwq(x) cout<<"# "<<#x<<" = "<<x<<endl;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define f(x,y) g[(x)][(y)+52]
using namespace std;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef long long ll;
template<class T> inline void read(T &x){
int f=0;x=0;char ch=getchar();
for(;!isdigit(ch);ch=getchar())f|=(ch=='-');
for(;isdigit(ch);ch=getchar())x=x*10+ch-'0';
if(f)x=-x;
}
const int N=1005;
int f[N][N],n,d1,d2,cnt;
void doit(int d){
int k=1;
while(d%4==0)d>>=2,k<<=1;
REP(i,n*2)REP(j,n*2)
f[i][j]+=(d&1)&&(i/k+j/k)%2==0||!(d&1)&&i/k%2==0;
}
int main(){
read(n),read(d1),read(d2);
doit(d1),doit(d2);
REP(i,n*2)REP(j,n*2)
if(f[i][j]==2&&cnt<n*n)
printf("%d %d\n",i,j),++cnt;
return 0;
} | 1 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<cmath>
#include<cstdio>
#include<queue>
#include<deque>
using namespace std;
typedef pair<int,int> ii;
typedef long long ll;
typedef pair<ll,ll> pll;
const int INF=1e9;
const ll MOD=1e9+7;
ll gcd(ll x,ll y){
if(y==0) return 0;
return gcd(y,x%y);
}
int dis2(int x1,int y1,int x2,int y2){
return (x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
}
int main(){
int n;cin>>n;
int a[n];
double avg=0;
for(int i=0;i<n;i++){
cin>>a[i];
avg+=a[i];
}
avg=(double)avg/(double)n;
double sub=1000000;
int ans=-1;
for(int i=0;i<n;i++){
if(sub>abs(a[i]-avg)){
sub=abs(a[i]-avg);
ans=i;
}
}
cout<<ans<<endl;
} | #include <iostream>
using namespace std;
int bubbleSort(int a[],int n){
int sw=0;
bool flag=1;
for(int i=0;flag;i++){
flag=0;
for(int j=n-1;j>=i+1;j--){
if(a[j]<a[j-1]){
swap(a[j],a[j-1]);
flag=1;
sw++;
}
}
}
return sw;
}
int main(){
int n,a[100],sw;
cin>>n;
for(int i=0;i<n;i++) cin>>a[i];
sw=bubbleSort(a,n);
for(int i=0;i<n;i++){
if(i) cout<<" ";
cout<<a[i];
}
cout<<endl;
cout<<sw<<endl;
return 0;
}
| 0 |
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wunused-result"
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#endif
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <sstream>
#include <numeric>
#include <map>
#include <set>
#include <queue>
#include <vector>
using namespace std;
typedef long long LL;
static const LL INF = 1LL << 60;
template<typename T, int SIZE, T DEF_VAL, const T& Compare(const T&, const T&)>
class SegmentTree {
vector<T> val;
public:
SegmentTree() : val(SIZE * 2, DEF_VAL) { }
void update(int i, const T& value) {
i += SIZE;
val[i] = value;
while (i > 1) i >>= 1, val[i] = Compare(val[i * 2], val[i * 2 + 1]);
}
T get(LL a, LL b, int l = 0, int r = SIZE, size_t i = 1) {
if (r <= a || b <= l) return DEF_VAL;
if (a <= l && r <= b) return val[i];
return Compare(get(a, b, l, (l + r) / 2, i * 2), get(a, b, (l + r) / 2, r, i * 2 + 1));
}
LL find_leftmost_index(LL a, LL b, const T& value, int l = 0, int r = SIZE, int i = 1) {
if (Compare(val[i], value) != val[i]) return -1;
if (r <= a || b <= l) return -1;
if (i >= SIZE) return i - SIZE;
LL leftmost_index = find_leftmost_index(a, b, value, l, (l + r) / 2, i * 2);
if (leftmost_index >= 0) return leftmost_index;
return find_leftmost_index(a, b, value, (l + r) / 2, r, i * 2 + 1);
}
LL find_rightmost_index(LL a, LL b, const T& value, int l = 0, int r = SIZE, int i = 1) {
if (Compare(val[i], value) != val[i]) return -1;
if (r <= a || b <= l) return -1;
if (i >= SIZE) return i - SIZE;
LL rightmost_index = find_rightmost_index(a, b, value, (l + r) / 2, r, i * 2 + 1);
if (rightmost_index >= 0) return rightmost_index;
return find_rightmost_index(a, b, value, l, (l + r) / 2, i * 2);
}
};
void solve(long long H, long long W, std::vector<long long> &A, std::vector<long long> &B) {
SegmentTree<long long, 1 << 18, INF, min> st;
for (int i = 0; i < W; ++i) {
st.update(i, 0);
}
for (LL y = 0; y < H; ++y) {
LL a = A[y], b = B[y];
while (true) {
LL min_value = st.get(a, b);
if (min_value == INF) break;
LL index = st.find_leftmost_index(a, b, min_value);
LL next_cost = min_value + b - index;
if (b < W && next_cost < st.get(b, b + 1)) {
st.update(b, next_cost);
}
st.update(index, INF);
}
LL cost = y + 1 + st.get(0, W);
cout << (cost < INF ? cost : -1) << endl;
}
}
int main() {
long long H;
scanf("%lld", &H);
long long W;
scanf("%lld", &W);
std::vector<long long> A(H);
std::vector<long long> B(H);
for (int i = 0; i < H; i++) {
scanf("%lld", &A[i]); A[i]--;
scanf("%lld", &B[i]);
}
solve(H, W, A, B);
return 0;
}
| #include <bits/stdc++.h>
#include <time.h>
#define rep(i,n) for(int i=0; i<(n); i++)
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
using vi = vector<ll>;
using vv = vector<vi>;
const ll INF = 1001001001;
const ll NUM = 1<<10;
//(開始, 今)を管理
//例:
//(0,0), (1,1), (2,2), (3,3), (4,4), (5,5)
//壁(1,2) . .(該当領域)
//(0,0), (1,3), (2,3), (3,3), (4,4), (5,5) ->(1,3),(2,3)は消す
//(0,0), (3,3), (4,4), (5,5)
//壁(2,3) .(該当領域)
//(0,0), (3,4), (4,4), (5,5) ->(3,4)は消す
//(0,0), (4,4), (5,5)
//
//・順序集合(map)を使う: map[今]=開始の最大値
//・ans = min(今-開始), multisetで管理
//・該当領域+1の範囲で開始が一番右のものだけ残す
//・それ以外はansからもmapからも消す
//
int main(){
int h,w;
cin >> h >> w;
map<int,int> s;
multiset<int> m;
rep(i,w)s[i] = i;
rep(i,w)m.insert(0);
rep(i,h){
int l,r;
cin>>l>>r;
--l;
auto itr = s.lower_bound(l);
int maxstart= -1;
while(itr!=s.end() && itr->first<=r){
maxstart= max(maxstart, itr->second);
int c = itr->first - itr->second;
m.erase(m.find(c));
s.erase(itr++);
//itr=s.erase(itr);//これでもいい
//s.erase(*itr); itr++;//これはだめ
}
if(r<w && maxstart != -1){
s[r] = maxstart;
m.insert(r-maxstart);
}
int ans = -1;
if(!m.empty())
ans = *m.begin() + (i+1);
cout<<ans<<endl;
}
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <map>
#include <queue>
using namespace std;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int N; cin >> N;
vector<int> V(N);
for(int i = 0; i < N; ++i) cin >> V[i];
map<int, int> odd, even;
for(int i = 0; i < N; ++i){
if(i%2 == 0) even[V[i]]++;
else odd[V[i]]++;
}
priority_queue<pair<int, int> > qOdd, qEven;
qOdd.emplace(0,0); qEven.emplace(0,0);
for(auto it : odd) qOdd.emplace(it.second, it.first);
for(auto it : even) qEven.emplace(it.second, it.first);
if(qOdd.top().second != qEven.top().second) {
int ans = N - qOdd.top().first - qEven.top().first;
cout << ans << '\n';
} else {
int a = qOdd.top().first;
int b = qEven.top().first;
qOdd.pop();
qEven.pop();
int c = qOdd.top().first;
int d = qEven.top().first;
int ans = min(N - a - d, N - b - c);
cout << ans << '\n';
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long signed int LL;
typedef long long unsigned int LU;
#define incID(i, l, r) for(int i = (l) ; i < (r); i++)
#define incII(i, l, r) for(int i = (l) ; i <= (r); i++)
#define decID(i, l, r) for(int i = (r) - 1; i >= (l); i--)
#define decII(i, l, r) for(int i = (r) ; i >= (l); i--)
#define inc(i, n) incID(i, 0, n)
#define inc1(i, n) incII(i, 1, n)
#define dec(i, n) decID(i, 0, n)
#define dec1(i, n) decII(i, 1, n)
#define inII(v, l, r) ((l) <= (v) && (v) <= (r))
#define inID(v, l, r) ((l) <= (v) && (v) < (r))
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define PQ priority_queue
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
#define FOR(it, v) for(auto it = v.begin(); it != v.end(); ++it)
#define RFOR(it, v) for(auto it = v.rbegin(); it != v.rend(); ++it)
template<typename T> bool setmin(T & a, T b) { if(b < a) { a = b; return true; } else { return false; } }
template<typename T> bool setmax(T & a, T b) { if(b > a) { a = b; return true; } else { return false; } }
template<typename T> bool setmineq(T & a, T b) { if(b <= a) { a = b; return true; } else { return false; } }
template<typename T> bool setmaxeq(T & a, T b) { if(b >= a) { a = b; return true; } else { return false; } }
template<typename T> T gcd(T a, T b) { return (b == 0 ? a : gcd(b, a % b)); }
template<typename T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
// ---- ----
int n, x[100], y[100];
map<double, int> mp;
double TAU = atan2(0, -1) * 2;
void add(double l, double r) {
if(l < 0.0) { add(1.0 + l, 1.0); add(0, r ); return; }
if(r > 1.0) { add( l, 1.0); add(0, r - 1.0); return; }
mp[l]++;
mp[r]--;
}
int main() {
cin >> n;
inc(i, n) { cin >> x[i] >> y[i]; }
inc(i, n) {
mp.clear();
mp[0.0] = 0;
mp[1.0] = 0;
inc(j, n) {
if(i == j) { continue; }
double v = atan2(y[j] - y[i], x[j] - x[i]) / TAU + 0.5;
add(v - 0.25, v + 0.25);
}
double ans = 0.0, pre = 0.0;
int c = 0;
for(auto && e: mp) {
if(c == 0) { ans += e.FI - pre; }
c += e.SE;
pre = e.FI;
}
printf("%.8f\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const ll INF = 100000000;
#define rep1(i, n) for (ll i=0; i<(n); i++)
#define rep2(i, k, n) for (ll i=k; 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; }
const ll mod = 2019;
int main() {
ll l, r;
cin >> l >> r;
map<ll, ll> m;
for (ll i = l; i <= r && i <= l+5000; i++){
m[i%mod]++;
}
ll ans = 2020;
vector<ll> a;
for (auto x: m){
rep1(i, x.second) a.push_back(x.first);
}
ll n = a.size();
for (ll i=0; i<(n); i++){
for (ll j=i+1; j<(n); j++){
ans = min(ans, a[i]*a[j]%2019);
}
}
cout << ans << endl;
//printf("%.12f", ans);
} | #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;
ll const INF = 1LL << 60;
ll search(ll l, ll r) {
ll ret = INF;
for (ll i = l; i <= r; i++) {
for (ll j = i + 1; j <= r; j++) {
ret = min((i * j) % 2019, ret);
}
}
return ret;
}
int main() {
ll l, r;
cin >> l >> r;
if (l <= 2019 && 2019 <= r) {
cout << 0 << endl;
} else if (l < 2019 && r < 2019) {
cout << search(l, r) << endl;
} else if (r - l < 2019) {
cout << search(l, r) << endl;
} else {
cout << 0 << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
const int N = 100054;
int n, K, ans;
int p[N], fc[N], nc[N], f[N];
inline void up(int &x, const int y) {x < y ? x = y : 0;}
inline void link(int x, int px) {nc[x] = fc[px], fc[px] = x;}
void dfs(int x, int dep = 0) {
for (int y = fc[x]; y; y = nc[y]) dfs(y, dep + 1), up(f[x], f[y] + 1);
if (dep > 1 && f[x] >= K - 1) ++ans, f[x] = -1;
}
int main() {
scanf("%d%d%d", &n, &K, &ans), ans = ans != 1;
for (int i = 2; i <= n; ++i) scanf("%d", p + i), link(i, p[i]);
dfs(1), printf("%d\n", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define sz(x) ((int) ((x).size()))
typedef long long ll;
typedef long double ld;
int n, k, r, a[100100];
vector<int> e[100100];
int dfs(int i = 0) {
int d = 0;
for (int j : e[i])
d = max(d, dfs(j) + 1);
if (d + 1 >= k) {
r += a[i] != 0;
return -1;
}
return d;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a[i], a[i]--;
r += a[0] != 0;
a[0] = 0;
for (int i = 1; i < n; i++)
e[a[i]].push_back(i);
dfs();
cout << r << "\n";
}
| 1 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int n,m,i,j,x,y,w,hd,s,xlh,g[100010],v[21][21],f[100010][21],sy,mx,ans,pr,sz;
int main(){
scanf("%d%d",&n,&m);
for(i=1;i<=m;i++){
scanf("%d%d%d",&x,&y,&w);
xlh+=w;
x--;y--;
v[x][y]=v[y][x]=w;
}
mx=1<<n;
for(s=1;s<mx;s++){
for(i=0;i<n;i++)if(s&(1<<i)){
pr=s^(1<<i);
sz=0;
for(j=0;j<n;j++)if((s&(1<<j))&&v[i][j])sz+=v[i][j];
g[s]=g[pr]+sz;break;
}
//printf("%d %d\n",s,g[s]);
}
memset(f,172,sizeof(f));
f[1][0]=0;
for(s=1;s<mx;s++)
for(hd=0;hd<n;hd++)if(f[s][hd]>=0){
for(i=0;i<n;i++)if(!(s&(1<<i))&&v[hd][i]){
f[s|(1<<i)][i]=max(f[s|(1<<i)][i],f[s][hd]+v[hd][i]);
}
sy=(mx-1)^s;
for(i=sy;i;i=(i-1)&sy)f[s|i][hd]=max(f[s|i][hd],f[s][hd]+g[i|(1<<hd)]);
}
for(i=1;i<mx;i++)ans=max(ans,f[i][n-1]);
printf("%d",xlh-ans);
} |
/*
Writer: SPD_9X2
https://atcoder.jp/contests/arc081/tasks/arc081_d
長方形にできる必要十分条件は、
内側にある四つ角の周り全てに関して、周りにある黒が偶数個
→そのような条件を満たす四つ角グリッドを考えると最大長方形になる
幅1の長方形に関しては全て作れるので、ans初期値はmax(H,W)
*/
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n,m) for(int (i)=(n);(i)<(m);(i)++)
#define rrep(i,n,m) for(int (i)=(n);(i)>(m);(i)--)
using ll = long long;
const ll mod = 1000000007;
const ll half = 500000004;
int LRIH(vector<int>& lis){
vector<vector<int>> stk(0);
int ans = 0;
int N = lis.size();
rep(i,0,N){
if (stk.size() == 0){
stk.push_back({lis[i],i});
}else if (stk[stk.size()-1][0] < lis[i]){
stk.push_back({lis[i],i});
}else if (stk[stk.size()-1][0] > lis[i]){
int lastpos = -1;
while ( (stk.size()>0) && (stk[stk.size()-1][0] > lis[i])){
int nh = stk[stk.size()-1][0];
int np = stk[stk.size()-1][1];
lastpos = np;
stk.pop_back();
ans = max(ans , (nh+1)*(i-np+1));
}
stk.push_back({lis[i] , lastpos});
}
}
return ans;
}
int main(){
int H,W;
cin >> H >> W;
vector<vector<char>> S(H,vector<char> (W));
rep(i,0,H){
rep(j,0,W){
cin >> S[i][j];
}
}
vector<vector<int>> lis(H-1,vector<int> (W-1,0));
rep(i,0,H-1){
rep(j,0,W-1){
if (S[i][j] == '#') lis[i][j] += 1;
if (S[i+1][j] == '#') lis[i][j] += 1;
if (S[i][j+1] == '#') lis[i][j] += 1;
if (S[i+1][j+1] == '#') lis[i][j] += 1;
lis[i][j] %= 2;
}
}
vector<vector<int>> hist(H-1,vector<int> (W,0));
rep(i,0,H-1){
rep(j,0,W-1){
if (lis[i][j] == 0){
if (i==0){
hist[i][j] = 1;
}else{
hist[i][j] = hist[i-1][j] + 1;
}
}
}
}
int ans = max(H,W);
rep(i,0,H-1){
ans = max(ans , LRIH(hist[i]));
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
#define MAX 100005
#define bit(x) (1ll << x)
using namespace std;
int n;
int cnt[64];
long long a[MAX], ans;
inline long long Rd() {
long long x = 0; char ch = getchar();
while(!isdigit(ch)) ch = getchar();
while(isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x;
}
struct linear_base {
long long u[60];
inline void insert(long long val) {
for(int i = 59; i >= 0; --i) {
if(val & bit(i)) {
if(u[i]) val ^= u[i];
else {
u[i] = val;
return;
}
}
}
}
inline long long query() {
long long res = 0;
for(int i = 59; i >= 0; --i)
if((res ^ u[i]) > res) res ^= u[i];
return res;
}
}lsk;
int main() {
n = Rd();
for(int i = 1; i <= n; ++i) {
a[i] = Rd();
for(int j = 59; j >= 0; --j)
if(a[i] & bit(j)) ++cnt[j];
}
for(int i = 59; i >= 0; --i) {
if(cnt[i] & 1) {
ans += bit(i);
for(int j = 1; j <= n; ++j) {
if(a[j] & bit(i)) {
a[j] ^= bit(i);
}
}
}
}
for(int i = 1; i <= n; ++i) lsk.insert(a[i]);
cout << ans + 2ll * lsk.query() << endl;
return 0;
} | #include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
int a[220];
int n;
int main(){
cin >> n;
for(int i=0;i<2*n;i++){
cin >> a[i];
}
sort(a,a+n*2);
int len=0;
for(int i=0;i<n;i++){
len+=a[2*i];
}
cout << len;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<(n);i++)
#define rrep(i,n) for(ll i = 1; i <= (n); ++i)
#define drep(i,n) for(ll i = (n)-1; i >= 0; --i)
#define all(v) v.begin(),v.end()
#define len(x) (ll)(x).length()
#define maxs(x,y) x = max(x,y)
#define mins(x,y) x = min(x,y)
#define pb push_back
#define sz(x) (ll)(x).size()
#define v(T) vector<T>
#define vv(T) vector<vector<T>>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
ll gcd(ll a,ll b){if(a%b==0){return b;}else{return(gcd(b,a%b));}}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
const int INF=1e9;
const ll MX = 1e18;
const ll MOD=INF+7;
const int di[] = {-1,0,1,0};
const int dj[] = {0,-1,0,1};
const double PI=acos(-1);
#define dame { puts("-1"); return 0;}
#define yn {puts("Yes");}else{puts("No");}
#define YN {puts("YES");}else{puts("NO");}
const ll MAX = 1000001;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {fac[0] = fac[1] = 1;finv[0] = finv[1] = 1;inv[1] = 1;for (ll i = 2; i < MAX; i++){fac[i] = fac[i - 1] * i % MOD;inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;finv[i] = finv[i - 1] * inv[i] % MOD;}}
long long COM(ll n, ll k){if (n < k) return 0;if (n < 0 || k < 0) return 0;return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;}
ll llpow(ll n,ll i){ll cnt=n; for(ll j=0;j<i-1;j++){n*=cnt;}return n;}
int main(){
int a,b;
cin>>a>>b;
ll cnt=0;
if(a<=b){
cout<<min(abs(abs(a)-abs(b))+1,b-a)<<endl;
return 0;
}
if(a>b){
if(a>0&&b>0){
cout<<a-b+2<<endl;
return 0;
}
if(a<0&&b<0){
cout<<a-b+2<<endl;
return 0;
}
else{
cout<<abs(abs(a)-abs(b))+1<<endl;
return 0;
}
}
} | # include <bits/stdc++.h>
typedef long long lint;
using namespace std;
lint gcd(lint x, lint y) {
if(x == 0) { return y; }
else { return gcd(y%x,x); }
}
lint lcm(lint x, lint y) { return x/gcd(x,y)*y; }
int main() {
lint x,y,ans; cin >> x >> y;
if(abs(x) == abs(y)) {
ans = 1;
} else if(abs(x) < abs(y)) {
ans = abs(y)-abs(x);
if(x < 0) { ans++; }
if(y < 0) { ans++; }
} else if(abs(x) > abs(y)) {
ans = abs(x)- abs(y);
if(x > 0) { ans++; }
if(y > 0) { ans++; }
}
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
#define PI 3.14159265359
#define NIL -1
using namespace std;
const int64_t MOD = 1e9 + 7;
int main() {
int64_t N;
cin >> N;
int64_t rt = sqrt(N);
for (int64_t i = rt; i > 0; i--) {
if (N % i == 0) {
//cout << i << endl;
int64_t n = N / i;
int64_t cnt = 0;
int64_t m = N / i;
while (m) {
cnt++;
m /= 10;
}
cout << cnt << endl;
return 0;
}
}
} | #include<iostream>
using namespace std;
int count(long long n){
int cnt=0;
while(n>0){
n/=10;
cnt++;
}
return cnt;
}
int main(){
long long n;
long long b;
int cur=0;
int ans=100000;
cin>>n;
for(long long i=1;i*i<=n;i++){
if(n%i==0){
b=n/i;
cur=max(count(i),count(b));
if(ans>cur)ans=cur;
}
}
cout<<ans<<endl;
return 0;
} | 1 |
/* When Talent doesn't work, Hard work beats Talent*/
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("unroll-loops")
#include"bits/stdc++.h"
using namespace std;
#define Fast_D cout<<fixed<<setprecision(2);
#define FastIO ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define nl "\n"
#define sp " "
#define int long long
#define double long double
#define all(v) v.begin(),v.end()
#define scanstr(s) cin>>ws; getline(cin,s);
const double PI=3.141592653589793;
void solve()
{
string s[3];
for(int i=0;i<3;i++) cin >> s[i];
for(auto &c : s) reverse(all(c));
int cur=0;
while(s[cur].size()>0)
{
int x=cur;
cur=s[x].back() - 'a';
s[x].pop_back();
}
char ans= 'A'+cur;
cout << ans << nl;
}
int32_t main()
{
FastIO;
Fast_D;
int T;
T=1;
while(T--)
{
solve();
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,cc,n) for(int i=cc;i<=n;++i)
using namespace std;
int main() {
vector<queue<char>> v(3);
string s;
cin >> s;
for (char c : s) v[0].push(c);
cin >> s;
for (char c : s) v[1].push(c);
cin >> s;
for (char c : s) v[2].push(c);
char c = 'a';
while (true)
{
char i = c - 'a';
if (v[i].empty())
{
putchar(toupper(c));
return 0;
}
c = v[i].front(); v[i].pop();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
vec<int> mult(vec<int>& A,vec<int>& B){
vec<int> C(A.size());
for(int i=0;i<A.size();i++) C[i] = B[A[i]];
return C;
}
vec<int> pow(vec<int>& A,ll n){
if(n==1) return A;
vec<int> R = pow(A,n>>1);
R = mult(R,R);
if(n&1) R = mult(A,R);
return R;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
vec<int> X(N);
vec<int> D(N-1);
for(int i=0;i<N;i++){
cin >> X[i];
if(i) D[i-1] = X[i]-X[i-1];
}
vec<int> perm(N-1);
iota(perm.begin(),perm.end(),0);
int M;
ll K;
cin >> M >> K;
for(int i=0;i<M;i++){
int a;
cin >> a;
a -= 2;
swap(perm[a],perm[a+1]);
}
auto res = pow(perm,K);
ll s = X[0];
for(int i=0;i<N;i++){
cout << s << "\n";
if(i!=N-1) s += D[res[i]];
}
} | #include <bits/stdc++.h>
using namespace std;
int MAX_N=262144*2;
vector<int64_t> seg(MAX_N*2-1);
int64_t qu(int a,int b,int k,int l, int r){
if(r<=a||b<=l){
return 0;
}
else if(a<=l&&r<=b){
return seg[k];
}
else{
int64_t X=qu(a,b,k*2+1,l,(l+r)/2);
int64_t Y=qu(a,b,k*2+2,(l+r)/2,r);
return X+Y;
}
}
void pu(int64_t a,int b){
int D=MAX_N-1+b;
while(D>0){
seg[D]+=a;
D--;
D/=2;
}
seg[0]+=a;
}
int main() {
int N,Q;
cin>>N>>Q;
vector<int> p(N);
for(int i=0;i<N;i++){
cin>>p[i];
p[i]--;
}
vector<tuple<int,int,int>> q(Q);
for(int i=0;i<Q;i++){
int a,b;
cin>>a>>b;
q[i]=make_tuple(b,a,i);
}
sort(q.begin(),q.end());
vector<int> la(N,-1);
vector<int> an(Q);
int W=0;
for(int i=0;i<Q;i++){
int a,b,c;
tie(a,b,c)=q[i];
while(W<a){
if(la[p[W]]!=-1){
pu(-1,la[p[W]]);
}
la[p[W]]=W;
pu(1,W);
W++;
}
an[c]=qu(b-1,a,0,0,MAX_N);
}
for(int i=0;i<Q;i++){
cout<<an[i]<<endl;
}
} | 0 |
#include <algorithm>
#include <iostream>
#include <vector>
#include <math.h>
#include <set>
#include <map>
#include <string>
#include <stack>
#include <queue>
#include <iomanip>
#include <numeric>
#include <tuple>
#include <bitset>
#include <complex>
#include <unistd.h>
#include <cassert>
#include <cctype>
#include <random>
#include <time.h>
#define _USE_MATH_DEFINES
#define _GLIBCXX_DEBUG
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> plglg;
typedef pair<double, ll> pdlg;
typedef tuple<int, int, int> tiii;
typedef tuple<ll, ll, ll> tlglglg;
typedef tuple<double, double, double> tddd;
typedef complex<double> xy_t;
typedef vector<ll> vll;
typedef vector< vector<ll> > matrix;
#define REP(i, x, y) for(ll i = (ll)x; i < (ll)y; i++)
#define DREP(i, x, y, d) for(ll i = (ll)x; i < (ll)y; i += (ll)d)
#define PER(i, x, y) for(ll i = (ll)x; i > (ll)y; i--)
#define DPER(i, x, y, d) for(ll i = (ll)x; i > (ll)y; i -= (ll)d)
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
double pi = 3.141592653589793;
ll mod = 998244353;
int intmax = 2147483647;
int intmin = -2147483648;
ll llmax = 9223372036854775807;
ll llmin = -9223372036854775807;
int iinf = intmax / 8;
ll inf = llmax / 8;
double eps = 1e-12;
ll modadd(ll x, ll y) {
return ((x + y) % mod + mod) % mod;
}
ll modminus(ll x, ll y) {
return (x - y + mod) % mod;
}
ll multiply(ll x, ll y) {
return (x % mod) * (y % mod) % mod;
}
ll modpower(ll x, ll y) {
if (y == 0) {
return 1;
} else if (y == 1) {
return x % mod;
} else if (y % 2 == 0) {
ll p = modpower(x, y / 2);
return p * p % mod;
} else {
ll p = modpower (x, y / 2);
return (p * p) % mod * (x % mod) % mod;
}
}
ll dp[310][90010];
ll dpb[310][90010];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin >> N;
ll a[N];
ll sum = 0;
REP(i, 0, N) {
cin >> a[i];
sum += a[i];
}
dp[0][0] = 1;
dpb[0][0] = 1;
REP(i, 0, N) {
REP(j, 0, 90000) {
dp[i + 1][j] = modadd(dp[i + 1][j], multiply(dp[i][j], 2));
dpb[i + 1][j] = modadd(dpb[i + 1][j], dpb[i][j]);
if (j + a[i] <= 90000) {
dp[i + 1][j + a[i]] = modadd(dp[i + 1][j + a[i]], dp[i][j]);
dpb[i + 1][j + a[i]] = modadd(dpb[i + 1][j + a[i]], dpb[i][j]);
}
}
}
ll dis = 0;
ll disa = 0;
REP(i, (sum + 1) / 2, sum) {
dis = modadd(dis, dp[N][i]);
}
dis = multiply(dis, 3);
if (sum % 2 == 0) {
disa = dpb[N][sum / 2];
}
disa = multiply(disa, 3);
ll base = modadd(modpower(3, N), -3);
ll ans = modadd(base, - modadd(dis, - disa));
cout << ans << endl;
}
| #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
const int MOD = 1000000007;
int main(){
const int maxSize = 100001;
vector<long long> inv(maxSize);
vector<long long> fact(maxSize);
vector<long long> factInv(maxSize);
for(int i=0;i<2;i++) inv[i] = fact[i] = factInv[i] = 1;
for(int i=2;i<maxSize;i++){
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
fact[i] = fact[i-1] * i % MOD;
factInv[i] = factInv[i-1] * inv[i] % MOD;
}
int N, X; cin >> N >> X;
vector<int> S(N);
for(auto& t : S) cin >> t;
sort(S.begin(), S.end());
vector<int> sum(100001, 0);
for(auto& t : S) sum[t] = 1;
for(int i=1;i<=100001;i++) sum[i] += sum[i-1];
vector dp(X+1, vector(N+1, 0LL));
dp[X][N-sum[X]] = 1;
for(int i=X;i>=S[0];i--){
for(int j=N;j>=0;j--){
if(!dp[i][j]) continue;
if(j > 0){
dp[i][j-1] += dp[i][j] * j;
dp[i][j-1] %= MOD;
}
for(int k=0;k<sum[i];k++){
int dst = i%S[k];
int add = sum[i] - sum[dst] - 1;
dp[dst][j+add] += dp[i][j];
dp[dst][j+add] %= MOD;
}
}
}
long long res = 0;
for(int i=1;i<S[0];i++){
for(int j=0;j<=N;j++){
res += dp[i][j] * fact[j] % MOD * i % MOD;
res %= MOD;
}
}
cout << res << endl;
} | 0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
int time(int a,int b,int c,int d,int e,int m){
int ret = a+b+c+d+e;
rep(i,m-1){
ret += d+e;
}
return ret;
}
bool cmp(const pair<double,string>&a,const pair<double,string>&b){
if( fabs(a.first-b.first) < 1e-8){
return a.second < b.second;
}
return a.first > b.first;
}
int main(){
int n;
while(cin >> n , n){
vector< pair<double,string> > data(n);
rep(i,n){
string l; int p,a,b,c,d,e,f,s,m;
cin >> l >> p >> a >> b >> c >> d >> e >> f >> s >> m;
data[i].first = (double)(f*s*m-p)/time(a,b,c,d,e,m);
data[i].second = l;
}
sort(data.begin(),data.end(),cmp);
rep(i,n){
cout << data[i].second << endl;
}
cout << "#" << endl;
}
} | #include <iostream>
#define N 100
#define WHITE 0
#define BLACK 1
#define INF 10000
using namespace std;
int M[N][N],n,d[N];
void prim(){
int color[n],p[n];
for(int i=0;i<n;i++){
color[i]=WHITE;
d[i]=INF;
}
d[0]=0;
p[0]=-1;
while(1){
int mincost=INF;
int u;
for(int i=0;i<n;i++){
if(color[i]!=BLACK && d[i]<mincost){
mincost=d[i];
u=i;
}
}
if(mincost==INF) break;
//connect u to p[u]
color[u]=BLACK;
for(int v=0;v<n;v++){
if(color[v]!=BLACK && M[u][v]!=-1){
if(M[u][v]<d[v]){
d[v]=M[u][v];
p[v]=u;
}
}
}
}
}
int main(){
cin >> n;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++) cin >> M[i][j];
}
prim();
int sum=0;
for(int i=0;i<n;i++) sum+=d[i];
cout << sum << endl;
} | 0 |
#include <algorithm>
#include <iostream>
using namespace std;
static const int MAX = 200000;
static const int sentinel = 1000000000;
long int ninvention = 0;
int merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int L[n1 + 1], R[n2 + 1];
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = sentinel;
R[n2] = sentinel;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
ninvention += max(0, n1 - i);
A[k] = R[j];
j++;
}
}
}
int mergeSort(int A[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int main() {
int data[MAX];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> data[i];
}
mergeSort(data, 0, n);
cout << ninvention << endl;
} | #include <cstdio>
#include <algorithm>
#include <vector>
#include <map>
using namespace std;
using i64=long long;
template <typename T>
struct BinaryIndexedTree {
size_t n;
vector<T> tree;
BinaryIndexedTree(size_t n, T e=0): n(n) {
tree = vector<T>(n+1, e);
}
void add(size_t i, T w) {
// v[i] += w;
// i in [1, n]
for (size_t j=i; j<=n; j+=j&-j)
tree[j] += w;
}
T sum(T m) {
// returns sum of v[i] for i in [1, m]
T sum_=0;
for (size_t i=m; i>0; i-=i&-i)
sum_ += tree[i];
return sum_;
}
};
int main() {
size_t n;
scanf("%zu", &n);
vector<int> a(n);
for (size_t i=0; i<n; ++i)
scanf("%d", &a[i]);
map<int, size_t> m;
for (size_t i=0; i<n; ++i)
m[a[i]] = i;
vector<int> b(n);
int rank_=1;
for (pair<const int, size_t> p: m)
b[p.second] = rank_++;
BinaryIndexedTree<i64> tree(n+1);
i64 res=0;
for (size_t i=0; i<n; ++i) {
res += i-tree.sum(b[i]);
tree.add(b[i], 1);
}
printf("%lld\n", res);
return 0;
} | 1 |
#include<iostream>
#include<string.h>
#include<vector>
#include<list>
#include<stdio.h>
#include<math.h>
#include<iomanip>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) range(i,0,b)
#define debug(x) cout << "debug " << x << endl;
using namespace std;
int flood(char map[][14], int i, int j){
if(map[i][j] == '1')
map[i][j] = '0';
if(map[i+1][j] == '1')
flood(map,i+1,j);
if(map[i][j+1] == '1')
flood(map,i,j+1);
if(map[i-1][j] == '1')
flood(map,i-1,j);
if(map[i][j-1] == '1')
flood(map,i,j-1);
return 1;
}
int main(){
bool loop = true;
char map[14][14] = {{'0'}}, s[14];
while(loop){
range(i,1,13){
if(!(cin >> s)) loop = false;
rep(j,12){
map[i][j+1] = s[j];
}
}
int ans = 0;
range(i,1,13){
range(j,1,13){
if(map[i][j] == '1')
ans += flood(map,i,j);
}
}
if(loop)
cout << ans << endl;
}
} | #include <bits/stdc++.h>
#define cinf(n,x) for(int i=0;i<(n);i++) cin >> x[i];
typedef long long int ll;
using namespace std;
int main(){
int n,p;
int have[50];
while(true){
cin >> n >> p;
if(n==0 && p==0) break;
for(int i=0;i<n;i++) have[i]=0;
int turn=0;
int cnt=p;
while(true){
if(cnt>0){
cnt--;
have[turn%n]++;
if(have[turn%n]==p){
cout << turn%n << endl;
break;
}
}
else{
cnt =have[turn%n];
have[turn%n]=0;
}
turn++;
}
}
}
| 0 |
#include<iostream>
int rounds;
int Ascore, Bscore;
int Acard,Bcard;
int main(){
while (true){
std::cin >> rounds;
if (rounds == 0)break;
for (int i = 0; i < rounds; i++){
std::cin >> Acard>> Bcard;
if (Acard > Bcard){
Ascore += (Acard + Bcard);
}
else if (Acard < Bcard){
Bscore += (Acard + Bcard);
}
else{
Ascore += Acard;
Bscore += Bcard;
}
}
std::cout << Ascore << " " << Bscore << "\n";
Ascore = 0, Bscore = 0;
}
return 0;
} | #include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<string>
#include<sstream>
#include<cmath>
#include<numeric>
using namespace std;
int main(){
int M[13] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
string w[7] = {"Wednesday", "Thursday", "Friday", "Saturday", "Sunday", "Monday", "Tuesday"};
int m, d;
while( cin >> m >> d ){
if( m == 0 || d == 0 ) break;
int tmp = d;
for(int i=0; i<m; i++) tmp += M[i];
cout << w[tmp%7] << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0; i<n; i++)
#define PI 3.14159265359
#define INF 1000100100
#define MOD 1000000007
#define all(x) (x).begin(),(x).end()
typedef long long ll;
#define P pair<ll,ll>
#define PP pair<P,P>
using namespace std;
int dp[80][80][16000];
int main(){
int h,w; cin >> h >> w;
int a[h][w];
int b[h][w];
rep(i,h)rep(j,w) cin >> a[i][j];
rep(i,h)rep(j,w) cin >> b[i][j];
rep(i,h)rep(j,w) a[i][j]=abs(a[i][j]-b[i][j]);
rep(i,h)rep(j,w)rep(k,16000) dp[i][j][k]=0;
dp[0][0][a[0][0]]=1;
rep(i,h)rep(j,w)rep(k,16000){
if(i>0){
if(dp[i-1][j][k]){
dp[i][j][k+a[i][j]]=1;
dp[i][j][abs(k-a[i][j])]=1;
}
}
if(j>0){
if(dp[i][j-1][k]){
dp[i][j][k+a[i][j]]=1;
dp[i][j][abs(k-a[i][j])]=1;
}
}
}
int now=0;
for(;;){
if(dp[h-1][w-1][now]){
cout << now << endl;
return 0;
}
now++;
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<long long>v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
vector<vector<long long>>dp(n, vector<long long>(2, 0));
dp[0][0] = v[0];
dp[0][1] = -v[0];
for (int i = 1; i < n - 1; i++) {
dp[i][0] = max(dp[i - 1][0] + v[i], dp[i - 1][1] - v[i]);
dp[i][1] = max(dp[i - 1][0] - v[i], dp[i - 1][1] + v[i]);
}
cout << (max(dp[n - 2][0] + v[n - 1], dp[n - 2][1] - v[n - 1])) << endl;
} | 0 |
#include <iostream>
#include <cmath>
using namespace std;
int sign(int x){
return (x>0)-(x<0);
}
int main(){
int x,y;
int count = 0;
cin >> x >> y;
if( sign(x)*sign(y)==1 ){
if( x<y ) cout << y-x << endl;
if( x>y ) cout << x-y+2 << endl;
}
if( sign(x)*sign(y)==-1 ){
if( sign(x)*x<=sign(y)*y ) cout << sign(y)*y-sign(x)*x+1 << endl;
if( sign(x)*x>sign(y)*y ) cout << sign(x)*x-sign(y)*y+1 << endl;
}
if( x*y==0 ){
if( x<y ) cout << y-x << endl;
if( x>y ) cout << x-y+1 << endl;
}
} | #include<bits/stdc++.h>
using namespace std;
using lli = long long;
#define rep(i,n) for(int i=0;i<n;i++)
lli x, y;
int main(void){
cin >> x >> y;
lli ans = 1e18;
rep(i, 2){
rep(j, 2){
lli xc, yc;
xc = x;
yc = y;
lli c = 0;
if(i == 1) xc*=-1, c++;
if(j == 1) yc*=-1, c++;
if(xc <= yc) c+=yc-xc;
else c+=1e18;
ans = min(ans, c);
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include<iostream>
using namespace std;
class Dice{
private:
int d_1,d_2,d_3,d_4,d_5,d_6;
public:
void setDice(int a,int b,int c,int d,int e,int f){
d_1 = a;
d_2 = b;
d_3 = c;
d_4 = d;
d_5 = e;
d_6 = f;
}
void roll_w(){
int tmp = d_1;
d_1 = d_3;
d_3 = d_6;
d_6 = d_4;
d_4 = tmp;
}
void roll_e(){
int tmp = d_1;
d_1 = d_4;
d_4 = d_6;
d_6 = d_3;
d_3 = tmp;
}
void roll_n(){
int tmp = d_1;
d_1 = d_2;
d_2 = d_6;
d_6 = d_5;
d_5 = tmp;
}
void roll_s(){
int tmp = d_5;
d_5 = d_6;
d_6 = d_2;
d_2 = d_1;
d_1 = tmp;
}
void spin(){
int tmp = d_2;
d_2 = d_3;
d_3 = d_5;
d_5 = d_4;
d_4 = tmp;
}
int findRight(int top,int front){
for(int i=0;i < 6;i++){
for(int j=0;j < 4;j++){
if((*this).d_1 == top && (*this).d_2 == front) return (*this).d_3;
(*this).spin();
}
if(i % 2 == 0)
(*this).roll_n();
else
(*this).roll_w();
}
return -1;
}
bool cmpDice(Dice d2){
for(int i=0;i < 6;i++){
for(int j=0;j < 4;j++){
if((*this).d_1 == d2.d_1 && (*this).d_2 == d2.d_2 && (*this).d_3 == d2.d_3
&& (*this).d_4 == d2.d_4 && (*this).d_5 == d2.d_5 && (*this).d_6 == d2.d_6){
return true;
}
d2.spin();
}
if(i % 2 == 0) d2.roll_n();
else d2.roll_w();
}
return false;
}
int getDice(){
return d_1;
}
};
int main(){
int n;
int a,b,c,d,e,f;
bool ok = true;
Dice D[100];
cin >> n;
for(int i=0;i < n;i++){
cin >> a >> b >> c >> d >> e >> f;
D[i].setDice(a,b,c,d,e,f);
}
for(int i=0;i < n;i++){
for(int j=0;j < n;j++){
if(i==j) continue;
if(D[i].cmpDice(D[j])){
ok = false;
break;
}
}
if(!ok) break;
}
if(ok) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
| #include <iostream>
#include <stdlib.h>
using namespace std;
int main() {
int count,box,random,a=0,b=0,i,j,k,n,dice[100][6];
cin >> n;
for(i=0;i<n;i++){
for(j=0;j<6;j++){
cin >> dice[i][j];
}
}
for(k=1;k<n;k++){
if(b==1){
break;
}
for(i=0;i<10000;i++){
count=0;
if(a==1){
b=1;
break;
}
for(int j=0;j<6;j++){
if(dice[0][j] == dice[k][j]){
count++;
}
}
if(count==6){
cout << "No" << endl;
a=1;
break;
}
random = rand() % 4 + 1;
if(random == 1){
box=dice[k][0];
dice[k][0]=dice[k][4];
dice[k][4]=dice[k][5];
dice[k][5]=dice[k][1];
dice[k][1]=box;
}
else if(random == 2){
box=dice[k][0];
dice[k][0]=dice[k][1];
dice[k][1]=dice[k][5];
dice[k][5]=dice[k][4];
dice[k][4]=box;
}
else if(random == 3){
box=dice[k][0];
dice[k][0]=dice[k][2];
dice[k][2]=dice[k][5];
dice[k][5]=dice[k][3];
dice[k][3]=box;
}
else if(random == 4){
box=dice[k][0];
dice[k][0]=dice[k][3];
dice[k][3]=dice[k][5];
dice[k][5]=dice[k][2];
dice[k][2]=box;
}
}
}
if(a!=1){
cout << "Yes" << endl;
}
return 0;
} | 1 |
//#include "debug.h"
#include <string.h>
#include <limits.h>
#include <map>
#include <set>
#include <vector>
#include <algorithm>
using namespace std;
const long long M=1000000007;
//typedef long T;
//#include "math/mod.h"
//#include "math/modulo.h"
template<class T, long long M>
struct modulo {
T n;
T gcd_ext(T a, T b, T *x, T *y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
T x1, y1;
T gcd = gcd_ext(b%a, a, &x1, &y1);
*x = y1 - (b/a) * x1;
*y = x1;
return gcd;
}
modulo(T n): n(n<0? n%M+M: n%M) {}
operator T() const { return n; }
modulo operator-() {
return modulo(-n);
}
modulo operator+(const modulo &o) {
return modulo(n+o.n);
}
modulo operator-(const modulo &o) {
return modulo(n-o.n);
}
modulo operator*(const modulo &o) {
return modulo(n*o.n);
}
modulo operator/(const modulo &o) {
T x, y;
T g = gcd_ext(o.n, M, &x, &y);
if (g != 1) return 0;
else return modulo(n * (x % M));
}
bool operator<(const modulo &o) const {
return n<o.n;
}
bool operator<=(const modulo &o) const {
return n<=o.n;
}
bool operator>(const modulo &o) const {
return n>o.n;
}
bool operator>=(const modulo &o) const {
return n>=o.n;
}
bool operator==(const modulo &o) const {
return n==o.n;
}
bool operator!=(const modulo &o) const {
return n!=o.n;
}
};
typedef modulo<long long, M> T;
//#include "math/comb.h"
void comb_inc_k(T &r, int n, int &k) {
//C(n,k+1) = C(n,k) * (n-k) / (k+1)
r = r * T(n-k) / T(k+1);
k++;
}
void comb_dec_k(T &r, int n, int &k) {
//C(n,k-1) = C(n,k) * k / (n-k+1)
r = r * T(k) / T(n-k+1);
k--;
}
void comb_inc_n(T &r, int &n, int k) {
//C(n+1,k) = C(n,k) * (n+1) / (n+1-k)
r = r * T(n+1) / T(n+1-k);
n++;
}
void comb_dec_n(T &r, int &n, int k) {
//C(n-1,k) = C(n,k) * (n-k) / n
r = r * T(n-k) / T(n);
n--;
}
T comb(int n, int k) {
if (k*2 > n) k = n-k;
if (n==0) return 0;
T r = 1; //C(n,0)
for (int i=0; i<k; ) comb_inc_k(r, n, i);
return r;
}
int h,w,a,b;
int input() {
if (scanf("%d %d %d %d", &h, &w, &a, &b) < 0) return 0;
return 1;
}
void init() {
}
int solve() {
T r = comb(h+w-2, h-1);
int xn = h-a+b-1, xk = b-1;
T x = comb(xn, xk);
int yn = a-1+w-b-1, yk = w-b-1;
T y = comb(yn, yk);
for (int i=0; i<a; i++) {
//T x = mod_combinations(h-a+i+b-1, b-1, M);
//T y = mod_combinations(a-1-i+w-b-1, w-b-1, M);
if (i) {
comb_inc_n(x, xn, xk);
comb_dec_n(y, yn, yk);
}
r = r-x*y;
}
/*
T r = mod_combinations(h+w-2, h-1, M);
T x = mod_combinations(h-a+b-1, b-1, M);
T y = mod_combinations(a-1+w-b-1, w-b-1, M);
for (int i=0; i<a; i++) {
//T x = mod_combinations(h-a+i+b-1, b-1, M);
//T y = mod_combinations(a-1-i+w-b-1, w-b-1, M);
if (i) {
T n = h-a+i+b-1, m = b-1;
x = mod_div(x*n, n-m, M);
n = a-1-i+w-b-1, m = w-b-1;
y = mod_div(y*(n+1-m), n+1, M);
}
T z = mod_mul(x, y, M);
//printf("%d: r=%ld %ld %ld %ld\n", i, r, x, y, z);
r = mod_sub(r, z, M);
}
*/
return r;
}
void output(int ans) {
printf("%d\n", ans);
}
void cleanup() {
}
int main() {
//precalc();
//int ca; scanf("%d", &ca);
while (input()) {
init();
output(solve());
cleanup();
//break;
}
}
| #include<cstring>
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#define ll long long
using namespace std;//往左走w-1,往下走h-1
const ll mod=1000000007;
ll f[1000000];
ll quick(ll a,ll b)
{
// cout<<"a"<<a<<"b"<<b<<endl;
ll ans=1;
while(b)
{
if(b&1)
{
ans=(ans*a)%mod;
}
b>>=1;
a=(a*a)%mod;
}
// cout<<"("<<ans<<endl;
return ans;
}
ll ni(ll a)
{
// cout<<"ni"<<endl;
return quick(a,mod-2);
}
ll c(int n,int m)
{
ll a=f[n];
// cout<<"a"<<f[n]<<endl;
ll b=(f[m]*f[n-m])%mod;
// cout<<"b"<<b<<endl;
return (a*ni(b))%mod;
}
int main()
{
int h,w,a,b;
f[0]=1;
for(int i=1;i<=200005;i++)
{
f[i]=(f[i-1]*i)%mod;
}
cin>>h>>w>>a>>b;
ll ans=0;
ll t;
for(int i=b+1;i<=w;i++)
{
// cout<<"-----"<<endl;
// cout<<"!"<<c(h-a-1+i-1,h-a-1)<<endl;
// cout<<"!"<<c(w-i+a-1,a-1)<<endl;
t=(c(h-a-1+i-1,h-a-1)*c(w-i+a-1,a-1))%mod;
ans=(ans+t)%mod;
}
cout<<ans<<endl;
} | 1 |
//#include "bits/stdc++.h"
#define _USE_MATH_DEFINES
#include<cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <deque>
#include <algorithm>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <iterator>
#include<iomanip>
#include<unordered_set>
#include<bitset>
using namespace std;
#define rep(i,a,b) for(int i=(a), i##_len=(b);i<i##_len;i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define all(c) begin(c),end(c)
#define int ll
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
//typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<double, double> pdd;
typedef vector< vector<int> > mat;
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 (b < a) { a = b; return true; } return false; }
const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
const int MAX_ROW = 100010; // to be set appropriately
const int MAX_COL = 70; // to be set appropriately
struct BitMatrix {
int H, W;
bitset<MAX_COL> val[MAX_ROW];
BitMatrix(int m = 1, int n = 1) : H(m), W(n) {}
inline bitset<MAX_COL>& operator [] (int i) { return val[i]; }
};
int GaussJordan(BitMatrix &A, bool is_extended = false) {
int rank = 0;
for (int col = 0; col < A.W; ++col) {
if (is_extended && col == A.W - 1) break;
int pivot = -1;
for (int row = rank; row < A.H; ++row) {
if (A[row][col]) {
pivot = row;
break;
}
}
if (pivot == -1) continue;
swap(A[pivot], A[rank]);
for (int row = 0; row < A.H; ++row) {
if (row != rank && A[row][col]) A[row] ^= A[rank];
}
++rank;
}
return rank;
}
int linear_equation(BitMatrix A, vector<int> b, vector<int> &res) {
int m = A.H, n = A.W;
BitMatrix M(m, n + 1);
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) M[i][j] = A[i][j];
M[i][n] = b[i];
}
int rank = GaussJordan(M, true);
// check if it has no solution
for (int row = rank; row < m; ++row) if (M[row][n]) return -1;
// answer
res.assign(n, 0);
for (int i = 0; i < rank; ++i) res[i] = M[i][n];
return rank;
}
BitMatrix encodeBM(vector<int> v, int col)
{
BitMatrix M(v.size(), col);
rep(i, 0, (int)v.size())
{
rep(j, 0, col)
{
M[i][col - (j + 1)] = (v[i] >> j) & 1;
}
}
return M;
}
vector<int> decodeBM(BitMatrix M)
{
vector<int> v(M.H);
rep(i, 0, M.H)
{
int n = 0;
rep(j, 0, M.W)
{
if (M[i][j])
{
n |= 1LL << (M.W - (j + 1));
}
}
v[i] = n;
}
return v;
}
int N;
int A[100010];
signed main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
int ans = 0;
rep(i, 0, N)
{
cin >> A[i];
ans ^= A[i];
}
vector<int> v;
rep(i, 0, N)
{
v.push_back(A[i] & (~ans));
}
BitMatrix M = encodeBM(v, 60);
GaussJordan(M, false);
v = decodeBM(M);
int res = 0;
for (auto n : v)
{
res ^= n;
}
ans += res * 2;
cout << ans << endl;
return 0;
} | #include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
typedef uint64_t ull;
typedef int64_t sll;
static const ull MOD = 1000000007LL;
int n;
int k;
int q;
ull a[200019];
ull umin (ull a, ull b) {
return (a < b) ? a : b;
}
ull umax (ull a, ull b) {
return (a > b) ? a : b;
}
ull solve () {
sll i, j, ki;
ull res = 0;
ull allxor = 0;
for (i = 0; i < n; i++) {
allxor ^= a[i];
}
for (i = 0; i < n; i++) {
a[i] &= ~allxor;
}
ull rank = 0;
for (i = 59; i >= 0; i--) {
for (j = rank; j < n; j++) {
if (a[j] & (1LL << i)) break;
}
if (j == n) {
continue;
}
if (j > rank) a[rank] ^= a[j];
for (j = rank + 1; j < n; j++) {
a[j] = umin(a[j], a[j] ^ a[rank]);
}
rank++;
}
ull x = 0;
for (i = 0; i < n; i++) {
x = umax(x, x ^ a[i]);
}
res = (x * 2) + allxor;
return res;
}
int main(void){
scanf("%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
}
printf("%lld\n", solve());
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(void){
int x[5];
for(int i=0;i<5;i++)
cin>>x[i];
int k;cin>>k;
sort(x,x+5);
cout<<((x[4]-x[0])>k?":(":"Yay!")<<endl;
return 0;}
| #include <bits/stdc++.h>
#include "atcoder/fenwicktree.hpp"
#define rep(i,n) for(int i = 0; i < (int)(n); ++i)
using namespace std;
using namespace atcoder;
using ll = long long;
int main() {
int n, q;
cin >> n >>q;
fenwick_tree<ll> ft(n);
rep(i, n) {
ll s;
cin >> s;
ft.add(i, s);
}
rep(i, q) {
bool t;
cin >> t;
if (!t) {
int p;
ll x;
cin >> p >> x;
ft.add(p, x);
}
else {
int p, x;
cin >> p >> x;
cout << ft.sum(p, x) << endl;;
}
}
return 0;
}
| 0 |
//
// main.cpp
// ITP1_6-A
//
// Created by Saicj on 2015/07/14.
// Copyright (c) 2015??´ saicj. All rights reserved.
//
#include <iostream>
#include <stdio.h>
using namespace std;
int main(int argc, const char * argv[])
{
int n;
int index = 0;
cin >> n;
int numList[n];
while (true) {
int temp;
cin >> temp;
numList[index] = temp;
index++;
if (index >= n){
break;
}
}
for (int i = index-1; i >= 0; i--) {
if (i == 0){
printf("%d",numList[0]);
break;
}
printf("%d ",numList[i]);
}
printf("\n");
return 0;
} | #include<stdio.h>
int main(void){
int a,i;
scanf("%d",&a);
int x[a];
for(i=0;i<a;i++){
scanf("%d",&x[i]);
}
for(i=0;i<a;i++){
printf("%d",x[a-i-1]);
if(i!=a-1){
printf(" ");
}else{
printf("\n");
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
ll n, t;
cin >> n >> t;
ll ans = n*t;
ll last;
cin >> last;
for(int i = 1; i < n; ++i){
int cur;
cin >> cur;
if(cur<(last+t)){
ans += (cur-(last+t));
}
last = cur;
}
cout << ans;
return 0;
}
| #include<iostream>
#include<vector>
using namespace std;
int main(){
int n,t;
cin>>n>>t;
vector<int>v(n);
for(int i=0;i<n;i++)
{
cin>>v[i];
}
int current_time=0;
int result=0;
for(int i=0;i<n;i++)
{
int start_time=v[i];
current_time=v[i]+t;
bool inside=false;
while(i<n&&v[i]<current_time){
current_time=v[i]+t;
i++;
inside=true;
}
if(inside)i--;
result+=current_time-start_time;
}
cout<<result<<endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
// Your code here!
int k, t;
cin >> k >> t;
vector<int> a(t);
for(int i=0; i<t; i++)cin >> a[i];
sort(a.begin(), a.end(), greater<int>());
cout << max(a[0] - 1 - (k - a[0]), 0) << endl;
}
| #include <cstdio>
#include <bits/stdc++.h>
#include <algorithm>
#include <iostream>
#include <string>
#include <cmath>
#include <functional>
#include <vector>
#include <stack>
#include <queue>
#include <map>
using ll = long long;
#define rep(i,n) for (ll i=0;i<n;i++)
using namespace std;
void solve(){
}
int main (){
ios::sync_with_stdio(0);
cin.tie(0);
ll n,m;
set<string> uni;
cin >> n;
vector<string> s(n);
rep(i,n) {
cin >> s[i];
uni.insert(s[i]);
}
cin >> m;
vector<string> t(m);
rep(i,m) {
cin >> t[i];
uni.insert(t[i]);
}
ll ans = 0;
for(string ss:uni){
ll tmp = 0;
rep(i,n){
if(s[i]==ss) tmp++;
}
rep(i,m){
if(t[i]==ss) tmp--;
}
ans = max(ans,tmp);
}
cout << ans << endl;
return 0;
} | 0 |
#include <iostream>
#include <vector>
std::vector<long long> common_divisors(long long a, long long b) {
if (a > b) std::swap(a, b);
std::vector<long long> ret(0), st(0);
for (int i = 1; i <= a / i; i++) {
if (a % i == 0) {
if (b % i == 0) ret.push_back(i);
if (b % (a / i) == 0 && i < a / i) st.push_back(a / i);
}
}
while (st.size()) {
ret.push_back(st.back());
st.pop_back();
}
return ret;
}
bool is_prime(long long n) {
if (n < 2) return false;
if (n == 2) return true;
if (n % 2 == 0) return false;
for (int i = 3; i <= n / i; i += 2) {
if (n % i == 0) return false;
}
return true;
}
int main() {
long long a, b;
std::cin >> a >> b;
std::vector<long long> v = common_divisors(a, b);
long long ans = 1;
for (auto i : v) {
if (is_prime(i)) ans++;
}
std::cout << ans << '\n';
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int64_t a,b;
cin >> a >> b;
vector<pair<int64_t,int64_t>> res;
int64_t n=gcd(a,b);
for(int64_t i=2;i*i<=n;i++){
if(n%i!=0)continue;
int64_t s=0;
while(n%i==0){
s++;
n/=i;
}
res.push_back({a,s});
}
if(n!=1)res.push_back({n,1});
cout << res.size()+1 << endl;
}
| 1 |
#include <bits/stdc++.h>
#define err(args...) {}
#ifdef DEBUG
#include "_debug.cpp"
#endif
using namespace std;
using ll = long long;
using ld = long double;
template <typename T> using lim = numeric_limits<T>;
template <typename T> istream& operator>>(istream& is, vector<T>& a) { for(T& x : a) { is >> x; } return is; }
template <typename X, typename Y> istream& operator>>(istream& is, pair<X, Y>& p) { return is >> p.first >> p.second; }
enum class event_t { start, end, query };
struct event {
event_t type;
int pos, val;
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, q;
cin >> n >> q;
vector<event> events;
for(int i = 0; i < n; i++) {
int s, t, x;
cin >> s >> t >> x;
events.push_back({event_t::start, s - x, x});
events.push_back({event_t::end, t - x, x});
}
for(int i = 0; i < q; i++) {
int d;
cin >> d;
events.push_back({event_t::query, d, i});
}
vector<int> ans(q);
sort(events.begin(), events.end(), [](auto& e1, auto& e2) {
return pair{e1.pos, e1.type} < pair{e2.pos, e2.type};
});
multiset<int> s;
for(auto& e : events) {
if(e.type == event_t::start) {
s.insert(e.val);
} else if(e.type == event_t::end) {
s.erase(s.find(e.val));
} else {
ans[e.val] = s.empty() ? -1 : *s.begin();
}
}
for(int i = 0; i < q; i++) {
cout << ans[i] << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define mset(a, b) memset(a, b, sizeof(a))
#define mcpy(a, b) memcpy(a, b, sizeof(a))
using namespace std;
typedef long long LL;
const int N = 15;
const int MAXS = (1 << N) + 5;
template <typename T> inline void read(T &AKNOI) {
T x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
AKNOI = flag * x;
}
template <typename T> inline void cmax(T &x, T y) {
if (x < y) x = y;
}
int n, m, S, g[N][N], bin[N], id[MAXS];
int sum[MAXS], dp[MAXS][N];
void init() {
read(n); read(m);
S = (1 << n);
for (int i = 0; i < n; ++i) {
bin[i] = (1 << i);
id[bin[i]] = i;
}
for (int i = 1; i <= m; ++i) {
int a, b, c;
read(a); read(b); read(c);
g[a - 1][b - 1] = g[b - 1][a - 1] = c;
}
for (int s = 1; s < S; ++s) {
int u = id[s & (-s)];
sum[s] = sum[s ^ bin[u]];
for (int i = u + 1; i < n; ++i) {
if ((s >> i) & 1) {
sum[s] += g[u][i];
}
}
}
}
void solve() {
mset(dp, 0x80);
int ans = dp[0][0];
dp[1][0] = 0;
for (int s = 1; s < S; ++s) {
for (int i = 0; i < n; ++i) {
for (int t = s; t; t = (t - 1) & s) {
if (t & bin[i]) {
cmax(dp[s][i], dp[s ^ t ^ bin[i]][i] + sum[t]);
}
}
for (int j = 0; j < n; ++j) {
if ((s >> j) & 1) continue;
if (!g[i][j]) continue;
cmax(dp[s | bin[j]][j], dp[s][i] + g[i][j]);
}
}
if (s & bin[n - 1]) {
cmax(ans, dp[s][n - 1]);
}
}
printf("%d\n", sum[S - 1] - ans);
}
int main() {
init();
solve();
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define int long long int
#define pb push_back
#define mp make_pair
#define all(x) x.begin(), x.end()
#define tr(it, a) for(auto it = a.begin(); it != a.end(); it++)
typedef vector<int> vi;
const int mod = 1000000007;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n,time,ans=0,flag=0;
cin>>n>>time;
int s,e;
cin>>s;
e=s+time;
for(int i =1;i <n;i++){
int inter;
cin>>inter;
if(inter <=e){
e = inter + time;
// cout<<"in between "<<e<<endl;
flag=0;
}
else{
ans = ans + (e-s);
//cout<<"broken"<<" "<<ans<<endl;
flag=1;
s = inter;
e = inter + time;
}
}
ans = ans + e-s ;
cout<<ans<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i,l,r) for(int i=(l);i<(r);i++)
#define pb push_back
#define fi first
#define se second
using ll = long long;
using G = vector<vector<int>>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
const ll MOD = 1000000007;
ll GCD(ll x, ll y){
return y ? GCD(y, x%y) : x;
}
int main() {
ll n, m; cin >> n >> m;
ll t[200005];
rep(i, 0, n) cin >> t[i];
ll ans = 0;
rep(i, 1, n){
if((t[i]-t[i-1])>m) ans += m;
else ans += t[i]-t[i-1];
}
ans += m;
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double R = 0;
cin >> R;//現在のレーティング
double G = 0;
cin >> G;//したいレーティング
//(R + ans) / 2 = G
//R + ans = 2*G
double ans = 0;
ans = 2*G - R;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG //GCC5.4.1で配列の範囲外アクセスをエラーにする
//cmdで g++ test.cpp とするとコンパイルできる
//制限1秒なら10^6は余裕 10^7は多分間に合う 10^8はよほど単純でないと厳しい
// https://github.com/atcoder/live_library
// cppdbg: test.exeのterminalに標準入力を打てる
#define ALL(x) x.begin(),x.end()
#define get_tp(t,i) get<i>(t)
#define len(x) (ll)(x.size())
#define ub(a,x) (upper_bound(ALL(a),x)-a.begin())
#define lb(a,x) (lower_bound(ALL(a),x)-a.begin())
typedef long long ll; //long long
typedef pair<int,int> pii; //pair<int,int>
typedef pair<long long,long long> pllll; //pair<ll,ll>
typedef vector<int> vi; //vector<int>
typedef vector<vector<int>> vvi; //vector<vector<int>>
typedef vector<ll> vll; //vector<long long>
typedef vector<vector<ll>> vvll; //vector<vector<long long>>
typedef priority_queue<ll, vector<ll>, greater<ll> > gpq; //逆順priority_queue
typedef priority_queue<ll> pq;
//const int MOD=998244353;
const int MOD=1000000007; //10^9+7
const long double PI=3.1415926535897932;
int main(){
int R,G;cin>>R>>G;
cout<<G+G-R<<endl;
} | 1 |
#include <bits/stdc++.h>
#define MAXN 100010
#define pii pair<int,int>
#define ff first
#define ss second
#define ll long long
#define in_range(x, y, n) (x >= 0 and x<n and y >=0 and y<n)
using namespace std;
const int mod = 1e9 + 7;
int main (){
string s;
cin >> s;
int n = s.size();
for (int i=0; i<n-2; i++){
if (s[i+1] == s[i] || s[i+2] == s[i]){
cout << i+1 << " " << i+3 << endl;
return 0;
}
}
if (s[n-1] == s[n-2]){
cout << n-1 << " " << n << endl;
}
else cout << "-1 -1" << endl;
return 0;
} | #include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#define ll long long
#define maxn 1010
inline ll read()
{
ll x=0; char c=getchar(),f=1;
for(;c<'0'||'9'<c;c=getchar())if(c=='-')f=-1;
for(;'0'<=c&&c<='9';c=getchar())x=x*10+c-'0';
return x*f;
}
inline void write(ll x)
{
static int buf[20],len; len=0;
if(x<0)x=-x,putchar('-');
for(;x;x/=10)buf[len++]=x%10;
if(!len)putchar('0');
else while(len)putchar(buf[--len]+'0');
}
inline void writeln(ll x){write(x); putchar('\n');}
inline void writesp(ll x){write(x); putchar(' ');}
const char mat4[4][5]={"aacd","bbcd","cdaa","cdbb"};
const char mat5[5][6]={"aabba","bcc.a","b..cb","a..cb","abbaa"};
const char mat6[6][7]={"aabcc.","b.b..c","baa..c","cc.aab","..cb.b","..cbaa"};
const char mat7[7][8]={"aa.bb.a",".cc..ca","b.dd.c.","b...d.b",".c..d.b","ac..cc.","a.bb.aa"};
char mat[maxn][maxn];
int n;
int main()
{
n=read();
if(n<=2){
puts("-1"); return 0;
}
if(n==3){
puts("aab\nb.b\nbaa");
return 0;
}
memset(mat,'.',sizeof(mat));
for(int i=0;i<=n-8;i+=4){
for(int j=0;j<4;j++)
for(int k=0;k<4;k++)
mat[i+j][i+k]=mat4[j][k];
}
switch(n%4)
{
case 0:{
for(int i=0;i<4;i++)
for(int j=0;j<4;j++)
mat[n-4+i][n-4+j]=mat4[i][j];
break;
}
case 1:{
for(int i=0;i<5;i++)
for(int j=0;j<5;j++)
mat[n-5+i][n-5+j]=mat5[i][j];
break;
}
case 2:{
for(int i=0;i<6;i++)
for(int j=0;j<6;j++)
mat[n-6+i][n-6+j]=mat6[i][j];
break;
}
case 3:{
for(int i=0;i<7;i++)
for(int j=0;j<7;j++)
mat[n-7+i][n-7+j]=mat7[i][j];
break;
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++)
putchar(mat[i][j]);
putchar('\n');
}
return 0;
} | 0 |
#include<iostream>
#include<cstdio>
using namespace std;
void solve(int delta_x){
int number_of_rectangle, height_of_rectangle;
int integer = 0;
number_of_rectangle = 600 / delta_x;
for(int i = 1;i < number_of_rectangle;i++){
height_of_rectangle = (delta_x * i) * (delta_x * i);
integer += height_of_rectangle * delta_x;
}
cout << integer << endl;
}
int main(){
int number_of_rectangle, delta_x;
while(cin >> delta_x){
solve(delta_x);
}
return 0;
} | #include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
using namespace std;
#define MAX 256
#define S(x) (x*x)
int f(int z){
if (z < 10)return 1;
return 1 + f(z / 10);
}
int main(void){
int ans[MAX];
for (int i = 0; i < MAX; i++){
ans[i] = 0;
}
int d;
int i = 0;
while (scanf("%d", &d) != EOF){
for (int j = d; j <= 600 - d; j += d){
ans[i] += S(j)*d;
}
i++;
}
for (int j = 0; j < i; j++){
printf("%d\n", ans[j]);
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define all(x) (x).begin(),(x).end()
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
const ll MOD9=1000000007;
const ll MOD=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
using Graph = vector<vector<int>>;
double nCk(int n, int k) {
double res=1.0;
for(int i=0; i<n; i++){
res*=0.5;}
for(int i=0; i<k; i++){
res*=(double)(n-i);
res/=(double)(k-i);
}
return res;}
struct edge{ll to, cost;};
typedef pair<ll,ll> P;
struct graph{
ll V;
vector<vector<edge> > G;
vector<ll> d;
graph(ll n){
init(n);
}
void init(ll n){
V = n;
G.resize(V);
d.resize(V);
rep(i,V){
d[i] = INF;
}
}
void add_edge(ll s, ll t, ll cost){
edge e;
e.to = t, e.cost = cost;
G[s].push_back(e);
}
void dijkstra(ll s){
rep(i,V){
d[i] = INF;
}
d[s] = 0;
priority_queue<P,vector<P>, greater<P> > que;
que.push(P(0,s));
while(!que.empty()){
P p = que.top(); que.pop();
ll v = p.second;
if(d[v]<p.first) continue;
for(auto e : G[v]){
if(d[e.to]>d[v]+e.cost){
d[e.to] = d[v]+e.cost;
que.push(P(d[e.to],e.to));
}
}
}
}
};
class UnionFind
{
public:
int par[100005];
int depth[100005];
int nGroup[100005];
UnionFind(int n) {
init(n);
}
void init(int n) {
for(int i=0; i<n; i++) {
par[i] = i;
depth[i] = 0;
nGroup[i] = 1;
}
}
int root(int x) {
if(par[x] == x) {
return x;
} else {
return par[x] = root(par[x]);
}
}
bool same(int x, int y) {
return root(x) == root(y);
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if(x == y) return;
if(depth[x] < depth[y]) {
par[x] = y;
nGroup[y] += nGroup[x];
nGroup[x] = 0;
} else {
par[y] = x;
nGroup[x] += nGroup[y];
nGroup[y] = 0;
if(depth[x] == depth[y])
depth[x]++;
}
}
};
const ll MAX = 510000;
ll fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
ll COM(ll n, ll k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
vector<ll> depth;
vector<ll> f;
vector<ll> g;
void dfs(const Graph &G, ll v, ll p, ll d) {
depth[v] = d;
for (auto nv : G[v]) {
if (nv == p) continue; // nv が親 p だったらダメ
dfs(G, nv, v, d+1);
}
// 帰りがけ時に、部分木サイズを求める
f[v] = 1;
g[v] = 1;// 自分自身
for (auto c : G[v]) {
if (c == p) continue;
f[v]*=g[c];
f[v]%=MOD;
g[v]*=f[c];
g[v]%=MOD;
}
f[v]+=g[v];
f[v]%=MOD;
}
int main() {
ll n,m,k; cin>>n>>m>>k;
ll ca = 0;
ll q = 1;
COMinit();
for(ll i=0; i<n-k-1; i++){
q*=m-1;
q%=MOD;}
q*=m;
q%=MOD;
for(ll i=k; i>0; i--){
ll c = 1;
c*=(COM(n-1,i))%MOD;
//c*=m;
//c%=MOD;
c*=q;
c%=MOD;
q*=(m-1);
q%=MOD;
ca+=c;
ca%=MOD;}
//cout << q << endl;
//q*=m;
//q%=MOD;
//cout << q << endl;
ca+=q;
ca%=MOD;
//ll p = 1;
//for(ll i =1; i<100; i++){
//p*=99;
//p%=MOD;
//}
//cout << p << endl;
//p*=100;
//p%=MOD;
cout << ca << endl;}
| #include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <unordered_map>
#include <queue>
#include <deque>
using namespace std;
using ll = long long;
void _cin(){} template <class Head, class... Tail> void _cin(Head&& head, Tail&&... tail){ cin >> head; _cin(forward<Tail>(tail)...); }
void _cout(){ cout << "\n"; } template <class Head, class... Tail> void _cout(Head&& head, Tail&&... tail){ cout << head; _cout(forward<Tail>(tail)...); }
template<typename S, typename T> ostream& operator<<(ostream &os, const pair<S, T> &p){ cout << "[" << p.first << ", " << p.second << "]"; return os; }
#define Sq(x) (x)*(x)
#define For(i, n) for(int i = 0; i < (n); i ++)
#define Rep(n) For(_, n)
#define Range(c) c.begin(), c.end()
#define RevRange(c) c.rbegin(), c.rend()
#define Contains(c, x) (find(Range(c), x) != c.end())
#define Search(rb, re, x) distance(rb, find(rb, re, x))
#define Sort(a) sort(Range(a))
#define DeSort(a) sort(RevRange(a))
#define Reverse(c) reverse(Range(c))
#define Unique(a) a.erase(unique(Range(a)), a.end())
#define Cusum(T, xs, sxs) vector<T> sxs(xs.size()+1); For(i, (int)xs.size()) sxs[i+1] = sxs[i] + xs[i]
#define Cin(T, ...) T __VA_ARGS__; _cin(__VA_ARGS__)
#define Cins(T, n, xs) vector<T> xs(n); For(i, n) cin >> xs[i]
#define Cins2(T, n, xs, ys) vector<T> xs(n), ys(n); For(i, n) cin >> xs[i] >> ys[i]
#define Cins3(T, n, xs, ys, zs) vector<T> xs(n), ys(n), zs(n); For(i, n) cin >> xs[i] >> ys[i] >> zs[i]
#define Cinm(T, n, map) unordered_map<T, int> map; Rep(n){ Cin(T, x); map[x] ++; }
#define Cout(...) _cout(__VA_ARGS__)
#define Couts(xs) { for(const auto &e : xs) cout << e << " "; cout << "\n"; }
#define Coutyn(cond) Cout((cond) ? "yes" : "no")
#define CoutYn(cond) Cout((cond) ? "Yes" : "No")
#define CoutYN(cond) Cout((cond) ? "YES" : "NO")
#define Return(expr) { Cout(expr); return 0; }
#define vc vector
#define Mini(a, x) a = min(a, x)
#define Maxi(a, x) a = max(a, x)
constexpr int MOD = 998244353;
ll modpow(ll n, ll p){
if(p == 0) return 1;
if(p % 2 == 1) return n * modpow(n, p-1) % MOD;
ll t = modpow(n, p/2);
return t*t % MOD;
}
constexpr int COMB_MAX = 210000;
ll fac[COMB_MAX], finv[COMB_MAX], inv[COMB_MAX];
void initComb(){
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for(int i = 2; i < COMB_MAX; i ++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll comb(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main(void){
Cin(int, n, m, k);
initComb();
ll ans = 0;
For(i, k+1){
ll tmp = m * modpow(m-1, n-i-1) % MOD * comb(n-i-1 + i, i) % MOD;
// Cout(tmp);
ans = (ans + tmp) % MOD;
}
Cout(ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define repd(i,a,b) for (int i=(a);i<(b);i++)
#define rep(i,n) repd(i,0,n)
#define all(x) (x).begin(),(x).end()
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
typedef long long ll;
const long long INF = 1LL << 60;
typedef pair<int, int> P;
int main()
{
int N, T;
cin >> N >> T;
vector<P> AB(N);
rep(i, N) {
int A, B;
cin >> A >> B;
AB[i] = {A, B};
}
sort(all(AB));
vector<vector<int>> dp(N + 1, vector<int>(7000, -1));
dp[0][0] = 0;
rep(i, N) {
rep(j, 7000) {
if (dp[i][j] != -1) {
if (j < T) chmax(dp[i + 1][j + AB[i].first], dp[i][j] + AB[i].second);
chmax(dp[i + 1][j], dp[i][j]);
}
}
}
int ans = 0;
rep(i, dp[N].size()) {
chmax(ans, dp[N][i]);
}
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define int long long int
int32_t main()
{
int d,g;
cin>>d>>g;
vector<array<int,2>> s(d);
for(int i=0;i<d;i++)
cin>>s[i][0]>>s[i][1];
int ans=INT_MAX;
for(int i=0;i<(1<<d);i++)
{
int left=-1,sum=0,count=0;
for(int j=0;j<d;j++)
{
if((i>>j)&1)
sum+=100*(j+1)*s[j][0]+s[j][1],count+=s[j][0];
else
left=j;
}
if(sum<g)
{
int c=100*(left+1);
int need=(g-sum+c-1)/c;
if(need>=s[left][0])
continue;
count+=need;
}
ans=min(ans,count);
}
cout<<ans<<endl;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.