code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 1
101M
|
|---|---|---|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); i++)
int main() {
int m, k;
cin >> m >> k;
if (k >= (1 << m)) {
puts("-1");
return 0;
}
if (m == 0) {
printf("0 0\n");
return 0;
}
if (m == 1) {
if (k == 0)
printf("0 0 1 1\n");
else
puts("-1");
return 0;
}
vector<int> half;
for (int i = 0; i < (1 << m); i++) {
if (i == k) continue;
cout << i << " ";
half.push_back(i);
}
cout << k << " ";
reverse(half.begin(), half.end());
for (int i : half) {
cout << i << " ";
}
cout << k << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = 1000000;
int main() {
ll N, M;
ll ans = 0;
cin >> N >> M;
vector<pair<ll, ll>>p(N);
priority_queue<ll>que;
for (int i = 0; i < N; i++) {
ll A, B;
cin >> A >> B;
p[i] = make_pair(A, B);
}
sort(p.begin(), p.end());
ll a = 1;
ll i = 0;
while (a <= M) {
while (i < N && p[i].first <= a) {
que.push(p[i].second);
i++;
}
a++;
if (!que.empty()) {
ans += que.top();
que.pop();
}
}
cout << ans << endl;
}
| 0
| 6,429,561
|
#include<bits/stdc++.h>
using namespace std;
long long N;
long long x[1005];
long long y[1005];
int main(){
cin >> N;
bool ok = true;
for(long long i = 0; i < N; i++){
cin >> x[i] >> y[i];
if(i != 0){
if((abs(x[0]) + abs(y[0]))%2 != (abs(x[i]) + abs(y[i]))%2){
ok = false;
}
}
}
if(!ok){
cout << -1 << endl;
return 0;
}
vector<long long> arm;
for(long long len = pow(2, 32); len>=1; len/=2){
arm.push_back(len);
}
if((abs(x[0]) + abs(y[0]))%2 == 0){
arm.push_back(1);
}
cout << arm.size() << endl;
for(long long i = 0; i < arm.size(); i++){
cout << arm[i];
if(i == arm.size() - 1){
cout << endl;
}else{
cout << " ";
}
}
for(long long i = 0; i < N; i++){
long long tarx = x[i];
long long tary = y[i];
long long curx = 0;
long long cury = 0;
string ans = "";
for(long long j = 0; j < arm.size(); j++){
long long diffx = tarx - curx;
long long diffy = tary - cury;
if(abs(diffx) > abs(diffy)){
if(diffx >= 0){
ans+="R";
curx += arm[j];
}else{
ans+="L";
curx -= arm[j];
}
}else{
if(diffy >= 0){
ans+="U";
cury += arm[j];
}else{
ans+="D";
cury -= arm[j];
}
}
}
cout << ans << endl;
}
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <numeric>
#include <cmath>
#include <iomanip>
#include <cassert>
using namespace std;
#define ll long long
#define pb push_back
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
#define P pair<int,int>
int mx8[] = {0,0,1,-1,-1,1,-1,1};
int my8[] = {-1,1,0,0,-1,-1,1,1};
int mx4[] = {1,-1,0,0};
int my4[] = {0,0,-1,1};
ll mod = 1000000007;
int main(){
ios::sync_with_stdio(false);
ll n, x, m;
cin >> n >> x >> m;
vector<pair<ll,ll>> c(100005);
vector<int> A(100005);
ll a = x;
ll k = 0;
while(k < 100005){
if(c[a].first) break;
c[a].first++;
c[a].second = k;
A[k] = a;
a = a * a % m;
k++;
}
ll ans = 0,temp = 0;
if(n <= k) {
rep(i,n) ans += A[i];
cout << ans << endl;
return 0;
}
for(int i = 0; i < c[a].second; ++i) ans += A[i];
for(int i = c[a].second; i < k; ++i) temp += A[i];
temp *= ((n-c[a].second) / (k-c[a].second));
for(int i = c[a].second; i < c[a].second - 1 + (n-c[a].second+1) % (k-c[a].second); ++i) ans += A[i];
cout << ans + temp << endl;
}
| 0
| 47,077,352
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
int main() {
int n;
cin >> n;
vector<int> w(n);
rep(i, n) cin >> w[i];
int sum = 0;
rep(i, n) sum += w[i];
int ans = 1001001001;
for (int k = 1; k < n; ++k) {
int l = 0;
rep(i, k) l += w[i];
int r = sum - l;
ans = min(ans, abs(r - l));
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
void printN (int N);
int main()
{
int N;
std::cin >> N;
printN (N);
return 0;
}
void printN (int N)
{
for (int i = 0; i < N; ++i) {
int x, y, z;
std::cin >> x >> y >> z;
if (x * x + y * y == z * z) {
std::cout << "YES" << std::endl;
} else if (y * y + z * z == x * x) {
std::cout << "YES" << std::endl;
} else if (z * z + x * x == y * y) {
std::cout << "YES" << std::endl;
} else {
std::cout << "NO" << std::endl;
}
}
}
| 0
| 19,180,964
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define ALL(A) A.begin(),A.end()
void ALLIN1_NUMBER(vector<ll>& V)
{
for(auto& x : V)
{
cin >> x;
}
}
void ALLOUT2_WITHOUT_SPACE(vector<vector<ll>> V)
{
ll Vsize = V.size();
ll Visize = V[0].size();
for(ll i=0;i<Vsize;i++)
{
for(ll j=0;j<Visize;j++)
{
cout << V[i][j];
}
cout << endl;
}
}
template<class T>
void OUT0(T N)
{
cout << N << endl;
}
static const double pi = acos(-1.0);
double Cos(double D)
{
return cos(pi/180 * D);
}
pair<ll,ll> Graph(ll H, ll W, ll A, ll B)
{
for(ll i=H;i>=0;i--)
{
for(ll j=W;j>=0;j--)
{
if(A*H + (W-2*A)*i == B*W + (H-2*B)*j)
{
return make_pair(i,j);
}
}
}
return make_pair(-1,-1);
}
void Ans_OUT(ll H, ll W, ll A, ll B, pair<ll,ll> notA_notB)
{
if(notA_notB.first == -1)
{
OUT0("No");
}
else
{
vector<ll> tate(H,A);
for(ll i=0;i<notA_notB.first;i++)
{
tate[i] = W-A;
}
vector<ll> yoko(W,B);
for(ll i=0;i<notA_notB.second;i++)
{
yoko[i] = H-B;
}
vector<vector<ll>> graph(H,vector<ll>(W,0));
for(ll i=0;i<H;i++)
{
for(ll j=0;j<W;j++)
{
if(tate[i]>0 && yoko[j]>0)
{
graph[i][j] = 1;
tate[i]--;
yoko[j]--;
}
}
}
ALLOUT2_WITHOUT_SPACE(graph);
}
}
int main()
{
ll H,W,A,B;
cin >> H >> W >> A >> B;
pair<ll,ll> notA_notB = Graph(H,W,A,B);
Ans_OUT(H,W,A,B,notA_notB);
return 0;
}
|
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pqueue priority_queue
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
int N;
cin>>N;
ll A;
int num=0;
ll ans = 0;
for(int i=0;i<N;++i) {
cin>>A;
if(A==0) {
num = 0;
}
else {
if(num==1) {
ans += 1;
A--;
ans += A/2;
num = A%2;
}
else {
ans += A/2;
num = A%2;
}
}
}
cout<<ans<<endl;
}
| 0
| 39,038,079
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(ll i = 0, i##_len = (n); i < i##_len; ++i)
#define rep2(i, x, n) for(ll i = x, i##_len = (n); i < i##_len; ++i)
#define all(n) begin(n), end(n)
using ll = long long;
using P = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vs = vector<string>;
using vc = vector<char>;
using vb = vector<bool>;
using vd = vector<double>;
vi dir = {-1, 0, 1, 0, -1, -1, 1, 1, -1};
int main() {
ll a, b;
cin >> a >> b;
cout << (a + b + 1) / 2 << endl;
}
|
#include <bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
const ull mod = 1e9+7;
#define fo(i, n) for (int i = 0; i < n; i++)
#define sc(n) scanf("%d", &n)
using namespace std;
void solve() {
int n, k; sc(n); sc(k);
int a[n]; fo(i, n) sc(a[i]);
int g = 0;
int el = 0;
for (int i = 0; i < n; i++) {
for (int j = i+1; j < n; j++) {
if (a[i] > a[j]) g++;
else if (a[i] < a[j]) el++;
}
}
ull num1 = (ull) k * (k+1);
num1 /= 2; num1 %= mod;
ull num2 = (ull) k * (k-1);
num2 /= 2; num2 %= mod;
num1 *= (ull) g; num1 %= mod;
num2 *= (ull) el; num2 %= mod;
ull ans = (num1 + num2) % mod;
cout << ans;
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 0
| 85,152,352
|
#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 ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
int main()
{
int N,M; cin >> N >> M;
int ans = 0, sum = 0;
vector<int> A(N);
REP(i,N){
cin >> A[i];
sum += A[i];
}
REP(i,N){
if(A[i] * 4 * M >= sum) ans++;
}
if(ans >= M)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define PI 4*atan(1)
#define INF 1e8
int dx[4] = {1,0,-1,0};
int dy[4] = {0,1,0,-1};
int main(){
int n;
while(cin >> n, n){
vector<int> a(n);
for(int i = 0; i < n; i++){
cin >> a[i];
}
int ans = INF;
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
if(i != j){
ans = min(ans, abs(a[i]-a[j]));
}
}
}
cout << ans << endl;
}
}
| 0
| 17,109,625
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, T;
cin >> n >> T;
vector<int> t(n);
for (int i = 0; i < n; i++) cin >> t[i];
int pushed = t[0];
int tot = 0;
for (int i = 1; i < n; i++) {
tot += min(T, t[i] - pushed);
pushed = t[i];
}
tot += T;
cout << tot << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int a, b, c, d;
cin >> a >> b >> c >> d;
int a1;
int a2;
if( b > a) a1 = b-a;
else if(a==b) a1 = d;
else a1 = a-b;
if(c > b) a2 = c - b;
else if(b==c) a2 = d;
else a2 = b-c;
int c1;
if(c > a) c1 = c-a;
else if(a==c) c1 = c1 = d;
else c1 = a-c;
if(a1 <= d && a2 <= d) cout << "Yes" << endl;
else if (c1 <= d) cout << "Yes" << endl;
else cout << "No" << endl;
}
| 0
| 33,734,194
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
sort(s.begin(), s.end());
sort(t.rbegin(), t.rend());
bool can = true;
int a = min(s.size(), t.size());
for(int i=0; i<a; i++) {
if(s[i]>t[i]) {
can = false;
break;
}
else if(s[i]<t[i]) break;
else if(i==a-1) {
if(s.size()>=t.size()) {
can = false;
break;
}
}
}
if(can) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
#define srep(i,s,t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(),a.end()
#define rrng(a) a.rbegin(),a.rend()
#define maxs(x,y) (x = max(x,y))
#define mins(x,y) (x = min(x,y))
#define limit(x,l,r) max(l,min(x,r))
#define lims(x,l,r) (x = max(l,min(x,r)))
#define isin(x,l,r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)),x.end())
#define show(x) cout<<#x<<" = "<<x<<endl;
#define PQ(T) priority_queue<T,v(T),greater<T> >
#define bn(x) ((1<<x)-1)
#define dup(x,y) (((x)+(y)-1)/(y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int,int> P;
typedef tuple<int,int,int> T;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
typedef vector<T> vt;
map<int,int> mp;
int n;
int f(int i) {
i %= n;
if (mp.count(i)) return mp[i];
cout<<i<<endl;
string res;
cin>>res;
if (res[0] == 'V') exit(0);
return mp[i] = (res[0] == 'M');
}
int g(int i, int j) { return (j-i+n)%n;}
int main() {
scanf("%d",&n);
int l = 0, r = n/2;
int a = f(l);
int b = f(r);
if ((a^b) == g(l,r)%2) {
swap(l,r); r += n;
}
while (1) {
int c = (l+r)>>1;
if ((f(l)^f(c)) == g(l,c)%2) l = c;
else r = c;
}
return 0;
}
| 0
| 15,857,978
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MOD 998244353
#define rep(i,a,b) for(ll i=a;i<b;++i)
#define rrep(i,a,b) for(ll i=a;i>b;--i)
#define vi vector<int>
#define vl vector<ll>
#define ld long double
#define vvi vector<vector<int>>
#define vvl vector<vector<long long>>
#define pii pair<int,int>
#define pll pair<long,long>
#define vpii vector<pii>
#define vpll vector<pll>
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define PI 3.1415926535897932384626433832795
#define fix(f,n) fixed<<setprecision(n)<<f
#define all(x) x.begin(),x.end()
#define endl "\n"
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
ll newmod(ll a,ll b)
{
return ((a%b)+b)%b;
}
ll powM(ll a,ll b,ll m )
{
a%=m;
ll ans=1LL;
while(b)
{
if(b&1)ans=ans*a%m;
a=a*a%m;
b>>=1;
}
return ans;
}
ll poww(ll a,ll b)
{
ll ans=1;
while(b)
{
if(b&1)ans=ans*a;
a=a*a;
b>>=1;
}
return ans;
}
const ll N=5e5+5;
ll sp[N];
void sieve(){
for(int i=2;i<N;i++)sp[i]=i;
for(int i=2;i*i<N;i++){
if(sp[i]==i){
for(int j=i*i;j<N;j+=i){
sp[j]=i;
}
}
}
}
ll fac[N],inv[N];
ll p=1e9+7;
void fill(){
fac[0]=inv[0]=1;
for(int i=1;i<N;i++){
fac[i]=fac[i-1]*i%p;
inv[i]=powM(fac[i],p-2,p);
}
}
ll c(ll a,ll b,ll p){
if(a<b)return 0;
return (fac[a]*inv[a-b]%p)*(inv[b])%p;
}
ll dp[3005][3005][2];
int main()
{
IOS;
ll n,x=0;
cin>>n;
vl a(n+1);
for(int i=1;i<=n;i++){
cin>>a[i];
x+=max(0LL,a[i]-a[i-1]);
}
cout<<x<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vl>;
using vb = vector<bool>;
using P = pair<ll, ll>;
template <typename T> using pq = priority_queue<T>;
template <typename T> using minpq = priority_queue<T, vector<T>, greater<T>>;
template <typename T, typename K> using ump = unordered_map<T, K>;
const ll dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const ll mod = 1000000007;
const ll inf = ll(1e9);
const ll e5 = ll(1e5);
const ll ll_inf = ll(1e9) * ll(1e9);
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repr(i, n) for (ll i = ll(n - 1); i >= 0; i--)
#define each(i, mp) for (auto &i : mp)
#define eb emplace_back
#define F first
#define S second
#define all(obj) (obj).begin(), (obj).end()
template <class T> ostream &operator<<(ostream &out, const vector<T> &list) {
ll n = list.size();
rep(i, n) out << list[i] << ' ';
return out;
}
template <class T> istream &operator>>(istream &in, vector<T> &list) {
ll n = list.size();
rep(i, n) in >> list[i];
return in;
}
template <class T> ostream &operator<<(ostream &out, const vector<vector<T>> &list) {
ll n = list.size();
rep(i, n) out << list[i] << '\n';
return out;
}
void solve() {
vl arr{1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
ll k;
cin >> k;
cout << arr[k - 1] << '\n';
}
int main() {
#ifdef MY_DEBUG
while (true) {
#endif
solve();
#ifdef MY_DEBUG
}
#endif
return 0;
}
| 0
| 1,354,260
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int main(){
int i,j,l,n,k;
cin >> n >> k;
if((n-1)*(n-2)/2<k){
cout << -1 << endl;
return 0;
}
int x[110][110];
for(i=0;i<n;i++){
for(j-0;j<n;j++){
x[i][j]=0;
}
}
for(i=1;i<n;i++){
x[0][i]=1;
}
k=(n-1)*(n-2)/2-k;
cout << k+n-1 << endl;
for(i=0;i<k;i++){
int res=0;
for(j=0;j<n;j++){
for(l=j+1;l<n;l++){
if(x[j][l]==0){
x[j][l]=1,res=1;
break;
}
}
if(res==1){
break;
}
}
}
for(i=0;i<n;i++){
for(j=i+1;j<n;j++){
if(x[i][j]==1){
cout << i+1 << ' ' << j+1 << endl;
}
}
}
}
|
#include<iostream>
using namespace std;
int main()
{
int ans[5];
cin>>ans[0]>>ans[1]>>ans[2]>>ans[3]>>ans[4];
for(int i=0;i<5;i++)
{
for(int j=4;j>i;j--)
{
if(ans[j]>ans[j-1])
{
int tmp=ans[j];
ans[j]=ans[j-1];
ans[j-1]=tmp;
}
}
}
for(int i=0;i<5;i++)
{
if(i!=0) cout<<" ";
cout<<ans[i];
}
cout<<endl;
return 0;
}
| 0
| 73,357,129
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double lb;
#define mod 1000000007
#define REP(i,j,n) for (int i=j;i<(n);i++)
#define RREP(i,n) for (int i = n; 0<i;i--)
#define print(out) cout<< out << "\n";
int main(){
string S1,S2;cin>>S1>>S2;
int s1_l=S1.length(), s2_l=S2.length();
int dp[s1_l+1][s2_l+1];
REP(s1,0,s1_l+1)dp[s1][0]=s1;
REP(s2,0,s2_l+1)dp[0][s2]=s2;
REP(s1,1,s1_l+1)REP(s2,1,s2_l+1){dp[s1][s2]=
min({dp[s1-1][s2]+1,dp[s1][s2-1]+1,dp[s1-1][s2-1]+((S1[s1-1]==S2[s2-1])?0:1)});
}
print(dp[s1_l][s2_l])
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define MOD 1000000007LL
#define rep(i, n) for(ll (i) = 0LL;(i) < (ll)(n);(i)++)
#define rep2(i, s, e) for(ll (i) = (ll)(s);(i) < (ll)(e);(i)++)
#define repi(i, n) for(ll (i) = 0LL;(i) <= (ll)(n);(i)++)
#define repi2(i, s, e) for(ll (i) = (ll)(s);(i) <= (ll)(e);(i)++)
#define per(i, n) for(ll (i) = (ll)(n) - 1LL;(i) >= 0LL;(i)--)
#define per2(i, s, e) for(ll (i) = (ll)(s) - 1LL;(i) >= (ll)(e);(i)--)
#define peri(i, n) for(ll (i) = (ll)(n);(i) >= 0LL;(i)--)
#define peri2(i, s, e) for(ll (i) = (ll)(s);(i) >= (ll)(e);(i)--)
#define iter(i, it) for(auto &(i): (it))
template<typename T, typename U> ostream& operator<<(ostream &s, const pair<T, U> m) {
cout << "(" << m.first << ", " << m.second << ")";
return s;
}
template<typename T, typename U> ostream& operator<<(ostream &s, const map<T, U> m) {
ll c = 0;
cout << "{ ";
iter(i, m) cout << i << (c++ == m.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const vector<T> &v) {
cout << "{ ";
rep(i, v.size()) cout << v[i] << (i == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const list<T> &v) {
ll c = 0;
cout << "{ ";
iter(i, v) cout << i << (c++ == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
int main(void) {
ll Y, M;
string S;
cin >> S;
Y = stoll(S.substr(0, 4));
M = stoll(S.substr(5, 2));
if(Y >= 2019 && M >= 5) cout << "TBD";
else cout << "Heisei";
cout << endl;
return 0;
}
| 0
| 24,802,594
|
#include <stdio.h>
int main(){
int a, b, c, i,j=0,check=0;
int yakusu[1000];
scanf("%d%d%d", &a, &b, &c);
for (i = 1;; i++){
if (c%i == 0){
yakusu[j] = i;
if (i == c){
break;
}
j++;
}
}
for (i = 0; i <= j; i++){
if (a <= yakusu[i] && yakusu[i] <= b){
check++;
}
}
printf("%d\n", check);
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
int n;cin>>n;
int ans=0;
for(int c=1;c<n;++c){
int ab=n-c;
int cnt=0;
for(int i=1;i*i<=ab;++i){
if(ab%i==0){
cnt++;
if(i!=ab/i) cnt++;
}
}
ans+=cnt;
}
cout<<ans<<endl;
return 0;
}
| 0
| 64,156,877
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,ini,n) for(int64_t i=ini;i<n;i++)
#define _rep(i,ini,n) for(int64_t i=ini;i>=n;i--)
#define ToEnd(a) a.begin(),a.end()
uint64_t MOD=1000000007;
int main(){
int64_t X,Y,A,B,C; cin>>X>>Y>>A>>B>>C;
vector<int64_t> P(A),Q(B),R(C);
rep(a,0,A) cin>>P.at(a);
rep(b,0,B) cin>>Q.at(b);
rep(c,0,C) cin>>R.at(c);
sort(ToEnd(P),greater<int64_t>());
sort(ToEnd(Q),greater<int64_t>());
sort(ToEnd(R),greater<int64_t>());
vector<int64_t> Ans;
rep(x,0,X) Ans.push_back(P.at(x));
rep(y,0,Y) Ans.push_back(Q.at(y));
sort(ToEnd(Ans));
rep(i,0,min(X+Y,C)){
if(Ans.at(i)<R.at(i)) Ans.at(i)=R.at(i);
else break;
}
int64_t ans=accumulate(ToEnd(Ans),0LL);
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pa pair<int, int>
#define pal pair<long long, long long>
#define pali pair<long long, int>
#define pad pair<double, double>
#define pb push_back
#define mp make_pair
#define COUT(v) \
for (int64_t i = 0; i < (v).size(); ++i) \
{ \
cout << v.at(i) << endl; \
}
#define REP(i, n) for (int64_t i = 0; i < n; ++i)
#define FOR(i, r, n) for (int64_t i = (r); i < n; ++i)
#define VIN(v) \
for (int64_t i = 0; i < (v).size(); ++i) \
{ \
cin >> (v).at(i); \
}
typedef vector<bool> bvec;
typedef vector<int> ivec;
typedef vector<long long> lvec;
typedef vector<double> dvec;
typedef vector<pa> pavec;
typedef vector<pali> palivec;
typedef vector<pal> palvec;
typedef vector<vector<bool> > bmat;
typedef vector<vector<int> > imat;
typedef vector<vector<long long> > lmat;
typedef vector<string> svec;
typedef vector<vector<string> > smat;
const ll infll = (1LL << 60) - 1;
const int inf = (1 << 30) - 1;
const ll MOD = 1000000007;
ll gcd(ll x, ll y)
{
ll r = x % y;
if (r == 0)
return y;
else
return gcd(y, r);
}
ll lcm(ll x, ll y)
{
return x * y / gcd(x, y);
}
lvec mfactor(ll n)
{
bvec ip(n, true);
lvec mf(n, -1);
ip[0] = false;
ip[1] = false;
mf[0] = 0;
mf[1] = 1;
REP(i, n)
{
if (ip[i])
{
mf[i] = i;
for (ll j = i * i; j < n; j += i)
{
ip[j] = false;
if (mf[j] == -1)
mf[j] = i;
}
}
}
return mf;
}
palivec get_prime(ll n, const lvec &mf)
{
palivec plist;
while (n != 1)
{
int cnt = 0;
ll m = mf[n];
while (mf[n] == m)
{
cnt++;
n /= m;
}
plist.pb(pali(m, cnt));
}
return plist;
}
void COMinit(int m, lvec &fac, lvec &finv)
{
lvec inv(m);
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < m; 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 pow_mod(ll a, ll n)
{
ll x = 1;
while (n > 0)
{
if (n & 1)
{
x = x * a % MOD;
}
a = a * a % MOD;
n >>= 1;
}
return x;
}
ll COM(int n, int k, const lvec &fac, const lvec &finv)
{
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return (fac[n] * (finv[k] * finv[n - k] % MOD)) % MOD;
}
ll modinv(ll a, ll m)
{
ll b = m, u = 1, v = 0;
while (b)
{
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll n, k;
cin >> n >> k;
lvec a(n), s(n);
map<int, int> mmap, mmap2;
for (int i=0; i<n; i++){
cin >> a[i];
}
s[0] = a[0];
for (int i=1; i<n; i++) s[i] = (s[i-1]+a[i]);
ll ans=0;
if(a[0]%k==1) ++ans;
for (int i=1; i<n; i++){
mmap[(s[i-1]-i)%k]++;
if(mmap.count((s[i]-i-1)%k)){
ans+=mmap[(s[i]-i-1)%k];
}
if(i+1>k){
mmap2[(s[i-k]-(i-k+1))%k]++;
if(mmap2.count((s[i]-i-1)%k)) {
ans-=mmap2[(s[i]-i-1)%k];
}
}
if(s[i]%k == i+1) ++ans;
}
cout << ans << endl;
}
| 0
| 96,795,742
|
#include <iostream>
using namespace std;
int main()
{
int n,x,t,count=0;
cin>>n>>x>>t;
if(n%x>0)
{count=((n/x)+1)*t;}
else{
count=(n/x)*t;
}
cout<<count<<"\n";
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
using lint=long long;
int main(){
int n; scanf("%d",&n);
vector<int> a(n),b(n);
rep(i,n) scanf("%d",&a[i]);
rep(i,n) scanf("%d",&b[i]);
lint asum=0,bsum=0;
rep(i,n){
asum+=a[i];
bsum+=b[i];
}
if(asum>bsum) return puts("No"),0;
lint k1=0,k2=0;
rep(i,n){
if(a[i]>b[i]){
k2+=a[i]-b[i];
}
else if(a[i]<b[i]){
if((b[i]-a[i])%2==0){
k1+=(b[i]-a[i])/2;
}
else{
k1+=(b[i]-a[i]+1)/2;
k2++;
}
}
}
lint m=bsum-asum;
if(k1<=m && k2<=m && 2*(m-k1)==m-k2){
puts("Yes");
}
else puts("No");
return 0;
}
| 0
| 54,291,497
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(ri,n) for(int ri = (int)(n-1); ri >= 0; ri--)
#define rep2(i,x,n) for(int i = (int)(x); i < (int)(n); i++)
#define rrep2(ri,x,n) for(int ri = (int)(n-1); ri >= (int)(x); ri--)
#define repit(itr,x) for(auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr,x) for(auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
const string G = "GREATER";
const string L = "LESS";
const string E = "EQUAL";
int main(){
string a, b;
cin >> a >> b;
if(a.size() > b.size()) cout << G << endl;
else if(a.size() < b.size()) cout << L << endl;
else{
if(a > b) cout << G << endl;
else if(a < b) cout << L << endl;
else cout << E << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(int)(n); i++)
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int h, w; cin >> h >> w;
vector<string> g(h);
vector<bool> ish(h), isw(w);
rep(i,h) cin >> g.at(i);
rep(i,h) {
int cnt = 0;
rep(j,w) {
if (g.at(i).at(j) == '.') cnt++;
}
if (cnt == w) ish.at(i) = true;
}
rep(i,w) {
int cnt = 0;
rep(j,h) {
if (g.at(j).at(i) == '.') cnt++;
}
if (cnt == h) isw.at(i) = true;
}
rep(i,h) {
if (ish.at(i)) continue;
rep(j,w) {
if (isw.at(j)) continue;
cout << g.at(i).at(j);
}
cout << endl;
}
return 0;
}
| 0
| 81,112,848
|
#include<iostream>
using namespace std;
int main()
{
int n,m;
cin>>n>>m;
for(int i=0;i<m;i++)
{
int a;
cin>>a;
n-=a;
if(n<0)
{
cout<<"-1";
return 0;
}
}
cout<<n;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e15;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const ll MOD = 1e9+7;
int main(){
ll N, MAX = 0; cin >> N;
multiset<ll> ST;
set<ll> ban;
for(int i = 0; i < N; i++){
ll x; cin >> x;
MAX = max(MAX, x);
if(ST.find(x) != ST.end()) ban.insert(x);
ST.insert(x);
}
for(auto x : ST){
ll i = 2;
while(x*i <= MAX){
ST.erase(x*i);
i++;
}
}
for(auto x : ban) ST.erase(x);
cout << ST.size() << endl;
}
| 0
| 89,000,886
|
#include<bits/stdc++.h>
#define int long long
using namespace std;
string s[45][45];
signed main(){
int a,b;
cin>>a>>b;
for(int i=0;i<a;i++){
for(int j=0;j<b;j++){
cin>>s[i][j];
}
}
for(int i=0;i<a;i++){
for(int j=0;j<b;j++){
if(s[i][j]=="snuke"){
cout<<char(j+'A')<<i+1<<endl;
return 0;
}
}
}
}
|
#include <vector>
#include <iostream>
using namespace std;
#define ll long long
vector<int> adj[100001];
ll ans[100001][2];
ll MOD = 1000000007;
void dfs(int i,int par){
ll prodW = 1;
ll prodTot = 1;
for(int next : adj[i]){
if(next!=par){
dfs(next,i);
prodW*=ans[next][0];
prodTot*=(ans[next][0]+ans[next][1]);
prodW%=MOD;
prodTot%=MOD;
}
}
ans[i][1] = prodW;
ans[i][0] = prodTot;
}
int main(){
int n;
cin >> n;
for(int i=0;i<n-1;i++){
int x,y;
cin >> x >> y;
x--; y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
dfs(0,-1);
ll ret = ans[0][0]+ans[0][1];
ret%=MOD;
cout << ret << endl;
}
| 0
| 88,545,210
|
#include "bits/stdc++.h"
#define F first
#define S second
using namespace std;
#define ll long long
#define ld long double
#define pb push_back
#define eb emplace_back
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
ll n = 0, k = 0;
cin >> n >> k;
ll ar[n];
ll ans = 0;
for (ll i = 0; i < n; ++i) cin >> ar[i];
sort(ar, ar + n);
for (ll i = 0; i < n - k; ++i) {
ans += ar[i];
}
cout << ans;
}
|
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include<bits/stdc++.h>
using namespace std ;
const int N = 1e5+5 ;
int n ,l ,q ,x[N] ,nxt[N] ,lst[N] ;
int main(){
scanf("%d",&n);
int sq = sqrt(n) ;
for(int i=1;i<=n;++i) scanf("%d",x+i);
scanf("%d",&l);
for(int i=1;i<=n;++i){
int st = i ,en = n ;
while(st<en){
int mid = (st+en+1)/2 ;
if(x[mid]-x[i]>l) en = mid-1 ;
else st = mid ;
}
nxt[i] = st ;
}
for(int i=1;i<=n;++i){
int cur = i ;
for(int j=0;j<sq;++j){
if(cur==n){
cur = 1e9+5 ;
break ;
}
cur = nxt[cur] ;
}
lst[i] = cur ;
}
lst[n] = 1e9+5 ;
scanf("%d",&q);
while(q--){
int a,b;
scanf("%d%d",&a,&b);
if(a>b) swap(a,b);
if(a==b){
puts("0");
continue ;
}
int ans = 0 ;
while(lst[a]<=b){
a = lst[a] ;
ans += sq ;
}
while(a<b){
++ans ;
a = nxt[a] ;
}
printf("%d\n",ans);
}
return 0;
}
| 0
| 14,165,128
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
typedef long long ll;
int main(){
int n,m; cin>>n>>m;
cout<<(ll)abs(n-2)*abs(m-2)<<endl;
}
|
#include<algorithm>
#include<bitset>
#include<cmath>
#include<complex>
#include<deque>
#include<functional>
#include<iomanip>
#include<iostream>
#include<iterator>
#include<map>
#include<numeric>
#include<queue>
#include<set>
#include<stack>
#include<string>
#include<unordered_map>
#include<unordered_set>
#include<utility>
#include<vector>
using namespace std;
typedef long long ll;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
#define ALL(x) (x).begin(),(x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define D()
#define INF 1000000000000
#define MOD 10000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define INITA(a,i,j,v) for(ll k=i;k<=j;k++){a[k]=v;}
int main() {
int n, m; cin >> n >> m;
int a[200001]; INITA(a, 0, 200000, 0);
int b[200001]; INITA(b, 0, 200000, 0);
set<int> st;
REP(i, m) {
cin >> a[i] >> b[i];
if (a[i] == 1) {
st.insert(b[i]);
}
if (b[i] == 1) {
st.insert(a[i]);
}
}
REP(i, m) {
if ((st.find(a[i]) != st.end()) && (b[i] == n)) {
cout << "POSSIBLE" << endl;
return 0;
} else if ((st.find(b[i]) != st.end()) && (a[i] == n)) {
cout << "POSSIBLE" << endl;
return 0;
}
}
cout << "IMPOSSIBLE" << endl;
return 0;
}
| 0
| 73,424,417
|
#include<bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
#define FOR(i,a,b) for (int i = a; i < b; ++i)
#define FORR(i,a,b) for (int i = b - 1; i >= a; --i)
#define REP(i,n) FOR(i,0,n)
#define REPR(i,n) FORR(i,0,n)
int main() {
int N, K;
cin >> N >> K;
int d, A;
vector<int> check(N, 1);
REP(k, K) {
cin >> d;
REP(i, d) {
cin >> A;
check[A-1] = 0;
}
}
cout << accumulate(check.begin(), check.end(), 0) << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
vector<int> adj[100001];
bool visited[100001];
int ans[100001];
void bfs(){
queue<int> q;
q.push(1);
visited[1] = true;
while(q.size()){
int cur = q.front(); q.pop();
for(auto i : adj[cur]){
if(!visited[i]){
ans[i] = cur;
q.push(i);
visited[i] = true;
}
}
}
}
int main()
{
memset(visited,false,sizeof(visited));
memset(ans,0,sizeof(ans));
int nodes,edges;
cin >> nodes >> edges;
for(int i=0;i<edges;i++)
{
int u,v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
bfs();
cout << "Yes\n";
for(int i=2;i<=nodes;i++)
cout << ans[i] << "\n";
}
| 0
| 95,477,026
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second
#define sz(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()
#define yn(x) ((x) ? "YES" : "NO")
typedef pair <int, int> ii;
typedef pair <int, ii> iii;
const int siz = 1e5 + 10;
const int SIZ = 1e5 + 10;
const int mod = 1e9 + 7;
const int maxx = 2e9;
const int MAXX = 1e18;
const string file = "3";
int quickPow(int x, int n) {
if (n == 0) {
return 1;
}
int t = quickPow(x, n / 2);
(t *= t) %= mod;
if (n % 2 == 0) {
return t;
}
return (t * x) % mod;
}
int fact[SIZ];
void precalc() {
fact[0] = 1;
for (int i = 1; i < SIZ; i++) {
fact[i] = (fact[i - 1] * i) % mod;
}
}
int choose(int n, int k) {
if (n < k) {
return 0;
}
return ((fact[n] * quickPow((fact[n - k] * fact[k]) % mod, mod - 2)) % mod);
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
precalc();
int n;
cin >> n;
int d;
map <int, int> mp;
for (int i = 1; i <= n + 1; i++) {
int a;
cin >> a;
if (mp.find(a) != mp.end()) {
d = i - mp[a] + 1;
}
else {
mp[a] = i;
}
}
for (int k = 1; k <= n + 1; k++) {
cout << (choose(n + 1, k) - choose(n + 1 - d, k - 1) + mod) % mod << "\n";
}
return 0;
}
|
#pragma region header
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for(int i = (int)(n); i > 0; i--)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define resort(v) sort((v).rbegin(), (v).rend())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
using ll = long long;
using P = pair<int, int>;
int dx[] = {1,0,-1,0};
int dy[] = {0,1,0,-1};
constexpr ll mod = 1e9+7;
constexpr int inf = INT32_MAX/2;
constexpr ll INF = LLONG_MAX/2;
constexpr long double eps = DBL_EPSILON;
constexpr long double pi = 3.141592653589793238462643383279;
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;
}
ll fact(int i) {
if (i == 0) return 1;
return (fact(i - 1)) * i % mod;
}
ll gcd(ll a, ll b) {
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
return a * b / gcd(a, b);
}
int keta(ll n) {
if(n == 0) return 1;
int count = 0;
while(n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) {
ll sum = 0;
while(n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
#pragma endregion
signed main() {
int n,k;cin >> n >> k;
int r,s,p;cin >> r >> s >> p;
string t;cin >> t;
int ans = 0;
rep(i, t.size()) {
if(i>=k) {
if(t[i]==t[i-k]) {
t[i]='z';
continue;
}
}
if(t[i]=='r') ans+= p;
else if(t[i]=='p') ans += s;
else if(t[i]=='s') ans+=r;
}
cout << ans << endl;
}
| 0
| 58,055,556
|
#include <iostream>
#include <algorithm>
#include <functional>
#include <utility>
using namespace std;
int main() {
int n, m;
while(true) {
pair<int, int> guard[100000];
int exp = 0;
cin >> n >> m;
if(n == 0 && m == 0) {
break;
}
for(int i = 0; i < n; ++i) {
cin >> guard[i].second >> guard[i].first;
exp += guard[i].second * guard[i].first;
}
sort(guard, guard + n, greater<pair<int, int> >());
for(int i = 0; i < n; ++i) {
int cost = min(guard[i].second, m);
m -= cost;
exp -= cost * guard[i].first;
if(m <= 0) {
break;
}
}
cout << exp << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define arep(i,x,n) for(int i=int(x);i<(int)(n);i++)
#define rep(i,n) for(long long i = 0;i < n;++i)
#define rrep(i,n) for(int i=int(n);i>0;i--)
#define fs first
#define sc second
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define pi 3.141592653589793
#define eps 0.00000001
#define INF 1e9+5
using ll = long long;
using P=pair<int,int>;
using lP=pair<ll,ll>;
using fP=pair<double,double>;
using PPI=pair<P,int>;
ll const mod=1e9+7;
const ll MAX=1000005;
using vi=vector<int>;
using vl=vector<ll>;
using vc=vector<char>;
using vd=vector<double>;
using vs=vector<string>;
using vp=vector<P>;
using vb=vector<bool>;
using vvi =vector<vector<int>>;
using vvl =vector<vector<ll>>;
using vvd=vector<vector<double>>;
using vvc=vector<vector<char>>;
using vvp =vector<vector<P>>;
using vvb=vector<vector<bool>>;
template <typename T>
bool chmax(T &a, const T b){if(a < b){a = b; return true;} return false;}
template <typename T>
bool chmin(T &a, const T b){if(a > b){a = b; return true;} return false;}
int main(){
int x,y,a,b,c;
cin>>x>>y>>a>>b>>c;
priority_queue<int,vi,greater<int>>red,green;
vi p(a),q(b),r(c);
rep(i,a)cin>>p[i];
rep(i,b)cin>>q[i];
rep(i,c)cin>>r[i];
sort(rall(p));
sort(rall(q));
sort(rall(r));
rep(i,x){
red.push(p[i]);
}
rep(i,y){
green.push(q[i]);
}
for(int x:r){
int tr=red.top(),tg=green.top();
if(tr<=tg&&tr<x){
red.pop();
red.push(x);
}
else if(tg<tr&&tg<x){
green.pop();
green.push(x);
}
}
ll ans=0;
rep(i,x){
ans+=red.top();
red.pop();
}
rep(i,y){
ans+=green.top();
green.pop();
}
cout<<ans<<endl;
return 0;
}
| 0
| 48,172,034
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int n, t;
cin >> n >> t;
int tm[n];
for (int i = 0; i < n; i++) cin >> tm[i];
ll ans = 0;
for (int i = 0; i < n - 1; i++) {
ans += min(t, tm[i + 1] - tm[i]);
}
ans += t;
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin>>n;
string s,x;
vector <int> a(26,0);
cin>>s;
for(int i=0;i<s.size();i++) a[s[i]-'a']++;
for(int i=0;i<n-1;i++)
{
cin>>x;
vector <int> b(26,0);
for(int j=0;j<x.size();j++)
b[x[j]-'a']++;
for(int j=0;j<26;j++)
a[j]=min(a[j],b[j]);
}
for(int i=0;i<26;i++)
for(int j=0;j<a[i];j++)
{
cout<<(char)(i+'a');
}
return 0;
}
| 0
| 78,563,274
|
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int n;
while(cin >> n, n) {
int x[n];
for (int i=0; i<n; i++)
cin >> x[i];
int ans = -(1<<30);
for (int i=0; i<n; i++) {
int sum = 0;
for (int j=i; j<n; j++) {
sum += x[j];
ans = max(ans, sum);
}
}
cout << ans << endl;
}
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <climits>
#include <queue>
using namespace std;
const int WHITE = 0, GRAY = 1, BLACK = 2;
struct BFS {
int n;
vector<vector<int>> g;
vector<int> depth;
vector<int> state;
int time = 0;
BFS(int n) : n(n) {
g.assign(n, vector<int>());
depth.assign(n, -1);
state.assign(n, WHITE);
}
void addEdge(int u, int v) {
g[u].push_back(v);
}
void bfs(int s) {
queue<int> q;
state[s] = GRAY;
depth[s] = 0;
q.push(s);
while (!q.empty()) {
int u = q.front();
q.pop();
if (state[u] == BLACK) {
return;
}
for (int v : g[u]) {
if (state[v] == WHITE) {
state[v] = GRAY;
depth[v] = depth[u] + 1;
q.push(v);
}
}
state[u] = BLACK;
}
}
void print() {
for (int i = 0; i < n; i++) {
cout << i << ":";
for (int v : g[i]) {
cout << v << " ";
}
cout << endl;
}
}
};
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
BFS dfs(n);
for (int i = 0; i < n; i++) {
int u, k;
cin >> u >> k;
u--;
for (int j = 0; j < k; j++) {
int v;
cin >> v;
v--;
dfs.addEdge(u, v);
}
}
dfs.bfs(0);
for (int i = 0; i < n; i++) {
cout << (i + 1) << " " << dfs.depth[i] << endl;
}
return 0;
}
| 0
| 89,005,178
|
#include <iostream>
using namespace std;
void print(int *p, int n)
{
cout << p[0];
for (int i = 1; i < n; i++) cout << " " << p[i];
cout << endl;
}
int selectionsort(int *p, int n)
{
int minj, j, v;
int count = 0;
for (int i = 0; i < n; i++)
{
minj = i;
for (j = i; j < n; j++) if (p[j] < p[minj]) minj = j;
if (minj != i)
{
v = p[i];
p[i] = p[minj];
p[minj] = v;
count++;
}
}
return count;
}
int main(void)
{
int A[100];
int N;
cin >> N;
for (int i = 0; i < N; i++) cin >> A[i];
int count = selectionsort(A, N);
print(A, N);
cout << count << endl;
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
typedef struct{
int x,y,t;
} acord_t;
int main(void)
{
int N;
cin >> N;
acord_t point[N];
for(int i=0; i<N; i++){
cin >> point[i].t;
cin >> point[i].x;
cin >> point[i].y;
}
for(int j=0; j<N; j++){
int x_dis,y_dis,t_dis;
if(j==0){
x_dis = point[j].x;
y_dis = point[j].y;
t_dis = point[j].t;
}else{
x_dis = point[j].x - point[j-1].x;
y_dis = point[j].y - point[j-1].y;
t_dis = point[j].t - point[j-1].t;
}
int x_front,x_back,y_front,y_back;
if((t_dis-x_dis-y_dis) %2 != 0){
cout << "No\n";
return 0;
}
int x_back_min, y_back_min;
if(x_dis>0) x_back_min = 0;
else x_back_min = -x_dis;
if(y_dis>0) y_back_min = 0;
else y_back_min = -y_dis;
if(x_back_min+y_back_min > (t_dis-x_dis-y_dis)/2){
cout << "No\n";
return 0;
}
}
cout << "Yes\n";
return 0;
}
| 0
| 84,687,759
|
#include <bits/stdc++.h>
#include <atcoder/dsu>
using namespace std;
using namespace atcoder;
typedef long long int ll;
#define rep(i,n) for (int i = 0; i < (n); i++)
#define all(v) (v).begin(), (v).end()
#define sz(x) int(x.size())
const ll mod = 1000000007;
const ll INF = 1001001001001001000;
int main() {
int n,q; cin >> n >> q;
dsu uf(n);
rep(i,q) {
int t,u,v; cin >> t >> u >> v;
if (t == 0) {
uf.merge(u,v);
} else {
if (uf.same(u,v)) printf("%d\n", (int)1);
else printf("%d\n", (int)0);
}
}
return 0;
}
|
#include<iostream>
#include<string>
using namespace std;
int main(){
int t = 0;
int h = 0;
int n;
string str1, str2;
cin >>n;
for(int i = 0; i<n; i++){
cin >>str1 >>str2;
if(str1 == str2){
t += 1;
h += 1;
}else if(str1 > str2){
t += 3;
}else if(str1 < str2){
h += 3;
}
}cout <<t <<" " <<h <<endl;
return 0;
}
| 0
| 77,823,781
|
#include<bits/stdc++.h>
using namespace std;
#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define pb push_back
#define ll long long
#define pii pair<int,int>
int fac[9];
void init() {
int i=0;
fac[0]=1;
for(int i=1;i<9;i++)
fac[i]=i*fac[i-1];
}
void test_case()
{
int n,a=0,b=0;
cin>>n;
int p[n], q[n];
for(int i=0;i<n;i++) cin>>p[i];
for(int i=0;i<n;i++) cin>>q[i];
do {
a++;
} while(prev_permutation(p,p+n));
do {
b++;
} while(prev_permutation(q,q+n));
cout<<abs(a-b);
}
int main()
{
fastio
test_case();
}
|
#include "bits/stdc++.h"
#define MOD 1000000007
#define rep(i, n) for(ll i=0; i < (n); i++)
#define rrep(i, n) for(ll i=(n)-1; i >=0; i--)
#define ALL(v) v.begin(),v.end()
#define rALL(v) v.rbegin(),v.rend()
#define FOR(i, j, k) for(ll i=j;i<k;i++)
#define debug_print(var) cerr << #var << "=" << var <<endl;
#define DUMP(i, v)for(ll i=0;i<v.size();i++)cerr<<v[i]<<" "
using namespace std;
typedef long long int ll;
typedef vector<ll> llvec;
typedef vector<double> dvec;
typedef pair<ll, ll> P;
typedef long double ld;
struct edge{ll x, c;};
ll mod(ll a, ll mod){
ll res = a%mod;
if(res<0)res=res + mod;
return res;
}
ll modpow(ll a, ll n, ll mod){
ll res=1;
while(n>0){
if(n&1) res=res*a%mod;
a=a*a%mod;
n>>=1;
}
return res;
}
ll modinv(ll a, ll mod){
return modpow(a, mod-2, mod);
}
ll gcd(ll a, ll b){
ll r = a%b;
if(r==0) return b;
else return gcd(b, a%b);
}
bool is_prime(ll n){
ll i = 2;
if(n==1)return false;
if(n==2)return true;
bool res = true;
while(i*i <n){
if(n%i==0){
res = false;
}
i = i+1;
}
if(n%i==0)res=false;
return res;
}
struct UnionFind{
ll N;
llvec p;
llvec cnt;
UnionFind(ll n){
N = n;
p=llvec(N);
cnt=llvec(N, 0);
rep(i, N){
p[i] = i;
cnt[i] = 1;
}
}
void con(ll a, ll b){
P at = root(a);
P bt = root(b);
if(at.second!=bt.second){
if(at.first>bt.first){
swap(at, bt);
swap(a, b);
}
p[at.second] = bt.second;
cnt[bt.second]+=cnt[at.second];
p[a]=bt.second;
}
}
P root(ll a){
ll atmp = a;
ll c=0;
while(atmp!=p[atmp]){
atmp = p[atmp];
c++;
}
p[a] = atmp;
return {c, atmp};
}
bool is_con(ll a, ll b){
P at=root(a);
P bt=root(b);
return at.second == bt.second;
}
};
struct dijkstra{
ll N;
llvec d;
vector<vector<edge>> e;
dijkstra(ll n){
N = n;
e = vector<vector<edge>>(N);
}
void add_edge(ll from, ll to, ll cost){
e[from].push_back({to, cost});
}
void run(ll start){
priority_queue<P, vector<P>, greater<P>> que;
que.push({0, start});
d = llvec(N, 1e18);
d[start]=0;
while(!que.empty()){
P q = que.top();que.pop();
ll dc = q.first;
ll x = q.second;
if(dc>d[x]){
continue;
}else{
for(auto ip: e[x]){
if(d[ip.x]<=d[x]+ip.c){
continue;
}else{
d[ip.x]= d[x]+ip.c;
que.push({d[ip.x], ip.x});
}
}
}
}
}
};
int main(){
string s;
cin >> s;
while(!s.empty()){
s.pop_back();
if(s.size()%2!=0)continue;
ll t = s.size()/2;
if(s.substr(0, t)==s.substr(t,t)){
break;
}
}
cout << s.size();
return 0;
}
| 0
| 91,594,248
|
#include <bits/stdc++.h>
#define rep(i,n)for(long long i=0;i<(n);i++)
using namespace std;
typedef long long ll;
const int MOD=1e9+7;
const int MAX = 1000000;
const ll INF = (1LL << 31) - 1;
const double pi=acos(-1);
long double n,m,d,ans=0;
int main(){
cin >> n >> m >> d;
if(d==0){
ans=(m-1)/n;
}
else{
ans=2*(m-1)*(n-d)/pow(n,2);
}
cout << fixed << setprecision(10) << ans << endl;
}
|
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i=0;i<(n);++i)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define all(x) (x).begin(), (x).end()
#define PI 3.14159265358979323846264338327950L
using namespace std;
typedef long long ll;
typedef long double ld;
int gcd(int a,int b){
if(b==0) return a;
return gcd(b,a%b);
}
int main() {
long n,x;
cin>>n>>x;
vector<int> a(n);
rep(i,n){
cin>>a[i];
a[i]=abs(x-a[i]);
}
int ans=0;
rep(i,n){
ans=gcd(ans,a[i]);
}
cout<<ans;
}
| 0
| 5,960,260
|
#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>
using namespace std;
class Graph
{
public:
int solve();
};
int Graph::solve()
{
int n;
cin >> n;
vector<vector<int>> adj( n + 1, vector<int>( n + 1, 0 ) );
for ( auto i = 0; i < n; ++i )
{
int u;
int k;
int v;
cin >> u;
cin >> k;
for ( auto j = 0; j < k; ++j )
{
cin >> v;
adj[u][v] = 1;
}
}
for ( auto i = 1; i <= n; ++i )
{
for ( auto j = 1; j <= n; ++j )
{
if ( j > 1 ) cout << " ";
cout << adj[i][j];
}
cout << endl;
}
return 0;
}
int main()
{
Graph g;
g.solve();
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<=n;++i)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout<< (x) << " "
int main(){
int r,g,b,n;cin>>r>>g>>b>>n;
int rmax=n/r,gmax=n/g;
ll ans = 0;
for(int i=0;i<=rmax;i++){
for(int j=0;j<=gmax;j++){
if((n-r*i-g*j)>=0&&((n-r*i-g*j)%b==0))ans++;
}
}
co(ans);
}
| 0
| 77,561,611
|
#include<iostream>
#include<cstdio>
#include<deque>
#include<algorithm>
using namespace std;
typedef pair<int,int>P;
const int maxn=1e3+5;
int inf=500;
int h,w,n,sx,sy;
char s[maxn][maxn];
int book[maxn][maxn],goal[10];
int Next[4][2]={{0,1},{1,0},{-1,0},{0,-1}};
int judge(int row,int col)
{
if(row>=0&&row<h&&col>=0&&col<w){
return 1;
}
return 0;
}
int bfs()
{
int res=0;
deque<P>q;
for(int ci=0;ci<n;ci++){
fill(book[0],book[0]+maxn*maxn,inf);
q.push_back(P(sx,sy));
book[sx][sy]=0;
while(!q.empty()){
int x=q.front().first;
int y=q.front().second;
q.pop_front();
if((int)s[x][y]==49+ci){
goal[ci]=book[x][y];
sx=x;
sy=y;
break;
}
for(int i=0;i<4;i++){
int nx=x+Next[i][0];
int ny=y+Next[i][1];
if(judge(nx,ny)&&s[nx][ny]!='X'&&book[nx][ny]==inf){
q.push_back(P(nx,ny));
book[nx][ny]=book[x][y]+1;
}
}
}
q.clear();
res+=goal[ci];
}
return res;
}
int main()
{
cin>>h>>w>>n;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
cin>>s[i][j];
if(s[i][j]=='S'){
sx=i;
sy=j;
}
}
}
int goalnum=bfs();
cout<<goalnum<<endl;
return 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);
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;
}
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;
void warshall_floyd(ll v_num,vector<vector<long long>> &d) {
for (long long k = 0; k < v_num; k++) {
for (long long i = 0; i < v_num; i++) {
for (long long j = 0; j < v_num; j++) {
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
}
int main() {
ll r;
cin >> n >> m >> r;
vl rls(r);
rep(i, 0, r) {
cin >> rls[i];
rls[i]--;
}
vvl graph(n, vl(n, INF));
rep(i, 0, n) {
graph[i][i] = 0;
}
rep(i, 0, m) {
cin >> x >> y >> w;
graph[x - 1][y - 1] = w;
graph[y - 1][x - 1] = w;
}
warshall_floyd(n, graph);
sort(rls.begin(), rls.end());
ll ans = INF;
do {
ll tmp = 0;
rep(i, 0, r - 1) {
tmp += graph[rls[i]][rls[i + 1]];
}
ans = min(ans, tmp);
} while (next_permutation(rls.begin(), rls.end()));
printf("%lld\n", ans);
}
| 0
| 39,628,143
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
int C = 0;
cin >> A >> B;
for (int i = A; i <= B; i++) {
int b = i / 10000;
int c = (i - (b * 10000)) / 1000;
int d = (i - (b * 10000) - (c * 1000)) / 100;
int e = (i - (b * 10000) - (c * 1000) - (d * 100)) / 10;
int f = (i - (b * 10000) - (c * 1000) - (d * 100) - (e * 10)) / 1;
if (i == b + (c * 10) + (d * 100) + (e * 1000) + (f * 10000) && f != 0) {
C += 1;
}
else {
continue;
}
}
cout << C << endl;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<VVI> VVVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef vector<PII> VPII;
typedef long long LL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<VVLL> VVVLL;
typedef pair<LL, LL> PLL;
typedef vector<PLL> VPLL;
#define SORT_ASC(c) sort((c).begin(), (c).end())
#define SORT_DESC(c) sort((c).begin(), (c).end(), greater<typeof((c).begin())>())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FORL(i,a,b) for(LL i=(a);i<(b);++i)
#define REPL(i,n) FORL(i,0,n)
#define SIZE(a) int((a).size())
#define ALL(a) (a).begin(),(a).end()
const double EPS = 1e-10;
const double PI = acos(-1.0);
template<typename T>
void vprint(vector<T> v) {
for(auto x : v) {
cerr << x << " ";
}
cerr << endl;
}
template<typename T>
void vvprint(vector<vector<T>> vv) {
REP(i, SIZE(vv)) {
REP(j, SIZE(vv[i])) {
cerr << vv[i][j] << " ";
}
cerr << endl;
}
}
template<typename T1, typename T2>
void vpprint(vector<pair<T1, T2>> vp) {
REP(i, SIZE(vp)) {
cerr << vp[i].first << ", " << vp[i].second << endl;
}
}
template<typename T1, typename T2>
void mprint(map<T1, T2> m) {
for(auto x : m) cerr << x.first << ", " << x.second << endl;
}
template <typename Iterator>
inline bool next_combination(const Iterator first, Iterator k, const Iterator last)
{
if ((first == last) || (first == k) || (last == k))
return false;
Iterator itr1 = first;
Iterator itr2 = last;
++itr1;
if (last == itr1)
return false;
itr1 = last;
--itr1;
itr1 = k;
--itr2;
while (first != itr1)
{
if (*--itr1 < *itr2)
{
Iterator j = k;
while (!(*itr1 < *j)) ++j;
iter_swap(itr1,j);
++itr1;
++j;
itr2 = k;
rotate(itr1,j,last);
while (last != j)
{
++j;
++itr2;
}
rotate(k,itr2,last);
return true;
}
}
rotate(first,k,last);
return false;
}
inline double get_time_sec(void){
return static_cast<double>(chrono::duration_cast<chrono::nanoseconds>(chrono::steady_clock::now().time_since_epoch()).count())/1000000000;
}
template<typename T>
T gcd(T a, T b) {
if(a > b) swap(a, b);
if(a == 0) return b;
else return gcd(b%a, a);
}
template<typename T>
T lcm(T a, T b) {
return (a / gcd(a, b)) * b;
}
template<typename T>
map<T, T> prime_list(T n) {
map<T, T> ret;
for(T i = 2; i*i <= n; i++) {
if(n % i == 0) {
ret[i] = 0;
while(n % i == 0) {
n /= i;
ret[i]++;
}
}
}
if(n != 1) ret[n]++;
return ret;
}
#define MOD 1000000007
LL mypow(LL a, LL n) {
if(n == 0) return 1;
if(n == 1) return a % MOD;
if(n % 2 == 1) return (a * mypow(a, n-1)) % MOD;
LL t = mypow(a, n/2);
return (t * t) % MOD;
}
LL mycomb(LL n, LL k) {
if(n == 0 || n == k) return 1;
LL x = 1, y = 1;
REP(i, k) {
x = x * (n-i) % MOD;
y = y * (i+1) % MOD;
}
return x * mypow(y, MOD - 2) % MOD;
}
VLL par, rnk, sz;
int root(int x) {
if(par[x] == x) return x;
else return par[x] = root(par[x]);
}
bool same(int x, int y) {
x = root(x);
y = root(y);
return x == y;
}
void unite(int x, int y) {
x = root(x);
y = root(y);
if(rnk[x] < rnk[y]) {
par[x] = y;
sz[y] += sz[x];
} else {
par[y] = x;
sz[x] += sz[y];
if(rnk[x] == rnk[y]) rnk[x]++;
}
}
#define INF 1e15
LL n, x;
VLL total, patty;
LL dfs(LL m, LL y) {
if(m == 0) return 1;
if(y == 0) return 0;
if(y > 0 && y < total[m] / 2) return dfs(m - 1, y - 1);
if(y == total[m] / 2) return patty[m - 1] + 1;
if(y > total[m] / 2 && y < total[m] - 1) return patty[m - 1] + 1 + dfs(m - 1, y - total[m] / 2 - 1);
if(y == total[m] - 1) return patty[m];
return 0;
}
int main(void) {
cin >> n >> x;
total = VLL(n+1, 1);
patty = VLL(n+1, 1);
FOR(i, 1, n+1) {
total[i] = 3 + 2 * total[i-1];
patty[i] = 1 + 2 * patty[i-1];
}
cout << dfs(n, x-1) << endl;
}
| 0
| 21,976,675
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int N, M;
cin >> N >> M;
vector<vector<int>> g;
g.resize(N + 1);
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
vector<int> v;
for (int i = 1; i <= N; i++)
v.push_back(i);
int ans = 0;
do {
if (v[0] == 1) {
bool canGo = true;
for (int i = 0; i < v.size() - 1; i++) {
if (find(g[v[i]].begin(), g[v[i]].end(), v[i + 1]) == g[v[i]].end())
canGo = false;
}
if (canGo)
ans++;
}
} while (next_permutation(v.begin(), v.end()));
cout << ans << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int n,b,f,r,v,college[4][3][10]={0};
cin>>n;
for(int m=0;m<n;m++){
cin>>b>>f>>r>>v;
college[b-1][f-1][r-1]+=v;
if(college[b-1][f-1][r-1]>9)college[b-1][f-1][r-1]=9;
if(college[b-1][f-1][r-1]<0)college[b-1][f-1][r-1]=0;
}
for(int i=0;i<4;i++){
if(i!=0){
for(int l=0;l<20;l++)cout<<"#";
cout<<endl;
}
for (int j = 0; j <3 ; j++) {
for (int k=0;k<10;k++){
if(college[i][j][k]!=0)cout<<" "<<college[i][j][k];
else{cout<<" "<<0;}
}
cout<<endl;
}
}
return 0;
}
| 0
| 46,740,280
|
#include <algorithm>
#include<iostream>
#include<vector>
#include<deque>
#include<queue>
#include<stack>
#include<list>
#include<map>
#include<set>
#include<string>
#include <sstream>
#include<bitset>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<limits.h>
const int INF = 0x7fffffff;
using lll = long long;
using ull = unsigned long long;
using namespace std;
bool isPalindrome(string s){
int n = s.size()/2;
int ii;
for(ii=0;ii<n;ii++){
if(s[ii] != s[s.size()-ii-1]){
return false;
}
}
return true;
}
int main(){
lll ii,jj,kk;
vector<int> ret;
string s;
cin >> s;
string first,last;
int n = s.size();
int start = (n+3)/2 - 1;
first = "";
last = "";
for(ii=0;ii<(n-1)/2;ii++){
first += s[ii];
last += s[start+ii];
}
if(isPalindrome(first) && isPalindrome(last) && isPalindrome(s)){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template<typename T>
void out(T x) { cout << x << endl; exit(0); }
#define watch(x) cout << (#x) << " is " << (x) << endl
using ll = long long;
const int maxn = 1e6 + 5;
int n;
string s, t;
map<char,set<char>> mp;
set<char> viz;
int main() {
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin>>s>>t;
n = s.size();
map<char,int> into;
for (int i=0; i<n; i++) {
mp[s[i]].insert(t[i]);
if (!into.count(s[i])) {
into[s[i]];
}
into[t[i]]++;
}
for (auto p: mp) {
int n = p.second.size();
if (n != 1) out("No");
}
for (auto qq: into) {
char c = qq.first;
if (viz.count(c)) continue;
if (qq.second>0) continue;
bool cycle = true;
while (!viz.count(c)) {
viz.insert(c);
if (!mp.count(c)) {
cycle = false;
break;
}
c = *mp[c].begin();
}
if (cycle) {
if (c != qq.first) {
out("No");
}
}
}
out("Yes");
return 0;
}
| 0
| 17,553,486
|
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<utility>
#include<cmath>
#include<string>
#include<cstring>
#include<map>
#include<queue>
#include<set>
#define rep(i,n) for(int i=0;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define prin(arg) std::cout<<arg<<"\n"
#define prin2(arg1,arg2) std::cout<<arg1<<" "<<arg2<<"\n"
#define fill(arg,n) std::memset(arg,n,sizeof(arg))
#define mp std::make_pair
#define pb push_back
using std::cin;
typedef long long ll;
typedef std::pair<int,int> pi;
typedef std::vector<int> vi;
typedef std::set<int> si;
typedef std::string str;
const int INF=1e+9;
const ll INFLL=1e+17;
const ll MOD=1e+9+7;
int N;
int main(){
cin>>N;
int n=1;
while((n+1)*n/2<N) n++;
int dis=(n+1)*n/2-N;
rep1(i,n){
if(i!=dis) prin(i);
}
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
typedef long long ll;
int main() {
ll k, l, cnt, a[100], ans = 0LL;
string s;
cin >> s >> k;
l = s.length();
cnt = 0LL;
for (int i = 0; i < l; i++) {
if (s[i] == s[0]) {
cnt++;
}
}
if (cnt == l) {
cout << l * k / 2LL << endl;
return 0;
}
for (ll i = 0LL; i < l; i++) {
if (i == 0) {
a[i] = 0;
} else if (s[i] == s[i - 1]) {
a[i] = a[i - 1];
} else {
a[i] = i;
if (a[i - 1] != 0 || s[0] != s[l - 1]) {
ans += (i - a[i - 1]) / 2LL * k;
} else {
ans += i / 2LL;
}
}
}
if (s[l - 1] == s[0]) {
ans += (l - a[l - 1]) / 2LL;
cnt = 0LL;
for (int i = 0; i < l; i++) {
if (a[i] == 0 || a[i] == a[l - 1]) {
cnt++;
}
}
ans += cnt / 2LL * (k - 1LL);
} else {
ans += (l - a[l - 1]) / 2LL * k;
}
cout << ans << endl;
}
| 0
| 96,345,805
|
#include <bits/stdc++.h>
using namespace std;
int A[100050];
int n,l,q;
int dp[100050][20];
int main(){
cin >> n;
for(int i=1; i<=n; ++i) cin >> A[i];
cin >> l;
for(int i=1; i<=n; ++i) dp[i][0] = upper_bound(A+1,A+n+1,A[i]+l)-A-1;
for(int k=1; k<=18; ++k){
for(int i=1; i<=n; ++i){
dp[i][k] = dp[dp[i][k-1]][k-1];
}
}
cin >> q;
while(q--){
int a, b; cin >> a >> b;
if(a > b) swap(a,b);
int ans = 0;
while(a < b){
int s=0,e=19,m;
for(int k=0; k<=18; ++k) if(dp[a][k] < b) s=k;
ans += (1<<s);
a = dp[a][s];
}
cout << ans << "\n";
}
}
|
#include <iostream>
#include <algorithm>
using namespace std;
long long lcm(long long a, long long b)
{
return a / __gcd(a, b) * b;
}
int main()
{
long long A, B;
cin >> A >> B;
cout << lcm(A, B) << endl;
return 0;
}
| 0
| 86,746,223
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
int main() {
long long int n;
cin >> n;
vector<long long int> a(10000000+1, 0);
for (long long int i = 1; i <= 10000000; i++) {
a[i] = a[i-1]+i;
}
vector<long long int>::iterator ite = lower_bound(a.begin(), a.end(), n);
long long int k = ite-a.begin();
while (k > 0) {
cout << k << endl;
n -= k;
k--;
k = min(n, k);
}
return 0;
}
|
#include<bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
#define REP(i, l, n) for(int i=(l), i##_len=(n); i<i##_len; ++i)
#define ALL(x) (x).begin(),(x).end()
#define pb push_back
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;}
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;
}
char alpha[26] = {'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'};
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int main(){
ll h, w, m; cin >> h >> w >> m;
vector<Pll> H(h, Pll(0, 0)), W(w, Pll(0, 0));
map<Pll, ll> mp;
REP(i, 0, h){
H[i].second = i;
}
REP(i, 0, w){
W[i].second = i;
}
REP(i, 0, m){
ll x, y; cin >> x >> y;
x--; y--;
H[x].first++;
W[y].first++;
mp[Pii(x, y)]++;
}
sort(ALL(H), [](auto &x, auto &y){return x.first > y.first;});
sort(ALL(W), [](auto &x, auto &y){return x.first > y.first;});
ll Hmax = H[0].first, Wmax = W[0].first, i = 0;
ll ans = 0;
while(i < h && Hmax - H[i].first < 1){
int l = 0;
while(l < w && Wmax - W[l].first < 1){
if(mp[Pii(H[i].second, W[l].second)] == 1){
chmax(ans, H[i].first + W[l].first - 1);
}else{
cout << H[i].first + W[l].first << endl;
return 0;
}
l++;
}
i++;
}
cout << ans << endl;
}
| 0
| 18,194,960
|
#pragma region template
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vvvll = vector<vvll>;
using vld = vector<ld>;
using vvld = vector<vld>;
using vvvld = vector<vvld>;
using vs = vector<string>;
using pll = pair<ll, ll>;
using vp = vector<pll>;
template <typename T>
using pqrev = priority_queue<T, vector<T>, greater<T>>;
#define rep(i, n) for (ll i = 0, i##_end = (n); i < i##_end; i++)
#define repb(i, n) for (ll i = (n)-1; i >= 0; i--)
#define repr(i, a, b) for (ll i = (a), i##_end = (b); i < i##_end; i++)
#define reprb(i, a, b) for (ll i = (b)-1, i##_end = (a); i >= i##_end; i--)
#define ALL(a) (a).begin(), (a).end()
#define SZ(x) ((ll)(x).size())
constexpr ll MOD = 1e9 + 7;
/*/
constexpr ll MOD = 998244353;
constexpr ll INF = 1e+18;
constexpr ld EPS = 1e-12L;
constexpr ld PI = 3.14159265358979323846L;
constexpr ll GCD(ll a, ll b) { return b ? GCD(b, a % b) : a; }
constexpr ll LCM(ll a, ll b) { return a / GCD(a, b) * b; }
template <typename S, typename T>
inline bool chmax(S &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename S, typename T>
inline bool chmin(S &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#ifdef OJ_LOCAL
#include "dump.hpp"
#else
#define dump(...) ((void)0)
#endif
template <typename T>
bool print_(const T &a) {
cout << a;
return true;
}
template <typename T>
bool print_(const vector<T> &vec) {
for (auto &a : vec) {
cout << a;
if (&a != &vec.back()) {
cout << " ";
}
}
return false;
}
template <typename T>
bool print_(const vector<vector<T>> &vv) {
for (auto &v : vv) {
for (auto &a : v) {
cout << a;
if (&a != &v.back()) {
cout << " ";
}
}
if (&v != &vv.back()) {
cout << "\n";
}
}
return false;
}
void print() { cout << "\n"; }
template <typename Head, typename... Tail>
void print(Head &&head, Tail &&... tail) {
bool f = print_(head);
if (sizeof...(tail) != 0) {
cout << (f ? " " : "\n");
}
print(forward<Tail>(tail)...);
}
#pragma endregion
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll n, a, b;
cin >> n >> a >> b;
if(a == n && b == 1){
vi ans(n);
iota(ALL(ans), 1);
print(ans);
}else if(a == 1 && b == n){
vi ans(n);
iota(ALL(ans), 1);
reverse(ALL(ans));
print(ans);
}else if(n >= a+b-1 && n <= a*b){
vvll x(b, vll(1, 0));
ll cnt = b;
rep(i, b){
rep(j, a-1){
if(cnt >= n) break;
x[i].emplace_back(0);
cnt++;
}
}
ll c = 1;
repb(i, b){
rep(j, SZ(x[i])){
x[i][j] = c;
c++;
}
}
vll ans;
rep(i, a){
rep(j, b){
if(SZ(x[j]) <= i){
break;
}
ans.emplace_back(x[j][i]);
}
}
print(ans);
}else{
print(-1);
}
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
set<int> chair;
for(int i=0;i<n;i++){
int l,r;
cin>>l>>r;
for(int i=l;i<=r;i++){
chair.insert(i);
}
}
cout<<chair.size()<<endl;
return 0;
}
| 0
| 41,092,306
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
int num;
vector<int> list;
while(cin >> num)
{
list.push_back(num);
}
sort(list.begin(), list.end(), greater<int>());
for(int i = 0 ; i< 3 ; i++)
{
cout<< list[i] <<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define rr(i, b) for (int i = 0; i < int(b); i++)
#define vi(n, a) vector <int> a(n); rr(i, n) cin >> a[i]
#define pvec(a) rr(i, a.size()) cout << a[i] << " "; cout << endl
#define bug(x) cout << #x << " " << x << endl
#define ll long long
#define vii vector <int>
using namespace std;
void solve() {
vector<vii> a(3, vii (3));
rr(i, 3) {
rr(j, 3) cin >> a[i][j];
}
int n;
cin >> n;
map<int, bool> is;
rr(i, n) {
int x;
cin >> x;
is[x] = true;
}
rr(i, 3) {
rr(j, 3) {
int x = a[i][j];
if(is[x] == true) a[i][j] = -1;
}
}
int flag = 0;
rr(i, 3) {
int counter = 0;
int counter2 = 0;
rr(j, 3) {
if(a[i][j] == -1) counter++;
if(a[j][i] == -1) counter2++;
}
if(counter == 3 || counter2 == 3) flag = 1;
}
int c = 0, c2 = 0;
rr(i, 3) {
rr(j, 3) {
if(i == j && a[i][j] == -1)c++;
if(i + j == 2 && a[i][j] == -1) c2++;
}
}
if(c == 3 || c2 == 3) flag = 1;
if(flag == 1) cout << "Yes" << endl;
else cout << "No" << endl;
}
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 0
| 57,066,318
|
#include <iostream>
#include <algorithm>
using namespace std;
long long n, p[200001], pmin[200001], ans = 0;
int main()
{
cin >> n;
for (int i = 0; i <= 200000; i++) pmin[i] = 200000;
for (int i = 1; i <= n; i++)
{
cin >> p[i];
pmin[i] = min(pmin[i - 1], p[i]);
}
for (int i = 1; i <= n; i++)
{
if (p[i] <= pmin[i]) ans++;
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
long long int n,k;
cin >> n >> k;
long long int a,b;
long long int ans=0;
for(int i=0;i<k;i++){
if(i==0)ans+=(n/k)*(n/k)*(n/k);
else{
if(n%k>=i)a=n/k+1;
else a=n/k;
if(n%k>=k-i)b=n/k+1;
else b=n/k;
if((2*k-2*i)%k==0)ans+=a*b*b;
}
}
cout << ans << endl;
}
| 0
| 42,106,819
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5;
inline bool cek_bit(ll mask, int x){
return mask&(1ll<<x);
}
int n;
ll li[N+5];
int depan[65];
int urut = 0;
int matrix[65][N+5];
bool masuk(int bit){
urut++;
for(int i=1;i<=n;i++){
if(cek_bit(li[i],bit)){
matrix[urut][i] = 1;
} else {
matrix[urut][i] = 0;
}
}
matrix[urut][n+1] = 1;
for(int i=1;i<urut;i++){
if(matrix[urut][depan[i]] == 1){
for(int j=1;j<=n+1;j++){
matrix[urut][j]^=matrix[i][j];
}
}
}
int awal = -1;
for(int i=1;i<=n;i++){
if(matrix[urut][i] == 1){
awal = i;
break;
}
}
if(awal == -1 && matrix[urut][n+1] == 0){
urut--;
return 1;
} else if(awal == -1 && matrix[urut][n+1] == 1){
urut--;
return 0;
}
depan[urut] = awal;
return 1;
}
int main(){
scanf("%d",&n);
ll ans = 0ll;
for(int i=1;i<=n;i++){
scanf("%lld",&li[i]);
}
for(int i=59;i>=0;i--){
int cnt = 0;
for(int j=1;j<=n;j++){
if(cek_bit(li[j],i)){
cnt++;
}
}
if(cnt&1){
ans+=(1ll<<i);
} else {
if(masuk(i)){
ans+=(1ll<<(i+1));
}
}
}
printf("%lld\n",ans);
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
#define prtd(var, i) cout << fixed << setprecision(i) << var << endl;
#define ll long long
#define P pair<int, int>
using namespace std;
int main(){
string s;
cin >> s;
vector<int> x(4);
rep(i, 4) x[i] = s[i] - '0';
if(x[0] + x[1] + x[2] + x[3] == 7){
printf("%d+%d+%d+%d=7", x[0], x[1], x[2], x[3]);
}else if(x[0] + x[1] + x[2] - x[3] == 7){
printf("%d+%d+%d-%d=7", x[0], x[1], x[2], x[3]);
}else if(x[0] + x[1] - x[2] + x[3] == 7){
printf("%d+%d-%d+%d=7", x[0], x[1], x[2], x[3]);
}else if(x[0] + x[1] - x[2] - x[3] == 7){
printf("%d+%d-%d-%d=7", x[0], x[1], x[2], x[3]);
}else if(x[0] - x[1] + x[2] + x[3] == 7){
printf("%d-%d+%d+%d=7", x[0], x[1], x[2], x[3]);
}else if(x[0] - x[1] + x[2] - x[3] == 7){
printf("%d-%d+%d-%d=7", x[0], x[1], x[2], x[3]);
}else if(x[0] - x[1] - x[2] + x[3] == 7){
printf("%d-%d-%d+%d=7", x[0], x[1], x[2], x[3]);
}else if(x[0] - x[1] - x[2] - x[3] == 7){
printf("%d-%d-%d-%d=7", x[0], x[1], x[2], x[3]);
}
cout << endl;
return 0;
}
| 0
| 88,245,360
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, D, X;
cin >> N >> D >> X;
int sum = N;
vector<int> A(N);
for (int i = 0; i < N; i++) {
cin >> A.at(i);
}
for (int i = 0; i < N; i++)
for (int j = 1; j <= D; j++)
if ((j * A.at(i) + 1) <= D)
sum++;
else
break;
cout << sum + X << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <iostream>
#include <unordered_map>
#include <unordered_set>
#define pb push_back
#define mpr make_pair
#define pii pair<int, int>
#define pll pair<ll, ll>
#define ll long long
#define ld long double
#define fi first
#define se second
#define all(arr) arr.begin(), arr.end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define fo(i, l, r) for (int i = l; i <= r; i++)
#define INF 1000000001
#define inf1 1000000000000000001
#define MOD 1000000007
#define mod 1000000007
#define pie 3.14159265358979323846264338327950L
#define N 200009
#define M 1e6 + 9
#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"
#define int long long
using namespace std;
int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
int ddx[8]={1,1,0,-1,-1,-1,0,1},ddy[8]={0,1,1,1,0,-1,-1,-1};
ll gcd(ll a,ll b){ if(!a)return b;return gcd(b%a,a);}
ll lcm(ll a, ll b) { return (a*b)/ gcd(a,b);}
void test_case()
{
string s,t;
cin>>s>>t;
string ans = t+s;
cout<<ans<<endl;
}
signed main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(20);
int t = 1;
while (t--)
{
test_case();
}
}
| 0
| 88,967,760
|
#include<bits/stdc++.h>
using namespace std;
int main(){
string s;
string t;
cin>>s>>t;
string s1=s;
string t1=t;
reverse(s.begin(),s.end());
reverse(t.begin(),t.end());
if(s1==t && t1==s){
cout << "YES" << endl;
}else{
cout<<"NO"<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
#define MODV 1000000007
#define INFLL LLONG_MAX
#define EPS 1e-9
#define rep(i, n) for(ll i=0, i##_len=(ll)(n); i<i##_len; i++)
#define repf(i, n) for(ll i=1, i##_len=(ll)(n+1); i<i##_len; i++)
#define all(v) v.begin(), v.end()
#define endl "\n"
#define vi vector<ll>
#define vvi vector<vector<ll>>
#define Yes() cout << "Yes" << endl
#define YES() cout << "YES" << endl
#define No() cout << "No" << endl
#define NO() cout << "NO" << endl
#define Init() std::ios::sync_with_stdio(false); std::cin.tie(0); std::cout<<fixed<<setprecision(15);
template<class T>bool chmax(T &a, const T &b){ if(a<b){ a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b){ if(b<a){ a=b; return 1; } return 0; }
using namespace std;
int main(){
Init();
ll n, k; cin >> n >> k;
vi a(n);
rep(i, n) cin >> a[i];
rep(cnt, k){
vi sum(n, 0);
rep(i, n){
ll left = max(0LL, i-a[i]);
ll right = min(n-1, i+a[i]);
sum[left]++;
if(right != n-1) sum[right+1]--;
}
ll cnt_n = 0;
rep(i, n){
a[i] = sum[i];
if(i < n-1) sum[i+1] += sum[i];
if(a[i] == n) cnt_n++;
}
if(cnt_n == n) break;
}
rep(i, n) cout << a[i] << (i == n-1 ? endl : " ");
}
| 0
| 15,396,446
|
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#pragma warning(disable:4996)
int main(){
int n = 0;
int arr[105][105] = { 0 };
scanf("%d", &n);
for (int m = 0; m < n; m++){
int a = 0;
int b = 0;
scanf("%d %d", &a, &b);
for (int x = 0; x < b; x++){
int c = 0;
scanf("%d", &c);
getchar();
arr[a - 1][c - 1] = 1;
}
}
for (int m = 0; m < n; m++){
for (int o = 0; o < n-1; o++){
printf("%d ", arr[m][o]);
}
printf("%d", arr[m][n-1]);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
typedef tree<
ll,
null_type,
less<ll>,
rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
ll nsum(ll n) {
return (n*(n+1))/2;
}
int main(){
int N;
cin >> N;
vll A(N);
for (int i=0;i<N;i++) cin >> A[i];
ll ns = nsum(N);
ll total = 0;
for (ll a : A) total += a;
if (total % ns != 0) {
cout << "NO" << endl;
return 0;
}
ll M = total / ns;
vll diffs(N);
diffs[0] = A[0] - A[N-1];
for (int i=1;i<N;i++) {
diffs[i] = A[i] - A[i-1];
}
for (int i=0;i<N;i++) {
if ((M-diffs[i]) % N != 0 || (M - diffs[i]) < 0) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 0
| 61,163,361
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <functional>
using namespace std;
#define int long long
#define double long double
#define pb push_back
#define mp make_pair
#define st(arr,a) memset(arr,a,sizeof arr)
#define nl cout<<endl
#define endl '\n'
#define bitcount(x) __builtin_popcountll(x)
const int MOD = 1000000007ll;
#define forn(i,a,b) for(int i=a;i<=b;i++)
#define rfor(i,a,b) for(int i=a;i>=b;i--)
#define all(x) x.begin() , x.end()
#define pi pair<int,int>
#define X first
#define Y second
#define N 1014159
#define vi vector<int>
#define v vector
#define die exit(0)
using namespace __gnu_pbds;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update> oset;
gp_hash_table<int, int> table;
const int RANDOM = chrono::high_resolution_clock::now().time_since_epoch().count();
struct chash {
int operator()(int x) const { return x ^ RANDOM; }
};
int n;
int arr[N];
void solve()
{
int m;
cin>>n>>m;
forn(i,1,n)
{
cin>>arr[i];
}
int a = -1,b;
forn(i,2,n)
{
if(arr[i] + arr[i-1]>=m)
{
a = i-1 , b = i;
break;
}
}
if(a==-1)
{
cout<<"Impossible";exit(0);
}
cout<<"Possible\n";
forn(i,1,a-1)
{
cout<<i<<"\n";
}
rfor(i,n-1,b)
{
cout<<i<<"\n";
}
cout<<a;
}
signed main()
{
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
int t = 1;
forn(i,1,t)
{
solve();
nl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, e) for (int i = (int)(s); i <= (int)(e); i++)
#define printYesNo(is_ok) puts(is_ok ? "Yes" : "No");
#define SORT(v) sort(v.begin(), v.end());
#define RSORT(v) sort(v.rbegin(), v.rend());
#define REVERSE(v) reverse(v.begin(), v.end());
template <typename T>
void printlnVector(T v)
{
rep(i, v.size())
{
cout << v[i] << endl;
}
}
template <typename T>
void printVector(T v)
{
rep(i, v.size())
{
cout << v[i] << " ";
}
cout << endl;
}
int main()
{
string S;
cin >> S;
int N = S.size() + 1;
vector<pair<long long, long long>> CS;
CS.push_back(make_pair(S[0], 0));
rep(i, N - 1)
{
if (CS.back().first == S[i])
CS.back().second++;
else
CS.push_back(make_pair(S[i], 1));
}
vector<long long> number;
number.push_back(0);
rep(i, CS.size())
{
if (CS[i].first == '<')
{
rep(j, CS[i].second)
{
number.push_back(j + 1);
}
}
else if (CS[i].first == '>')
{
number.back() = max(CS[i].second, number.back());
rep(j, CS[i].second)
{
number.push_back(CS[i].second - j - 1);
}
}
}
long long ans = 0;
for (long long n : number)
ans += n;
cout << ans << endl;
return 0;
}
| 0
| 63,432,647
|
#include<iostream>
using namespace std;
int main(){
int car[100];
int input;
int i = 0;
while(cin >> input){
if(input == 0){
i--;
cout << car[i] << endl;
}else{
car[i] = input;
i++;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int h, w;
cin >> h >> w;
vector<string> s(h);
for (int i = 0; i < h; i++) {
cin >> s[i];
}
vector<vector<int>> cnt(h, vector<int>(w));
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (i == 0 && j == 0) {
if (s[0][0] == '#') cnt[0][0] = 1;
} else if (i == 0) {
cnt[i][j] = cnt[i][j - 1] + (s[i][j - 1] == '.' && s[i][j] == '#');
} else if (j == 0) {
cnt[i][j] = cnt[i - 1][j] + (s[i - 1][j] == '.' && s[i][j] == '#');
} else {
cnt[i][j] = cnt[i][j - 1] + (s[i][j - 1] == '.' && s[i][j] == '#');
chmin(cnt[i][j],
cnt[i - 1][j] + (s[i - 1][j] == '.' && s[i][j] == '#'));
}
}
}
cout << cnt[h - 1][w - 1] << '\n';
return 0;
}
| 0
| 85,259,969
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, kakikae = 0;
cin >> n >> k;
map<int, int> a;
for (int i = 0; i < n; i++) {
int ai; cin >> ai;
if (a.count(ai)) a[ai]++;
else a[ai] = 1;
}
int syurui = a.size();
if (syurui <= k) goto OUT;
for (int i = 1; i < n; i++) {
for (auto p: a) {
if (p.second == i) {
syurui--;
kakikae += i;
if (syurui <= k) goto OUT;
}
}
}
OUT:
cout << kakikae;
}
|
#include<iostream>
#include<cmath>
#include<map>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1c(i, n) for (int i = 1; i <= (int)(n); i++)
using namespace std;
int N, dp[100][2][3];
map<int, int> m;
void solve() {
rep1c(i, N) {
int j = 2;
int k = i;
while (k > 1 || i >= j) {
if (k % j == 0) {
m[j] += 1;
k /= j;
} else {
j++;
}
}
}
dp[0][0][0] = 1;
int ki = 1;
for ( auto it : m ) {
rep(i, 2) rep(j, 3) dp[ki][i][j] = dp[ki-1][i][j];
if(it.second >= 74) {
dp[ki][1][2] += dp[ki-1][0][0];
}
if(it.second >= 24) {
dp[ki][1][2] += dp[ki-1][1][0];
dp[ki][0][2] += dp[ki-1][0][0];
}
if(it.second >= 14) {
dp[ki][1][2] += dp[ki-1][0][1];
dp[ki][1][1] += dp[ki-1][0][0];
}
if(it.second >= 4) {
dp[ki][1][2] += dp[ki-1][1][1];
dp[ki][1][1] += dp[ki-1][1][0];
dp[ki][0][2] += dp[ki-1][0][1];
dp[ki][0][1] += dp[ki-1][0][0];
}
if(it.second >= 2) {
dp[ki][1][2] += dp[ki-1][0][2];
dp[ki][1][1] += dp[ki-1][0][1];
dp[ki][1][0] += dp[ki-1][0][0];
}
ki++;
}
cout << dp[m.size()][1][2] << endl;
}
int main() {
cin >> N;
solve();
return 0;
}
| 0
| 25,679,330
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define P pair<ll,ll>
#define FOR(I,A,B) for(ll I = (A); I < (B); ++I)
#define FORR(I,A,B) for(ll I = (B-1); I >= (A); --I)
const ll INF=1e18+7;
const ll MOD=1e9+7;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
ll n,m;
cin >> n >> m;
vector<ll> c(m);
FOR(i,0,m)cin >> c[i];
vector<ll> dp(n+1);
FOR(i,0,n+1)dp[i]=i;
FOR(i,0,m){
FOR(j,0,n+1){
if(j+c[i]<=n)dp[j+c[i]] = min(dp[j+c[i]],dp[j]+1);
}
}
cout << dp[n] << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <set>
#include <utility>
#include <algorithm>
using namespace std;
typedef pair<long long, long long> P;
int main(){
int N, M;
cin >> N >> M;
vector<long long> A(N), B(N);
vector<long long> ind(N);
set<int> s;
for(int i = 1; i <= M; i++) s.insert(i);
for(int i = 0; i < N; i++) {
cin >> A[i] >> B[i];
ind[i] = i;
}
sort(ind.begin(), ind.end(), [&](int x, int y){
if(B[x] != B[y]) return B[x] > B[y];
return A[x] > A[y];
});
long long ans = 0;
for(int i = 0; i < N; i++){
auto ite = s.lower_bound(A[ind[i]]);
if(ite != s.end()){
ans += B[ind[i]];
s.erase(*ite);
}
}
cout << ans << endl;
}
| 0
| 58,383,906
|
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int debt=100000, n;
cin >> n;
for(int i=0;i<n;i++){
debt += debt*(5.0/100.0);
if(debt%1000!=0){
debt=(debt/1000)*1000+1000;
}
}
if(debt%1000!=0){
debt=(debt/1000)*1000+1000;
}
cout << debt << endl;
return 0;}
|
#include<iostream>
int n, m;
long long x[100000], y[100000];
long long ansx, ansy;
int waru = 1000000000+7;
long long ans;
int main() {
std::cin >> n >> m;
for (int i = 0; i < n; i++) {
std::cin >> x[i];
}
for (int j = 0; j < m; j++) {
std::cin >> y[j];
}
for (int i = 1; i <= n; i++) {
ansx = ((i + i - n - 1)*x[i - 1] + ansx) % waru;
}
for (int i = 1; i <= m; i++) {
ansy = ((i + i - m - 1)*y[i - 1] + ansy) % waru;
}
ans = (ansx*ansy) % waru;
std::cout << ans << std::endl;
return 0;
}
| 0
| 76,945,821
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using VI = vector<int>;
using VL = vector<ll>;
using PII = std::pair<int, int>;
using PLL = std::pair<ll, ll>;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define allpt(v) (v).begin(), (v).end()
#define allpt_c(v) (v).cbegin(), (v).cend()
#define allpt_r(v) (v).rbegin(), (v).rend()
const int mod = 1e9 + 7;
const string wsp = " ";
const string tb = "\t";
const string rt = "\n";
template <typename T>
void show1dvec(const vector<T> &v)
{
if (v.size() == 0)
return;
int n = v.size() - 1;
rep(i, n) cout << v[i] << wsp;
cout << v[n] << rt;
return;
}
template <typename T>
void show2dvec(const vector<vector<T>> &v)
{
int n = v.size();
rep(i, n) show1dvec(v[i]);
}
template <typename T, typename S>
void show1dpair(const vector<pair<T, S>> &v)
{
int n = v.size();
rep(i, n) cout << v[i].first << wsp << v[i].second << rt;
return;
}
template <typename T, typename S>
void pairzip(const vector<pair<T, S>> &v, vector<T> &t, vector<T> &s)
{
int n = v.size();
rep(i, n)
{
t.push_back(v[i].first);
s.push_back(v[i].second);
}
return;
}
template <typename T>
void maxvec(vector<T> &v)
{
T s = v[0];
int n = v.size();
rep(i, n - 1)
{
if (s > v[i + 1])
{
v[i + 1] = s;
}
s = v[i + 1];
}
}
template <typename T, typename S>
bool myfind(T t, S s)
{
return find(t.cbegin(), t.cend(), s) != t.cend();
}
vector<int> make_kmp_table(string t)
{
int lt = t.length();
VI kmptable(lt, 0);
kmptable[0] = -1;
return kmptable;
}
int main()
{
#ifdef DEBUG
cout << "DEBUG MODE" << endl;
ifstream in("input.txt");
cin.rdbuf(in.rdbuf());
#endif
int n, x, y, mina, maxa;
cin >> n;
VI v(n + 1), a(n);
bool judge = true;
string ans = "Impossible";
rep(i, n)
{
cin >> a[i];
v[a[i]]++;
}
mina = *min_element(allpt_c(a)), maxa = *max_element(allpt_c(a));
if (maxa == 2 * mina)
{
rep2(i, mina, maxa + 1)
{
if (i == mina && v[mina] != 1)
judge = false;
else if (i > mina && v[i] < 2)
judge = false;
}
if (judge) ans = "Possible";
}
else if (maxa == 2 * mina - 1)
{
rep2(i, mina, maxa + 1)
{
if (i == mina && v[mina] != 2)
judge = false;
else if (i > mina && v[i] < 2)
judge = false;
}
if (judge) ans = "Possible";
}
cout << ans << rt;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<ll> vll;
#define fi first
#define se second
#define pb push_back
#define nn "\n"
#define all(p) p.begin(),p.end()
#define zz(v) (ll)v.size()
#define S(a) scanf("%lld",&a)
#define SS(a,b) scanf("%lld %lld",&a,&b)
#define SSS(a,b,c) scanf("%lld %lld %lld",&a,&b,&c)
#define ss ' '
#define pii pair<ll,ll>
#define gcd(a,b) __gcd(a,b)
#define lcm(a,b) (a*b)/gcd(a,b)
const double eps = 1e-8;
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
ll n;
cin>>n;
ll ar[n+10];
for(ll i=1;i<=n;i++) ar[i]=2;
ar[1]=1;
for(ll i=2;i<=n;i++)
{
for(ll j=i+i;j<=n;j+=i)
{
ar[j]++;
}
}
ll ans=0;
for(ll i=1;i<=n;i++)
{
ans+=i*ar[i];
}
cout<<ans<<nn;
}
| 0
| 61,815,511
|
#include<bits/stdc++.h>
using namespace std;
int main(){
char c;
cin >> c;
if(c == 'a' || c == 'i' || c == 'u' || c == 'e' || c == 'o'){
puts("vowel");
}
else puts("consonant");
}
|
#include<bits/stdc++.h>
using namespace std;
#define all(v) v.begin(),v.end()
#define all(v) v.begin(),v.end()
#define meow ios::sync_with_stdio(0);cin.tie(0);
typedef long long int ll;
typedef unsigned long long int ull;
int main()
{
meow;
ll i,n,j,cnt=0,k;
cin>>n;
for(i=0;i<=n;i++){
string str;
str=to_string(i);
if(str.size()%2==1){
cnt++;
}
}
cout<<cnt-1<<endl;
}
| 0
| 21,947,600
|
#include <bits/stdc++.h>
using namespace std;
int main () {
int n;
cin >> n;
vector<pair<int, int>> a_i(n);
for (int i = 0; i < n; i++) {
int a;
cin >> a;
a_i.at(i) = make_pair(i + 1, a);
}
sort(a_i.begin(), a_i.end(), [](const auto &x, const auto &y) {
return x.second < y.second;
});
for (int i = 0; i < n - 1; i++)
cout << a_i.at(i).first << ' ';
cout << a_i.at(n - 1).first << endl;
}
|
#include <iostream>
#include <string>
#include <algorithm>
#include <functional>
#include <vector>
#include <cstring>
#include <iomanip>
#include <numeric>
#include <cmath>
#include <cassert>
#include <queue>
#include <map>
#include <set>
using namespace std;
using Int = int64_t;
using P = pair<Int, Int>;
const Int INF = 1<<30;
const Int MOD = (Int)1e9 + 7;
const Int MAX_N = (Int)1e5 + 5;
#define debug(x) cout << #x << ": " << x << endl
#define debug2(x, y) cout << #x << ": " << x << ", " << #y << ": " << y << endl;
template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2>& p) { os << p.first << " " << p.second; return os; }
template<typename T>
ostream &operator<<(ostream &os, const vector<T> &v) { for(Int i = 0; i < (Int) v.size(); i++) os << v[i] << (i + 1 != v.size() ? " " : ""); return os; }
Int N, K;
void make_group(const vector<Int> &P, vector<vector<Int>> &G)
{
vector<Int> used(N, 0);
for(Int i = 0; i < N; i++)
{
Int s = i;
if(used[s]) continue;
vector<Int> tmp;
while (s < N)
{
if (used[s]) break;
used[s] = 1;
tmp.push_back(s);
s = P[s];
}
G.push_back(tmp);
}
}
void solve()
{
cin >> N >> K;
vector<Int> P(N), C(N);
for(Int i = 0; i < N; i++)
{
cin >> P[i];
P[i]--;
}
for(Int i = 0; i < N; i++) cin >> C[i];
vector<vector<Int>> G;
make_group(P, G);
Int ans = *max_element(C.begin(), C.end());
for(const vector<Int> &p : G)
{
Int value = 0;
Int n = (Int)p.size();
for(Int i = 0; i < n; i++) value += C[p[i]];
if(value > 0)
{
Int k = K % n + n;
for(int i = 0; i < n; i++)
{
Int sum = value * (K / n - 1);
ans = max(ans, sum);
for (int j = 1; j <= k; j++)
{
sum += C[p[(i + j) % n]];
ans = max(ans, sum);
}
}
}
else
{
Int k = min(n, K);
for(int i = 0; i < n; i++)
{
Int sum = 0;
for(int j = 1; j <= k; j++)
{
sum += C[p[(i + j) % n]];
ans = max(ans, sum);
}
}
}
}
cout << ans << endl;
}
signed main()
{
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| 0
| 50,397,686
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using vl = vector<ll>;
using vll = vector<vl>;
using Pll = pair<ll, ll>;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(v) v.begin(), v.end()
#define sz(x) ((int) x.size())
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define F first
#define S second
const int MOD = 1e9+7;
const ll INF = 2e15;
template<class T> void print(const T& t){ cout << t << endl; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
int main(){
ll n, m, k;
cin >> n >> m >> k;
rep(i,n+1){
rep(j,m+1){
if(i*(m-j)+j*(n-i)==k){
print("Yes");
return 0;
}
}
}
print("No");
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
void chmin(double &a, double b){
if( a > b){ swap(a,b);} return;}
int main(){
int N; cin >> N;
vector<int> t(N); vector<int> v(N); int time = 0;
for(int i = 0; i < N; i++){ cin >> t[i]; time += t[i];}
for(int i = 1; i < N; i++){ t[i] += t[i-1];}
for(int i = 0; i < N; i++){ cin >> v[i];}
vector<double> speed(2*time+10,0.0);
for(int i = 0; i < N; i++){
int res;
if(!i){ res = 0;} else{ res = t[i-1];}
for(int j = 2*res; j <= 2*t[i]; j++){
if( j == 2*res){ int res1;
if(!i){ res1 = 0;} else{ res1 = v[i-1];}
speed[j] = min(res1, v[i]);}
else if( j == 2*t[i]){
speed[j] = min(v[i],v[i+1]);}
else{
speed[j] = v[i];}}
}
speed[0] = 0.0; speed[2*time] = 0.0;
for(int i = 1; i < 2*time; i++){
chmin( speed[i], speed[i-1]+0.5);}
for(int j = 2*time-1; j >= 0; j--){
chmin( speed[j], speed[j+1]+0.5);}
double area = 0.0;
for(int i = 0; i < 2*time; i++){
area += 0.5*(speed[i]+speed[i+1])*0.5;}
cout << fixed << setprecision(5) << area << endl;
return 0;}
| 0
| 44,944,771
|
#include <stdio.h>
int main(){
int N;
unsigned long long int sum=1;
scanf("%d", &N);
unsigned long long int A[N];
for(int i=0;i<N;i++){
scanf("%llu", &A[i]);
if(A[i]==0){
printf("0");
return 0;
}
for(int i=0;i<N; i++){
}
}
for(int i=0; i<N;i++){
if(A[i]<=1000000000000000000/sum){
sum*=A[i];
}
else{
printf("-1");
return 0;
}
}
printf("%lld", sum);
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <vector>
const int MOD = 1e9 + 7;
const int iINF = 2147483647 / 2;
const long long int llINF = 9223372036854775807 / 2;
using namespace std;
using ll = long long int;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using vvvl = vector<vector<vector<ll>>>;
typedef pair<ll, ll> pll;
bool paircomp(const pll &a, const pll &b) {
if (a.first == b.first)
return a.second < b.second;
return a.first < b.first;
}
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define RREP(i, n) for (ll i = (n)-1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define AUTO(i, m) for (auto &i : m)
#define ALL(a) (a).begin(), (a).end()
#define MAX(vec) *std::max_element(vec.begin(), vec.end())
#define MIN(vec) *std::min_element(vec.begin(), vec.end())
#define ARGMAX(vec) \
std::distance(vec.begin(), std::max_element(vec.begin(), vec.end()))
#define ARGMIN(vec) \
std::distance(vec.begin(), std::min_element(vec.begin(), vec.end()))
#define REV(T) greater<T>()
#define PQ(T) priority_queue<T, vector<T>, greater<T>>
#define VVL(a, b, c) vector<vector<ll>>(a, vector<ll>(b, c))
#define VV(T, a, b, c) vector<vector<T>>(a, vector<T>(b, c))
#define VVVL(a, b, c, d) \
vector<vector<vector<ll>>>(a, vector<vector<ll>>(b, vector<ll>(c, d)))
#define VVV(T, a, b, c, d) \
vector<vector<vector<T>>>(a, vector<vector<T>>(b, vector<T>(c, d)))
#define SP(a) setprecision(a)
#define SQRT(a) sqrt((long double)(a))
#define DPOW(a, b) pow((long double)(a), (long double)(b))
#define UNIQUE(vec) \
do { \
sort(ALL((vec))); \
(vec).erase(std::unique(ALL((vec))), (vec).end()); \
} while (0)
ll POW(ll n, ll m) {
if (m == 0) {
return 1;
} else if (m % 2 == 0) {
ll tmp = POW(n, m / 2);
return (tmp * tmp);
} else {
return (n * POW(n, m - 1));
}
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll N, A, B;
cin >> N >> A >> B;
if (A == N && B == 1) {
REP(i, N) cout << (i + 1) << " ";
cout << endl;
} else if (A == 1 && B == N) {
RREP(i, N) cout << (i + 1) << " ";
cout << endl;
} else if (B != 1 && A != 1) {
ll down = ceil((long double)N / A);
ll up = (N - A) + 1;
if (A >= 1 && A <= N && B >= 1 && B <= N && up >= B && down <= B) {
ll po = N - A;
ll yo = po / (B - 1);
ll ko = po % (B - 1);
for (ll i = N - A + 1; i <= N; i++)
cout << i << " ";
for (ll i = N - A; i >= 1;) {
ll zo = ko > 0 ? (yo + 1) : yo;
FOR(k, i - zo + 1, i + 1) { cout << k << " "; }
ko--;
i -= zo;
}
cout << endl;
} else {
cout << -1 << endl;
}
} else {
cout << -1 << endl;
}
return 0;
}
| 0
| 4,337,261
|
#include <algorithm>
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define ll long long
#define ld long double
#define INF 1000000000000000000
typedef pair<ll, ll> pll;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, D, A;
cin >> N >> D >> A;
vector<ll> X(N), H(N + 100), diff(N + 100);
map<ll, ll> ma;
rep(i, N) {
cin >> X[i] >> H[i];
ma[X[i]] = H[i];
}
sort(all(X));
rep(i, N) { H[i] = ma[X[i]]; }
ll ans = 0;
rep(i, N) {
if (H[i] > 0) {
ll tar = X[i] + 2 * D;
int a = upper_bound(all(X), tar) - X.begin();
ll cnt = (H[i] / A) + (H[i] % A != 0 ? 1 : 0);
ans += cnt;
H[a] += (A * cnt);
diff[a] += (A * cnt);
diff[i] -= (A * cnt);
}
H[i + 1] += diff[i];
diff[i + 1] += diff[i];
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Edge = int;
using Graph = vector<vector<Edge>>;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
const ll MOD = 1000000007;
const ll nmax = 8;
const ll INF = 1e13;
const int MAX = 510000;
bool graph[nmax][nmax];
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit()
{
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++)
{
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll COM(int n, int k)
{
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
vector<vector<ll>> dist = vector<vector<ll>>(nmax, vector<ll>(nmax, INF));
struct SegmentTree
{
private:
ll n;
vector<ll> node;
public:
SegmentTree(vector<ll> v)
{
ll sz = v.size();
n = 1;
while (n < sz)
{
n *= 2;
}
node.resize(2 * n - 1, INF);
for (ll i = 0; i < sz; i++)
{
node[i + n - 1] = v[i];
}
for (ll i = n - 2; i >= 0; i--)
{
node[i] = min(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(ll x, ll val)
{
x += (n - 1);
node[x] = val;
while (x > 0)
{
x = (x - 1) / 2;
node[x] = min(node[2 * x + 1], node[2 * x + 2]);
}
}
ll find(ll a, ll b, ll k = 0, ll l = 0, ll r = -1)
{
if (r < 0)
r = n;
if (r <= a || b <= l)
return INF;
if (a <= l && r <= b)
return node[k];
ll vl = find(a, b, 2 * k + 1, l, (l + r) / 2);
ll vr = find(a, b, 2 * k + 2, (l + r) / 2, r);
return min(vl, vr);
}
};
void warshall_floyd(ll n)
{
for (size_t i = 0; i < n; i++)
{
for (size_t j = 0; j < n; j++)
{
for (size_t k = 0; k < n; k++)
{
dist[j][k] = min(dist[j][k], dist[j][i] + dist[i][k]);
}
}
}
}
class UnionFind
{
public:
vector<ll> Parent;
UnionFind(ll N)
{
Parent = vector<ll>(N, -1);
}
ll find(ll A)
{
if (Parent[A] < 0)
return A;
return Parent[A] = find(Parent[A]);
}
ll size(ll A)
{
return -Parent[find(A)];
}
bool Union(ll A, ll B)
{
A = find(A);
B = find(B);
if (A == B)
{
return false;
}
if (size(A) < size(B))
swap(A, B);
Parent[A] += Parent[B];
Parent[B] = A;
return true;
}
};
ll gcd(ll a, ll b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b)
{
ll g = gcd(a, b);
return a / g * b;
}
ll mulMod(ll a, ll b)
{
return (((a % MOD) * (b % MOD)) % MOD);
}
ll powMod(ll a, ll p)
{
if (p == 0)
{
return 1;
}
else if (p % 2 == 0)
{
ll half = powMod(a, p / 2);
return mulMod(half, half);
}
else
{
return mulMod(powMod(a, p - 1), a);
}
}
ll ceil(ll a, ll b)
{
return (a + b - 1) / b;
}
vector<ll> tsort(Graph G)
{
ll N = G.size();
vector<ll> in(N);
for (auto &&edges : G)
{
for (auto &&edge : edges)
{
in[edge]++;
}
}
queue<int> que;
for (int i = 0; i < N; i++)
{
if (in[i] == 0)
{
que.push(i);
}
}
int cnt = 0;
vector<ll> ans;
while (!que.empty())
{
int v = que.front();
que.pop();
ans.push_back(v);
for (auto &&next : G[v])
{
in[next]--;
if (in[next] == 0)
{
que.push(next);
}
}
}
return ans;
}
void solve(long long N, long long K, std::vector<long long> a){
vector<ll> ruiseki(N+1,0);
for (int i = 0; i < N; i++)
{
ruiseki[i+1] = ruiseki[i] + a[i];
}
vector<ll> sum;
for (int i = 0; i < N+1; i++)
{
for (int j = i+1; j < N+1; j++)
{
sum.push_back(ruiseki[j]-ruiseki[i]);
}
}
RSORT(sum);
vector<ll> tmp = sum;
for (ll i = 50LL; i >= 0; i--)
{
ll count = 0;
for (ll j = 0; j < tmp.size(); j++)
{
if(tmp[j] & (1LL << i)) count++;
}
if(count >= K){
vector<ll> d;
for (ll j = 0; j < tmp.size(); j++)
{
if(tmp[j] & (1LL << i)) d.push_back(tmp[j]);
}
tmp = d;
}
}
ll ans = 0;
if(tmp.size() >= K){
ans = tmp[0];
for (int i = 0; i < K; i++)
{
ans &= tmp[i];
}
}
cout << ans << endl;
}
int main(){
long long N;
scanf("%lld",&N);
long long K;
scanf("%lld",&K);
std::vector<long long> a(N);
for(int i = 0 ; i < N ; i++){
scanf("%lld",&a[i]);
}
solve(N, K, std::move(a));
return 0;
}
| 0
| 4,775,045
|
#ifndef BZ
#pragma GCC optimize "-O3"
#endif
#include <bits/stdc++.h>
#define FASTIO ios_base::sync_with_stdio(false),cin.tie(0),cout.tie(0);
#define rep(i, l, r) for (ll i = (l); i < (r); ++i)
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
#define vi vector<int>
#define vll vector<ll>
#define pii pair<int, int>
#define int ll
#define pll pair<ll, ll>
#define pdd pair<ld, ld>
#define pb push_back
#define reset(x,v) memset(x,v,sizeof(x))
#define mod 998244353
using namespace std;
void dfs(vector<int> adj[], int sv, vector<bool> &vis){
vis[sv] = true;
for(int i = 0; i < adj[sv].size(); i++){
if(!vis[adj[sv][i]]){
dfs(adj, adj[sv][i], vis);
}
}
}
ll power(ll x, ll y){
if(x == 1 || y == 0)
return 1;
ll res = 1;
x = x % mod;
if (x == 0)
return 0;
while (y > 0){
if (y & 1)
res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
signed main(){
FASTIO
int k;
cin >> k;
queue<int> q;
rep(i, 1, 10)
q.push(i);
while(!q.empty()){
int f = q.front();
q.pop();
if(k == 1){
cout << f;
return 0;
}
k--;
if(f%10 != 0)
q.push(f*10 + f%10 -1);
q.push(f*10 + f%10);
if(f%10 != 9)
q.push(f*10 + f%10 +1);
}
return 0;
}
|
#include<iostream>
#include<cstdio>
const int MAX_N = int(1e6);
int N, a[MAX_N+10];
int res, m[MAX_N+10];
int main()
{
std::cin>>N;
for (int i = 0; i < N; ++i)
scanf("%d", a+i);
res = 0;
for (int i = 0; i < N; ++i)
{
int l = 0, r = res+1;
while (r-l>1)
{
int mid = l+r>>1;
if (a[m[mid]] < a[i])
l = mid;
else
r = mid;
}
if (res < l+1)
{
res = l+1;
m[l+1] = i;
}
if (a[m[l+1]] > a[i])
m[l+1] = i;
}
std::cout<<res<<"\n";
}
| 0
| 34,395,814
|
#include <bits/stdc++.h>
#include <atcoder/all>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define REP(i,n) for (int64_t i=0; i<(n); ++i)
#define P pair<int,int>
using ll=int64_t;
using namespace std;
#define ketasuu(n) fixed<<setprecision(n)
#define btoe(p) p.begin(),p.end()
#define etob(p) p.rbegin(),p.rend()
#define chmax(x,y) x=max(x,y)
int main(){
int n,q; cin>>n>>q;
atcoder::dsu uf(n);
rep(i,q){
int a,b,c; cin>>a>>b>>c;
if(a==0){
uf.merge(b,c);
}else{
if(uf.same(b,c)){
cout<<1<<endl;
}else{
cout<<0<<endl;
}
}
}
}
|
#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 1e9
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 s; cin >> s;
int n = s.size();
int k; cin >> k;
ll ans = 0;
bool same = true;
rep(i,n-1){
if(s[i] == s[i+1]){
ans++;
i++;
}
if(s[0] != s[i+1]) same = false;
}
if(same){
ans = (ll)n*k/2;
}else{
ans *= k;
if(s[0] == s[n-1]){
int a = 0, b = n-1;
while(s[0] == s[a]) a++;
while(s[n-1] == s[b]) b--;
b = n-1 - b;
ans -= (a/2 + b/2 - (a+b)/2)*(k-1);
}
}
cout << ans;
cout << "\n";
return 0;
}
| 0
| 47,509,366
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll MOD = 1e9+7;
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()
int main(int argc, char **argv)
{
ll N; cin >> N;
vector<ll> T(N), A(N);
REP(i, N) cin >> T[i];
REP(i, N) cin >> A[i];
vector<pair<ll, ll>> tt(N), aa(N);
tt[0].first = tt[0].second = T[0];
REP(i, N-1)
{
ll l, r;
if (tt[i].second < T[i+1])
{
r = l = T[i+1];
}
else
{
r = tt[i].second;
l = 1;
}
tt[i+1].first = l;
tt[i+1].second = r;
}
reverse(ALL(A));
aa[0].first = aa[0].second = A[0];
REP(i, N-1)
{
ll l, r;
if (aa[i].second < A[i+1])
{
r = l = A[i+1];
}
else
{
r = aa[i].second;
l = 1;
}
aa[i+1].first = l;
aa[i+1].second = r;
}
reverse(ALL(aa));
ll res{1};
REP(i, N)
{
auto &a = aa[i];
auto &t = tt[i];
ll tmp = min(a.second, t.second) - max(a.first, t.first);
(res *= max(0ll, tmp+1)) %= MOD;
}
std::cout << res << std::endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int s;
cin >> s;
map<int, int> mp;
int count = 0;
while (1)
{
++count;
if (mp[s] == 1)
{
cout << count << endl;
return 0;
}
mp[s]++;
if (s % 2 == 0)
{
s /= 2;
}
else
{
s = 3 * s + 1;
}
}
}
| 0
| 12,290,398
|
#include<bits/stdc++.h>
using namespace std;
int main() {
int h,w;
cin >> h >> w;
for (int i = 0;i < h*w;++i) {
string s;
cin >> s;
if (s == "snuke") {
char a = 'A';
a += i%w;
cout << a << i/w+1 << "\n";
break;
}
}
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
int main()
{
int num;
int win_point = 3;
int draw_point = 1;
int taro_point = 0;
int hanako_point = 0;
string card_taro, card_hanako;
cin >> num;
for (int i = 0; i < num; ++i)
{
cin >> card_taro >> card_hanako;
if (card_taro > card_hanako){
taro_point += win_point;
}else if(card_taro < card_hanako){
hanako_point += win_point;
}
else{
taro_point += draw_point;
hanako_point += draw_point;
}
}
cout << taro_point << " " << hanako_point << endl;
}
| 0
| 72,918,196
|
#include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define yorn(f) cout<<((f)?"Yes":"No")<<endl;
#define YORN(f) cout<<((f)?"YES":"NO")<<endl;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, n) for (int i = 1; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define put(x) cout << x << endl;
#define println(x) cout << x << endl;
using namespace std;
int main()
{
ll X, Y;
cin >> X >> Y;
ll cnt = 0;
while (X <= Y) {
X *= 2;
cnt++;
}
put(cnt);
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<(n);++i)
#define sayyes cout<<"Yes"<<endl;
#define sayno cout<<"No"<<endl;
using namespace std;
typedef long long ll;
typedef pair<int,ll>P;
const int mod =998244353;
int main()
{
int n;
cin>>n;
vector<ll> d(n);
rep(i,n)
{
cin>>d[i];
}
if(d[0]!=0)
{
cout<<0;
return 0;
}
map<int,int> dc;
rep(i,n)
{
dc[d[i]]++;
}
if(dc[0]!=1)
{
cout<<0;
return 0;
}
ll ans=1;
P prev=P(0,1);
for(auto v:dc)
{
if(v.first-prev.first>1)
{
cout<<0;
return 0;
}
if(v.first>1)
{
rep(i,v.second)
{
ans=ans*prev.second%mod;
}
}
prev=v;
}
cout<<ans;
}
| 0
| 98,800,824
|
#include<bits/stdc++.h>
using namespace std;
#define itn int
#define endl "\n"
int main(void){
int n;
cin >> n;
long long int a[n],num[n];
for(int i = 0;i < n;i++)cin >> a[i];
num[0] = a[0];
for(int i = 1;i < n;i++)num[i] = num[i-1] + a[i];
long long int sum = abs(num[0] - (num[n-1] - num[0]));
for(int i = 1;i < n-1;i++)sum = min(sum,abs(num[i]-(num[n-1]-num[i])));
cout << sum << endl;
}
|
#include <iostream>
#include <stack>
#include <math.h>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#define rep(i,n) for(int i=0; i < n; i++)
using ll = long long;
using namespace std;
#define pi 3.14159265358979
int main()
{
int a, b;
cin >> a >> b;
int i = 1;
while((int)(i * 0.08) <= a && (int)(i * 0.1) <= b)
{
double x = i * 0.08;
double y = i * 0.1;
if ((int)x == a && (int)y == b)
{
cout << i;
return 0;
}
i++;
}
cout << -1;
return 0;
}
| 0
| 91,821,818
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
int calc(int y, int m, int d) {
int dy = y - 1, dm = m - 1;
int sum = 0;
sum += (dy - dy / 3) * (39 * 5) + (dy / 3) * (10 * 20);
sum += (y % 3) ? (dm / 2 * 39 + (dm % 2) * 20) : (dm * 20);
sum += d - 1;
return sum;
}
int main() {
int n;
while (cin >> n && n) {
rep(i, n) {
int y, m, d; cin >> y >> m >> d;
cout << calc(1000, 1, 1) - calc(y, m, d) << endl;
}
}
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int main()
{
int n, p[300000], min, ans = 0;
cin >> n;
rep(i, n) cin >> p[i];
min = p[0];
rep(i, n)
{
if (min >= p[i])
{
min = p[i];
ans++;
}
}
cout << ans << endl;
return 0;
}
| 0
| 2,833,077
|
#include <iostream>
#include <queue>
using namespace std;
int w,h;
int g[21][21];
bool visited[21][21];
int moves[4][2]={{-1,0},{1,0},{0,-1},{0,1}};
int count;
bool legal(int x, int y)
{
if(visited[x][y]!=true&&0<=x&&x<h&&0<=y&&y<w&&g[x][y]==0)
return true;
else
return false;
}
void dfs(int x,int y)
{
visited[x][y]=true;
count++;
for(int i=0;i<4;i++)
{
int newx=x+moves[i][0];
int newy=y+moves[i][1];
if(legal(newx,newy))
{
dfs(newx,newy);
}
}
}
int main()
{
while(1)
{
cin>>w>>h;
if(w==0&&h==0) break;
for(int i=0;i<h;i++)
for(int j=0;j<w;j++)
{
g[i][j]=-1;
visited[i][j]=false;
}
int psx,psy;
for(int i=0;i<h;i++)
for(int j=0;j<w;j++)
{
char s;
cin>>s;
switch(s)
{
case '.':
g[i][j]=0;break;
case '#':
g[i][j]=1;break;
case '@':
g[i][j]=2;psx=i;psy=j;break;
}
}
count=0;
dfs(psx,psy);
cout<<count<<endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define NIL -1
#define MAX 100001
struct Node{
int parent;
int left;
int right;
};
Node tree[MAX];
int n;
int depth[MAX];
void setdepth(int r,int i){
depth[r]=i;
if(tree[r].right != NIL)setdepth(tree[r].right,i);
if(tree[r].left != NIL) setdepth(tree[r].left,i+1);
}
void print_ch(int r){
int ch = tree[r].left;
for(int i=0;ch!=NIL;i++){
if(i)cout << ", ";
cout << ch;
ch = tree[ch].right;
}
}
void print(){
for(int i=0;i<n;i++){
cout << "node " <<i;
cout << ": parent = " << tree[i].parent;
cout << ", depth = " << depth[i];
if(tree[i].parent==NIL)cout << ", root";
else if(tree[i].left ==NIL)cout << ", leaf";
else cout << ", internal node";
cout << ", [";
print_ch(i);
cout << "]\n";
}
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
int id,k,ch;
int left;
for(int i=0;i<n;i++)tree[i].parent=tree[i].left=tree[i].right=NIL;
for(int i=0;i<n;i++){
cin >> id >> k;
for(int j=0;j<k;j++){
cin >> ch;
tree[ch].parent=id;
if(!j)tree[id].left=ch;
else tree[left].right=ch;
left=ch;
}
}
int r;
for(int i=0;i<n;i++){
if(tree[i].parent==NIL)r=i;
}
setdepth(r,0);
print();
return 0;
}
| 0
| 95,054,716
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#define ll long long
#define rep(i, a, b) for(ll i = (ll)a; i < (ll)b; i++)
using namespace std;
int main() {
int a, b, c, d;
cin >> a >> b >> c >> d;
if(a+b < c+d) cout << "Right\n";
else if(a+b > c+d) cout << "Left\n";
else cout << "Balanced\n";
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<(n); ++i)
#define chmin(x,y) x = min(x,y)
#define chmax(x,y) x = max(x,y)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int inf = 1<<21;
const ll INF = 1LL << 60;
const ll mod = 1e9+7;
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);
int n;
cin >> n;
vector<ll> a(n);
rep(i, n){
ll tmp;
cin >> tmp;
a[i] = tmp-i-1;
}
sort(a.begin(), a.end());
ll ans = 0;
rep(i, n){
ans += abs(a[i] - a[n/2]);
}
cout << ans << endl;
return 0;
}
| 0
| 10,731,581
|
#include <iostream>
#include <vector>
#include <climits>
#include <algorithm>
#include <cmath>
#include <map>
#include <set>
#include <string>
#include <bitset>
#include <utility>
#include <numeric>
#include <queue>
#include <stack>
using ll = long long;
using namespace std;
constexpr int MOD = 1e9 + 7;
constexpr ll MOD_LL = ll(1e9 + 7);
int main(void) {
char c;
cin >> c;
if( c == 'A' ) cout << 'T' << endl;
if( c == 'T' ) cout << 'A' << endl;
if( c == 'G' ) cout << 'C' << endl;
if( c == 'C' ) cout << 'G' << endl;
return 0;
}
|
#include <iostream>
#include <complex>
#include <vector>
#include <string>
#include <algorithm>
#include <cstdio>
#include <numeric>
#include <cstring>
#include <ctime>
#include <cstdlib>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <list>
#include <cmath>
#include <bitset>
#include <cassert>
#include <queue>
#include <stack>
#include <deque>
#include <random>
#include <iomanip>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef long long int ll;
typedef long double ld;
typedef pair<ll,ll> P;
const ll MOD=1000000007;
const ll MAX_N=500010;
const ll INF=999999999999;
int main(){
int k;
cin>>k;
string s;
cin>>s;
string ans="";
if(s.length()>k){
for(int i=0;i<k;i++){
ans+=s[i];
}
ans+="...";
}else{
ans=s;
}
cout<<ans<<endl;
}
| 0
| 81,651,261
|
#include <bits/stdc++.h>
#include <ext/numeric>
using namespace std;
using namespace __gnu_cxx;
#define all(v) v.begin(), v.end()
#define UNIQUE(c) (c).resize(unique(all(c)) - (c).begin())
#define endl "\n"
#define pb push_back
#define F first
#define S second
#define START cin.tie(0); cout.tie(0); ios_base::sync_with_stdio(0);
#define isOdd(n) (n&1)
#define LLMAX LLONG_MAX
#define LLMIN LLONG_MIN
#define IMN INT_MIN
#define IMX INT_MAX
#define pow(n, m) power((ll)n, (ll)m)
#define numOfDigits(n) ((n)? (ll)(log10(n))+1 : 1)
#define mem(x, val) memset(x, val, sizeof(x))
#define var auto
#define MOD 1000000007
typedef long long ll;
typedef long double ld;
typedef double dd;
typedef pair<int, int> pii;
int main()
{
START
char c; cin>>c;
cout<<(c=='a'||c=='e'||c=='i' || c=='o' || c=='u'? "vowel":"consonant");
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(ll i=0;i<(n);i++)
#define rrep(i,n) for(ll i=(n)-1;i>=0;i--)
template<typename T =ll> using v = vector<T>;
template<typename T =ll> using vv = v<v<ll>>;
template<typename T=ll,typename U=ll> using p = pair<T,U>;
template<typename T> T chmin(T &a,T b) {return a=min(a,b);}
template<typename T> T chmax(T &a,T b) {return a=max(a,b);}
const ll INF = (ll)1e9;
ll misum =0;
ll func(ll i,const v<> &c){
if(i>=c.size()||misum>=0)return 0;
misum+=c[i];
return func(i+1,c)+1;
}
int main(){
ll n; cin >> n;
auto a = v<>(n,0);
auto b = v<>(n,0);
auto c = v<>(n,0);
rep(i,n) cin >> a[i];
rep(i,n) cin >> b[i];
rep(i,n) c[i] = a[i]-b[i];
sort(c.begin(),c.end());
ll ans =count_if(c.begin(),c.end(),[](ll i)mutable{
if(i<0) {
misum+=i;
return true;
}
return false;
});
if(accumulate(c.begin(),c.end(),(ll)0)<0){
cout << -1 << endl;
return 0;
}
sort(c.begin(),c.end(),greater<ll>());
cout << ans+func(0,c);
return 0;
}
| 0
| 88,358,674
|
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
int main() {
string s;
int a, b, c;
cin >> s;
if(s[0]==s[1] && s[1]==s[2])
cout << "No" << endl;
else
cout << "Yes" << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,x,n) for(int i=x; i<(int)(n); i++)
#define rep_eq(i,x,n) for(int i=x; i<=(int)(n); i++)
using namespace std;
using ll=long long;
int main() {
int N,M,X; cin >>N >>M >>X;
vector<int> C(N);
vector<vector<int>> A(N,vector<int>(M));
rep(i,0,N) {
cin >>C[i];
rep(j,0,M) {
cin >>A[i][j];
}
}
int ans=INT_MAX;
int all=1<<N;
rep(mask,0,all) {
vector<int> level(M);
int cost=0;
rep(i,0,N) {
if (mask>>i&1) {
cost+=C[i];
rep(j,0,M) {
level[j]+=A[i][j];
}
}
}
bool flag=true;
rep(j,0,M) {
if (level[j]<X) {
flag=false;
}
}
if (flag) {
ans=min(ans,cost);
}
}
if (ans==INT_MAX) {
cout <<-1 <<endl;
} else {
cout <<ans <<endl;
}
return 0;
}
| 0
| 1,944,756
|
#ifdef debug
#include <chrono>
#endif
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <cmath>
#include <vector>
#include <sstream>
#include <string>
#include <cstring>
#include <cstdio>
#include <stack>
#include <queue>
#include <list>
#include <numeric>
#include <fstream>
#include <iterator>
#include <cassert>
using namespace std;
#define dout cout
#ifdef OUTPUTFILE
#define dout outputfile
ofstream outputfile(OUTPUTFILE);
#define OutputFilePath "/Users/Nag/Documents/Prgm/Test/DerivedData/Test/Build/Products/Debug/output.txt"
#endif
#define din cin
#ifdef INPUTFILE
#define din inputfile
ifstream inputfile(INPUTFILE);
#endif
#define scand(A) scanf("%d", &(A))
#define scans(A) scanf("%s", (A))
#define disp(A) dout << #A << " = " << setw(3) << (A) << endl
#define disP(A) dout << setw(3) << (A) << " "
#define rep(i,a,n) for(int (i)=(a); (i)<(n); (i)++)
#define dispAll(A,n) dout << #A << " = "; rep(j, 0, (n)) {disP(A[j]);} dout << endl
#define sign(x) ((x)>0)-((x)<0)
#define p(i) (i)/2
#define l(i) (i)*2
#define r(i) (i)*2+1
int dx[] = {1,-1, 0, 0, 1, 1,-1,-1};
int dy[] = {0, 0,-1, 1,-1, 1, 1,-1};
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef long long ll;
typedef unsigned long ull;
const int INF = (int)2e9+10;
const ll INF_LL = (ll)9e18-1LL;
const ull INF_ULL = (ull)1e19-1ULL;
const int NONE = -1;
const ll MOD = (ll)1e9+7;
const int N_MAX = 10010;
const int M_MAX = 100010;
const int DATA_MAX = 1010;
int N;
int root[N_MAX];
int Rank[N_MAX] = {0};
int find(int x) {
if(root[x]==x) return x;
else return root[x] = find(root[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if(x==y) return;
if(Rank[x] < Rank[y]) root[x] = y;
else {
root[y] = x;
if(Rank[x]==Rank[y]) Rank[x]++;
}
}
#define isSame(x,y) (find(x)==find(y))
#ifdef debug
void display() {
}
#endif
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
din >> N;
int Q; din >> Q;
rep(i,0,N) root[i] = i;
#ifdef debug
auto startTime = chrono::system_clock::now();
#endif
int x, y;
while(din >> Q >> x >> y) {
if(Q) {
dout << isSame(x,y) << endl;
}
else {
unite(x,y);
}
#ifdef debug
dout << "----------------------------\n";
dout << (Q?"unite":"isSame") << " " << x << " " << y << endl;
dout << " i = "; rep(i,0,N) disP(i);
dout << endl;
dispAll(root, N);
dispAll(Rank, N);
#endif
}
#ifdef debug
auto endTime = chrono::system_clock::now();
auto dur = endTime - startTime;
auto msec = chrono::duration_cast<chrono::milliseconds>(dur).count();
dout << fixed << setprecision(4) << (double)msec/1000 << " sec \n";
#endif
#ifdef INPUTFILE
inputfile.close();
#endif
#ifdef OUTPUTFILE
outputfile.close();
cout << "\"" << OutputFilePath << "\"" << endl;
#endif
return 0;
}
|
#include <iostream>
using namespace std;
int main(){
int N, M, P;
while( 1 ){
cin >> N >> M >> P;
if( N == 0 && M == 0 && P == 0 ) break;
int money = 0, mn;
for( int i = 1; i <= N; i++ ){
int j;
cin >> j;
if(M == i) mn = j;
money += j;
}
if( mn == 0 ){
cout << 0 << endl;
}else{
money = money * (100 - P) / mn;
cout << money << endl;
}
}
}
| 0
| 40,880,408
|
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
#define LL long long
#define fgx cerr<<"--------------"<<endl;
#define dgx cerr<<"=============="<<endl;
inline LL read(){
LL x=0,f=1;char c=getchar();
for(;!isdigit(c);c=getchar()) if(c=='-') f=-1;
for(;isdigit(c);c=getchar()) x=x*10+c-'0';
return x*f;
}
const int MAXN = 200010;
const LL INF = 2147483600;
struct dat{
LL id,val;
}a[MAXN+1]; LL N;
bool cmpval(dat a,dat b){
return a.val>b.val;
}
LL Node[MAXN<<1],Next[MAXN<<1],Root[MAXN+1],cnt;
inline void insert(LL u,LL v){
Node[++cnt]=v; Next[cnt]=Root[u]; Root[u]=cnt; return ;
} LL sz[MAXN+1],f[MAXN+1],b[MAXN+1];
inline void dfs(LL k,LL Fa){
sz[k]=1; for(LL x=Root[k];x;x=Next[x]){
LL v=Node[x]; if(v==Fa) continue;
dfs(v,k); sz[k]+=sz[v]; f[1]+=sz[v];
} return ;
}
inline void dfs2(LL k,LL Fa){
if(f[k]!=b[k]){ puts("-1"); exit(0); }
for(LL x=Root[k];x;x=Next[x]){
LL v=Node[x]; if(v==Fa) continue;
f[v]=f[k]+N-2*sz[v]; dfs2(v,k);
} return ;
} LL s1[MAXN+1],s2[MAXN+1],top;
int main(){
N=read();
for(LL i=1;i<=N;i++){
a[i].id=i; a[i].val=read(); b[i]=a[i].val;
} sort(a+1,a+N+1,cmpval);
for(LL i=1;i<=N;i++) sz[i]=1;
for(LL i=1;i<N;i++){
LL val=a[i].val-N+2*sz[i];
LL l=i+1,r=N,pos=-1;
while(l<=r){
LL mid=(l+r)>>1;
if(a[mid].val>=val) pos=mid,l=mid+1;
else r=mid-1;
} if(pos==-1||a[pos].val!=val){
puts("-1"); return 0;
} sz[pos]+=sz[i];
s1[++top]=a[i].id; s2[top]=a[pos].id;
insert(a[i].id,a[pos].id);
insert(a[pos].id,a[i].id);
} dfs(1,0); dfs2(1,0);
for(LL i=1;i<=top;i++) printf("%lld %lld\n",s1[i],s2[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MOD (long long)(1e9+7)
#define INF (1LL<<60)
#define rep(i,n) for(ll i = 0; i < (n); i++)
#define rep1(i,n) for(ll i = 1; i <= (n); i++)
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;
}
ll gcd(ll a, ll b)
{
if(b == 0) return a;
return gcd(b, a % b);
}
ll modinv(ll a, ll m) {
ll b = m, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
vector<pair<ll, ll>> prim;
void pf(ll n)
{
ll s = sqrt(n);
ll r = 0;
for(ll i = 2; i <= s; i++) {
if((n % i) == 0) {
r = 0;
do {
r++;
n = n / i;
} while((n % i) == 0);
prim.push_back({i, r});
}
}
if(n > s) {
prim.push_back({n, 1});
}
}
void solve()
{
ll N; cin >> N;
vector<ll> a(N); rep(i, N) cin >> a[i];
ll ans = 0;
ll cnt = 0;
sort(a.begin(), a.end());
rep(i, N - 1) {
if(a[i] == a[i + 1]) cnt++;
}
ans = N - ((cnt + 1) / 2) * 2;
cout << ans << endl;
}
int main(void)
{
solve();
}
| 0
| 51,281,513
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(),(x).end()
const int mod=998244353,MAX=100005,INF=1<<28;
int main(){
std::ifstream in("text.txt");
std::cin.rdbuf(in.rdbuf());
cin.tie(0);
ios::sync_with_stdio(false);
while(1){
int N;cin>>N;
if(N==0) break;
int a=0,b=0;
int cnt=0;
for(int i=0;i<N;i++){
string S;cin>>S;
if(S=="lu") a++;
if(S=="ld") a--;
if(S=="ru") b++;
if(S=="rd") b--;
if(cnt%2==0&&a==1&&b==1) cnt++;
if(cnt%2==1&&a==0&&b==0) cnt++;
}
cout<<cnt<<endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
using pll = pair<ll,ll>;
#define INF (1LL << 60)
#define MOD 1000000007
#define PI 3.14159265358979323846
#define REP(i,m,n) for(ll (i)=(m),(i_len)=(n);(i)<(i_len);++(i))
#define FORR(i,v) for(auto (i):v)
#define ALL(x) (x).begin(), (x).end()
#define PR(x) cout << (x) << endl
#define PS(x) cout << (x) << " "
#define SZ(x) ((ll)(x).size())
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
#define REV(x) reverse(ALL((x)))
#define ASC(x) sort(ALL((x)))
#define DESC(x) ASC((x)); REV((x))
#define pb push_back
#define eb emplace_back
int main()
{
ll N;
cin >> N;
vec A = {1, 6, 6*6, 6*6*6, 6*6*6*6, 6*6*6*6*6, 6*6*6*6*6*6, 9, 9*9, 9*9*9, 9*9*9*9, 9*9*9*9*9};
vec dp(N+1, INF);
dp[0] = 0;
REP(i,1,N+1) {
REP(j,0,SZ(A)) {
if(i >= A[j]) dp[i] = MIN(dp[i],dp[i-A[j]]+1);
}
}
PR(dp[N]);
return 0;
}
| 0
| 33,218,823
|
#include <iostream>
using namespace std;
using ll = long long;
using ld = long double;
#define ALL(x) begin(x), end(x)
#define REP(i, n) for (size_t i = 0, i##_len = (n); i < i##_len; ++i)
void solve(ll N) {
cout << (N-1)/2 << endl;
}
int main() {
ll N;
cin >> N;
solve(N);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const int mod = 1e9+7;
int main()
{
int x, n;
cin >> x >> n;
if(n == 0)
{
cout << x << endl;
return 0;
}
int p[n];
rep(i, n) cin >> p[i];
sort(p, p+n);
auto it1 = lower_bound(p, p+n, x);
int tmp=*it1, tmpl=*it1, tmpr=*it1;
while(tmp >= 1 && tmp <= 100)
{
if(!binary_search(p, p+n, tmp)) break;
if(abs(x-tmpl) >= abs(tmpr-x))
{
tmpr--;
tmp = tmpr;
}
else
{
tmpl++;
tmp = tmpl;
}
}
cout << tmp << endl;
}
| 0
| 55,415,384
|
#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 vi = vector<int>;
using vvi = vector<vi>;
int main() {
string str;
cin >> str;
rep(i,4) cout << str.at(i);
cout << " ";
rep(i,8) cout << str.at(i+4);
cout << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rng(i,a,b) for(int i=int(a);i<int(b);i++)
#define rep(i,b) rng(i,0,b)
#define gnr(i,a,b) for(int i=int(b)-1;i>=int(a);i--)
#define per(i,b) gnr(i,0,b)
#define bg begin()
#define ed end()
#define all(x) x.bg,x.ed
#define pb push_back
#define pf push_front
#define eb emplace_back
using namespace std;
typedef long long ll;
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(b<a)a=b;}
template<class t> using vc=vector<t>;
template<class t> using vvc=vc<vc<t>>;
using pi=pair<int,int>;
using vi=vc<int>;
void yes(){ cout << "Yes" << endl; }
void no(){ cout << "No" << endl; }
int SIZE(string s){return (int)s.size();}
const long long INF = 1LL << 60;
int main(){
cout << fixed << setprecision(20);
ll n,c,k; cin >> n >> c >> k;
vc<ll> a(n);
rep(i,n) cin >> a[i];
sort(a.begin(), a.end());
ll cnt = 0, ans = 1, cri=a[0];
rep(i,n){
if(a[i]-cri > k || cnt == c){
cri = a[i];
ans++;
cnt = 0;
}
cnt++;
}
cout << ans << endl;
return 0;
}
| 0
| 57,018,862
|
#pragma region Macros
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Graph = vector<vector<int>>;
using WGraph = vector<vector<pair<int, ll>>>;
template<class T>bool chmax(T &a, const T &b) { if (b > a) { 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; }
constexpr int dx[4] = {-1, 0, 0, 1}, dy[4] = {0, -1, 1, 0};
constexpr int INF = 1e9;
constexpr long long LINF = 1e18;
#pragma endregion
void solve() {
int n, a, b;
cin >> n >> a >> b;
int cnt0 = 0, cnt1 = 0, cnt2 = 0;
for (int i=0; i<n; i++) {
int tmp;
cin >> tmp;
if (tmp <= a) cnt0++;
else if (tmp > a && tmp <= b) cnt1++;
else cnt2++;
}
cout << min(cnt0, min(cnt1, cnt2)) << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(20);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
long long N; cin >> N;
long long ans = 9999999999;
int tmp_a = 0;
int tmp_b = 0;
for(long long i = 1; i * i <= N; i++){
if(N % i == 0){
long long a,b;
a = i;
b = N / i;
while(a > 0){
a /= 10;
tmp_a++;
}
while(b > 0){
b /=10;
tmp_b++;
}
if(max(tmp_a,tmp_b) < ans) ans = max(tmp_a,tmp_b);
}
tmp_a = 0;
tmp_b = 0;
}
cout << ans << endl;
}
| 0
| 64,492,188
|
#include <iostream>
#include <map>
#include <string>
#include <algorithm>
#include <vector>
#define ll long long
int main()
{
ll a, b, c, d;
std::cin >> a >> b >> c >> d;
ll max_num = -1000000000000000000;
max_num = (max_num > (a*c)) ? max_num : (a*c);
max_num = (max_num > (a*d)) ? max_num : (a*d);
max_num = (max_num > (b*c)) ? max_num : (b*c);
max_num = (max_num > (b*d)) ? max_num : (b*d);
std::cout << max_num << std::endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(i,a,n) for(ll i=(ll)a;i<(ll)n;i++)
#define RFOR(i,a,n) for(ll i=(ll)n-1;i >= (ll)a;i--)
#define rep(i,n) FOR(i,0,n)
#define rrep(i,n) RFOR(i,0,n)
#define ALL(v) v.begin(), v.end()
#define bra(first,second) '(' << first << ',' << second << ')'
ll MOD = 1000000007;
ll INF = 100100100100100100;
long double EPS = 1e-11;
long double PI = 3.141592653589793238;
template<typename T>
void remove(std::vector<T>& vector, unsigned int index){
vector.erase(vector.begin() + index);
}
using Graph = vector<vector<ll>>;
template <class T>
class SegmentTree{
ll N;
vector<T> data;
T def;
function<T(T,T)> operation;
function<T(T,T)> update;
T _query(ll a,ll b,ll k,ll l,ll r){
if(b <= l || r <= a) return def;
if(a <= l && r <= b){
return data[k];
}else{
T c1 = _query(a,b,k*2+1,l,(l+r)/2);
T c2 = _query(a,b,k*2+2,(l+r)/2,r);
return operation(c1,c2);
}
}
public:
SegmentTree(size_t _N,T _def,function<T(T,T)> _operaition,function<T(T,T)> _update):def(_def),operation(_operaition),update(_update){
N = 1;
while(N < _N){
N *= 2;
}
data = vector<T>(2*N-1,def);
}
void change(ll i,T x){
i += N-1;
data[i] = update(data[i],x);
while(i > 0){
i = (i-1)/2;
data[i] = operation(data[i*2+1],data[i*2+2]);
}
}
T query(ll a,ll b){
return _query(a,b,0,0,N);
}
T operator[](ll i){
return data[i+N-1];
}
};
ll N;
auto f = [](ll a,ll b){return max(a,b);};
auto g = [](ll a,ll b){return b;};
SegmentTree<ll> ST(100010,0,f,g);
ll lwb(ll x,ll t){
ll l = t,r = N+1;
while(r-l > 1){
ll mid = (l+r)/2;
if(ST.query(t,mid) > x)r = mid;
else l = mid;
}
if(r == N+1)return N;
return r-1;
}
ll lwb2(ll x,ll t){
ll l = -1,r = t;
while(r-l > 1){
ll mid = (l+r)/2;
if(ST.query(mid,t) > x)l = mid;
else r = mid;
}
return l;
}
int main(){
cin >> N;
vector<ll> A(N);
rep(i,N){
cin >> A[i];
ST.change(i,A[i]);
}
ll ans = 0;
rep(i,N){
ll a,b,c,d;
c = lwb(A[i],i);b = lwb2(A[i],i);
d = lwb(A[i],c+1);a = lwb2(A[i],b);
ans += ((d-c) * (i-b) + (c-i) * (b-a)) * A[i];
}
cout << ans << endl;
}
| 0
| 14,613,094
|
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<unordered_map>
#include<utility>
#include<cmath>
#include<random>
#include<cstring>
#include<queue>
#include<stack>
#include<bitset>
#include<cstdio>
#include<sstream>
#include<iomanip>
#include<assert.h>
#include<typeinfo>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define FOR(i,a) for(auto i:a)
#define pb push_back
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
#define show1d(v) rep(i,v.size())cout<<" "<<v[i];cout<<endl<<endl;
#define show2d(v) rep(i,v.size()){rep(j,v[i].size())cout<<" "<<v[i][j];cout<<endl;}cout<<endl;
using namespace std;
typedef long long ll;
typedef int Def;
typedef pair<Def,Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def,pii> pip;
typedef vector<pip>vip;
template<typename A,typename B>bool cmin(A &a,const B &b){return a>b?(a=b,true):false;}
template<typename A,typename B>bool cmax(A &a,const B &b){return a<b?(a=b,true):false;}
const double PI=acos(-1);
const double EPS=1e-9;
Def inf = sizeof(Def) == sizeof(long long) ? 2e18 : 1e9+10;
int dx[]={0,1,0,-1};
int dy[]={1,0,-1,0};
int main(int argc, char *argv[])
{
string s;
cin >> s;
cout << s.substr(0, 4) << " " << s.substr(4) << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define f first
#define s second
#define MOD 1000000007
#define PMOD 998244353
#define pb(x) push_back(x)
using namespace std;
typedef long long int ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> plii;
typedef pair<int, pii> piii;
const int INF = 1e9+10;
const ll LINF = 1LL*INF*INF;
const int MAXN = 3e5+10;
const int MAXM = 5e3+10;
priority_queue<int> pq;
vector<vector<int> > graph;
queue<int> que;
int A[MAXN];
int ans[MAXN];
pii id[MAXN];
char S[MAXN];
void chmin(pii &a,int x)
{
if(x==-1)return;
if(a.f==x||a.s==x)return;
if(a.f==-1){a.f = x; return;}
else if(A[a.f]<=A[x]){
a.s = a.f; a.f = x;
return;
}
else {
if(a.s==-1)a.s = x;
else if(A[a.s]<A[x])a.s = x;
return;
}
}
int main()
{
int n,m,k,a,b,x,y,q;
int sum = 0;
int cnt = 0;
int mx = 0;
int mn = INF;
int cur = 0, idx = -1;
int tc;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin>>n;
for(int i=0;i<(1<<n);i++)
cin>>A[i];
id[0] = pii(0,-1);
for(int i=1;i<(1<<n);i++){
id[i] = pii(i,-1);
for(int j=0;j<n;j++){
if(!((1<<j)&i))continue;
cur = i^(1<<j);
chmin(id[i],id[cur].f);
chmin(id[i],id[cur].s);
chmin(id[i],(1<<j));
}
ans[i] = max(ans[i-1],A[id[i].f]+A[id[i].s]);
}
for(int i=1;i<(1<<n);i++)
cout<<ans[i]<<"\n";
return 0;
}
| 0
| 19,460,621
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for(int i = (a); i < (b); ++i)
#define REP(i, n) for(int i = 0; i < (n); ++i)
#define REPr(i, n) for(int i = (n)-1; i >= 0; --i)
#define FORq(i, m, n) for(int i = (m); i <= (n); ++i)
#define FORqr(i, m, n) for(int i = (n); i >= (m); --i)
#define MP make_pair
#define SIN(x, S) (S.count(x) != 0)
#define M0(x) memset(x, 0, sizeof(x))
#define FILL(x, y) memset(x, y, sizeof(x))
#define MM(x) memset(x, -1, sizeof(x))
#define ALL(x) (x).begin(), (x).end()
#define DB(x) cerr << #x << " = " << x << endl
#define DB2(x, y) \
cerr << "(" << #x << ", " << #y << ") = (" << x << ", " << y << ")\n";
#define DEBUG \
int x12345; \
cin >> x12345;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef long long ll;
typedef long long integer;
const long long MOD = 1e9 + 7;
template <class T> inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
}
int main() {
int ans = 0;
int count = 0;
int N, X, T;
cin >> N >> X >> T;
while(true) {
count += X;
ans += T;
if(count >= N) {
cout << ans << 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;
typedef pair<ll,double> P;
typedef tuple<ll,ll,ll> T;
const long long INF = 1LL<<60;
const int MOD = 1000000000+7;
#define rev(s) (string((s).rbegin(), (s).rend()))
template < typename T > inline string toString( const T &a ) { ostringstream oss; oss << a; return oss.str(); };
ll dp[110][2][5];
int main() {
string s;cin>>s;
int k;cin>>k;
int n = s.size();
dp[0][0][0] = 1;
rep(i,n) {
int num = s[i] - '0';
rep(j,5) {
dp[i+1][1][min(4,j+1)] += 9*dp[i][1][j];
dp[i+1][1][j] += dp[i][1][j];
}
if(num==0) {
rep(j,5) dp[i+1][0][j] += dp[i][0][j];
} else {
rep(j,5) dp[i+1][0][min(4,j+1)] += dp[i][0][j];
}
if(num>=1) {
rep(j,num) {
if(j==0) rep(p,5) dp[i+1][1][p] += dp[i][0][p];
else rep(p,5) dp[i+1][1][min(4,p+1)] += dp[i][0][p];
}
}
}
cout << dp[n][0][k] + dp[n][1][k] << endl;
}
| 0
| 65,562,126
|
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using ll=long long;
using namespace std;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const ll INF=1LL<<60;
int n;
vector<int> a(1000100);
vector<int> cnt(1000100);
int main(){
cin>>n;
rep(i,n){
cin>>a[i];
cnt[a[i]]++;
cnt[a[i]+1]++;
if(a[i]>0) cnt[a[i]-1]++;
}
sort(cnt.begin(),cnt.end(),greater<int>());
cout<<cnt[0]<<"\n";
return 0;
}
|
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int n;
cin>>n;
int r[n], c[n], a[n][n];
for(int i=0;i<n;i++) cin>>r[i]>>c[i];
for(int i=0;i<n;i++)
a[i][i] = 0;
for(int i=1;i<n;i++){
for(int j=0;j+i<n;j++){
a[j][j+i] = 2000000000;
for(int k=0;k+1<=i;k++)
a[j][j+i] = min(a[j][j+i], a[j][j+k]+a[j+k+1][j+i] + r[j]*c[j+k]*c[j+i]);
}
}
cout<<a[0][n-1]<<endl;
return 0;
}
| 0
| 70,121,957
|
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <utility>
#include <algorithm>
#include <cstdio>
#include <iomanip>
#include <queue>
#include <deque>
#include <stack>
#include <fstream>
#include <cmath>
#include <random>
#include <complex>
#include <functional>
#include <bitset>
#include <sstream>
#include <cassert>
#include <time.h>
#define ll int64_t
#define Rep(i, n) for (ll i = 0; i < n; i++)
using namespace std;
typedef vector<ll> vec;
typedef vector<vec> mat;
const ll inf = 1LL << 60;
template<class T> inline void chmin(T& a, T b) {
if (a > b) {
a = b;
}
}
template<class T> inline void chmax(T& a, T b) {
if (a < b) {
a = b;
}
}
void printvec (vec &v) {
Rep (i, (ll)v.size()) {
cout << v[i] << " \n"[i+1 == (ll)v.size()];
}
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll N, X, M;
cin >> N >> X >> M;
if (N <= 1000000) {
ll ans = 0;
Rep (i, N) {
ans += X;
X *= X;
X %= M;
}
cout << ans << endl;
return 0;
}
ll tmp = X;
vec appear(M, -1);
deque<ll> A;
ll start;
while (true) {
if (appear[tmp] > -1) {
start = tmp;
break;
}
A.push_back(tmp);
appear[tmp] = 1;
tmp *= tmp;
tmp %= M;
}
ll ans = 0;
while (A.front() != start) {
ans += A.front();
A.pop_front();
N--;
}
ll s = 0;
for (ll e : A) {
s += e;
}
ll n = A.size();
ll div = N / n;
ll rem = N % n;
ans += s * div;
Rep (i, rem) {
ans += A[i];
}
cout << ans << "\n";
}
|
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iomanip>
#include <numeric>
#include <queue>
#include <cmath>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<long long int>> v(8, vector<long long int>(0));
for (int i = 0; i < n; i++) {
long long int a, b, c;
cin >> a >> b >> c;
for (int ia = -1; ia <= 1; ia += 2) {
for (int ib = -1; ib <= 1; ib += 2) {
for (int ic = -1; ic <= 1; ic += 2) {
int index = 0;
if (ia == 1) index += 4;
if (ib == 1) index += 2;
if (ic == 1) index += 1;
v[index].push_back(ia * a + ib * b + ic * c);
}
}
}
}
long long int res = 0;
for (int i = 0; i < 8; i++) {
sort(v[i].begin(), v[i].end(), greater<long long int>());
res = max(res, accumulate(v[i].begin(), v[i].begin() + m, (long long int)0));
}
cout << res << endl;
}
| 0
| 29,665,601
|
#include <map>
#include <set>
#include <list>
#include <cmath>
#include <queue>
#include <stack>
#include <cstdio>
#include <string>
#include <vector>
#include <complex>
#include <cstdlib>
#include <cstring>
#include <numeric>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <functional>
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define repi(i,a,b) for(int i = (a); i < (b); i++)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef pair<int,int> pii;
const int INF=1<<29;
const double EPS=1e-9;
const int dx[]={1,0,-1,0},dy[]={0,-1,0,1};
pii A[200];
int dp[200][200];
int n;
int f[200][200];
void solve(){
for(int i =0;i < n;i++){
for(int j =0;j < n;j++){
if(i==j)dp[i][j]=0;
else dp[i][j]=INF;
}
}
for(int k =1;k <n;k++){
for(int i =0;i <n-k;i++){
for(int j =i;j <i+k;j++){
int tmp =A[i].first*A[j].second*A[i+k].second;
if(dp[i][i+k] >dp[i][j]+dp[j+1][i+k]+tmp){
dp[i][i+k]=dp[i][j]+dp[j+1][i+k]+tmp;
f[i][i+k] =j;
}
}
}
}
}
void print(int i,int j){
if(i==j){
cout <<"A"<<i;
}else{
cout <<"(";
print(i,f[i][j]);
print(f[i][j]+1,j);
cout <<")";
}
}
int main(){
cin>>n;
for(int i =0;i < n;i++){
cin>>A[i].first>>A[i].second;
}
solve();
cout <<dp[0][n-1]<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define s second
#define FIO ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define mod 1000000007
#define pb push_back
#define mp make_pair
#define f first
const ll N=1e3+5;
ll bexpo(ll x,ll n){
if(n==0)return 1;
else if(n%2==0)return bexpo(x*x,n/2);
else return x*bexpo(x*x,(n-1)/2);
}
ll gcd(ll a,ll b){if(!b)return a;return gcd(b,a%b);}
int Arr[N];
void initialize()
{
for(int i = 0;i<N;i++)
Arr[ i ] = i ;
}
int root(int i)
{
while(Arr[ i ] != i)
{
i = Arr[ i ];
}
return i;
}
void unio(int A ,int B)
{
int root_A = root(A);
int root_B = root(B);
if(root_A<root_B)
Arr[ root_A ] = root_B ;
else
Arr[root_B]=root_A;
}
bool find(int A,int B)
{
if( root(A)==root(B) )
return true;
else
return false;
}
ll dp[N][N];
vector<ll> adj[N];
string a[N];
ll h,w;
ll dfs(ll i,ll j)
{
if(i>h || j>w)
return 0;
if(dp[i][j]!=-1)
return dp[i][j];
if(i==h && j==w)
return 1;
ll cnt=0;
for(ll x=0;x<=1;x++)
{
for(ll y=0;y<=1;y++)
{
if(x!=y && a[i+x-1][j+y-1]=='.')
cnt=(cnt+dfs(i+x,j+y))%mod;
}
}
return dp[i][j]=cnt;
}
int main() {
FIO;
cin>>h>>w;
ll i,j;
for(i=0;i<h;i++)
{
cin>>a[i];
}
for(i=1;i<=h;i++)
for(j=1;j<=w;j++)
dp[i][j]=-1;
cout<<dfs(1,1);
}
| 0
| 59,149,929
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll ans;
int main()
{
int n;
scanf("%d", &n);
ans = 1ll * n * (n + 1) * (n + 2) / 6;
for(int i = 1; i < n; ++i)
{
int u, v;
scanf("%d%d", &u, &v);
if(u > v) swap(u, v);
ans -= 1ll * u * (n - v + 1);
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define bug printf("bug\n");
#define bug2(var) cout<<#var<<" "<<var<<endl;
#define co(q) cout<<q<<endl;
#define all(q) (q).begin(),(q).end()
typedef long long int ll;
typedef unsigned long long int ull;
const int MOD = (int)1e9+7;
const int MAX = 1e6;
#define pi acos(-1)
#define inf 1000000000000000LL
#define FastRead ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int arr[MAX];
int main()
{
FastRead
ll n,m;
cin>>n>>m;
vector<pair<ll,ll> >v;
for(int i=0; i<n; i++)
{
ll a,b;
cin>>a>>b;
v.push_back({a,b});
}
sort(all(v));
ll sum=0;
for(int i=0; i<n; i++)
{
if(v[i].second<=m)
{
m-=v[i].second;
sum+=v[i].first*v[i].second;
}
else
{
sum+=v[i].first*m;
m=0;
break;
}
}
cout<<sum<<endl;
return 0;
}
| 0
| 56,862,800
|
#include <algorithm>
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(X, Y) for (int(X) = 0; (X) < (Y); ++(X))
#define rrep(X, Y) for (int(X) = (Y)-1; (X) >= 0; --(X))
#define all(X) (X).begin(), (X).end()
#define pb push_back
#define mp make_pair
#define fi first
#define sc second
#define print(x) cout << x << endl
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
void solve(long long N) {
vector<ll> ans;
for (ll i = 1; i < (ll)sqrt(N) + 1; i++) {
if (N % i == 0) {
ll j = N / i - 1;
if (j > i) {
ans.push_back(j);
}
}
}
ll sum = 0;
for (ll i : ans) {
sum += i;
}
print(sum);
}
int main() {
long long N;
scanf("%lld", &N);
solve(N);
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cstring>
#include <complex>
#include <stack>
#include <queue>
#include <unordered_map>
#include <set>
#include <deque>
#include <map>
#define INF 100000000
#define rep(i, a) for (int i = 0; i < (a); i++)
using namespace std;
using P = pair<long, long>;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if(a < b) return euclidean_gcd(b, a);
unsigned r;
while ((r=a%b)) {
a = b;
b = r;
}
return b;
}
int main(){
long long n, k;
cin >> n >> k;
vector<long long> a(n);
long long m = 0;
for(long long i = 0; i < n; i++){
cin >> a[i];
m = max(m, a[i]);
}
long long g = a[0];
for(long long i = 1; i < n; i++){
g = euclidean_gcd(g, a[i]);
}
if(m >= k && k%g == 0){
cout << "POSSIBLE" << endl;
}else{
cout << "IMPOSSIBLE" << endl;
}
}
| 0
| 90,246,607
|
#include<bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; i++)
#define repo(i, n) for(int i=1; i<=n; i++)
#define ssort(a) sort(a.begin(), a.end(), greater<ll>())
#define INF 1001001001
#define INFll 100100100100100
#define PrintVec(x) for (auto elementPrintVec: x) { cout << elementPrintVec << " "; } cout << endl;
using namespace std;
using ull = unsigned long long;
using ll = long long;
using P = pair<int, int>;
const int mod = 1000000007;
bool added[1005][1005][1005];
struct element{
ll abc;
int ei;
int ej;
int ek;
};
struct Compareabc {
bool operator()(element const& p1, element const& p2)
{
return p1.abc < p2.abc;
}
};
int main(){
int x, y, z, k;
cin >> x >> y >> z >> k;
vector<ll> a(x);
vector<ll> b(y);
vector<ll> c(z);
rep(i, x){
cin >> a[i];
}
rep(i, y){
cin >> b[i];
}
rep(i, z){
cin >> c[i];
}
ssort(a);ssort(b);ssort(c);
priority_queue<element, vector<element>, Compareabc> PQ;
element e0={a[0]+b[0]+c[0], 0, 0, 0};
PQ.push(e0);
rep(qi, k){
element p=PQ.top(); PQ.pop();
cout << p.abc << endl;
if(p.ei+1<x && !added[p.ei+1][p.ej][p.ek]){
element e1={a[p.ei+1]+b[p.ej]+c[p.ek], p.ei+1, p.ej, p.ek};
PQ.push(e1);
added[p.ei+1][p.ej][p.ek]=true;
}
if(p.ej+1<y && !added[p.ei][p.ej+1][p.ek]){
element e2={a[p.ei]+b[p.ej+1]+c[p.ek], p.ei, p.ej+1, p.ek};
PQ.push(e2);
added[p.ei][p.ej+1][p.ek]=true;
}
if(p.ek+1<z && !added[p.ei][p.ej][p.ek+1]){
element e3={a[p.ei]+b[p.ej]+c[p.ek+1], p.ei, p.ej, p.ek+1};
PQ.push(e3);
added[p.ei][p.ej][p.ek+1]=true;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
ll min, max;
cin >> min >> max;
vector<ll> A;
A.push_back(min);
ll n = min;
for(;;) {
n *= 2;
if(n > max) {
break;
}
A.push_back(n);
}
cout << A.size() << endl;
}
| 0
| 84,988,280
|
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<functional>
using namespace std;
int main() {
int i,n, sum1, sum2;
sum1 = 0; sum2 = 0;
string s, t;
cin >> n;
for (i = 0; i < n; i++) {
cin >> s; cin >> t;
if (s < t) {
sum2 += 3;
}
else if (s > t) {
sum1 += 3;
}
else if (s == t) {
sum1 += 1; sum2 += 1;
}
}
cout << sum1 << " " << sum2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n); i >= 0; i--)
#define FOR(i, m, n) for (int i = (m); i < (n); i++)
#define ALL(obj) begin(obj), end(obj)
using namespace std;
using ll = long long;
using ull = unsigned long long;
const int INF = 200000000;
const int MOD = 1e9 + 7;
template <class T> vector<T> make_vec(size_t a) { return vector<T>(a); }
template <class T, class... Ts> auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
vector<int> num = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
int N, M;
cin >> N >> M;
auto A = make_vec<int>(M);
REP(i, M) { cin >> A.at(i); }
sort(ALL(A), greater<int>());
vector<int> dp(N + 4, -INF);
dp[0] = 0;
REP(i, N + 1) {
REP(j, M) {
if (i >= num[A[j]]) {
dp[i] = max(dp[i], dp[i - num[A[j]]] + 1);
}
};
}
int cur = N;
string S = "";
while (cur > 0) {
for (auto a : A) {
if (cur - num[a] >= 0) {
if (dp[cur - num[a]] == dp[cur] - 1) {
cur = cur - num[a];
S.push_back(a + '0');
break;
}
}
}
}
cout << S << endl;
return 0;
}
| 0
| 96,272,205
|
#include<iostream>
#include<string>
using namespace std;
int main()
{
int n, a, b, c,f;
cin >> n;
a = n / 15;
b = a * 200;
c = n * 800;
f = c - b;
cout << f;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll dp[100001][2];
ll mod = 1e9+7;
vector<ll>v[100001];
ll add(ll x , ll y)
{
x += y;
if(x >= mod)
x -= mod;
return x;
}
void dfs(ll x , ll p)
{
ll mult2 = 1 , mult1 = 1;
for(ll i = 0 ; i < (ll)v[x].size() ; i++)
{
if(v[x][i] == p)
continue;
dfs(v[x][i] , x);
ll num2 = add(dp[v[x][i]][1] , dp[v[x][i]][0]);
mult2 = (mult2*num2)%mod;
mult1 = (mult1 * dp[v[x][i]][1])%mod;
}
dp[x][0] = add(dp[x][0] , mult1);
dp[x][1] = add(dp[x][1] , mult2);
}
int main() {
ll n;
cin >> n;
for(ll i =0 ; i < n-1 ; i++)
{
ll x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1, 1);
ll ans = add(dp[1][1] , dp[1][0]);
cout << ans;
}
| 0
| 2,619,242
|
#include<bits/stdc++.h>
using namespace std;
#define inf 1e9
#define ll long long
#define ull unsigned long long
#define M 1000000007
#define P pair<int,int>
#define PLL pair<ll,ll>
#define FOR(i,m,n) for(int i=m;i<n;i++)
#define RFOR(i,m,n) for(int i=m;i>=n;i--)
#define rep(i,n) FOR(i,0,n)
#define rrep(i,n) RFOR(i,n,0)
#define all(a) a.begin(),a.end()
const int vx[4] = {0,1,0,-1};
const int vy[4] = {1,0,-1,0};
#define PI 3.14159265
int w,h;
ll p[1000000],q[1000000];
ll ans;
ll a,b;
int main(){
cin>>w>>h;
rep(i,w){
cin>>p[i];
}
rep(i,h){
cin>>q[i];
}
sort(p,p+w);
sort(q,q+h);
for(ll i=0;i<h+w;i++){
if(a<w&&p[a]<q[b]||b==h){
ans+=p[a]*(h+1-b);
a++;
}
else{
ans+=q[b]*(w+1-a);
b++;
}
}
cout<<ans<<endl;
return 0;
}
|
#include <cstring>
#include <iostream>
struct card {
char mark;
unsigned int number;
};
static void print_cards(const card cards[], const unsigned int n) {
const char* sep = "";
for (unsigned int i = 0; i < n; ++i) {
const card* const cardp = &cards[i];
std::cout << sep << cardp->mark << cardp->number;
sep = " ";
}
std::cout << std::endl;
}
static void swap(card* a, card* b) {
card tmp = *a;
*a = *b;
*b = tmp;
}
void bubble_sort(card cards[], const unsigned int n) {
for (unsigned int j = 0; j < n-1; ++j) {
for (unsigned int i = n-1; i > j; --i) {
if (cards[i-1].number > cards[i].number) {
swap(&cards[i-1], &cards[i]);
}
}
}
}
void selection_sort(card cards[], const unsigned int n) {
for (unsigned int i = 0; i < n-1; ++i) {
unsigned int min_j = i;
for (unsigned int j = i+1; j < n; ++j) {
if (cards[min_j].number > cards[j].number) {
min_j = j;
}
}
if (i != min_j) {
swap(&cards[i], &cards[min_j]);
}
}
}
int main(void) {
unsigned int n;
std::cin >> n;
card cards1[n], cards2[n];
for (unsigned int i = 0; i < n; ++i) {
std::cin >> cards1[i].mark;
std::cin >> cards1[i].number;
}
std::memcpy(cards2, cards1, sizeof(cards1));
bubble_sort(cards1, n);
print_cards(cards1, n);
std::cout << "Stable" << std::endl;
selection_sort(cards2, n);
print_cards(cards2, n);
if (std::memcmp(cards1, cards2, sizeof(cards1)) == 0) {
std::cout << "Stable" << std::endl;
} else {
std::cout << "Not stable" << std::endl;
}
return 0;
}
| 0
| 39,090,647
|
#include <bits/stdc++.h>
#define mod 1000000007
#define INF LLONG_MAX
#define ll long long
#define ln cout<<endl
#define Yes cout<<"Yes"<<endl
#define NO cout<<"NO"<<endl
#define YES cout<<"YES"<<endl
#define No cout<<"No"<<endl
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
#define rep(i,n) REP(i,0,n)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
using namespace std;
ll dx[4]={1,0,-1,0};
ll dy[4]={0,1,0,-1};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll a,b,c,d,m,n,maxi=0,f=0,mini=INF,sum=0;
string str;
ll k;
ll w,x;
cin>>a>>d>>x;
rep(i,10){
x=x*a-d;
cout<<x<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#include <algorithm>
using namespace std;
void debug() {cout<<endl;}
template<typename T,typename... Args>
void debug(T x,Args... args) {cout<<x<<" ";debug(args...);}
#define forn(i,a,b) for(int i=a;i<b;++i)
#define pb push_back
#define F first
#define S second
#define endl "\n"
typedef long long ll;
typedef pair<int, int> pii;
int main() {
ios::sync_with_stdio(0); cin.tie(0);
int n;
string s, u;
char c;
ll x, y;
cin >> n;
ll ans = 0, btc = 0;
forn(i, 0, n){
cin >> s >> u;
if(u == "BTC"){
int m = s.size();
y = stoll(s.substr(m-8, 8));
x = stoll(s.substr(0, m-8-1));
x = x*100000000+y;
btc += x*380000;
}else{
x = stoll(s);
ans += x;
}
}
double r = btc;
r /= 100000000;
cout << r+ans << endl;
}
| 0
| 35,762,229
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define ll long long
using namespace std;
int main() {
ios::sync_with_stdio(false);
int a, b;
cin >> a >> b;
if (a + b == 15) {
cout << "+";
} else if (a * b == 15) {
cout << "*";
} else cout << 'x';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const ll INF = 1LL << 60;
const int MAX = 1000000010;
const ll MOD = 1000000007;
const double PI = acos(-1);
int main() {
int N, M; cin >> N >> M;
vector<bool> valid1(N + 1);
vector<bool> validN(N + 1);
for (int i = 0; i < M; i++) {
int a, b; scanf("%d %d", &a, &b);
if (a == 1) valid1[b] = 1;
if (b == N) validN[a] = 1;
}
for (int i = 2; i <= N - 1; i++) {
if (valid1[i] && validN[i]) {
cout << "POSSIBLE" << endl;
return 0;
}
}
cout << "IMPOSSIBLE" << endl;
return 0;
}
| 0
| 23,601,714
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i=0; i<n; i++)
#define rep1(i, n) for(int i=1; i<=n; i++)
#define repr(i, n) for(int i=n-1; i>=0; i--)
#define repr1(i, n) for(int i=n; i>=1; i--)
#define all(v) v.begin(),v.end()
using ll = long long;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const int INF = 1e9;
const ll LLINF = 1e18;
const ll MOD = 1e9+7;
const double EPS = 1e-10;
const double PI = acos(-1);
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main() {
int n, k; cin >> n >> k;
vector<ll> a(n);
rep(i, n) cin >> a[i];
vector<ll> v;
for (int i = 0; i < n; i++) {
ll sum = 0;
for (int j = i; j < n; j++) {
sum += a[j];
v.push_back(sum);
}
}
ll res = 0;
for (int i = 40; i >= 0; i--) {
int cnt = 0;
vector<ll> next;
for (auto &x: v) {
if (x & (1ll << i)) {
next.push_back(x);
cnt++;
}
}
if (cnt >= k) {
v = next;
res |= 1ll << i;
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main () {
string S;
cin >> S;
int N = S.size();
int counta = 0;
int countb = 0;
if (S.at(0) == 'k'){
counta++;
if (counta == 1 && S.at(1) == 'e'){
counta++;
if (counta == 2 && S.at(2) == 'y'){
counta++;
if (counta == 3 && S.at(3) == 'e'){
counta++;
if (counta == 4 && S.at(4) == 'n'){
counta++;
if (counta == 5 && S.at(5) == 'c'){
counta++;
if (counta == 6 && S.at(6) == 'e'){
counta++;
}
}
}
}
}
}
}
if (S.at(N-1) == 'e'){
countb++;
if (countb == 1 && S.at(N-2) == 'c'){
countb++;
if (countb == 2 && S.at(N-3) == 'n'){
countb++;
if (countb == 3 && S.at(N-4) == 'e'){
countb++;
if (countb == 4 && S.at(N-5) == 'y'){
countb++;
if (countb == 5 && S.at(N-6) == 'e'){
countb++;
if (countb == 6 && S.at(N-7) == 'k'){
countb++;
}
}
}
}
}
}
}
if (counta + countb >= 7){
cout << "YES" << endl;
}
else {
cout << "NO" << endl;
}
}
| 0
| 82,237,536
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int mod = 1e9 + 7;
int main () {
ios_base::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
int n;
string s;
cin >> n >> s;
vector < char > d (2 * n);
d[0] = 'L';
int cnt = 1;
for (int i = 1; i < 2 * n; i++) {
if (s[i] == s[i - 1]) {
if (d[i - 1] == 'L') {
d[i] = 'R';
} else {
d[i] = 'L';
}
} else {
d[i] = d[i - 1];
}
if (d[i] == 'L') cnt++;
else cnt--;
}
if (cnt != 0 || s[0] != 'B' || s[2 * n - 1] != 'B') {
cout << 0 << '\n';
return 0;
}
ll ans = 1;
for (int i = 0; i < 2 * n; i++) {
if (d[i] == 'R') ans = (ans * cnt) % mod;
if (d[i] == 'L') cnt++;
else cnt--;
}
for (int i = 1; i <= n; i++) ans = (ans * i) % mod;
cout << ans << '\n';
}
|
#include <iostream>
#include <fstream>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for(ll i=0; i<n; i++)
#define repr(i, s, e) for(ll i=s; i>=e; i--)
#define reps(i, s, e) for(ll i=s; i<=e; i++)
#define inf 1e18
#define all(v) v.begin(),v.end()
#define ceill(a, b) (a+b-1)/b
#define ok cout << "ok" << endl;
#define sp << " " <<
void ans(bool b){ cout << (b ? "Yes" : "No") << endl; }
void ans2(bool b){ cout << (b ? "YES" : "NO") << endl; }
template<typename T> inline bool chmax(T &a, T b){ if(a<b) a=b; return a<b; }
template<typename T> inline bool chmin(T &a, T b){ if(b<a) a=b; return b<a; }
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
fill((T*)array, (T*)(array+N), val);
}
template<typename T> void vdeb(T v){
cout << "#vector set debug" << endl;
for(auto vv : v) cout << vv << " ";
cout << endl;
}
template<typename T1, typename T2> void adeb(T1 arr[], T2 n){
cout << "#adebug" << endl;
for(int i=0; i<=n; i++) cout << arr[i] << " ";
cout << endl;
}
template<typename T1> void mdeb(T1 mp){
cout << "#map pair debug" << endl;
for(auto const& m : mp) cout << m.first sp m.second << endl;
}
int dx[] = {1, 0, -1, 0, 1, -1, 1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, -1, 1};
class CSuccessiveSubtraction {
public:
void solve(std::istream& in, std::ostream& out) {
int n;
in >> n;
vector<int> a(n, 0);
vector<int> neg, pos;
rep(i, n){
in >> a[i];
if(a[i] >= 0) pos.push_back(a[i]);
else neg.push_back(a[i]);
}
if(pos.size() == 0){
sort(all(neg));
pos.push_back(neg[neg.size()-1]);
neg.erase(neg.begin() + neg.size() - 1);
}
if(neg.size() == 0){
sort(all(pos));
neg.push_back(pos[0]);
pos.erase(pos.begin());
}
ll res = neg[0];
vector<pair<int, int>> resv;
rep(i, pos.size() - 1){
resv.push_back(make_pair(res, pos[i]));
res = res - pos[i];
}
resv.push_back(make_pair(pos[pos.size()-1], res));
res = pos[pos.size()-1] - res;
reps(i, 1, neg.size()-1){
resv.push_back(make_pair(res, neg[i]));
res = res - neg[i];
}
out << res << endl;
for(auto const& e : resv){
out << e.first sp e.second << endl;
}
}
};
int main() {
CSuccessiveSubtraction solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 0
| 12,485,767
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); i++)
typedef pair<int,int> P;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> ans(n+1);
rep(i,n) {
int a;
cin >> a;
ans[a] = i+1;
}
for(int i = 1; i < n; i++)
cout << ans[i] << " ";
cout << ans[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define PI 3.1415926535897
using namespace std;
typedef long long ll;
const int INF = 1000000000;
const ll LINF = 1000000000000000000;
const double EPS = 1e-10;
int gcd(int a, int b)
{
if (a % b == 0)
{
return (b);
}
else
{
return (gcd(b, a % b));
}
}
int main(void)
{
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++)
{
cin >> A[i];
}
ll ans = A[0];
for (int i = 0; i < N; i++)
{
ans = gcd(ans, A[i]);
}
cout << ans << endl;
return (0);
}
| 0
| 41,685,371
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
int A[100000];
rep(i, N) cin >> A[i];
int k = 0;
vector<int> V, V2;
V.pb(0);
rep(i, N) {
if (A[i] > k) {
V.pb(A[i]);
V2.pb(i);
k = A[i];
}
}
ll B[100001] = {};
int C[100001] = {};
rep(i, N) {
int k2 = lower_bound(V.begin(), V.end(), A[i]) - V.begin();
B[k2] += A[i] - V[k2 - 1];
C[k2]++;
}
int mae = V.back();
ll l = C[(int)V.size()];
ll kotae[100001] = {};
for (int k = (int)V.size() - 2; k >= 0; k--) {
kotae[V2[k]] = B[k + 1] + l * (mae - V[k]);
mae = V[k];
l += C[k + 1];
}
rep(i, N) co(kotae[i]);
Would you please return 0;
}
|
#include "bits/stdc++.h"
#include "math.h"
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<vvll> vvvll;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<int> vin;
typedef vector<pair<ll,ll> > vp;
#define rep(i,a,b) for(ll i=(a);i<(b);++i)
#define drep(i,a,b) for(ll i=(a);i>(b);--i)
const int MOD = 1000000007;
const int MAX = 510000;
int main(){
ll n,h,hp=0,ans=0;cin>>n>>h;
vp a(2*n);
rep(i,0,n){
cin>>a[2*i].first>>a[i*2+1].first;
a[2*i].second=MOD;
a[i*2+1].second=1;
}
sort(a.begin(),a.end());reverse(a.begin(),a.end());
ll i=0;
while(hp<h&&a[i].second==1){
hp+=a[i].first*a[i].second;
i++;
ans++;
}
if(hp<h){
ll x=(h-hp)/a[i].first;
ans+=x;
if((h-hp)%a[i].first!=0)ans++;
}
cout<<ans<<endl;
}
| 0
| 68,509,126
|
#include <bits/stdc++.h>
#define mem(i,j) memset(i,j,sizeof(i))
#define pl (p<<1)
#define pr (p<<1)|1
#define int long long
using namespace std;
inline int read(){
char ch=' ';int res=0,f=1;
while(!isdigit(ch)){ch=getchar();if(ch=='-')f=-1;}
while(isdigit(ch)){res=res*10+ch-'0';ch=getchar();}
return res*f;
}
int _min(int x,int y){return x<y?x:y;}
int _max(int x,int y){return x>y?x:y;}
const int N=1e6+5;
int k,vis[N];
struct node{
int x,ans;
};
#undef int
int main() {
k=read();
deque<node>q;
q.push_front({1,1});
while(!q.empty()){
node kk=q.front();
q.pop_front();
if(vis[kk.x])continue;
vis[kk.x]=1;
if(!kk.x){
printf("%lld\n",kk.ans);
return 0;
}
q.push_front({(kk.x*10)%k,kk.ans});
q.push_back({(kk.x+1)%k,kk.ans+1});
}
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
ll const INF = 1LL << 60;
int main() {
string s;
cin >> s;
string target = "keyence";
int index = 0;
if (s == target) {
cout << "YES" << endl;
return 0;
}
for (int i = 0; i < s.length(); i++) {
for (int j = i; j < s.length(); j++) {
string part = "";
for (int k = 0; k < s.length(); k++) {
if (i <= k && k <= j) continue;
part += s[k];
}
if (part == target) {
cout << "YES" << endl;
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 0
| 83,141,115
|
#include <bits/stdc++.h>
using namespace std;
#include <math.h>
#include <iomanip>
int main() {
int n;
cin>>n;
vector<int>a(n);
deque<int>k;
for(int i=0;i<n;i++){
cin>>a[i];
if(i%2==n%2){k.push_back(a[i]);}
else{k.push_front(a[i]);}
}
for(int i=0;i<n;i++){
cout<<k[i];
if(i<n-1){cout<<" ";}
}cout<<endl;
return 0;
}
|
#include <iostream>
#include <array>
#include <algorithm>
#include <vector>
#include <set>
#include <cmath>
#include <complex>
#include <deque>
#include <iterator>
#include <numeric>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <limits>
#include <iomanip>
using namespace std;
using ll=long long;
template<class T> using V = vector<T>;
template<class T, class U> using P = pair<T, U>;
using vll = V<ll>;
using vvll = V<vll>;
#define rep(i, k, n) for (ll i=k; i<(ll)n; ++i)
#define REP(i, n) rep(i, 0, n)
template<class T> inline bool chmax(T& a, T b) {if (a<b) {a=b; return true;} return false;}
template<class T> inline bool chmin(T& a, T b) {if (a>b) {a=b; return true;} return false;}
const ll MOD = 1000000007;
const ll HIGHINF = (ll)1e18;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n; cin >> n;
ll p = 1;
ll ans = 0;
REP(i, n) {
ll a; cin >> a;
if (a > p) {
if (a%p==0) {
ans += (a/p-1);
if (p==1) p++;
} else ans += a/p;
}
else if (a==p) p++;
}
cout << ans << endl;
return 0;
}
| 0
| 63,777,983
|
#include <iostream>
#include <complex>
using namespace std;
#define EPS (pow(10, -10))
#define EQ(a,b) (abs((a)-(b)) < EPS)
typedef complex<double> P;
double cross(P a, P b) {
return(a.real() * b.imag() - a.imag() * b.real());
}
int is_parallel(P a1, P a2, P b1, P b2) {
return(EQ(cross(a1 - a2, b1 - b2), 0.0));
}
int main(void) {
int n;
double x1,x2,x3,x4,y1,y2,y3,y4;
cin >> n;
for(int r = 0; r < n; r++) {
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> x4 >> y4;
P a(x1, y1), b(x2, y2), c(x3, y3), d(x4, y4);
if(is_parallel(a, b, c, d)) cout << "YES" << endl;
else cout << "NO" << endl;
}
return(0);
}
|
#include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define repLRE(i, l, r) for (ll i = (l); i <= (r); ++i)
#define rrepLRE(i, l, r) for (ll i = (l); i >= (r); --i)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.end())
#define Lower_bound(v, x) \
distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) \
distance(v.begin(), upper_bound(v.begin(), v.end(), x))
using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vP = vector<P>;
using vT = vector<T>;
using vvll = vector<vector<ll>>;
using vvP = vector<vector<P>>;
using dqll = deque<ll>;
ll dx[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
ll dy[9] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
const ll INF = 1LL << 50;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
ll n;
string s, t;
cin >> n >> s >> t;
ll tot = s.size() + t.size();
if (n >= tot) {
cout << n << endl;
return 0;
}
ll m = min(s.size(), t.size());
ll cnt = 0;
repLRE(i, 1, m) {
bool ok = true;
rep(j, i) {
if (s[n - i + j] != t[j]) {
ok = false;
break;
}
}
if (ok) cnt = i;
}
ll ans = max(tot - cnt, n);
cout << ans << endl;
return 0;
}
| 0
| 24,813,856
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define forn(i, a, b) for (int i = a; i < b; ++i)
#define SZ(x) int(x.size())
#define pb push_back
#define F first
#define S second
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
int main() {
#ifdef LOCAL
freopen("c.txt", "r", stdin);
#define dbg(...) cerr << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
#else
ios::sync_with_stdio(0);
cin.tie(0);
#define endl '\n'
#define dbg(...) 18
#endif
int a, b, c;
cin >> a >> b >> c;
for (int i = min(a, b); i >= 1; i--) {
if (a % i == 0 && b % i == 0) c--;
if (!c) {
cout << i << endl;
break;
}
}
return 0;
}
|
#include <stdio.h>
int main(){
int n,b,f,r,v;
scanf("%d",&n);
int o[3][10] = {};
int p[3][10] = {};
int q[3][10] = {};
int t[3][10] = {};
for(int k = 1; k <= n; k++){
scanf("%d%d%d%d",&b,&f,&r,&v);
if(b==1){
o[f-1][r-1] = o[f-1][r-1] + v;
if(o[f-1][r-1] < 0){
o[f-1][r-1] = 0;
}
}
else if(b==2){
p[f-1][r-1] = p[f-1][r-1] + v;
if(p[f-1][r-1] < 0){
p[f-1][r-1] = 0;
}
}
else if(b==3){
q[f-1][r-1] = q[f-1][r-1] + v;
if(q[f-1][r-1] < 0){
q[f-1][r-1] = 0;
}
}
else{
t[f-1][r-1] = t[f-1][r-1] + v;
if(t[f-1][r-1] < 0){
t[f-1][r-1] = 0;
}
}
}
for(int k = 1; k <= 4;k++){
for(int i = 0; i < 3; i++){
for(int j = 0; j < 10; j++){
if(k == 1){
printf(" %d",o[i][j]);
}
else if(k == 2){
printf(" %d",p[i][j]);
}
else if(k == 3){
printf(" %d",q[i][j]);
}
else {
printf(" %d",t[i][j]);
}
}
printf("\n");
}
if(k != 4){
printf("####################\n");
}
}
return 0;
}
| 0
| 97,279,442
|
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define debug(var) cerr << (#var) << " = " << (var) << endl;
#else
#define debug(var)
#endif
void init() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
}
void solve() {
long long a, b, c; scanf("%lld %lld.%lld", &a, &b, &c);
printf("%lld", a * (100LL * b + c) / 100LL);
}
int main() {
int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
#define rrep(i,n) for (int i = (int)(n - 1); i >= 0; i--)
#define rep2(i,s,n) for (int i = (s); i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define pcnt(bit) __builtin_popcountll(bit)
using ll = long long;
using P = pair<int,int>;
const long double pi = acos(-1.0);
const int MAX = 1000010;
const int INF = 1ll << 60;
const int MOD = 1000000007;
template<typename T> inline bool chmax(T &a, T b) {if (a < b) {a = b; return 1;} return 0;}
template<typename T> inline bool chmin(T &a, T b) {if (b < a) {a = b; return 1;} return 0;}
template<typename T> T pow(T a, ll n) {T r(1); while(n) {if (n & 1) r *= a; a *= a; n >>= 1;} return r;}
struct faster_io {faster_io() {cin.tie(0); ios_base::sync_with_stdio(false);}} faster_io_;
struct graph {
struct edge {
int to, cost;
edge(int t, int c) : to(t), cost(c) {}
};
int n;
vector<vector<edge>> G;
vector<int> d, pre;
graph(int i) : n(i), G(i), d(i,INF), pre(i) {}
void add_edge(int s, int to, int cost) {
G[s].push_back(edge(to,cost));
}
void dijkstra(int s) {
rep(i,n) {d[i] = INF; pre[i] = 0;}
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(); int 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; pre[e.to] = v;
que.push(P(d[e.to],e.to));
}
}
}
};
signed main() {
int n; cin >> n;
graph g(n);
rep(i,n-1) {
int a, b, c; cin >> a >> b >> c;
a--; b--;
g.add_edge(a,b,c);
g.add_edge(b,a,c);
}
int q, k;
cin >> q >> k;
k--;
g.dijkstra(k);
rep(i,q) {
int a, b; cin >> a >> b;
a--; b--;
cout << g.d[a] + g.d[b] << endl;
}
return 0;
}
| 0
| 56,482,053
|
#include <stdio.h>
#include <vector>
#include <queue>
using namespace std;
#define PB push_back
const int N=1e4+10;
int main(){
int n,m,l,r,d[N],nxt;
queue<int> q;
vector<int> graph[N];
scanf("%d%d",&n,&m);
for(int i=0;i<n;i++)d[i]=0;
while(m--){
scanf("%d%d",&l,&r);
graph[l].PB(r);
d[r]++;
}
for(int i=0;i<n;i++)if(d[i]==0)q.push(i);
while(!q.empty()){
nxt=q.front();
q.pop();
printf("%d\n",nxt);
for(int i=0;i<graph[nxt].size();i++){
d[graph[nxt][i]]--;
if(d[graph[nxt][i]]==0)q.push(graph[nxt][i]);
}
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,j,n) for(int i=(int)(j);i<(int)(n);i++)
#define REP(i,j,n) for(int i=(int)(j);i<=(int)(n);i++)
#define MOD 1000000007
#define int long long
#define ALL(a) (a).begin(),(a).end()
#define vi vector<int>
#define vii vector<vi>
#define pii pair<int,int>
#define priq priority_queue<int>
#define disup(A,key) distance(A.begin(),upper_bound(ALL(A),(int)(key)))
#define dislow(A,key) distance(A.begin(),lower_bound(ALL(A),(int)(key)))
#define tii tuple<int,int,int>
#define Priq priority_queue<int,vi,greater<int>>
#define pb push_back
#define mp make_pair
#define INF (1ll<<60)
int N;
int A[100000];
int func(int X){
rep(i,0,N) X=X/A[i]*A[i];
return X;
}
signed main(){
cin>>N;
rep(i,0,N) cin>>A[i];
int left=0,right=INF;
while(left+1<right){
int mid=(left+right)/2;
int X=func(mid);
if(X<2) left=mid;
else right=mid;
}
int ans=-1;
if(func(right)==2) ans=right;
if(func(left)==2) ans=left;
cout<<ans<<endl;
if(ans!=-1){
left=0;
right=INF;
while(left+1<right){
int mid=(left+right)/2;
int X=func(mid);
if(X<=2) left=mid;
else right=mid;
}
int ans;
if(func(right)==2) ans=right;
else ans=left;
cout<<ans<<endl;
}
}
| 0
| 49,172,210
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
#include <unordered_map>
typedef long long ll;
using namespace std;
const int mod=1e9+7;
ll solve(){
int n,x,t;
cin>>n>>x>>t;
return ((n/x)+(n%x != 0))*t;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
int t=1;
while(t--) cout<<solve()<<'\n';
return 0;
}
|
#include <iostream>
#include <set>
#include <vector>
#include <map>
#include <string>
#include <math.h>
#include <queue>
using namespace std;
int solve(int Y,int M, int D){
int res;
res=0;
if(Y%3==0 || M%2!=0){
for(int dd=D;dd<=20;dd++) res++;
}
else{
for(int dd=D;dd<=19;dd++) res++;
}
for(int mm=M+1;mm<=10;mm++){
if(Y%3==0){
for(int dd=1;dd<=20;dd++) res++;
}
else{
if(mm%2==0){
for(int dd=1;dd<=19;dd++) res++;
}
else{
for(int dd=1;dd<=20;dd++) res++;
}
}
}
for(int yy=Y+1;yy<1000;yy++){
for(int mm=1;mm<=10;mm++){
if(yy%3==0){
for(int dd=1;dd<=20;dd++){
res++;
}
}
else{
if(mm%2==0){
for(int dd=1;dd<=20;dd++){
res++;
}
}
else{
for(int dd=1;dd<=19;dd++){
res++;
}
}
}
}
}
return res;
}
int main(void){
int n;
int Y,M,D;
while(true){
cin >> n;
for(int i=0;i<n;i++){
cin >> Y;
cin >> M;
cin >> D;
cout << solve(Y,M,D) << endl;
}
return 0;
}
return 0;
}
| 0
| 6,091,755
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0; i < (int)(N); ++i)
#define REP(type, name, beginValue, endCondValue) \
for (type name = beginValue; name < endCondValue; ++name)
#define VECTOR_DIM3(T, name, d1, d2, d3, initValue) \
std::vector<std::vector<std::vector<T>>> name(d1, std::vector<std::vector<T>>(d2, std::vector<int>(d3, initValue)));
#define VECTOR_DIM2(T, name, d1, d2, initValue) \
std::vector<std::vector<T>> name(d1, std::vector<T>(d2, initValue));
#define VECTOR_DIM1(T, name, d1, initValue) \
std::vector<T> name(d1, initValue);
#define ll long long
#define ld long double
int main(){
int h, w;
cin >> h >> w;
VECTOR_DIM2(bool, grid, h, w, false);
rep(i,h) {
string s;
cin >> s;
rep(j,w) {
if (s[j] == '#') {
grid[i][j] = true;
}
}
}
vector<bool> hValid(h, true), wValid(w, true);
rep(i, h) {
bool hasBlack = false;
rep(j,w) {
if (grid[i][j] == true) {
hasBlack = true;
break;
}
}
if (!hasBlack) {
hValid[i] = false;
}
}
rep(j, w) {
bool hasBlack = false;
rep(i,h) {
if (grid[i][j] == true) {
hasBlack = true;
break;
}
}
if (!hasBlack) {
wValid[j] = false;
}
}
rep (i, h) {
if (!hValid[i]) {
continue;
}
rep(j, w) {
if (!wValid[j]) {
continue;
}
cout << (grid[i][j] ? '#' : '.');
}
cout << endl;
}
return 0;
}
|
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define rep(i, n) for(int i=0;i<n;++i)
#define rrep(i, n) for(int i=n;i>=0;--i)
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
string S;
ll K;
cin>>S>>K;
if(S.size()==1) {
cout<<K/2<<endl;
return 0;
}
ll ans = 0;
if(S[0]!=S[S.size()-1]) {
for(int i=0;i<S.size()-1;++i) {
if(S[i]==S[i+1]) {
ans++;
i++;
}
}
cout<<ans*K<<endl;
return 0;
}
bool haji1 = false, haji2 = false;
ll ans1 = 1, ans2 = 0;
for(int i=1;i<S.size()-1;++i) {
if(S[i]==S[i+1]) {
if(i+1==S.size()-1) haji1 = true;
ans1++;
i++;
}
}
for(int i=0;i<S.size()-1;++i) {
if(S[i]==S[i+1]) {
if(i+1==S.size()-1) haji2 = true;
ans2++;
i++;
}
}
if(haji1 && haji2) {
cout<<ans2*K<<endl;
}
else if(haji1 && !haji2) {
cout<<ans2*((K+1)/2)+ans1*(K/2)<<endl;
}
else if(!haji1 && haji2) {
cout<<ans2*K<<endl;
}
else {
cout<<ans2+ans1*(K-1)<<endl;
}
}
| 0
| 35,175,487
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = (a); i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define endl '\n'
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
const ll mod = 1000000007;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
ll n, x, m;
cin >> n >> x >> m;
ll curr = x;
ll ans = 0;
vector<bool> vis(m + 1);
vector<ll> s;
vector<ll> repeated;
int cnt = 1;
while(cnt <= n) {
if(!vis[curr]) {
vis[curr] = true;
s.pb(curr);
ans += curr;
curr = curr * curr % m;
} else {
while(s.back() != curr) {
repeated.pb(s.back());
s.pop_back();
}
repeated.pb(s.back());
break;
}
cnt++;
}
cnt--;
reverse(all(repeated));
n -= cnt;
if(n > 0) {
ll cyclen = repeated.size();
ll times = n / cyclen;
ll ex = n % cyclen;
for(int i = 0; i < repeated.size(); i++) {
ans += repeated[i] * times;
if(i < ex) {
ans += repeated[i];
}
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <map>
#include <cmath>
#include <ios>
#include <iomanip>
#include <algorithm>
#include <queue>
#include <stack>
#include <numeric>
using namespace std;
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;
template<class T> using VVV = V<VV<T>>;
template<class T1, class T2> using P = pair<T1, T2>;
using I = int;
using D = double;
using B = bool;
using C = char;
using S = string;
using LL = long long;
using LD = long double;
using ULL = unsigned long long;
using PII = P<I, I>;
using VPII = V<PII>;
using PLL = P<LL, LL>;
using VPLL = V<PLL>;
using VI = V<I>;
using VVI = VV<I>;
using VLL = V<LL>;
using VVLL = VV<LL>;
using VC = V<C>;
using VVC = VV<C>;
using VS = V<S>;
using VVS = VV<S>;
using VB = V<B>;
using VVB = VV<B>;
#define REP(type, i, n) for (type i = 0; i < (type)(n); ++i)
#define REP2(type, i, m, n) for (type i = (m); i < (type)(n); ++i)
#define REPR(type, i, n) for (type i = (n)-1; i >= 0; --i)
#define REPR2(type, i, m, n) for (type i = (n)-1; i >= (m); --i)
#define REPx(x, a) for(auto x : a)
#define ALL(a) a.begin(), a.end()
#define SORT(a) sort(ALL(a))
#define SORTR(a, type) sort(ALL(a), greater<type>())
#define SORTF(a, comp) sort(ALL(a), comp)
#define REVERSE(a) reverse(ALL(a))
#define SIZE(a, type) ((type)(a).size())
#define bit_search(bit, n) REP(LL, bit, 1LL<<(n))
#define bit_check(bit, i) ((bit>>(i)) & 1)
#define setpre(n) fixed << setprecision((n))
#define UNIQUE(a) do {SORT(a); (a).erase(unique(ALL(a)), (a).end());} while(0)
#define MAX(a) *max_element(ALL(a))
#define MIN(a) *min_element(ALL(a))
#define bisect_left(a, x) lower_bound(ALL(a), (x)) - a.begin()
#define bisect_right(a, x) upper_bound(ALL(a), (x)) - a.begin()
#define INPUT(a) REPx(&x, a) cin >> x;
#define INPUT2(a) REPx(&x, a) INPUT(x);
#define INPUTP(a) REPx(&x, a) cin >> x.first >> x.second;
#define ENDL cout << endl;
const int INF = 2e9;
const LL MOD = 1e9+7;
template<class T> using PRIORITY_QUEUE = priority_queue< T, V<T>, greater<T> >;
template<class T> inline bool chmin(T &a, T b){if (a > b) {a = b; return true;} return false;}
template<class T> inline bool chmax(T &a, T b){if (a < b) {a = b; return true;} return false;}
template<class T> inline void debug1(V<T> A){REP(int, i, SIZE(A, int)){if (A[i] == INF) cout << "I ";else cout << A[i] << " ";}ENDL}
template<class T> inline void debug2(VV<T> A){REP(int, i, SIZE(A, int)){REP(int, j, SIZE(A[i], int)){if (A[i][j] == INF) cout << "I "; else cout << A[i][j] << " ";}ENDL}}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int x, y, a, b, c;
cin >> x >> y >> a >> b >> c;
priority_queue<LL> A, B, APPLE;
REP(int, i, a)
{
LL in;
cin >> in;
A.push(in);
}
REP(int, i, b)
{
LL in;
cin >> in;
B.push(in);
}
REP(int, i, c)
{
LL in;
cin >> in;
APPLE.push(in);
}
REP(int, i, x)
{
APPLE.push(A.top());
A.pop();
}
REP(int, i, y)
{
APPLE.push(B.top());
B.pop();
}
LL ans = 0;
REP(int, i, x+y)
{
ans += APPLE.top();
APPLE.pop();
}
cout << ans << endl;
return 0;
}
| 0
| 75,844,756
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double doublel;
#define f first
#define s second
const int N = 1e6 + 100;
const ll mod = 1e9 + 7;
const ll inf = 1e17;
set<pair<ll, ll>> s;
int par[N], cnt[N];
ll h[N];
vector<pair<int, int>> ans;
vector<int> adj[N];
void dfs(int u)
{
for(auto x : adj[u])
{
h[x] = h[u] + 1;
dfs(x);
}
}
int main()
{
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for(int i = 0; i < n; i++)
{
ll w;
cin >> w;
s.insert({-w, i});
cnt[i] = 1;
par[i] = i;
}
bool fl = true;
while(s.size() != 1)
{
ll w = -s.begin()->f;
int x = s.begin()->s;
ll w2 = w-n+2*cnt[x];
s.erase(s.begin());
auto it = s.lower_bound({-w2, -1});
if(it == s.end() || it->f != -w2)
fl = false;
else
{
int y = it->s;
par[x] = y;
cnt[y] += cnt[x];
}
}
for(int i = 0; i < n; i++)
{
if(i == par[i])
continue;
ans.push_back({min(i, par[i]), max(i, par[i])});
adj[par[i]].push_back(i);
}
int r = s.begin()->s;
dfs(r);
ll sum = 0;
for(int i = 0; i < n; i++)
sum += h[i];
if(sum != -s.begin()->f)
{
fl = false;
}
if(!fl)
{
cout << -1 << endl;
return 0;
}
sort(ans.begin(), ans.end());
for(auto e : ans)
cout << e.f + 1 << ' ' << e.s + 1<< endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int n;
while (cin >> n, n != 0) {
vector<int> imos(100000, 0);
for (int i=0; i<n; i++) {
int h, m, s, start, goal;
char colon;
cin >> h >> colon >> m >> colon >> s;
start = s + m*60 +h*60*60;
cin >> h >> colon >> m >> colon >> s;
goal = s + m*60 +h*60*60;
imos[start] += 1;
imos[goal] -= 1;
}
int sum = 0;
for (int i=0; i<100000; i++) {
sum += imos[i];
imos[i] = sum;
}
cout << *max_element(imos.begin(), imos.end()) << endl;
}
}
| 0
| 16,661,007
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.