code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 137
101M
|
|---|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n;
vector<int> d(n);
for (int i = 0; i < n; i++) {
cin >> x;
d.at(i) = x;
}
int count = 0, a = 0;
for (;;) {
if (a == 1) {
cout << count << endl;
break;
}
if (count >= n) {
cout << "-1" << endl;
break;
}
count++;
a = d.at(a);
a = a - 1;
}
}
|
#include <bits/stdc++.h>
#include <boost/range/adaptors.hpp>
#include <boost/range/irange.hpp>
using namespace std;
using namespace boost;
using namespace boost::adaptors;
main() {
int64_t n;
cin >> n;
cout << 0 << endl;
string s;
cin >> s;
if (s == "Vacant") {
return 0;
}
int64_t f = (s == "Female" ? 0 : 1);
int64_t b = 1, e = n;
while (b < e) {
auto mid = (b + e) / 2;
cout << mid << endl;
cin >> s;
if (s == "Vacant") {
return 0;
}
int64_t tmp = (s == "Female" ? 0 : 1);
if ((f + mid) % 2 == tmp) {
b = mid + 1;
} else {
e = mid;
}
}
cout << b << endl;
}
| 0
| 10,317,499
|
#include <iostream>
using namespace std;
int main()
{
long long a, b, c = 0;
cin >> a >> b;
cout << min(a,b/2)+max(b-a*2,c)/4;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main(){
int h,w,d;
cin >> h >> w >> d;
vector<P> a(h*w);
rep(i,h){
rep(j,w){
int x;
cin >> x;
P p(i,j);
x--;
a[x] = p;
}
}
int vec_num = (h*w)/d+2;
vector<vector<int>> cum_sum(d,vector<int>(vec_num));
rep(i,d){
cum_sum[i][0]=0;
}
rep(i,d){
int temp = i;
int j = 0;
while(temp+d<(h*w)){
cum_sum[i][j+1]=cum_sum[i][j]+ abs(a[temp+d].first-a[temp].first)+abs(a[temp+d].second-a[temp].second);
temp+=d;
j++;
}
}
int query;
cin >> query;
vector<int> res;
rep(i,query){
int l,r;
cin >> l >> r;
l--; r--;
int ind = 0;
ind = l%d;
l = l/d; r = r/d;
res.push_back(cum_sum[ind][r]-cum_sum[ind][l]);
}
for(auto r:res) cout << r << endl;
}
| 0
| 64,099,163
|
#include <bits/stdc++.h>
using namespace std ;
typedef double du ;
typedef string st ;
typedef long long ll ;
typedef long double ld ;
typedef long long int lli ;
#define vi vector <lli>
#define loop(num) for (lli i = 0 ; i < num ; i ++ )
#define loopcin(num , ar ) for (lli i = 0 ; i < num ; i ++ ) {cin >> ar [i] ;}
#define loopcout(num , ar) for (lli i = 0 ; i < num ; i ++ ) {cout << ar [i] << ' '; }
#define forr(num1 , num2) for (lli i = num1 ; i < num2 ; i ++ )
#define forrcin(num1 , num2 , ar ) for (lli i = num1 ; i < num2 ; i ++ ) {cin >> ar [i] ;}
#define forrcout(num1 , num2 , ar) for (lli i = num1 ; i < num2 ; i ++ ) {cout << ar [i] << ' '; }
#define D2forrcin(num1_1 , num1_2 , num2_1 , num2_2 , A ) for (lli i = num1_1 ; i < num1_2 ; i ++){ for (lli j = num2_1 ; j < num2_2 ; j++){cin >> A[i][j] ;}}
#define D2forrcout(num1_1 , num1_2 , num2_1 , num2_2 , A ) for (lli i = num1_1 ; i < num1_2 ; i ++){ for (lli j = num2_1 ; j < num2_2 ; j++){cout << A[i][j] << ' ' ;}cout << endl ;}
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
#define F first
#define S second
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
int main ()
{
fastio
lli a[4] ;
loopcin(4 , a) ;
sort(a + 0 , a + 2) ;
sort(a + 2 , a + 4) ;
cout << a[0] + a[2] ;
return 0 ;
}
|
#include <iostream>
#include <algorithm>
#include <bitset>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <valarray>
#include <fstream>
#include <cassert>
#include <cmath>
#include <functional>
#include <iomanip>
#include <chrono>
#include <random>
#include <numeric>
#define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);
#define VAR(type, ...)type __VA_ARGS__;MACRO_VAR_Scan(__VA_ARGS__);
template<typename T> void MACRO_VAR_Scan(T& t) { std::cin >> t; }
template<typename First, typename...Rest>void MACRO_VAR_Scan(First& first, Rest&...rest) { std::cin >> first; MACRO_VAR_Scan(rest...); }
#define VEC_ROW(type, n, ...)std::vector<type> __VA_ARGS__;MACRO_VEC_ROW_Init(n, __VA_ARGS__); for(int i=0; i<n; ++i){MACRO_VEC_ROW_Scan(i, __VA_ARGS__);}
template<typename T> void MACRO_VEC_ROW_Init(int n, T& t) { t.resize(n); }
template<typename First, typename...Rest>void MACRO_VEC_ROW_Init(int n, First& first, Rest&...rest) { first.resize(n); MACRO_VEC_ROW_Init(n, rest...); }
template<typename T> void MACRO_VEC_ROW_Scan(int p, T& t) { std::cin >> t[p]; }
template<typename First, typename...Rest>void MACRO_VEC_ROW_Scan(int p, First& first, Rest&...rest) { std::cin >> first[p]; MACRO_VEC_ROW_Scan(p, rest...); }
#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
#define MAT(type, c, m, n) std::vector<std::vector<type>> c(m, std::vector<type>(n));for(auto& r:c)for(auto& i:r)std::cin>>i;
#define OUT(d) std::cout<<d;
#define FOUT(n, d) std::cout<<std::fixed<<std::setprecision(n)<<d;
#define SOUT(n, c, d) std::cout<<std::setw(n)<<std::setfill(c)<<d;
#define SP std::cout<<" ";
#define TAB std::cout<<"\t";
#define BR std::cout<<"\n";
#define SPBR(i, n) std::cout<<(i + 1 == n ? '\n' : ' ');
#define ENDL std::cout<<std::endl;
#define FLUSH std::cout<<std::flush;
#define SHOW(d) {std::cerr << #d << "\t:" << d << "\n";}
#define SHOWVECTOR(v) {std::cerr << #v << "\t:";for(const auto& xxx : v){std::cerr << xxx << " ";}std::cerr << "\n";}
#define SHOWVECTOR2(v) {std::cerr << #v << "\t:\n";for(const auto& xxx : v){for(const auto& yyy : xxx){std::cerr << yyy << " ";}std::cerr << "\n";}}
#define SHOWQUEUE(a) {auto tmp(a);std::cerr << #a << "\t:";while(!tmp.empty()){std::cerr << tmp.front() << " ";tmp.pop();}std::cerr << "\n";}
#define ALL(a) (a).begin(),(a).end()
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define RFOR(i, a, b) for(int i=(b)-1;i>=(a);--i)
#define REP(i, n) for(int i=0;i<int(n);++i)
#define RREP(i, n) for(int i=int(n)-1;i>=0;--i)
#define FORLL(i, a, b) for(ll i=ll(a);i<ll(b);++i)
#define RFORLL(i, a, b) for(ll i=ll(b)-1;i>=ll(a);--i)
#define REPLL(i, n) for(ll i=0;i<ll(n);++i)
#define RREPLL(i, n) for(ll i=ll(n)-1;i>=0;--i)
#define IN(a, x, b) (a<=x && x<b)
template<typename T> inline T CHMAX(T& a, const T b) { return a = (a < b) ? b : a; }
template<typename T> inline T CHMIN(T& a, const T b) { return a = (a > b) ? b : a; }
#define EXCEPTION(msg) throw std::string("Exception : " msg " [ in ") + __func__ + " : " + std::to_string(__LINE__) + " lines ]"
#define TRY(cond, msg) try {if (cond) EXCEPTION(msg);}catch (std::string s) {std::cerr << s << std::endl;}
void CHECKTIME(std::function<void()> f) { auto start = std::chrono::system_clock::now(); f(); auto end = std::chrono::system_clock::now(); auto res = std::chrono::duration_cast<std::chrono::nanoseconds>((end - start)).count(); std::cerr << "[Time:" << res << "ns (" << res / (1.0e9) << "s)]\n"; }
template<class T> std::vector<std::vector<T>> VV(int n) {
return std::vector<std::vector<T>>(n);
}
template<class T> std::vector<std::vector<T>> VV(int n, int m, T init = T()) {
return std::vector<std::vector<T>>(n, std::vector<T>(m, init));
}
template<typename S, typename T>
std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) {
os << "(" << p.first << ", " << p.second << ")"; return os;
}
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using PAIR = std::pair<int, int>;
using PAIRLL = std::pair<ll, ll>;
constexpr int INFINT = 1 << 30;
constexpr int INFINT_LIM = (1LL << 31) - 1;
constexpr ll INFLL = 1LL << 60;
constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62);
constexpr double EPS = 1e-9;
constexpr int MOD = 1000000007;
constexpr double PI = 3.141592653589793238462643383279;
int dp[1 << 26];
signed main() {
INIT;
VAR(std::string, s);
REP(i, 1 << 26) dp[i] = INFINT;
dp[0] = 0;
int now = 0;
REP(i, s.size()) {
now ^= 1 << (s[i] - 'a');
REP(j, 26) {
CHMIN(dp[now], dp[now ^ (1 << j)] + 1);
}
}
OUT(std::max(1, dp[now]))BR;
return 0;
}
| 0
| 2,979,044
|
#include <bits/stdc++.h>
#define pb push_back
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,n,s) for(int i=(s);i<(n);i++)
#define rrep(i,n) for(int i=(n-1);i>=0;i--)
#define rreps(i,n,s) for(int i=s;i>=n;i--)
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
using ll = long long;
using namespace std;
constexpr long long MAX = 5100000;
constexpr long long INF = 1LL << 60;
constexpr int MOD = 1000000007;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin>>s;
int n=s.size();
ll ans=0;
ll last=n-1;
rrep(i,n){
if(s[i]=='B'){
ans+=last-i;
last--;
}
}
cout<<ans<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int t;
t=1;
while(t--){
string s;
cin >> s;
int ans = 0;
for(int i=0;i<s.length();i++){
ans=(ans%9+(s[i]-'0')%9)%9;
}
if(ans == 0)cout << "Yes" << endl;
else{
cout << "No"<< endl;
}
}
}
| 0
| 28,090,248
|
#include <bits/stdc++.h>
#define ll long long int
#define MOD 1000000007
#define P pair<ll,ll>
#define INF 1000000000000000000
using namespace std;
int main(void){
ll x, n;
cin >> x >> n;
set<ll> s;
for (int i = 0; i < n; i++){
ll p;
cin >> p;
s.insert(p);
}
int ans = -100, m = abs(x+100);
for (int i = -100; i < 201; i++){
if (abs(x-i) < m && s.find(i) == s.end()){
ans = i;
m = abs(x-i);
}
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define endl '\n'
#define INF INT_MAX
vector<ll> dp;
ll f(vector<ll> &v,ll n,ll k)
{
ll i,j;
dp[0]=0;
for(i=1;i<=min(n,k);i++)
{
for(j=0;j<i;j++)
{
dp[i]=min(dp[i],dp[j]+abs(v[j]-v[i]));
}
}
for(;i<=n;i++)
{
for(j=1;j<=k;j++)
{
dp[i]=min(dp[i],dp[i-j]+abs(v[i]-v[i-j]));
}
}
return dp[n];
}
void solve()
{
ll n,i,ans,k;
cin>>n>>k;
dp.resize(n,INF);
vector<ll> v(n);
for(i=0;i<n;i++)
{
cin>>v[i];
}
ans=f(v,n-1,k);
cout<<ans;
}
int main()
{
solve();
}
| 0
| 47,080,279
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define rep2(i,x,n) for(int i=x; i<(n); i++)
#define all(n) begin(n),end(n)
struct cww{cww(){ios::sync_with_stdio(false);cin.tie(0);}}star;
const long long INF = numeric_limits<long long>::max();
int main(){
int N;
cin >> N;
vector<int> A(N);
rep(i,N){
cin>>A[i];
}
map<int,int> cnt;
rep(i,N){
if(cnt.count(A[i])){
cnt[A[i]]++;
}else{
cnt[A[i]]=1;
}
}
int oc=0;
int tc=0;
rep(i,100001){
if(cnt[i]==0){
continue;
}else{
if(cnt[i]>=3){
cnt[i]= (cnt[i]%2==0) ? 2 : 1;
}
if(cnt[i]==1){
oc++;
}else{
tc++;
}
}
}
int ans=0;
ans=(tc%2==0)?oc+tc:oc+tc-1;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP1(i,n) for(int i=1, i##_len=(n); i<i##_len; ++i)
#define REP(i,n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define pow(x) x*x
#define ll long long
static const ll MAX = 1000000;
static const ll INFTY = 1e12;
static const ll MOD = 1000000007;
template < typename T > inline string toString( const T &a ) { ostringstream oss; oss << a; return oss.str(); };
struct edge {
ll to, cost;
};
using Graph = vector<vector<int>>;
using _Graph = vector<vector<edge>>;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
vector<bool> seen;
vector<int> colors;
int H, W, N;
int sx, sy, gx, gy;
vector<vector<char>> field;
vector<vector<int>> dist;
deque<pair<int, int>> que;
typedef vector<vector<int> > Matrix;
const ll INF = 1e18;
int main() {
int N, M, X, Y;
cin >> N >> M >> X >> Y;
vector<int> x(N), y(M);
REP(i, N){
cin >> x[i];
}
REP(i, M){
cin >> y[i];
}
sort(x.begin(), x.end(), greater<int>());
sort(y.begin(), y.end());
for(int i = X+1; i <= Y; i++){
if(i <= y[0]){
if(i>x[0]){
cout << "No War" << endl;
return 0;
}
}
}
cout << "War" << endl;
}
| 0
| 92,518,368
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i,a,b) for(ll i=a;i<=b;i++)
#define FORD(i,a,b) for(ll i=a;i>=b;i--)
#define ALL(a) (a).begin(),(a).end()
#define SZ(a) int((a).size())
#define SORT(c) sort((c).begin(),(c).end())
#define PB push_back
#define MP make_pair
#define MEMSET(v, h) memset((v), h, sizeof(v))
#define sqr(x) ((x) * (x))
#define cub(x) ((x) * (x) * (x))
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(){
ll n,k; cin >> n >> k;
ll a[n];
FOR(i,0,n-1) cin >> a[i];
vector<ll> cand;
FOR(i,0,n-1){
ll sum = 0;
FOR(j,i,n-1){
sum += a[j];
cand.PB(sum);
}
}
ll mask = 0;
FORD(i,40,0){
int cnt = 0;
for(ll x: cand){
if((x & ((1LL<<i) | mask)) == ((1LL<<i) | mask)) ++cnt;
}
if(cnt>=k) mask |= (1LL << i);
}
cout << mask << endl;
}
|
#include <bits/stdc++.h>
template<class T> inline bool chmin(T&a, T b){if(a > b){a = b; return true;}else{return false;}}
template<class T> inline bool chmax(T&a, T b){if(a < b){a = b; return true;}else{return false;}}
#define ll long long
#define double long double
#define rep(i,n) for(int i=0;i<(n);i++)
#define REP(i,n) for(int i=1;i<=(n);i++)
#define mod (ll)(1e9+7)
#define inf (ll)(3e18+7)
#define pi (double) acos(-1.0)
#define P pair<int,int>
#define PiP pair<int,pair<int,int>>
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
using namespace std;
int main() {
ll n;
cin >> n;
ll ans = 0;
REP(i, n)ans += i * (n-i+1);
rep(i, n-1){
ll v, w;
cin >> v >> w;
if(v > w)swap(v, w);
ans -= v * (n-w+1);
}
cout << ans << endl;
}
| 0
| 45,340,746
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a, b;
int n10k, nk, nc, nd, n1, counter = 0;
cin >> a >> b;
for (int n = a; n< b + 1; n++)
{
n10k = n / 10000;
nk = (n - n10k * 10000) / 1000;
nc = (n - n10k * 10000 - nk * 1000) / 100;
nd = (n - n10k * 10000 - nk * 1000 - nc * 100) / 10;
n1 = (n - n10k * 10000 - nk * 1000 - nc * 100 - nd * 10);
if ((n10k == n1) && (nk == nd))
{
counter++;
}
}
cout << counter;
return 0;
}
|
#include <bits/stdc++.h>
#include <boost/multiprecision/cpp_int.hpp>
#define rep_n(_1, _2, _3, NAME, ...) NAME
#define rep_2(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define rep_3(i, initial, n) \
for (int(i) = (int)(initial); (i) < (int)(n); ++(i))
#define rep(...) rep_n(__VA_ARGS__, rep_3, rep_2, rep_1)(__VA_ARGS__)
#define rep_r_n(_1, _2, _3, NAME, ...) NAME
#define rep_r_2(i, n) for (int(i) = (int)(n); (i) > 0; (i)--)
#define rep_r_3(i, initial, n) \
for (int(i) = (int)(initial); (i) > (int)(n); (i)--)
#define rep_r(...) rep_r_n(__VA_ARGS__, rep_r_3, rep_r_2)(__VA_ARGS__)
using namespace std;
typedef long long ll;
using mpint = boost::multiprecision::cpp_int;
typedef pair<int, int> P;
const double EPS = numeric_limits<double>::epsilon();
const ll MOD = ll(1e9) + 7;
const ll INF = ll(1e10);
const string ALPHABET = "abcdefghijklmnopqrstuvwxyz";
const double PI = acos(-1);
ll gcd(const ll a, const ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(const ll a, const ll b) { return a / gcd(a, b) * b; }
int ctoi(char c) { return (int)(c - '0'); }
vector<pair<ll, ll>> prime_factorize(ll n) {
vector<pair<ll, ll>> p;
for (ll i = 2; i * i <= n; i++) {
if ((n % i) != 0) continue;
pair<ll, ll> a = make_pair(i, 0);
while ((n % i) == 0) {
n /= i;
a.second += 1;
}
p.push_back(a);
}
if (n != 1) p.push_back(make_pair(n, 1));
return p;
}
ll modinv(ll a) {
ll b = MOD, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= MOD;
if (u < 0) {
u += MOD;
}
return u;
}
ll permutation(const ll n, const ll m) {
ll result = 1;
for (ll i = n; i > n - m; i--) {
result = (result * i) % MOD;
}
return result;
}
ll repeat_square(const ll n, const ll x) {
if (x == 0) return 1;
ll res = repeat_square(n, x / 2);
res = res * res % MOD;
if ((x % 2) == 1) res = res * n % MOD;
return res;
}
ll combination(ll n, ll m) {
ll p = permutation(n, m);
ll div = 1;
for (ll i = 2; i <= m; i++) {
div = (div * i) % MOD;
}
return (p * modinv(div)) % MOD;
}
string get_alphabet(ll n) {
n--;
return string(1, 'a' + (n % 26));
}
int main() {
int N, K;
cin >> N >> K;
vector<int> A(N, 0);
rep(i, N) {
int a;
cin >> a; a--;
A[a]++;
}
sort(A.begin(), A.end());
int ans = 0;
rep(i, A.size()) {
if (A[i] == 0) continue;
int check = 0, prev = -1;
rep(j, i, A.size()) {
check++;
}
if (check <= K) break;
ans += A[i];
}
cout << ans << endl;
return 0;
}
| 0
| 19,621,999
|
#include<bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define pai acos(-1)
#define ll long long
const ll mod = 1e9 +07;
const ll mxn = 1e6 +10;
int main()
{
ll i,j,k,a,b,c,d,n,m,t,h,u,v,x,y,z;
string s;
cin>>s;
if(s[0]=='R'&&(s[0]==s[1]&&s[1]==s[2]))
{
cout<<3<<endl;
}
else if(s[1]=='R'&&(s[0]==s[1]||s[1]==s[2]))
{
cout<<2<<endl;
}
else if(count(s.begin(),s.end(),'R')>0)
{
cout<<1<<endl;
}
else
{
cout<<0<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#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, n, m) for(int (i)=(n); (i)<(m); ++i)
constexpr ll INF = 1LL << 62;
constexpr int mod = 1e9+7;
int main(){
int K, N;
cin >> N >> K;
vector<ll> x(N), y(N), px(N), py(N);
REP(i, N){
cin >> x[i] >> y[i];
px[i] = x[i], py[i] = y[i];
}
sort(px.begin(), px.end());
sort(py.begin(), py.end());
REP(i, N){
auto itr = lower_bound(px.begin(), px.end(), x[i]);
x[i] = itr-px.begin()+1;
itr = lower_bound(py.begin(), py.end(), y[i]);
y[i] = itr-py.begin()+1;
}
vector<vector<ll>> sum(N+1, vector<ll>(N+1, 0));
REP(i, N){
sum[y[i]][x[i]]++;
}
REP(i, N+1){
REP(j, N){
sum[i][j+1] += sum[i][j];
}
}
REP(j, N+1){
REP(i, N){
sum[i+1][j] += sum[i][j];
}
}
ll ans = INF;
REP(i, N+1){
FOR(j, i+1, N+1){
REP(k, N+1){
FOR(l, k+1, N+1){
ll v = sum[j][l] - sum[j][k] - sum[i][l] + sum[i][k];
if(v >= K){
ll u = j-1, b = i, left = l-1, right = k;
u = py[u], b = py[b], left = px[left], right = px[right];
ll S = (u-b) * (left-right);
ans = min(ans, S);
}
}
}
}
}
cout << ans << endl;
return 0;
}
| 0
| 92,816,138
|
#include<algorithm>
#include<iostream>
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<cmath>
#include<list>
#include<set>
#include<map>
using namespace std;
long long MOD = 1000000007LL;
const double PI = 3.14159265358979323846;
#undef INT_MIN
#undef INT_MAX
#define INT_MIN -2147483648
#define INT_MAX 2147483647
#define endl "\n"
int main() {
int X, Y;
cin >> X >> Y;
int a2 = (4 * X - Y);
if (a2 % 2 == 0 && 0 <= a2 / 2 && a2 / 2 <= X) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
#define FOR(i,n,j) for(int i=(j);i<(n);++i)
#define ssort(n) sort((n).begin(),(n).end())
#define rsort(n) sort((n).begin(),(n).end(),greater<int>())
using ll=long long;
using ld=long double;
typedef pair<double,int> P;
#define repl(i,n) for(ll i=0;i<(n);++i)
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define YES cout << "YES" << endl
#define NO cout << "NO" << endl
#define INF 11711711
int main()
{
char a,b;
cin >> a >> b;
if(a<=b){
rep(i,b-'0'){
cout << a;
}
cout << endl;
}else{
rep(i,a-'0'){
cout << b;
}
cout << endl;
}
}
| 0
| 69,336,442
|
#include <bits/stdc++.h>
using namespace std;
using ull = unsigned long long;
using ll = long long;
using lli = long long int;
using ld = long double;
using pa = pair<int,int>;
using ppa = pair<pa,int>;
#define SORT(v, n) sort(v, v+n);
#define ALL(v) v.begin(),v.end()
#define VSORT(v) sort(ALL(v))
#define GRESORT(v) sort(ALL(v),greater<ll>())
#define REVERSE(v) reverse(ALL(v))
#define overlap(v) v.erase(unique(ALL(v)),v.end())
#define debug(x) cout << #x << ": " << x << endl
#define FOR(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,n) FOR(i,0,n)
#define RFOR(i,a,b) for(int i = (b-1); i >= a; i--)
#define rrep(i,n) RFOR(i,0,n)
#define INF INT_MAX
#define SUP INT_MIN
#define mins(a,b) a = min(a,b)
#define maxs(a,b) a = max(a,b)
const ll MOD = 1000000007;
ll pow_mod(ll a,ll b,ll mod){
ll tmp = 1;
a %= mod;
if(b > 0){
tmp = pow_mod(a, b/2, mod);
if(b % 2) tmp = (((tmp*tmp)%mod)*a)%mod;
else tmp = (tmp*tmp)%mod;
}
return tmp;
}
int mm = 1000000;
vector<bool> d(mm);
void hoge(){
d[0] = d[1] = true;
FOR(i,2,mm){
if(d[i]) continue;
for(int j = 2; i*j <= mm; j++){
d[i*j] = true;
}
}
}
void solve() {
vector<int> dp(mm,INF);
int val;
int m = 2;
dp[0] = dp[1] = 0;
hoge();
while(cin >> val){
if(dp[val] == INF){
FOR(i,m,val+1){
dp[i] = dp[i-1] + (!d[i] ? 1 : 0);
}
m = val;
}
cout << dp[val] << endl;
}
}
int main(){
std::ios::sync_with_stdio(false);
std::cin.tie(0);
solve();
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
#include <cmath>
#include <climits>
#include <iomanip>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
ll mod = 998244353;
long long power(long long m,long long n){
long long res = 1;
if(n > 0){
res = power(m,n / 2);
if(n % 2 == 0){
res = (res * res) % mod;
}
else{
res = (((res * res) % mod) * m) % mod;
}
}
return res;
}
int main(){
ll n = 0;
cin >> n;
ll res = 0;
res = 1;
vector<ll> count(n);
for(int i = 0;i < n;i++){
ll in;
cin >> in;
count[in]++;
if((i == 0 && in != 0) || (i != 0 && in == 0)){
cout << 0 << endl;
return 0;
}
}
for(int i = 1;i < n;i++){
if(count[i] > 0){
res *= power(count[i - 1],count[i]);
res %= mod;
}
}
if(n == 1){
if(count[0] == 1)res = 1;
else res = 0;
}
if(count[0] != 1)res = 0;
cout << res << endl;
}
| 0
| 57,796,385
|
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<LL, LL> PII;
template <class T>
inline bool chmax(T &a, T b)
{
if (a < b)
{
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T &a, T b)
{
if (a > b)
{
a = b;
return 1;
}
return 0;
}
template <typename T>
function<T(T, T)> op_max = [](T a, T b) -> T { return max(a, b); };
template <typename T>
function<T(T, T)> op_min = [](T a, T b) -> T { return min(a, b); };
template <typename T>
function<T(T, T)> op_sum = [](T a, T b) -> T { return a + b; };
using namespace std;
template <typename T>
void dump(const T &data, vector<int> &iter)
{
cout << data << " ";
}
template <typename T>
void dump(const vector<T> &data, vector<int> &iter)
{
for (auto elem : data)
dump(elem, iter);
cout << endl;
}
template <typename T>
void dump(const vector<vector<T>> &data, vector<int> &iter)
{
for (auto elem : iter)
{
cout << "[" << elem << "]";
}
cout << endl;
for (int i = 0; i < data.size(); i++)
{
iter.push_back(i);
dump(data[i], iter);
iter.pop_back();
}
cout << endl;
}
template <typename T>
void dump(const vector<T> &data, int dummy)
{
for (int i = 0; i < data.size(); i++)
{
cout << "[" << i << "] " << data[i] << endl;
}
}
template <typename T>
void dump(const T &data)
{
vector<int> iter;
dump(data, iter);
}
void solve(long long S, long long W)
{
if (S <= W)
cout << "unsafe" << endl;
else
cout << "safe" << endl;
}
int main()
{
cout << setprecision(10);
long long S;
scanf("%lld", &S);
long long W;
scanf("%lld", &W);
solve(S, W);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define ALL(v) v.begin(), v.end()
#define V vector
#define P pair
typedef long double ld;
typedef long long ll;
const int MOD = 1000000007;
const int IINF = INT_MAX;
const ll INF = 1LL << 60;
int main() {
int n, k; cin >> n >> k;
string s; cin >> s;
V<int> v;
if(s[0] == '0') v.push_back(0);
for(int i = 0; i < n;){
int j = i;
while(j < n && s[j] == s[i]) j++;
v.push_back(j - i);
i = j;
}
if(s[n - 1] == '0') v.push_back(0);
V<int> w((int)v.size() + 1, 0);
for(int i = 0; i < (int)v.size(); i++){
w[i + 1] = w[i] + v[i];
}
int ans = 0;
int m = w.size();
for(int i = 0; i < m; i+=2){
int j = i + k * 2 + 1;
if(j >= m) j = m - 1;
ans = max(ans, w[j] - w[i]);
}
cout << ans << endl;
return 0;
}
| 0
| 55,156,526
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000*1000*1000 + 7;
int mul(int a, int b) {
return (1LL * a * b) % mod;
}
int mpow(int a, int n) {
if(n == 0) return 1;
int x = mpow(a, n/2);
x = mul(x, x);
if(n % 2) x = mul(a, x);
return x;
}
void add_self(int& a, int b) {
a += b;
if(a >= mod) a -= mod;
}
void sub_self(int& a, int b) {
a -= b;
if(a < 0) a += mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> arr(n);
for(int& x : arr) cin >> x;
int ans = 0;
vector<int> less(n), less_left(n);
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
if(arr[j] < arr[i]) {
less[i]++;
if(j < i) less_left[i]++;
}
}
}
for(int i = 0; i < n; i++) {
int sum = mul(k, k+1);
sum = mul(sum, mpow(2, mod-2));
add_self(ans, mul(sum, less[i]));
sub_self(ans, mul(k, less_left[i]));
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const long long INF = 1LL << 60;
int main() {
ll N, Y;
cin >> N >> Y;
for(int i=0; i<=N; i++) {
for(int j=0; j<=N-i; j++) {
int k = N - i - j;
if(i * 1000 + j * 5000 + k * 10000 == Y) {
cout << k << " " << j << " " << i << endl;
return 0;
}
}
}
cout << -1 << " " << -1 << " " << -1 << endl;
}
| 0
| 87,546,795
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using V = vector<int>;
using VV = vector<vector<int>>;
using VVV = vector<vector<vector<int>>>;
using VL = vector<ll>;
using VVL = vector<vector<ll>>;
using VVVL = vector<vector<vector<ll>>>;
template<class T> using pq = priority_queue<T>;
template<class T> using P = pair<T, T>;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep1(i,n) for(int i=1;i<=(n);i++)
#define REP(i,k,n) for(int i=(k);i<(n);i++)
#define all(a) (a).begin(),(a).end()
#define output(x,y) cout << fixed << setprecision(y) << x << endl;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
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; }
const ll MOD = 1e9 + 7;
const ll BetsuMOD = 998244353;
ll upper = MOD + MOD;
ll under = -upper;
ll UPPER = MOD * MOD;
ll UNDER = -UPPER;
const long double pi = 3.141592653589793;
int main() {
string s;
cin >> s;
int n = s.size();
deque<char> dq;
rep(i, n) {
dq.push_back(s[i]);
}
int ans = 0;
while (!dq.empty()) {
if (dq.size() == 1) break;
if (dq.front() == dq.back()) {
dq.pop_front();
dq.pop_back();
}
else if (dq.front() == 'x' && dq.back() != 'x' || dq.back() == 'x' && dq.front() != 'x') {
ans++;
if (dq.front() == 'x') dq.pop_front();
else dq.pop_back();
}
else {
cout << -1 << endl;
return 0;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define INF 1e9+7
#define rep(i,n) for(ll i=0;i<n;i++)
const int maxn = 200000;
ll mod = INF;
int n;
int a[maxn];
bool key=false;
int ans;
int main(){
cin >> n;
rep(i,n){
cin >> a[i];
}
ans=n;
int now=0;
rep(i,n){
if(a[i]==now+1){
now=a[i];
ans--;
}
}
if(ans==n){
cout << -1<<endl;
}else{
cout << ans<<endl;
}
return 0;
}
| 0
| 14,733,129
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define ull unsigned long long int
#define ld long double
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define intarr(arr, n) ll arr[n]; for (ll i = 0; i < n; i++) cin >> arr[i]
#define inpvec(vec,n) for(ll i=0;i<n;i++){ll var;cin>>var;vec.push_back(var);}
#define ff first
#define ss second
#define pb push_back
#define mkp make_pair
#define vec vector<ll>
#define pi pair<ll,ll>
#define changeline cout<<endl
#define loop(i,a,b) for(ll i=a;i<b;i++)
#define rev(i,a,b) for(ll i=a;i>=b;i--)
#define all(v) v.begin(),v.end()
#define mod2 998244353
#define NO cout << "NO" <<endl
#define YES cout << "YES" <<endl
#define mem(arr,val) memset(arr,val,sizeof(arr));
const ll mod=1e9+7;
#define piii 3.14159265358979323846264338327950
#define print(a, n, m) for (ll i = n; i < m; i++) { cout << a[i] << " "; } cout << endl
#define con continue
bool prime(ll n)
{
if (n <= 1) return false;
if (n <= 3) return true;
if (n%2 == 0 || n%3 == 0) return false;
for (ll i=5; i*i<=n; i=i+6)
if (n%i == 0 || n%(i+2) == 0)
return false;
return true;
}
bool isPerfectSquare(ll x) {
long double sr = sqrt(x);
return ((sr - floor(sr)) == 0);
}
bool subsequence_checker(string str1, string str2, ll m, ll n)
{
if (m == 0) return true;
if (n == 0) return false;
if (str1[m-1] == str2[n-1])
return subsequence_checker(str1, str2, m-1, n-1);
return subsequence_checker(str1, str2, m, n-1);
}
bool cmp(const pair<int,int> &a, const pair<int,int> &b)
{
if(a.ff == b.ff)
return a.ss < b.ss;
return (a.ff > b.ff);
}
int gcd(int p, int q){
if(p % q == 0)return q;
return gcd(q, p % q);
}
void solve()
{
ll n,m;
cin>>n>>m;
intarr(a,n);
ll sum = 0;
loop(i,0,n) sum+= a[i];
ll ans = 0;
ld req = (ld)sum/(4.0*m);
loop(i,0,n)
{
if(a[i]>=req)
ans++;
}
if(ans>=m)
{
cout<<"Yes";
}
else
cout<<"No";
return;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
IOS;
ll t;
t=1;
while(t--){
solve();
cout<<endl;
}
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << "ms\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cout<<fixed; cout<<setprecision(12);
#define randomINT mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#define newl cout<<"\n"
#define DISP(as) for(auto it : as) cout<<it<<" ";newl;
#define all(x) (x).begin(),(x).end()
#define mset(x,val) memset(x,val,sizeof(x))
#define newl cout<<"\n"
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define dline cerr<<"
#define deb1(x) cerr<<#x<<" = "<<x<<'\n';
#define deb2(x,y) cerr<<'['<<#x<<','<<#y<<"] = "<<'['<<x<<','<<y<<']'<<'\n';
#define deb3(x,y,z) cerr<<'['<<#x<<','<<#y<<','<<#z<<"] = "<<'['<<x<<','<<y<<','<<z<<']'<<'\n';
typedef long long ll;
typedef long double ld;
typedef vector<ll> vll;
typedef pair<ll ,ll> pll;
typedef pair<ld,ld> pld;
typedef unordered_map<ll,ll> um;
typedef vector<pll> vpll;
const ll MAX5 = 1e+5+7;
const ll MAX7 = 1e+7+7;
const ll MAXN = MAX7;
const ll INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
const ll MOD = 1e+9+7;
const ll N = 2*1e6;
ll T=1;
ll n,x,y,m;
string s,t;
vll a;
void MAIN() {
cin >> s;
vll cnt(26,0);
for(auto ch : s) {
cnt[ch-'a']++;
}
n = s.length();
ll ans = n*(n-1)/2 + 1;
for(ll i=0;i<26;i++) ans -= cnt[i]*(cnt[i]-1)/2;
cout<<ans;
}
int main() {
fastio;randomINT;
while(T--) {
MAIN();
}
return 0;
}
| 0
| 31,442,350
|
#include <bit>
#include <bitset>
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <set>
#include <map>
#include <vector>
#include <math.h>
#include <stdlib.h>
#include <queue>
#include <stack>
typedef long double ld;
typedef long long ll;
using namespace std;
#define MAXN (1 << 10)
ll a[MAXN], s[MAXN];
vector<ll> v;
int n, k;
void solve(vector<ll> & v, int pos, ll cur) {
if (pos < 0) {
cout << cur << endl;
return;
}
vector<ll> tv;
ll posmask = (1LL << pos);
for (int i = 0; i < v.size(); i++) {
if (v[i] & posmask) {
tv.push_back(v[i]);
}
}
if (tv.size() >= k) {
solve(tv, pos - 1, cur | posmask);
} else {
solve(v, pos - 1, cur);
}
}
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
s[i] += a[i] + s[i - 1];
}
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
v.push_back(s[j] - s[i - 1]);
}
}
solve(v, 41, 0);
return 0;
}
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPS(I, a, b) for (int i = (a); i < (b); ++i)
using namespace std;
using ll = long long;
int main() {
ll n,m;
cin >> n >> m;
vector<pair<ll,ll>> v(n);
REP(i,n){
int a,b;
cin >> a >> b;
v[i].first = a;
v[i].second = b;
}
sort(v.begin(),v.end());
ll ans = 0;
ll i = 0;
while(m > 0){
if(v[i].second <= m){
ans += v[i].first * v[i].second;
m -= v[i].second;
}
else{
ans += v[i].first * m;
m = 0;
}
i++;
}
cout << ans << endl;
}
| 0
| 61,178,092
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
using namespace std;
int main() {
int n, m, x;
cin >> n >> m >> x;
int cs[12] = {};
int as[12][12] = {{}};
rep(i, n) {
cin >> cs[i];
rep(j, m) { cin >> as[i][j]; }
}
int mmmoney = 100000000;
for (int bit = 1; bit < (1 << n); bit++) {
int money = 0;
int totals[m];
rep(i, m) { totals[i] = 0; }
rep(i, n) {
if (bit & (1 << i)) {
rep(j, m) { totals[j] += as[i][j]; }
money += cs[i];
}
}
bool c = true;
rep(i, m) {
if (totals[i] < x) {
c = false;
}
}
if (c) {
mmmoney = min(mmmoney, money);
}
}
if (mmmoney == 100000000) {
mmmoney = -1;
}
cout << mmmoney << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
typedef long long ll;
int main(void)
{
int N,H,W,cnt = 0,x0,x1,y0,y1,a,xi,yi,ans;
cin >> W >> H >> N;
x0 = 0;
y0 = 0;
x1 = W;
y1 = H;
rep(i, N){
cin >> xi >> yi >> a;
switch (a)
{
case 1:
x0 = max(xi,x0);
break;
case 2:
x1 = min(xi,x1);
break;
case 3:
y0 = max(yi,y0);
break;
default:
y1 = min(yi,y1);
break;
}
}
ans = (x1-x0)*(y1-y0);
if(x1-x0 < 0 || y1-y0 < 0)
ans = 0;
cout << ans << endl;
return 0;
}
| 0
| 47,941,908
|
#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, K;
cin >> N >> K;
if (K == 1)
cout << 0 << endl;
else
cout << N - K << endl;
return 0;
}
|
#include<cstdio>
using namespace std;
int main(void) {
int X, A;
scanf("%d %d", &X, &A);
if (X < A) {
printf("%d\n", 0);
} else {
printf("%d\n", 10);
}
return 0;
}
| 0
| 30,550,993
|
#include "bits/stdc++.h"
#define rep(i,n) for(int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
typedef pair<ll, int> LP;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
ll k;
cin >> n >> k;
vector<P> v(n);
rep(i,n) cin >> v[i].first >> v[i].second;
sort(v.begin(), v.end());
rep(i,n){
if(v[i].second < k) k -= v[i].second;
else{
cout << v[i].first << endl;
return 0;
}
}
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
int main(void){
string s;
int shf;
int tmp;
while (1) {
int sum = 0;
cin >> s;
if (s == "-") break;
cin >> shf;
for (int i = 0; i < shf; i++) {
cin >> tmp;
sum += tmp;
}
tmp = sum % s.length();
string ans = s.substr(tmp, s.length()) + s.substr(0, tmp);
cout << ans << endl;
}
}
| 0
| 90,286,021
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define ld long double
#define fi first
#define se second
#define pb push_back
#define all(v) v.begin(),v.end()
#define repf(i,a,b) for(ll i=a;i<b;i++)
#define repb(i,a,b) for(ll i=a;i>=b;i--)
#define IOS ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define mod 1000000007
#define MOD 998244353
using namespace std;
using namespace __gnu_pbds;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
ordered_set<ll> ors;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
ld PI=3.14159265359;
ll power(ll a, ll n, ll m)
{
ll ans=1;
while(n)
{
if(n&1) ans=(ans*a)%m;
n>>=1;
a=(a*a)%m;
}
return ans;
}
ll invmod(ll a, ll m)
{
return power(a,m-2,m);
}
ll lp[1000001];
vector<ll> pr;
void prime()
{
repf(i,1,1000001) lp[i]=i;
repf(i,2,1000001)
{
if(lp[i]==i)
{
for(ll j=2*i;j<1000001;j+=i)
{
if(lp[j]==j) lp[j]=i;
}
}
}
}
const ll MX=200001;
vector<ll> v[MX];
ll depth[MX];
ll D[MX][22];
void dfs(ll x, ll p, ll h=0) {
D[x][0]=p;
depth[x]=h;
repf(i,1,22)
{
if(D[x][i-1]!=-1 && D[D[x][i-1]][i-1]!=-1)
{
D[x][i]=D[D[x][i-1]][i-1];
}
}
for(auto i:v[x]) {
if(i==p) continue;
dfs(i,x,h+1);
}
}
ll walk(ll x, ll k)
{
repf(i,0,22)
{
if((1<<i)&k)
{
x=D[x][i];
}
}
return x;
}
ll lca(ll x, ll y)
{
if(depth[x]>depth[y]) x=walk(x,depth[x]-depth[y]);
if(depth[y]>depth[x]) y=walk(y,depth[y]-depth[x]);
if(x==y) return x;
repb(i,21,0)
{
if(D[x][i]!=D[y][i])
{
x=D[x][i];
y=D[y][i];
}
}
return D[x][0];
}
void init() {
prime();
}
void solve(ll tt) {
ll n,x,m;
cin>>n>>x>>m;
bool vis[m]={false};
vector<ll> v;
ll sum=0;
while(v.size()<n && !vis[x]) {
v.pb(x);
vis[x]=true;
sum+=x;
x=(x*x)%m;
}
ll ans=sum;
ll sz=v.size();
if(sz==n) {
cout<<ans<<endl;
return;
}
vector<ll> vtmp;
sum=0;
repf(i,0,sz) {
if(v[i]==x) {
repf(j,i,sz) sum+=v[j],vtmp.pb(v[j]);
break;
}
}
ll rem=n-sz;
ll times=rem/vtmp.size();
ll rr=rem%vtmp.size();
ans+=sum*times;
repf(i,0,rr) ans+=vtmp[i];
cout<<ans<<endl;
}
int main()
{
init();
ll t=1;
repf(tt,1,t+1) {
solve(tt);
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<ll> vi;
typedef pair<ll,ll> pii;
#define fo(i,s,e_ex) for(i=s;i<e_ex;i++)
#define Fo(i,k,n) for(i=k;k<n?i<=n:i>=n;k<n?i+=1:i-=1)
#define endl '\n'
#define MOD 1000000007
#define pbb push_back
#define mpp make_pair
#define ff first
#define ss second
#define all(x) x.begin(),x.end()
#define mset(arr,val) memset(arr,val,sizeof(arr))
ll arr[105],dp[105][100005];
void solve(ll caseno){
ll i,j,n,k;
cin>>n>>k;
for(i=1;i<=n;i++) cin>>arr[i];
fo(i,0,k+1) dp[0][i]=1;
for(i=1;i<=n;i++){
for(j=0;j<=k;j++){
ll mn=j-arr[i]-1;
dp[i][j]=dp[i-1][j];
if(mn>=0) dp[i][j]-=dp[i-1][mn];
dp[i][j]=(dp[i][j]+MOD)%MOD;
}
if(i==n){
cout<<dp[n][k]<<endl;
return;
}
for(j=1;j<=k;j++) {
dp[i][j]+=dp[i][j-1];
dp[i][j]%=MOD;
}
}
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
ll t=1;
for(ll i=1;i<=t;i++){
solve(i);
}
return 0;
}
| 0
| 33,957,462
|
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
#define endl "\n"
int main()
{
i64 N, X, M;
cin >> N >> X >> M;
vector<i64> A(M + 2), sum(M + 2), ind(M + 1, -1);
A[1] = X;
sum[1] = X;
ind[X] = 1;
i64 loopStart, loopSize;
for (i64 i = 2; i <= M + 1; i++)
{
A[i] = (A[i - 1] * A[i - 1]) % M;
sum[i] = sum[i - 1] + A[i];
if (i == N)
{
cout << sum[i] << endl;
return 0;
}
if (ind[A[i]] != -1)
{
loopStart = ind[A[i]];
loopSize = i - ind[A[i]];
break;
}
ind[A[i]] = i;
}
i64 ans = 0;
i64 loopCnt = (N - loopStart) / loopSize;
ans += loopCnt * (sum[loopSize + loopStart] - sum[loopStart]);
N -= loopSize * loopCnt;
ans += sum[N];
cout << ans << endl;
return 0;
}
|
#include <algorithm>
#include <functional>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <bitset>
#include <climits>
#define all(c) (c).begin(), (c).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const int INF=100000000;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
using namespace std;
typedef pair<int ,int > P;
typedef long long ll;
struct RollingHash {
typedef long long int_type;
typedef pair<int_type,int_type> hash_type;
int_type base1;
int_type base2;
int_type mod1;
int_type mod2;
vector<int_type> hash1;
vector<int_type> hash2;
vector<int_type> pow1;
vector<int_type> pow2;
RollingHash() : base1(1009), base2(1007), mod1(1000000007), mod2(1000000009) {}
void init(const string &s) {
int n = s.size();
hash1.assign(n+1,0);
hash2.assign(n+1,0);
pow1.assign(n+1,1);
pow2.assign(n+1,1);
for(int i=0;i<n;i++) {
hash1[i+1] = (hash1[i]+s[i]) * base1 % mod1;
hash2[i+1] = (hash2[i]+s[i]) * base2 % mod2;
pow1[i+1] = pow1[i] * base1 % mod1;
pow2[i+1] = pow2[i] * base2 % mod2;
}
}
hash_type get(int l,int r) {
int_type t1 = ((hash1[r] - hash1[l] * pow1[r-l]) % mod1 + mod1) % mod1;
int_type t2 = ((hash2[r] - hash2[l] * pow2[r-l]) % mod2 + mod2) % mod2;
return make_pair(t1, t2);
}
RollingHash::hash_type concat(hash_type h1, hash_type h2, int h2_len) {
return make_pair((h1.fr*pow1[h2_len]+h2.fr)%mod1, (h1.sc*pow2[h2_len]+h2.sc)%mod2);
}
};
int n;
set<RollingHash::hash_type> S;
int main() {
ios::sync_with_stdio(false);
cin>>n;
RollingHash rh;
while(n--) {
string q,s;
cin>>q>>s;
rh.init(s);
RollingHash::hash_type hash = rh.get(0,s.size());
if(q=="insert") {
S.insert(hash);
}
else {
if(S.count(hash)) cout<<"yes"<<endl;
else cout<<"no"<<endl;
}
}
return 0;
}
| 0
| 37,550,315
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<pii,int> ppii;
typedef pair<int,pii> pipi;
typedef pair<ll,ll> pll;
typedef pair<pll,ll> ppll;
typedef pair<ll,pll> plpl;
typedef tuple<ll,ll,ll> tl;
ll mod=1000000007;
ll mod2=998244353;
ll mod3=1000003;
ll mod4=998244853;
ll inf=1000000000000000000;
double pi=2*acos(0);
#define rep(i,m,n) for(ll i=m;i<n;i++)
#define rrep(i,n,m) for(ll i=n;i>=m;i--)
int dh[4]={1,-1,0,0};
int dw[4]={0,0,1,-1};
int ddh[8]={-1,-1,-1,0,0,1,1,1};
int ddw[8]={-1,0,1,-1,1,-1,0,1};
ll lmax(ll a,ll b){
if(a<b)return b;
else return a;
}
ll lmin(ll a,ll b){
if(a<b)return a;
else return b;
}
ll gcd(ll a,ll b){
if(a<b)swap(a,b);
if(b==0)return a;
if(a%b==0)return b;
return gcd(b,a%b);
}
ll Pow(ll n,ll k){
ll ret=1;
ll now=n;
while(k>0){
if(k&1)ret*=now;
now*=now;
k/=2;
}
return ret;
}
int main(){
ios::sync_with_stdio(false);cin.tie(0);
int n;cin>>n;
int a[n];
vector<int> v;
rep(i,0,n){
cin>>a[i];
v.push_back(a[i]);
}
sort(v.begin(),v.end());
unordered_map<int,int> mp;
rep(i,0,v.size()){
mp[v[i]]=i+1;
}
rep(i,0,n)a[i]=mp[a[i]];
int ans=0;
for(int i=0;i<n;i+=2){
if(a[i]%2==0)ans++;
}
cout<<ans<<endl;
}
|
#include<iostream>
using namespace std;
#include<stdio.h>
#include<cctype>
int main() {
int r[26], i, j;
char ch;
for(i = 0; i < 26; i++) {
r[i] = 0;
}
for(i = 0; i < 26; i++) {
while( cin >> ch ) {
if(isupper(ch)) ch = (char)(tolower(ch));
j = ch - 'a';
if (j < 26 && j >= 0) r[j]++;
}
}
for(i = 0; i < 26; i++) {
cout << (char)('a' + i) << " : " << r[i] << endl;
}
return 0;
}
| 0
| 1,689,873
|
#include <iostream>
int main(){
unsigned long long f = 1;
int n;
std::cin >> n;
for(int i=1;i<=n;++i){
f *= i;
}
std::cout << f << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n); i >= 0; i--)
#define REP(i, m, n) for (int i = (int)(m); i <= (int)(n); i++)
#define REPR(i, m, n) for (int i = (int)(m); i >= (int)(n); i--)
#define all(v) v.begin(), v.end()
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
using Graph = vector<vector<int> >;
vector<bool> seen;
vector<int> order;
vector<int> indeg;
void bfs(const Graph &G, int u){
queue<int> q;
q.push(u);
while(!q.empty()){
int v = q.front(); q.pop();
seen[v] = true;
order.push_back(v);
for(int nv : G[v]){
indeg[nv]--;
if(seen[nv]) continue;
if(indeg[nv] != 0) continue;
q.push(nv);
}
}
}
int main(){
int n, e; cin >> n >> e;
indeg.assign(n, 0);
Graph G(n);
rep(i, e){
int s, t; cin >> s >> t;
G[s].push_back(t);
indeg[t]++;
}
seen.assign(n, false);
order.clear();
rep(i, n){
if(indeg[i] == 0 && !seen[i]) bfs(G, i);
}
rep(i, n) cout << order[i] << endl;
return 0;
}
| 0
| 32,061,479
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, A, B;
cin >> N >> A ;
B = N % 500 ;
if (A-B >=0 ) {
cout << "Yes" << endl;
}
if (A-B <0 ) {
cout << "No" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
typedef long long ll;
#define _GLIBCXX_DEBUG
typedef vector<int> vec;
typedef vector<ll> lvec;
typedef vector<char> cvec;
typedef vector<double> dvec;
typedef pair<ll, ll> LP;
typedef tuple<ll, ll, ll> LT;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
#define fs first
#define sc second
int main() {
string s;
cin>>s;
vector<int>a(4);
rep(i,4) a[i]=s[i]-'0';
for(int tmp=0;tmp<(1<<3);tmp++){
bitset<4>t(tmp);
int sum=a[0];
string str;
str+=(char)(a[0]+'0');
rep(i,3){
if(t.test(i)){
str+='+';
sum+=a[i+1];
}
else{
str+='-';
sum-=a[i+1];
}
str+=s[i+1];
}
if(sum==7){
str+="=7";
cout<<str<<endl;
return 0;
}
}
}
| 0
| 95,031,157
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,k;
scanf("%d %d",&n,&k);
vector<int> v(n);
for(int&x:v) scanf("%d",&x);
vector<int> dp(n+1,1e9);
dp[0] = 0;
for(int i = 1; i < n; i++)
for(int j = 1; j <= k; j++)
if(i-j >= 0)
dp[i] = min(dp[i], dp[i-j]+abs(v[i]-v[i-j]));
printf("%d\n", dp[n-1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
ll n, k, d, x;
bool ans[107];
int main() {
cin >> n >> k;
for(ll i = 0; i < k; ++i) {
cin >> d;
for(ll j = 0; j < d; ++j) {
cin >> x;
ans[x] = 1;
}
}
ll cnt = 0;
for(ll i = 1; i <= n; ++i) {
if(!ans[i]) cnt++;
}
cout << cnt << endl;
return 0;
}
| 0
| 45,411,558
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
int main() {
int A;
int c = 1;
cin >> A;
rep(i, 10000) {
if(c > A) {
break;
}
c *= 2;
}
cout << c / 2 << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, a, b) for(int i = a; i < b; i++)
#define Rep(i, a, b) for(int i = a; i <= b; i++)
#define _GLIBCXX_DEBUG
#define Vl vector<ll>
#define Vs vector<string>
#define ll long long
#define ALL(v) (v).begin(),(v).end()
using namespace std;
void solve() {
string s; cin >> s;
bool f = false;
if(s.substr(s.size()-7, 7) == "keyence")
f = true;
if(s.substr(0, 1) == "k" && s.substr(s.size()-6, 6) == "eyence")
f = true;
if(s.substr(0, 2) == "ke" && s.substr(s.size()-5, 5) == "yence")
f = true;
if(s.substr(0, 3) == "key" && s.substr(s.size()-4, 4) == "ence")
f = true;
if(s.substr(0, 4) == "keye" && s.substr(s.size()-3, 3) == "nce")
f = true;
if(s.substr(0, 5) == "keyen" && s.substr(s.size()-2, 2) == "ce")
f = true;
if(s.substr(0, 6) == "keyenc" && s.substr(s.size()-1, 1) == "e")
f = true;
if(s.substr(0, 7) == "keyence")
f = true;
if(f) cout << "YES" << endl;
else cout << "NO" << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| 0
| 45,332,845
|
#include <iostream>
using namespace std;
long long int get_digit(long long int l){
long long int digit = 0;
while(l != 0){
l /= 10;
digit++;
}
return digit;
}
int main(void){
long long int n;
cin >> n;
long long int j;
long long int x,y,z;
long long int ans = 20000000000000;
for(long long int i=1; i*i <= n;i++){
if(n%i == 0){
j = n/i;
x = get_digit(i);
y = get_digit(j);
z = max(x,y);
if(z < ans){
ans = z;
}
}
}
cout << ans << endl;
}
|
#include<bits/stdc++.h>
int main(){
int n;std::cin>>n;
std::vector<long long>a(n+2);
for(int i=0;i<n;i++){
std::cin>>a.at(1+i);
}
std::vector<int>ord(n);
std::iota(ord.begin(),ord.end(),1);
std::sort(ord.begin(),ord.end(),[&a](int x,int y){return a.at(x)>a.at(y);});
std::multiset<int>set;
set.insert(0);
set.insert(0);
set.insert(n+1);
set.insert(n+1);
long long ans=0;
for(int i:ord){
auto it=set.insert(i);
auto l1=std::prev(it);
auto l0=std::prev(l1);
auto r0=std::next(it);
auto r1=std::next(r0);
ans+=a.at(i)*((*l1-*l0)*(*r0-i)+(i-*l1)*(*r1-*r0));
}
std::cout<<ans<<std::endl;
}
| 0
| 90,287,490
|
#include <iostream>
using namespace std;
int main()
{
int a[5];
for (int i = 0; i < 5; i++) {
cin >> a[i];
}
for (int i = 4; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (a[j] < a[j+1]) {
swap(a[j], a[j+1]);
}
}
}
for (int i = 0; i < 5; i++) {
if (i > 0) cout << " ";
cout << a[i];
}
cout << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll>pll;
typedef pair<ll,pair<ll,ll>>plll;
#define fastread() (ios_base:: sync_with_stdio(false),cin.tie(NULL));
#define vll(v) v.begin(),v.end()
#define all(x) x.rbegin(),x.rend()
#define min3(a, b, c) min(a, min(b, c))
#define max3(a, b, c) max(a, max(b, c))
#define F first
#define S second
#define in freopen("input.txt", "r", stdin)
#define out freopen("output.txt", "w", stdout)
#define minheap int,vector<int>,greater<int>
#define pb push_back
#define eb emplace_back
#define ischar(x) (('a' <= x && x <= 'z') || ('A' <= x && x <= 'Z'))
#define isvowel(ch) ((ch=='a'||ch=='e'||ch=='i'||ch=='o'||ch=='u')||(ch=='A'|| ch=='E' || ch=='I'|| ch=='O'|| ch=='U'))
#define bug cout<<"BUG"<<endl;
const int Max = 2e6 + 10;
const int Mod = 1e9 + 7;
const double PI =3.141592653589793238463;
bool compare(const pair<ll,ll> &a, const pair<ll,ll> &b)
{
return (a.first > b.first);
}
ll lcm(ll a,ll b)
{
if(a==0 || b==0)return 0;
return a/__gcd(a,b)*b;
}
void input(ll ara[],ll n)
{
for(ll i=0; i<n; i++)cin>>ara[i];
}
void print(ll ara[],ll n)
{
for(ll i=0; i<n; i++)
cout<<ara[i]<<" ";
cout<<endl;
}
vector<ll>v[Max+10];
int main()
{
fastread();
ll i,j,n,m,p,a,sum=0,k,t,b,c,d,cnt=0,q,l,r,ans=0;
bool flag=false;
string str;
cin>>n>>d;
for(i=0; i<n; i++)
{
for(j=0; j<d; j++)
{
cin>>a;
v[i].eb(a);
}
}
for(i=0; i<n; i++)
{
for(j=i+1; j<n; j++)
{
sum=0;
for(k=0; k<d; k++)
{
a=abs(v[i][k]-v[j][k]);
sum+=(a*a);
}
a=sum;
double aa=sqrt(a),bb;
a=aa;
bb=a;
if(aa==bb)ans++;
}
}
cout<<ans<<endl;
}
| 0
| 61,555,350
|
#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 <math.h>
#include <cstdlib>
#include<iomanip>
#define rep(i,x) for(int i=0;i<x;i++)
#define all(a) (a).begin(),(a).end()
using namespace std;
using ld = long double;
using ll = long long;
const ll INF = 1001001001;
typedef pair<ll, ll> P;
const ll mod = 1000000007;
ll gcd(ll a, ll b) {
if (a < b)swap(a, b);
if (a % b == 0) return b;
else return gcd(b, a % b);
}
int main() {
ll N;
cin >> N;
if (N > 17)cout << "Yes" << endl;
else if (N == 4 || N == 8 || N == 12 || N == 7 || N == 14 || N == 16 || N == 11 || N == 15) {
cout << "Yes" << endl;
}
else cout << "No" << endl;
}
|
#pragma GCC optimize ("O3")
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() {
cerr << endl;
}
template <typename H, typename... T>
void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
template <typename T>
void print(T x) {
cout << x << endl;
}
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REVFOR(i, m, n) for (int i = (n - 1); i >= (m); --i)
#define REP(i, n) FOR(i, 0, n)
#define REVREP(i, n) REVFOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll,ll> Pll;
typedef pair<int,int> Pin;
ll INF = 1e16;
int inf = 1e9;
ll MOD = 1e9+7;
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int N, K;
cin >> N >> K;
ll zero = 0, half = 0;
FOR(i, 1, N + 1) {
if (i % K == 0) zero++;
if (~K & 1 && i % K == K / 2) half++;
}
print(ll(pow(zero, 3) + pow(half, 3)));
}
| 0
| 52,119,996
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
string a, b;
long long e=0;
cin >> a >>b;
for (int i=0; i<3;i++){
char c=a[i], d=b[i];
if (c==d){
e++;}}
cout << e;}
|
#include<bits/stdc++.h>
#include<cmath>
#define pb push_back
#define ld long double
#define mp make_pair
#define vl vector<ll>
#define vd vector<double>
#define vld vector<long double>
#define ll long long int
#define pl pair<ll, ll>
#define all(a) a.begin(), a.end()
#define forr(i, n) for(ll i=0; i<n; i++)
#define forr1(i, n) for(ll i=1; i<=n; i++)
using namespace std;
const ld PI =3.1415926535897923846;
const ll MOD = 1000000007;
const ll N=998244353;
ll power(ll x,ll n){ll res=1;while(n>0){if(n&1) res=res*x%MOD;x=x*x%MOD;n>>=1;}return res;}
ll modinverse(ll a){return power(a, MOD-2);}
void solve()
{
ll n;
cin>>n;
unordered_map<ll, ll> mp1;
vl a(n);
forr(i, n)
{
cin>>a[i];
mp1[a[i]]++;
}
if(mp1.find(1)==mp1.end())
{
cout<<-1<<endl;
return;
}
ll to_be_found=1;
for(ll i=0; i<n; i++)
{
if(a[i]==to_be_found)
{
to_be_found++;
}
}
cout<<(n-to_be_found+1)<<endl;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll test=1;
while(test--)
{
solve();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC << "ms\n";
}
| 0
| 20,128,042
|
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long int ull;
typedef long long int ll;
int main() {
char a, b;
cin >> a >> b;
if ((a == 'H')&&(b == 'H')) {
cout << 'H' << endl;
} else if ((a == 'H')&&(b == 'D')) {
cout << 'D' << endl;
} else if ((a == 'D')&&(b == 'H')) {
cout << 'D' << endl;
} else if ((a == 'D')&&(b == 'D')) {
cout << 'H' << endl;
} else {
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma region MACRO
#define P(x) cout << (x) << endl
#define p(x) cout << (x)
#define PED cout << "\n"
#define rep(i,n) for(int i=0; i<(int)n; ++i)
#define REP(i,x,n) for(int i=x; i<(int)n; ++i)
#define repi(i,n) for(int i=0; i<=(int)n; ++i)
#define REPI(i,x,n) for(int i=x; i<=(int)n; ++i)
#define ILP while(true)
#define FOR(i,c) for(__typeof((c).begin())!=(c).begin(); i!=(c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define mp make_pair
#pragma endregion
#pragma region TYPE_DEF
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<string, string> pss;
typedef pair<string, int> psi;
typedef pair<int, string> pis;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<long double> vld;
typedef vector<long> vl;
typedef vector<long long> vll;
typedef vector<string> vs;
#pragma endregion
#pragma region ESTD
template<typename C, typename T> int count(C& c, T t) { return count(ALL(c), t); }
template<typename C, typename F> int count_if(C& c, F f) { return count_if(ALL(c), f); }
template<typename C, typename T> void erase(C& c, T t) { remove(ALL(c), t), c.end(); }
template<typename C> void remove(vector<C>& c, unsigned int index) { c.erase(c.begin()+index); }
template<typename C, typename T, typename U> void replace(C& c, T t, U u) { replace(ALL(c), t, u); }
template<typename C, typename F, typename U> void replace_if(C& c, F f, U u) { (ALL(c), f, u); }
template<typename C> void reverse(C& c) { reverse(ALL(c)); }
template<typename C> void sort(C& c) { sort(ALL(c)); }
template<typename C, typename Pred> void sort(C& c, Pred p) { sort(ALL(c), p); }
#pragma endregion
#pragma region CONST_VAL
constexpr int PI = (2*acos(0.0));
constexpr int EPS = (1e-9);
constexpr int MOD = (int)(1e9+7);
constexpr int INF = 100000000;
#pragma endregion
int main()
{
string s;
while(getline(cin, s)) {
if(s==".") break;
int flg = 1;
stack<char> st;
for(int i=0; i<s.size(); ++i) {
if(s[i]=='(') st.push(s[i]);
else if(s[i]=='[') st.push(s[i]);
else if(s[i]==')') {
if(!st.empty()&&st.top()=='(') st.pop();
else {
flg = 0;
break;
}
}
else if(s[i]==']') {
if(!st.empty()&&st.top()=='[') st.pop();
else {
flg = 0;
break;
}
}
}
if(!st.empty()) flg = 0;
if(flg==1) cout << "yes" << endl;
else cout << "no" << endl;
}
return 0;
}
| 0
| 93,814,468
|
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); i++)
using ll = long long;
using namespace std;
using P = pair<int,int>;
int main(){
ll a, b, k;
cin >> a >> b >> k;
if(k <= a) cout << a - k << " " << b << endl;
else if(k <= a + b) cout << 0 << " " << b - (k - a) << endl;
else cout << 0 << " " << 0 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define rep(i, n) for (int i = 0; i < n; ++i)
#define REP(i, n) for (int i = 0; i < n; ++i)
#define range(i,a,b) ((a)<=(i) && (i)<(b))
#define debug(x) cout << #x << ' ' << '=' << ' ' << (x) << endl;
#define fs first
#define sc second
#define pb push_back
#define eb emplace_back
typedef long long ll;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> T;
typedef vector<ll> vec;
typedef vector<P> pvec;
typedef vector<vector<ll>> vvec;
typedef vector<vector<P>> pvvec;
typedef priority_queue<ll> PQI;
typedef priority_queue<P> PQP;
typedef priority_queue<ll,vector<ll>,greater<ll>> PQIG;
typedef priority_queue<P,vector<P>,greater<P>> PQPG;
const vector<int> dx = {0, -1, 0, 1, 1, 1, -1, -1};
const vector<int> dy = {1, 0, -1, 0, 1, -1, 1, -1};
const int MOD = (1000000007);
const int INF = (1LL << 60);
const double EPS = (1 >> 30);
template<class T> inline bool chmin(T& a, T b) {if (a > b) {a = b; return 1;} return 0;}
template<class T> inline bool chmax(T& a, T b) {if (a < b) {a = b; return 1;} return 0;}
template< typename T1, typename T2 > istream &operator>>(istream &is, pair< T1, T2 > &p) { is >> p.first >> p.second; return is; }
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
string s;
cin>>s;
rep(i,4){
cout<<s[i];
}
cout<<" ";
rep(i,8){
cout<<s[4+i];
}
cout<<endl;
}
| 0
| 31,416,168
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
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 long long INF = 1LL << 60;
const int inf = 1001001001;
int main(){
ll n,ans=0;
cin >> n;
vector<ll> data(n);
vector<ll> dp(n+1,0);
dp.at(0)=0;
rep(i,n){
cin >> data.at(i);
}
rep(i,n+1){
if(i==0) continue;
dp.at(i)=dp.at(i-1)+data.at(i-1);
}
map<ll,ll> cnt;
for(ll i=0; i<=n; i++){
cnt[dp.at(i)]++;
}
for(auto it : cnt){
ll num=it.second;
ans+=num*(num-1)/2;
}
cout << ans << endl;
}
|
#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, K;
cin >> N >> K;
int A;
map<ll, ll> MAP;
rep(i, N) {
cin >> A;
MAP[A]++;
}
int C[5001][5001] = {};
int k = 0;
C[0][0] = 1;
for (auto itr2 : MAP) {
ll kazu = itr2.second;
rep(i, K) {
if (C[k][i]) {
rep1(ii, kazu) {
ll kari = i + itr2.first * ii;
if (kari <= K) {
C[k + 1][kari] = 1;
}
}
C[k + 1][i] = 1;
}
}
k++;
}
int iranai = 0;
int k1 = 0;
for (auto itr : MAP) {
if (itr.first < K) {
int B[10001] = {};
int OK = 0;
int k2 = 0;
rep(i, K + 1) {
B[i] = C[k1][i];
}
for (auto itr2 : MAP) {
if (k1 <= k2) {
ll kazu = itr2.second;
if (itr.first == itr2.first) kazu--;
vector<int> V;
rep(i, K) {
if (B[i]) {
rep1(ii, kazu) {
ll kari = i + itr2.first * ii;
if (kari <= K) {
V.pb(kari);
}
}
}
}
for (auto itr3 : V) {
B[itr3] = 1;
}
for (int i = K - itr.first; i < K; i++) {
if (B[i] == 1) OK = 1;
}
if (OK) break;
}
k2++;
}
if (OK == 0) {
iranai += itr.second;
}
}
k1++;
}
co(iranai);
Would you please return 0;
}
| 0
| 30,249,454
|
#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <functional>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
long double n, m, d, ans;
long long i, j, k;
cin >> n >> m >> d;
if (d == 0) ans = 1.0 / n;
else {
ans = (n - d) * 2.0 / (n * n);
}
ans *= (m - 1);
cout << setprecision(10) << fixed << ans << "\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
ll l1[51][51];
ll dir[8][2]={{1,0},{0,1},{0,-1},{-1,0},{-1,1},{-1,-1},{1,-1},{1,1}};
map<ll,ll>di;
int main()
{
string s,t;
cin>>s;
cin>>t;
ll n,m;
n=s.size();
m=t.size();
if(m>n){
cout<<"UNRESTORABLE";return 0;
}
string ans="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz";
for(int i=0;i<=n-m;i++){
string s2=s;bool ok=true;
for(int j=0;j<m;j++){
if(s[i+j]!='?'&&s[i+j]!=t[j])ok=false;
s2[i+j]=t[j];
}
if(ok){
replace(s2.begin(),s2.end(),'?','a');
ans=min(ans,s2);
}
}
if(ans=="zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz")cout<<"UNRESTORABLE";
else cout<<ans;
}
| 0
| 72,940,830
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define gap ' '
#define L(i) ((i) - (&i))
const int MAXN = 1000010;
const int MAX = 1e6 + 1;
const int MOD = 1e9;
const int INF = 1e9;
int main(){
int n, k; cin >> n >> k;
vector<int> a(n,0);
for(int i = 0; i < n; ++i)
cin >> a[i];
vector<int> dp(n,INF);
dp[0] = 0;
for(int i = 0; i < n; ++i){
int e = i+1;
for(int j = 1; j <= k; ++j){
if(e < n){
dp[e] = min(dp[e], dp[i]+abs(a[i]-a[e]));
e++;
}
else
break;
}
}
cout << dp[n-1] << "\n";
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int N;
string s;
bool f(vector<int> &t) {
for(int i=1; i<=N; i++) {
if(s[i] == 'o' && t[i]) {
t[i+1] = 1 - t[i-1];
} else if(s[i] == 'o') {
t[i+1] = t[i-1];
} else if(t[i]) {
t[i+1] = t[i-1];
} else {
t[i+1] = 1 - t[i-1];
}
}
if(t[0] == t[N] && t[1] == t[N+1]) {
for(int i=0; i<N; i++) {
if(t[i]) {
cout << 'W';
} else {
cout << 'S';
}
}
cout << endl;
return true;
} else {
return false;
}
}
int main(void) {
cin >> N >> s;
s.push_back(s[0]);
s.push_back(s[1]);
vector<int> t(N+2);
t[0] = 0;
t[1] = 0;
if(f(t)) return 0;
t[0] = 0;
t[1] = 1;
if(f(t)) return 0;
t[0] = 1;
t[1] = 0;
if(f(t)) return 0;
t[0] = 1;
t[1] = 1;
if(f(t)) return 0;
cout << -1 << endl;
return 0;
}
| 0
| 38,703,356
|
#include <stdio.h>
int main(void){
char chara[1200];
int count[26];
for(int i=0;i<1200;i++)chara[i]=0;
for (int i = 0; i<26; i++)count[i] = 0;
while(fgets(chara, sizeof(chara), stdin) != NULL){
for (int i = 0; i < sizeof(chara);i++) {
int ch = chara[i];
if (ch < 65 || ch >122)continue;
if (ch >= 97 && ch <= 122)ch = ch - 32;
count[ch - 65]+=1;
}
for(int i=0;i<1200;i++)chara[i]=0;
}
for (int i = 0; i < sizeof(count) / 4; i++){
printf("%c : %d\n", 97+i, count[i]);
}
return 0;
}
|
#define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <string.h>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i,n) for(int i=0;i<(lint)(n);i++)
#define REP(i,n) for(int i=1;i<=(lint)(n);i++)
#define all(V) V.begin(),V.end()
#define stackReplaceBegin(size)\
void* p=malloc(size);\
esp_new=(lint)p+size-1;\
void * stack_extend_memory_ = malloc(size);\
void * stack_extend_origin_memory_;\
char * stack_extend_dummy_memory_ = (char*)alloca((1+(int)(((long long)stack_extend_memory_)&127))*16);\
*stack_extend_dummy_memory_ = 0;\
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp":"=b"(stack_extend_origin_memory_):"a"((char*)stack_extend_memory_+(size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX/2;
constexpr lint LINF = LLONG_MAX/2;
constexpr double eps = DBL_EPSILON;
constexpr double PI=3.141592653589793238462643383279;
lint esp_new;
template<class T>
class prique :public std::priority_queue<T, std::vector<T>, std::greater<T>> {};
template <class T, class U>
inline bool chmax(T& lhs, const U& rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U>
inline bool chmin(T& lhs, const U& rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b; b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) {
return a / gcd(a, b) * b;
}
bool isprime(lint n) {
if (n == 1)return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)return false;
}
return true;
}
template<typename T>
T mypow(T a, unsigned int b) {
T res(1),now(a);
while(b){
if(b&1)res*=now;
b>>=1;
now*=now;
}
return res;
}
template<typename T>
void printArray(std::vector<T>& vec) {
rep(i, vec.size() - 1)std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template<typename T>
void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int a[110];
int main() {
int N;
std::cin>>N;
for(int i=0;i<N;i++)std::cin>>a[i];
int ans=0;
for(int i=1;i<N;i++){
if(a[i-1]==a[i]){
a[i]=-1;
ans++;
}
}
std::cout<<ans<<std::endl;
return 0;
}
| 0
| 42,570,510
|
#include <bits/stdc++.h>
using namespace std;
int64_t mod=998244353;
int64_t jo(int64_t a,int64_t b){
int64_t c=a;
for(int i=0; i<b-1; i++){
c = c*a;
c = c%mod;
}
if (b==0) c=1;
return c;
}
int main(){
int n;
cin >> n;
int64_t ans=1;
vector<int64_t> cnt(n);
for(int i=0; i<n; i++){
int64_t x;
cin >> x;
cnt.at(x)++;
if (x==0&&i!=0) ans=0;
if (x!=0&&i==0) ans=0;
}
for(int i=0; i<n-1; i++){
ans = ans*jo(cnt[i],cnt[i+1]);
ans = ans%mod;
}
cout << ans << endl;
}
|
#include <iostream>
#include <string>
#include <cstring>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <cmath>
#include <numeric>
#include <float.h>
#include <math.h>
#include <sstream>
#include <iterator>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define vi vector<int>
#define vl vector<ll>
const long long INF = 1LL << 60;
typedef long long ll;
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int ctoi(char c) {
switch (c) {
case '0': return 0;
case '1': return 1;
case '2': return 2;
case '3': return 3;
case '4': return 4;
case '5': return 5;
case '6': return 6;
case '7': return 7;
case '8': return 8;
case '9': return 9;
default: return 0;
}
}
bool is_prime(const unsigned n){
switch(n){
case 0:
case 1: return false;
case 2:
case 3: return true;
}
if(n % 2 == 0 || n % 3 == 0) return false;
for(unsigned i = 5; i * i <= n; i += 6) {
if(n % i == 0) return false;
if(n % (i+2) == 0) return false;
}
return true;
}
map<ll,ll> mp;
auto findFactors(ll num){
ll i;
while (num % 2 == 0){
if(mp.count(2)){
mp[2] = mp[2] + 1;
}
else{
mp[2] = 1;
}
num /= 2;
}
for (i = 3; i <= num; i++){
while (num % i == 0){
if(mp.count(i)){
mp[i] = mp[i] + 1;
}
else{
mp[i] = 1;
}
num /= i;
}
}
return 0;
}
ll kaizyou(ll n){
if(n == 1){
return 1;
}
else{
return (n * kaizyou(n-1)) % 1000000007;
}
}
int main(){
ll mod = 1000000007;
ll N,M; cin >> N >> M;
vl dp(N+2,0);
rep(i,M){
ll a; cin >> a;
dp[a] = -1;
}
dp[N] = 1;
for(int i = N - 1; i >= 0; i--){
if(dp[i] != -1){
dp[i] = dp[i+1] + dp[i+2];
dp[i] %= mod;
}
else{
dp[i] = 0;
}
}
cout << dp[0] << endl;
}
| 0
| 32,165,131
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int) 1e5 + 7;
int n, sum[N];
pair<int, int> pmin[N];
string s;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> s;
n = (int) s.size();
for (int ch = 0; ch < 26; ch++) {
for (int i = 1; i <= n; i++) {
if (s[i - 1] - 'a' == ch) {
sum[i] = sum[i - 1] + 1;
} else {
sum[i] = sum[i - 1] - 1;
}
pmin[i] = min(pmin[i - 1], {sum[i], i});
}
for (int i = 2; i <= n; i++) {
if (sum[i] - pmin[i - 2].first > 0) {
cout << pmin[i - 2].second + 1 << " " << i << "\n";
return 0;
}
}
}
cout << "-1 -1\n";
}
|
#include <bits/stdc++.h>
using namespace std;
void input(int& rnAchieve, vector<int>& rvnPrice, vector<vector<int>>& rvvnSkill)
{
int nPriceSiz, nSkillSiz;
cin >> nPriceSiz >> nSkillSiz >> rnAchieve;
rvnPrice.resize(nPriceSiz);
rvvnSkill.resize(nPriceSiz, vector<int>(nSkillSiz));
for (int ny = 0; ny < rvvnSkill.size(); ny++)
{
cin >> rvnPrice[ny];
for (int nx = 0; nx < rvvnSkill[ny].size(); nx++)
cin >> rvvnSkill[ny][nx];
}
}
int calcMinPriceSkillup(int nAchieve, const vector<int> cnrvnPrice,
const vector<vector<int>>& cnrvvnSkill)
{
int nMinPrice = INT_MAX;
for (int nCtl = 0; nCtl < ( 1 << cnrvnPrice.size() ); nCtl++)
{
int nPrice = 0;
vector<int> vnSumSkill(cnrvvnSkill[0].size());
for (int ny = 0; ny < cnrvnPrice.size(); ny++)
if (nCtl & ( 1 << ny ))
{
for (int nx = 0; nx < cnrvvnSkill[ny].size(); nx++)
vnSumSkill[nx] += cnrvvnSkill[ny][nx];
nPrice += cnrvnPrice[ny];
}
bool bRslt = true;
for (int nSumSkill : vnSumSkill)
if (nSumSkill < nAchieve)
{
bRslt = false;
break;
}
if (bRslt)
nMinPrice = min(nMinPrice, nPrice);
}
if (nMinPrice == INT_MAX)
return -1;
else
return nMinPrice;
}
int main()
{
int nAchieve;
vector<int> vnPrice;
vector<vector<int>> vvnSkill;
input(nAchieve, vnPrice, vvnSkill);
cout << calcMinPriceSkillup(nAchieve, vnPrice, vvnSkill) << endl;
return 0;
}
| 0
| 100,248,934
|
#include<stdio.h>
#include<string.h>
int main(){
char s[100];
char p[100];
char a[200];
scanf("%s",s);
scanf("%s",p);
strcpy(a,s);
strcat(a,s);
if(strstr(a,p))
printf("Yes\n");
else
printf("No\n");
return 0;
}
|
#include "iostream"
using namespace std;
int main(){
int mplication, mplicand;
for (int mplication = 1; mplication <= 9; ++mplication)
{
for (int mplicand = 1; mplicand <= 9; ++mplicand)
{
cout << mplication << "x" << mplicand << "=" << mplication * mplicand << endl;
}
}
return 0;
}
| 0
| 15,987,003
|
#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
static const int MAX = 10000;
using namespace std;
int V,E;
vector<int> G[MAX];
vector<int> ans;
bool used[MAX];
int indeg[MAX];
void bfs(int s){
queue<int> q;
q.push(s);
used[s]=true;
while(!q.empty())
{
int u=q.front(); q.pop();
ans.push_back(u);
for(int i=0;i<G[u].size();i++)
{
int k = G[u][i];
indeg[k]--;
if(indeg[k]==0 && !used[k])
{
used[k]=true;
q.push(k);
}
}
}
}
void topological()
{
for(int u=0;u<V;u++)
{
if(indeg[u]==0 && !used[u])
{
bfs(u);
}
}
}
int main(){
cin>>V>>E;
fill(indeg,indeg+MAX,0);
fill(used,used+MAX,0);
for(int i=0;i<E;i++){
int s,t;
cin>>s>>t;
G[s].push_back(t);
indeg[t]++;
}
topological();
for(int i=0;i<V;i++)
{
cout<<ans[i]<<"\n";
}
}
|
#include <algorithm>
#include <iostream>
#include <stack>
#include <set>
#include <cstdio>
#include <cstring>
using namespace std;
int ans[100005];
int res[100005];
int kun[100005];
int a[200005][2]={0};
int main(){
int n;
cin>>n;
long long a[200005];
long long res=0;
for(int i=0;i<n;i++){
cin>>a[i];
res+=a[i];
a[i]=res;
}
long long mi=0;
for(int i=0;i<n-1;i++){
long long ans=res;
long long x,y;
x=a[i];
y=ans-a[i];
if(i==0){
mi=abs(x-y);
}
else{
long long zz=abs(x-y);
if(zz<mi){
mi=zz;
}
}
}
cout<<mi;
}
| 0
| 1,524,109
|
#include<bits/stdc++.h>
#define ll long long
#define ld long double
#define ull unsigned long long
#define pb push_back
#define n_p next_permutation
#define p_p prev_permutation
#define in insert
#define rev reverse
#define pf push_front
#define pob pop_back
#define uniq(v) v.resize(distance(v.begin(),unique(v.begin(),v.end())))
#define all(x) (x).begin(),(x).end()
#define pof pop_front
#define ios ios_base::sync_with_stdio(0);cin.tie();cout.tie();
#define scn scanf
#define prt printf
#define rep(i, a, n) for(int i = a; i < n; i++)
#define mod 1000000007
#define yes cout << "Yes\n"
#define no cout << "No\n";
#define take for(auto &it : a) cin >> it;
#define out cout << a << "\n";
#define l_b lower_bound
#define u_b upper_bound
#define f first
#define s second
#define Max 1005
using namespace std;
void solve() {
int n;
scanf("%d", &n);
ll ans = 0;
for(int i = 1; i <= n; i++) {
ll num = (ll)n / i;
num *= (num + 1);
num /= 2;
num *= i;
ans += num;
}
printf("%lld\n", ans);
}
int main() {
solve();
return 0;
}
|
#include <iostream>
#include <sstream>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <deque>
#include <stack>
#include <iomanip>
#include <cmath>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll MOD = 1000000007ll;
ll modSum(ll a, ll b) {
return ((a % MOD) + (b % MOD)) % MOD;
}
ll modProd(ll a, ll b) {
return ((a % MOD) * (b % MOD)) % MOD;
}
ll getPowMod(ll x, ll e) {
if (e == 0) return 1;
if (e % 2 == 0) {
ll tmp = getPowMod(x, e/2);
return modProd(tmp, tmp);
} else {
ll tmp = getPowMod(x, e-1);
return modProd(tmp, x);
}
}
ll getPow(ll x, ll e) {
if (e == 0) return 1;
if (e % 2 == 0) {
ll tmp = getPow(x, e/2);
return tmp * tmp;
} else {
ll tmp = getPow(x, e-1);
return tmp * x;
}
}
bool isEven(ll x) {
ll tmp = ((x % 2) + 2) % 2;
return tmp == 0;
}
ll getSumOfDigitsInBase(ll n, ll b) {
ll ret = 0;
while (n > 0) {
ret += n % b;
n /= b;
}
return ret;
}
const int MAXN = 100002;
const int MAXLOG = 20;
ll N, L, Q;
vector<ll> X;
ll memo[MAXN][MAXLOG];
void input() {
cin >> N;
ll tmp;
for (int i = 0 ; i < N ; i++) {
cin >> tmp;
X.push_back(tmp);
}
cin >> L >> Q;
}
void preprocess() {
for (int l = 0 ; l < MAXLOG ; l++) {
memo[N][l] = N;
}
for (int i = N-1 ; i >= 0 ; i--) {
auto it = lower_bound(X.begin(), X.end(), X[i]+L+1);
if (it != X.end()) {
it--;
}
memo[i][0] = (int)(it-X.begin());
for (int l = 1 ; l < MAXLOG ; l++) {
memo[i][l] = memo[memo[i][l-1]][l-1];
}
}
}
ll getAns(ll from, ll to) {
ll ans = 0;
ll at = from;
for (int i = MAXLOG-1 ; i >= 0 ; i--) {
if (memo[at][i] <= to) {
ans += getPow(2, i);
at = memo[at][i];
}
}
if (at != to) {
ans++;
}
return ans;
}
void solve() {
int a, b;
for (int i = 1 ; i <= Q ; i++) {
cin >> a >> b;
cout << getAns(min(a, b)-1, max(a, b)-1) << "\n";
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
int T;
T = 1;
for (int i = 0 ; i < T ; i++) {
input();
preprocess();
solve();
}
return 0;
}
| 0
| 24,284,631
|
#include <bits/stdc++.h>
#include<iostream>
#include<string>
using namespace std;
int main() {
string n;
cin>>n;
if( n[0] == n[1] && n[1]==n[2])
{
cout<< "Yes" <<endl;}
else if(n[2] == n[3] && n[2]==n[1] )
{
cout<< "Yes" <<endl;}
else {cout<<"No"<<endl;}
}
|
#include <iostream>
using namespace std;
int main() {
while (true) {
int x, y;
cin >> x >> y;
if (x > y) {
swap(x, y);
}
if (x == 0 && y == 0) {
break;
} else {
cout << x << " " << y << endl;
}
}
}
| 0
| 77,158,242
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define REP(i,m,n) for(int i=(int)(m); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define RREP(i,m,n) for(int i=(int)(m); i>=(int)(n); i--)
#define rrep(i,n) RREP(i,(n)-1,0)
#define all(v) v.begin(), v.end()
#define endk '\n'
const int inf = 1e9+7;
const ll longinf = 1LL<<60;
const ll mod = 1e9+7;
const ld eps = 1e-10;
template<typename T1, typename T2> inline void chmin(T1 &a, T2 b){if(a>b) a=b;}
template<typename T1, typename T2> inline void chmax(T1 &a, T2 b){if(a<b) a=b;}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s; cin >> s;
ll k; cin >> k; k--;
rep(i, s.size()) {
if(s[i] == '1') {
if(i == k) {
cout << s[i] << endk;
break;
}
} else {
cout << s[i] << endk;
break;
}
}
return 0;
}
|
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx")
#pragma GCC optimize("unroll-loops")
#ifdef _MSC_VER
#include <intrin.h>
#define __builtin_popcount __popcnt
#define __builtin_popcountll __popcnt64
#endif
#include <limits.h>
#include <math.h>
#include <time.h>
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define REPR(i, n) for (int i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (int i = m; i < n; ++i)
#define FORR(i, m, n) for (int i = m - 1; i >= n; --i)
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define REVERSE(v, n) reverse(v, v + n);
#define VREVERSE(v) reverse(v.begin(), v.end())
#define ll long long
#define print(x) cout << (x) << '\n'
#define pe(x) cout << (x) << " "
#define DEBUG(x) cout << #x << ": " << x << endl
#define lb(v, n) lower_bound(v.begin(), v.end(), (n))
#define ub(v, n) upper_bound(v.begin(), v.end(), (n))
#define int long long
#define all(x) (x).begin(), (x).end()
#define print_space(v) REP(i, v.size()) cout << v[i] << ((i == v.size() - 1) ? "\n" : " ")
template <typename T1, typename T2> inline void chmin(T1& a, T2 b) {if (a > b) a = b;}
template <typename T1, typename T2> inline void chmax(T1& a, T2 b) {if (a < b) a = b;}
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
std::random_device rd;
std::mt19937 mt(rd());
constexpr ll MOD = 1e9 + 7;
constexpr int MAX = 500050;
const double pi = acos(-1);
constexpr double EPS = 1e-8;
constexpr ll LINF = 1e18 + 1;
constexpr int INF = 1e9 + 1;
void solve() {
int N, L, T; cin >> N >> L >> T;
vector<int>X(N), W(N);
REP(i, N)cin >> X[i] >> W[i];
vector<int>tmp(N);
REP(i, N) {
if (W[i] == 1)tmp[i] = (X[i] + T) % L;
else tmp[i] = ((X[i] - T) % L+L) % L;
}
VSORT(tmp);
int cnt = 0;
REP(i, N) {
if (W[i] == 1)cnt -= (T - (L - X[i]) + L) / L;
else cnt += (T - (X[i] + 1) + L) / L;
}
cnt = (cnt%N + N) % N;
vector<int>res(N);
REP(i, N) {
res[(cnt + i) % N] = tmp[i];
}
REP(i, N)print(res[i]);
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
}
| 0
| 83,444,550
|
#include<bits/stdc++.h>
using namespace std;
#define LL long long
struct Q{char x; int a, b, c, d;} a[2001][2001];
int n, m;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++) cin >> a[i][j].x;
for(int i = 1; i <= n; i++) {
int cur = 1;
for(int j = 1; j <= m; j++) {
a[i][j].a = cur;
if(a[i][j].x == '#') cur = j + 1;
}
}
for(int i = 1; i <= n; i++) {
int cur = m;
for(int j = m; j >= 1; j--) {
a[i][j].b = cur;
if(a[i][j].x == '#') cur = j - 1;
}
}
for(int j = 1; j <= m; j++) {
int cur = 1;
for(int i = 1; i <= n; i++) {
a[i][j].c = cur;
if(a[i][j].x == '#') cur = i + 1;
}
}
for(int j = 1; j <= m; j++) {
int cur = n;
for(int i = n; i >= 1; i--) {
a[i][j].d = cur;
if(a[i][j].x == '#') cur = i - 1;
}
}
int ans = 0;
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++) {
if(a[i][j].x == '.') ans = max(ans, a[i][j].b - a[i][j].a + 1 + a[i][j].d - a[i][j].c + 1 - 1);
}
cout << ans;
}
|
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
#define fo(i,n) for(int i=0;i<n;i++)
#define Fo(i,k,n) for(int i=k;i<n;i++)
#define endl "\n"
#define ff first
#define ss second
#define int long long
#define pb push_back
#define mp make_pair
#define vec(x) vector<x>
#define matrix(x) vector<vector<x>>
#define mem(a,b) memset(a, b, sizeof a)
#define vii vector<pair<int,int>>
#define pii pair<int,int>
#define vi vector<int>
#define mii map<int,int>
#define pqb priority_queue<int>
#define pqs priority_queue<int,vi,greater<int> >
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define MOD 998244353
#define deb(x) cerr <<#x<<" = "<<x<<"\n"
#define inf 1e18
#define ps(x,y) fixed<<setprecision(y)<<x
#define mk(arr,n,type) type *arr=new type[n];
#define w(x) int x; cin>>x; while(x--)
#define all(v) v.begin(),v.end()
#define rep(i,a,b) for (int i = a; i<b; ++i)
#define len(s) s.length()
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
int power(int a,int b,int m=mod)
{int ans=1;while(b>0){if(b&1)ans=(ans*a)%m;a=(a*a)%m;b>>=1;}
return ans;}
void angshuGod()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
const int N = 1e5+1;
const double pi = acos(-1);
void solve(){
int n,m;
cin>>n>>m;
vii v(n);
fo(i,n){
cin>>v[i].ff>>v[i].ss;
}
sort(all(v));
int cost = 0;
for(int i = 0;i<n;i++){
if(m==0) break;
else if(m>v[i].ss){
cost += v[i].ff*v[i].ss;
m -= v[i].ss;
}
else{
cost += v[i].ff*m;
m = 0;
}
}
cout<<cost;
}
int32_t main()
{
angshuGod();
int t;
t = 1;
while(t--){
solve();
}
return 0;
}
| 0
| 80,260,261
|
#include <bits/stdc++.h>
using namespace std;
int main() {
char A;
cin >> A;
int c = 0;
string ALP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for(int i = 0; i < 26; i++) {
if(A == ALP.at(i)) {
cout << "A" << endl;
c++;
}
}
if(c == 0) {
cout << "a" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9+9;
int g[103][103];
int edg[1004][3];
int main(){
int n,m;
cin>>n>>m;
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
g[i][j] = inf;
}
g[i][i] = 0;
}
for(int i=0;i<m;i++){
for(int j=0;j<3;j++)cin>>edg[i][j];
g[edg[i][0]][edg[i][1]] = min (edg[i][2],g[edg[i][0]][edg[i][1]]);
g[edg[i][1]][edg[i][0]] = min (edg[i][2],g[edg[i][1]][edg[i][0]]);
}
int ans = m;
for(int k=1;k<=n;k++){
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
g[i][j] = min(g[i][j],g[i][k]+g[k][j]);
}
}
}
for(int i=0;i<m;i++){
bool shortest = false;
for(int j=1;j<=n;j++){
if(g[j][edg[i][0]]+edg[i][2]==g[j][edg[i][1]])shortest = true;
}
if(shortest)ans--;
}
cout<<ans<<endl;
return 0;
}
| 0
| 67,512,924
|
#include <stdio.h>
#include <string>
#include <string.h>
#include <cstring>
#include <algorithm>
const float a=1.05;
using namespace std;
int main(void)
{
int debt,week;
scanf("%d",&week);
debt=100000;
for(int loop=1;loop<=week;loop++)
{
debt*=1.05;
if(debt%1000!=0)
{
debt=debt-(debt%1000)+1000;
}
}
printf("%d\n",debt);
return 0;
}
|
#include <iostream>
#include <cstdio>
#define INF (1ll << 32)
#define int64 long long
using namespace std;
long long dp[105][105];
void pre (int size) {
for ( int i = 0 ;i < size; i++) {
for ( int j = 0;j < size; j++) {
dp[i][j] = ((i == j) ? 0 : INF );
}
}
}
main()
{
int v, e;
int s, t, d;
int p = 0;
scanf("%d %d", &v, &e);
pre(v);
for ( int i = 0; i < e; i++) {
scanf("%d %d %d", &s, &t, &d);
dp[s][t] = d;
}
for ( int i = 0; i < v ; i++) {
for ( int j = 0; j < v ; j++) {
for ( int k = 0; k < v ; k++) {
if ( dp[j][i] != INF && dp[i][k] != INF ) {
dp[j][k] = min(dp[j][k], dp[j][i] + dp[i][k]);
}
}
}
}
for (int i = 0; i < v; i++) {
if ( dp[i][i] < 0 ) {
p = 1;
}
}
if (p) {
cout << "NEGATIVE CYCLE" << endl;
} else {
for ( int i = 0; i < v; i++) {
for ( int j = 0; j < v; j++) {
if (j) {
cout << " " ;
}
if ( dp[i][j] == INF ) {
cout << "INF";
} else {
cout << dp[i][j];
}
}
cout << endl;
}
}
return (0);
}
| 0
| 31,693,251
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, start, end) for(uint64_t i=start; i<end; i++)
#define REP(i, n) FOR(i, 0, n)
uint64_t gcd(uint64_t m, uint64_t n) {
uint64_t temp;
while (m % n != 0){
temp = n;
n = m % n;
m = temp;
}
return n;
}
uint64_t lcm(uint64_t m, uint64_t n) {
return (m*n)/gcd(m,n);
}
void comb(vector<vector <uint64_t> > &v){
for(uint64_t i = 0;i <v.size(); i++){
v[i][0]=1;
v[i][i]=1;
}
for(uint64_t k = 1;k <v.size();k++){
for(uint64_t j = 1;j<k;j++){
v[k][j]=(v[k-1][j-1]+v[k-1][j]);
}
}
}
bool is_product_overflow(uint64_t a, uint64_t b) {
uint64_t prod = a * b;
return (prod / b != a);
}
void primeFactorization(uint64_t a, list<uint64_t> &factors){
long i,sq;
if(a%2==0){
factors.push_back(2);
primeFactorization(a/2,factors);
return;
}
sq = sqrt(a);
for(i=3;i<=sq;i+=2){
if(a%i==0){
factors.push_back(i);
primeFactorization(a/i,factors);
return;
}
}
if(a!=1){
factors.push_back(a);
}
}
int64_t modinv(int64_t a, int64_t m) {
int64_t b = m, u = 1, v = 0;
while (b) {
int64_t t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
int64_t getVal(int64_t d){
int64_t ans = 1;
for(int i=1;i<d;i++){
ans *= 10;
}
return ans;
}
signed main() {
int n;
cin >> n;
string s;
cin >> s;
int count = 0;
char lastC = 0;
for(auto c:s){
if(c==lastC) continue;
lastC = c;
count++;
}
cout << count << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int64_t mod = 1e9 + 7;
int64_t sum_mod (int64_t a, int64_t b) {
return (a + b) % mod;
}
int64_t sub_mod (int64_t a, int64_t b) {
return (a - b + mod) % mod;
}
int64_t mul_mod (int64_t a, int64_t b) {
return (a * b) % mod;
}
int64_t pow_mod (int64_t a, int64_t b) {
int64_t res = 1, t = a;
while (b) {
if (b & 1)
res = mul_mod(res, t);
t = mul_mod(t, t);
b >>= 1;
}
return res;
}
int64_t div_mod (int64_t a, int64_t b) {
return mul_mod(a, pow_mod(b, mod - 2));
}
signed main () {
int n;
string s;
cin >> n >> s;
int64_t ans = 0;
map < char, int64_t > cnt;
for (int i = 0; i < n; ++i) {
int64_t pref = 1;
for (auto pr: cnt) {
if (pr.first != s[i])
pref = mul_mod(pref, pr.second + 1);
}
ans = sum_mod(ans, pref);
++cnt[s[i]];
}
cout << ans << '\n';
}
| 0
| 52,134,178
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int counter(ll n)
{
int cnt = 0 ;
while(n)
{
n/=10;
cnt++;
}
return cnt ;
}
int main()
{
ll n,m;
cin >> n ;
int mn = INT_MAX;
for(ll i=1; i*i<=n; i++)
{
if(n%i==0)
{
int mx = 0;
int x = counter(i);
int y = counter(n/i);
mx = max(x,y);
mn = min(mn,mx);
}
}
cout << mn << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP0(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define RREP0(i, n) for (int i = (n)-1; i >= 0; --i)
#define REP1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; ++i)
#define RREP1(i, n) for (int i = (n); i >= 1; --i)
typedef long long LL;
typedef pair<LL, LL> pii;
const int INTINF = int(1e9) + 1;
const LL LLINF = LL(1e18) + 1;
long double eps = 1.0E-14;
#define pow10(n) int(1e##n + n)
struct edge
{
int to;
LL cost;
};
LL d[pow10(5)];
void solve()
{
int V;
cin >> V;
vector<vector<edge>> adj(V);
REP0 (i, V - 1)
{
int a, b;
LL c;
cin >> a >> b >> c;
a--;
b--;
adj[a].push_back(edge{b, c});
adj[b].push_back(edge{a, c});
d[i] = LLINF;
}
int Q, K;
cin >> Q >> K;
K--;
d[V - 1] = LLINF;
d[K] = 0;
priority_queue<pii, vector<pii>, greater<pii>> PQ;
PQ.push(pii(0, K));
while (PQ.size())
{
pii p = PQ.top();
PQ.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (auto e : adj[v])
{
if (d[e.to] > d[v] + e.cost)
{
d[e.to] = d[v] + e.cost;
PQ.push(pii(d[e.to], e.to));
}
}
}
REP0 (i, Q)
{
int x, y;
cin >> x >> y;
x--;
y--;
std::cout << d[x] + d[y] << endl;
}
}
int main(int argc, char const *argv[])
{
cin.tie(0);
ios::sync_with_stdio(false);
std::cout << std::fixed << std::setprecision(20);
solve();
return 0;
}
| 0
| 4,510,237
|
#include<bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
typedef long long ll;
#define pb push_back
#define fi first
#define se second
#define ALL(x) (x).begin(),(x).end()
#define RALL(x) (x).rbegin(),(x).rend()
template <class T, class U> ostream &operator<<(ostream &os, const pair<T, U> &p){os<<"("<<p.first<<","<< p.second<<")";return os;}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v){os<<"{";REP(i,(int)v.size()){if(i)os<<",";os<<v[i];}os<<"}";return os;}
template <typename T, size_t S> void printArray(const T (&array)[S]){for(auto val : array)std::cout << val << ", ";std::cout << "\n";}
void Yes() {cout << "Yes" << endl;}
void No() {cout << "No" << endl;}
void YES() {cout << "YES" << endl;}
void NO() {cout << "NO" << endl;}
const double PI=acos(-1);
const ll MOD = 1000000007;
using Graph = vector<vector<int>>;
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;
void solve(){
ll n; cin >> n;
vector<ll> c(n), s(n), f(n), res(n, 0);
REP(i, n-1){
cin >> c[i] >> s[i] >> f[i];
}
REP(i, n-1){
ll time = c[i] + s[i];
for(int j = i+1; j<n-1; j++){
if(time%f[j] == 0 && time >= s[j]){
time += c[j];
}
else if(time >= s[j]){
ll departure = s[j];
while(departure < time){
departure += f[j];
}
time += (departure - time);
time += c[j];
}
else if(time%f[j] == 0){
time += (s[j] - time);
time += c[j];
}
else{
time += (s[j] - time);
time += c[j];
}
}
cout << time << endl;
}
cout << 0 << endl;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
solve();
}
|
#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 FORR(i, m, n) for (int i = (m); i >= (n); --i)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
const ll mod = 1000000007;
const int inf = 1e9 + 10;
const ll INF = 1e18;
const ld EPS = 1e-10;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(25);
string s;
cin >> s;
int n = s.length();
vector<ll> dp(n + 1, INF);
dp[n] = 0;
map<int, int> mp;
mp[0] = n;
int res = 0;
repr(i, n - 1) {
dp[i] = min(dp[i], dp[i + 1] + 1);
int t = s[i] - 'a';
res ^= (1 << t);
if (mp[res]) dp[i] = min(dp[i], dp[mp[res]] + 1);
rep(j, 26) {
int res2 = res ^ (1 << j);
if (mp[res2]) dp[i] = min(dp[i], dp[mp[res2]] + 1);
}
if (dp[i] < dp[mp[res]]) mp[res] = i;
}
cout << dp[0] << '\n';
return 0;
}
| 0
| 10,307,425
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N,M;cin>>N>>M;vector<bool>V(N,true);vector<int>F(N);int P=0;int A=0;
for(int X=0;X<M;X++){
int L;string S;cin>>L>>S;
if(V[L-1]&&S=="WA"){
P++;F[L-1]++;
}
if(V[L-1]&&S=="AC"){
A++;V[L-1]=false;
}
}
for(int X=0;X<N;X++){
if(V[X])P-=F[X];
}
cout<<A<<" "<<P<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
char str[603][603]; int N , len[603][603][2];
int qry(int x1 , int y1 , int tp){
if(len[x1][y1][tp] != -1) return len[x1][y1][tp];
int &l = len[x1][y1][tp] = !tp;
int p = x1 , q = y1 , r = x1 - tp , s = y1 + tp;
while(str[p + l][q - l] && str[r - l][s + l] && str[p + l][q - l] == str[r - l][s + l])
++l;
return l;
}
int main(){
scanf("%d" , &N); memset(len , -1 , sizeof(len));
for(int i = 1 ; i <= N ; ++i) scanf("%s" , str[i] + 1);
for(int i = 1 ; i <= N ; ++i)
for(int j = 1 ; j <= N ; ++j)
str[i + N][j] = str[i][j + N] = str[i + N][j + N] = str[i][j];
int ans = 0;
for(int i = 1 ; i <= N ; ++i)
for(int j = 1 ; j <= N ; ++j){
bool flg = 1;
for(int k = 0 ; k < N ; ++k) flg &= qry(i + k , j + k , 0) >= min(k + 1 , N - k);
for(int k = 1 ; k < N ; ++k) flg &= qry(i + k , j + k - 1 , 1) >= min(k , N - k);
ans += flg;
}
cout << ans; return 0;
}
| 0
| 29,077,867
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<ll, ll>;
using iii = pair<ii, ll>;
#define vt vector
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define __lcm(a, b) a * b / __gcd(a, b)
const ll MOD = 1e9 + 7;
const ll INF = 2e9;
const ll N = 1e2 + 5;
ll n, m, temp, ans;
priority_queue<ll> pq;
void solve() {
cin >> n >> m;
for(ll i = 1, x; i <= n; i++) {
cin >> x;
pq.push(x);
}
while(m--) {
temp = pq.top(); pq.pop();
pq.push(temp / 2);
}
ans = 0;
while(pq.size()) {
ans += pq.top(); pq.pop();
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
solve();
}
|
#include"bits/stdc++.h"
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, n) FOR(i, 0, n)
#define RFOR(i, a, b) for (int i = b - 1; i >= a; i--)
#define RREP(i, n) RFOR(i, 0, n)
#define rep(i, a, b) for (auto i = a; i < b; i++)
#define rrep(i, a, b) for (auto i = a; i > b; i--)
#define range(i, a, b) (a <= i && i < b)
#define fi first
#define fs first
#define se second
#define sc second
using namespace std;
using vec = vector<int>;
using mat = vector<vec>;
typedef pair<int, int> P;
#define ll long long
void solve() {
int y, m, d;
cin >> y >> m >> d;
int base = 39*5*666 + 40*5*333+1;
int tmp = 0;
FOR(i, 1, y) {
if(i%3 == 0) tmp += 40 * 5;
else tmp += 39 * 5;
}
FOR(i, 1, m) {
if (i % 2 || y % 3 == 0) tmp += 20;
else tmp += 19;
}
tmp += d;
cout << base - tmp << endl;
}
int main() {
int n;
cin >> n;
REP(_, n) solve();
}
| 0
| 80,941,030
|
#include <bits/stdc++.h>
using namespace std;
long long int solve(vector<long long int> H, long long int K){
sort(H.begin(), H.end());
if(H.size()<=K) return 0;
long long int cost = 0;
for(long long int i=0; i<H.size()-K; ++i) cost += H[i];
return cost;
}
int main(){
long long int N, K; cin>>N>>K;
vector<long long int> H(N);
for(int i=0; i<N; ++i) cin>>H[i];
cout<<solve(H, K)<<endl;
}
|
#include<stdio.h>
#include<string.h>
int main(){
char s1[101],s2[101];
int n,i,taro=0,hana=0;
scanf("%d",&n);
for(i=0;i<n;i++){
scanf("%s %s",s1,s2);
if(strcmp(s1,s2)==0){
taro++;
hana++;
}
if(strcmp(s1,s2)>0){
taro=taro+3;
}
if(strcmp(s1,s2)<0){
hana=hana+3;
}
}
printf("%d %d\n",taro,hana);
return(0);
}
| 0
| 820,975
|
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
int main()
{
string s;
cin >> s;
if (s == "SSS")
cout << "0" << endl;
if (s == "SSR")
cout << "1" << endl;
if (s == "SRS")
cout << "1" << endl;
if (s == "SRR")
cout << "2" << endl;
if (s == "RSS")
cout << "1" << endl;
if (s == "RSR")
cout << "1" << endl;
if (s == "RRS")
cout << "2" << endl;
if (s == "RRR")
cout << "3" << endl;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define int long long
#define pb push_back
#define fi first
#define se second
#define fr(i, a, b) for(int i = a; i <= b; i++)
#define all(x) x.begin(), x.end()
#define IO ios :: sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define pii pair<int,int>
#define sz(x) (int)x.size()
const int mod = 1e9 + 7;
typedef long double f80;
#ifndef LOCAL
#pragma GCC optimize ("O2")
#define endl '\n'
#endif
ll pwr(ll a,ll b, ll mod){
a %= mod;
ll ans = 1;
while(b){
if(b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
string to_string(string s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
const int N = 1e5 + 5;
int x[N];
const int LOGN = 18;
int dp[LOGN][N];
void solve(){
int n, l, q;
cin >> n;
fr(i, 1, n) {
cin >> x[i];
}
cin >> l >> q;
int pt = 1;
fr(i, 1, n) {
while(pt + 1 <= n && x[pt + 1] - x[i] <= l) {
pt++;
}
dp[0][i] = pt;
}
for(int i = 1; i < LOGN; i++) {
fr(j, 1, n) {
dp[i][j] = dp[i - 1][dp[i - 1][j]];
}
}
fr(i, 1, q) {
int l, r;
cin >> l >> r;
if(l > r) swap(l, r);
int ans = 0;
for(int i = LOGN - 1; i >= 0; i--) {
if(dp[i][l] < r) {
ans += (1 << i);
l = dp[i][l];
}
}
ans++;
cout << ans << endl;
}
}
signed main(){
IO;
#ifdef LOCAL
freopen("inp.txt","r", stdin);
#endif
cout << setprecision(3) << fixed;
int t = 1;
fr(tt, 1, t){
solve();
}
return 0;
}
| 0
| 49,499,448
|
#include <iostream>
using namespace std;
int main()
{
int i=0,j, k, l, h[100], w[100];
cin >> h[0] >> w[0];
while ((h[i] != 0) && (w[i] != 0)) {
i++;
cin >> h[i] >> w[i];
}
for (j=0; j < i; j++) {
for (k=0; k < w[j]; k++)
cout << '#';
cout << endl;
for (k=0; k < (h[j]-2); k++) {
cout << '#';
for (l=0; l < (w[j]-2); l++)
cout << '.';
cout << '#' << endl;
}
for (k=0; k < w[j]; k++)
cout << '#';
cout << endl;
cout << endl;
}
return 0;
}
|
#define loop(i, s, e) for(ll i = s;i < e;i++)
#include <iostream>
#include <set>
#include <vector>
#include <queue>
#include <stack>
#include <utility>
#include <algorithm>
using namespace std;
typedef long long signed ll;
ll v, e, s, t;
vector<pair<ll, ll>> w;
bool color[10000];
ll indeg[10000];
queue<ll> q;
vector<ll> out;
void bfs(ll ss){
q.push(ss);
color[ss] = true;
while(!q.empty()){
int u = q.front();q.pop();
out.push_back(u);
auto l = lower_bound(w.begin(),w.end(),make_pair((ll)u,(ll)0));
auto r = lower_bound(w.begin(),w.end(),make_pair((ll)u+1,(ll)0));
for(auto itr = l;itr != r;itr++){
indeg[itr->second]--;
if(!indeg[itr->second] && !color[itr->second]){
color[itr->second] = true;
q.push(itr->second);
}
}
}
}
int main() {
cin >> v >> e;
loop(i, 0, e) {
cin >> s >> t;
indeg[t]++;
w.push_back(make_pair(s, t));
}
sort(w.begin(), w.end());
loop(u,0,v) if(!indeg[u] && !color[u]) bfs(u);
for(auto x:out) cout << x << endl;
}
| 0
| 73,128,277
|
#pragma region
#define _USE_MATH_DEFINES
#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <map>
#include <queue>
#include <stack>
#include <set>
#include <list>
#include <iomanip>
#include <cstdint>
#include <cstdlib>
using namespace std;
typedef long long ll;
#define rep(i, e) for (int(i) = 0; (i) < (e); ++(i))
#define rrep(i, s) for (int(i) = (s) - 1; (i) >= 0; --(i))
#define all(x) x.begin(),x.end()
#pragma endregion
int main()
{
int n; cin >> n;
ll x; cin >> x;
vector<ll> p(52), l(52);
p[0] = l[0] = 1;
rep(i, 51)
{
p[i + 1] = 2 * p[i] + 1;
l[i + 1] = 2 * l[i] + 3;
}
int now = n - 1;
ll res = 0;
while (now >= 0)
{
if (l[now] + 2 <= x)
{
res += p[now] + 1;
x -= l[now] + 2;
}
else if (x > 0)--x;
--now;
}
if (x)++res;
cout << res << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define reps(i,n) for(int i = 1; i <= (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define SZ(x) ((int)(x).size())
using namespace std;
using ll = long long;
ll M = 1000000000 + 7;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a = b; return 1; } return 0; }
ll qp(int a, ll b) { int ans = 1; do { if (b & 1)ans = 1ll * ans*a; a = 1ll * a*a; } while (b >>= 1); return ans; }
ll qp(int a, ll b, ll Mod = M) { int ans = 1; do { if (b & 1)ans = 1ll * ans*a%Mod; a = 1ll * a*a%Mod; } while (b >>= 1); return ans; }
int gcd(int a, int b) { return b ? gcd(b, a%b) : a; }
int dx[4] = { 1,0,-1,0 };
int dy[4] = { 0,1,0,-1 };
ll RS(ll N, ll P, ll Mod = M) { if (P == 0)return 1; else if (P % 2 == 0) { ll sq = RS(N, P / 2, Mod); return sq*sq%Mod; } else { return N*RS(N, P - 1, Mod) % Mod; } }
ll nPr(ll n, ll r, ll Mod = M) { ll ans = 1; rep(i, r) { ans = ans * (n - i) % Mod; } return ans; }
ll nCr(ll n, ll r, ll Mod = M) { ll bunbo = 1; ll bunshi = 1; rep(i, r) { bunbo = bunbo * (i + 1) % Mod; bunshi = bunshi * (n - i) % Mod; } return bunshi * RS(bunbo, Mod - 2, Mod) % Mod; }
struct UnionFind {
vector<int> par;
vector<int> par_num;
UnionFind(int N) : par(N) {
for(int i = 0; i < N; i++) par[i] = i;
par_num.assign(N,1);
}
int root(int x) {
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry) return;
par[rx] = ry;
par_num[root(rx)]++;
}
bool same(int x, int y) {
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
int main(void) {
int N,M; cin >> N >> M;
vector<int> nums(N);
rep(i,N){
cin >> nums[i];
nums[i]--;
}
UnionFind tree(N);
rep(i,M){
int x,y; cin >> x >> y;
tree.unite(x-1,y-1);
}
int ans = 0;
rep(i,N){
if (nums[i]==i) ans++;
else if (nums[i]!=i && tree.same(nums[i],i)) ans++;
}
cout << ans << endl;
return 0;
}
| 0
| 55,557,893
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n)for(int i=0;i<(n);i++)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define pb push_back
using ll = long long;
using P = pair<int, int>;
int main(){
int n; cin >> n;
for(int i = n; i <= 999; ++i){
int t = i;
int a = t % 10;
t /= 10;
int b = t % 10;
t /= 10;
int c = t;
if(a == b && b == c) {
cout << i << endl;
return 0;
}
}
}
|
#include <iostream>
#include <complex>
using namespace std;
typedef complex<double> P;
#define EPS (1e-10)
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) ((EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))
double cross(P a, P b)
{
return (a.real() * b.imag() - a.imag() * b.real());
}
bool is_parallel(P a1, P a2, P b1, P b2)
{
return EQ(cross(a1 - a2, b1 - b2), 0.0);
}
int main()
{
int num;
double x1, y1, x2, y2, x3, y3, x4, y4;
cin >> num;
for (int i = 0; i < num; i++) {
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> x4 >> y4;
if (is_parallel(P(x1, y1), P(x2, y2), P(x3, y3), P(x4, y4)))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 0
| 10,680,263
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for (int i = 1; i < (int)(n); i++)
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define debug(var) do{cout << #var << " : "; view(var);}while(0)
template<class T> bool chmin(T &a, T b) {if(a>b) {a=b;return 1;}return 0;}
template<class T> bool chmax(T &a, T b) {if(a<b) {a=b;return 1;}return 0;}
using namespace std;
template<class T> void view(T e) {cout << e << endl;}
template<class T> void view(const vector<T> &v) {for(const auto &e : v){cout << e << " ";} cout << endl;}
template<class T> void view(const vector<vector<T>> &vv) {for(const auto &v : vv){view(v);}}
using vint = vector<int>;
using vvint = vector<vector<int>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<int,int>;
const int inf = 1e9;
const ll inf_l = 1e18;
const int MAX = 1e5;
ll gcd(ll a, ll b) {return(b?gcd(b,a%b):a);}
ll lcm(ll a, ll b) {return(a/gcd(a,b)*b);}
int main() {
int x; cin >> x;
ll lm = lcm(x,360);
int ans = lm / x;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
const int INF=1e9,MOD=1e9+7,ohara=1e6;
const ll LINF=1e18;
using namespace std;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
#define rrep(i,a,b) for(int i=(a);i<(b);i++)
#define rrrep(i,a,b) for(int i=(a);i>=(b);i--)
#define all(v) (v).begin(), (v).end()
#define Size(n) (n).size()
#define Cout(x) cout<<(x)<<endl
ll n,cnt,ans,a[ohara],b[ohara],c,d,tmp,tmpp,m,h,w,x,y,sum,pos,k;
ld doua;
int dy[]={1,0,-1,0};
int dx[]={0,1,0,-1};
string alph("abcdefghijklmnopqrstuvwxyz"),s;
bool fl;
struct edge{int to,cost;};
int main(void){
cin.tie(0);
ios::sync_with_stdio(false);
cin>>n>>k;
rep(i,n)cin>>a[i]>>b[i];
c=k;
while(1){
c/=2;
d++;
if(c==0)break;
}
tmp=0;
rrrep(i,d,0){
if((k&(1LL<<i))!=0){
tmpp=0;
if(tmp<k){
rrep(j,0,i){
tmpp=(tmpp|(1LL<<j));
}
}
if((tmp|tmpp)<=k){
pos=(tmp|tmpp);
}
else{
pos=tmp;
}
if(i==0)pos=k;
rep(j,n){
if((pos|a[j])==pos)cnt+=b[j];
}
ans=max(ans,cnt);
tmp=(tmp|(k&(1LL<<i)));
cnt=0;
}
}
rep(i,n){
if((k|a[i])==k)cnt+=b[i];
}
Cout(max(ans,cnt));
return 0;
}
| 0
| 58,100,196
|
#include <bits/stdc++.h>
using namespace std;
int main(){
long long n;
long long flag=0;
cin >> n;
vector<string> a(n);
set<string> b;
for(int i=0; i<n;i++){
cin >> a[i];
b.insert(a[i]);
}
if(b.size()!=n) flag=1;
for(int i=0; i<n-1; i++){
if(a[i+1][0]!=a[i][a[i].size()-1]){
flag=1;
break;
}
}
if(flag==1) cout << "No" << endl;
else cout << "Yes" << endl;
}
|
#include<iostream>
#include<vector>
int main(void){
int n;
std::cin >> n;
std::vector<int> a(n+1), b(n);
for(int i = 0; i < n+1; i++){
std::cin >> a[i];
}
for(int i = 0; i < n; i++){
std::cin >> b[i];
}
long long ans = 0;
for(int i = 0; i < n; i++){
if(a[i] >= b[i]){
ans += b[i];
}else{
if(b[i] - a[i] >= a[i+1]){
ans += a[i] + a[i+1];
a[i+1] = 0;
}else{
ans += b[i];
a[i+1] -= b[i] - a[i];
}
}
}
std::cout << ans << std::endl;
return 0;
}
| 0
| 99,497,689
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
using namespace std;
signed main() {
int n;
string s;
cin >> n >> s;
if(s.substr(0, n/2) == s.substr(n/2, n/2) && n % 2 == 0) {
cout << "Yes" << '\n';
} else {
cout << "No" << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (long long i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
const ll MOD = 1000000007;
#define all(v) v.begin(), v.end()
int main(){
ll N,P,a=0,b=0,ans=1;
cin >> N >> P;
vector<ll> A(N);
rep(i,N){
cin >> A.at(i);
A.at(i)%=2;
if(A.at(i)==0){
a++;
}else{
b++;
}
}
ans*=(ll)pow(2,a);
if(P==0){
ll t=0,x=0;
while(t<=b){
ll y=1;
rep(i,t){
y*=b-i;
y/=i+1;
}
x+=y;
t+=2;
}
ans*=x;
cout << ans << endl;
}else{
if(b==0){
cout << 0 << endl;
return 0;
}
ll t=1,x=0;
while(t<=b){
ll y=1;
rep(i,t){
y*=b-i;
y/=i+1;
}
x+=y;
t+=2;
}
ans*=x;
cout << ans << endl;
}
}
| 0
| 38,598,505
|
#include <bits/stdc++.h>
using namespace std;
int main(){
signed long long int K,A,B;
cin>>K>>A>>B;
unsigned long long int bisket=1;
for(int i=1;i<=K;i++){
if(i>=A&&B-A>=2&&i!=K){
i++;
bisket+=B-A;
}
else bisket++;
}
cout<<bisket<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll> P;
ll N;
ll solve(vector<ll> A, vector<bool> B) {
ll ans = 0;
for (int i = 0; i < N; i++) {
if (i > 0) {
if (A.at(i-1) == A.at(i)) {
B.at(A.at(i)) = false;
continue;
}
}
for (ll j=2; A.at(i)*j <= A.at(N-1); j++) B.at(A.at(i)*j) = false;
}
for (int i = 0; i < N; i++) {
if (B.at(A.at(i))) ans++;
}
return ans;
}
int main(){
cin >> N;
vector<ll> A(N);
for (int i = 0; i < N; i++) cin >> A.at(i);
sort(A.begin(), A.end());
vector<bool> B(A.at(N-1)+1, true);
cout << solve(A,B) << endl;
return 0;
}
| 0
| 92,952,299
|
#include <iostream>
#include <iomanip>
#include <string>
#include <algorithm>
#include <functional>
#include <set>
#include <map>
#include <unordered_map>
#include <queue>
#include <deque>
#include <cmath>
#include <cstdio>
using namespace std;
typedef long long ll;
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) for (int i = 0; i < (n); ++i)
int main(int argc, char **argv)
{
string S;
cin >> S;
S.replace(4, 1, "");
S.replace(6, 1, "");
int n = stoi(S);
if (n <= 20190430) cout << "Heisei" << endl;
else cout << "TBD" << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
int n;
int cnt[86401];
int toSec(string s) {
int h = (s[0] - '0') * 10 + (s[1] - '0');
int m = (s[3] - '0') * 10 + (s[4] - '0');
int sec = (s[6] - '0') * 10 + (s[7] - '0');
return h * 3600 + m * 60 + sec;
}
int main() {
while (cin >> n) {
if (!n) return 0;
int i;
for (i = 0; i < 86400; i++) cnt[i] = 0;
for (i = 0; i < n; i++) {
string s, t;
cin >> s >> t;
cnt[toSec(s)]++;
cnt[toSec(t)]--;
}
for (i = 1; i < 86400; i++) cnt[i] += cnt[i - 1];
int ans = 0;
for (i = 0; i < 86400; i++) ans = max(ans, cnt[i]);
cout << ans << endl;
}
return 0;
}
| 0
| 31,860,487
|
#include<bits/stdc++.h>
using namespace std;
#define ft ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define ll long long
#define pi pair<int,int>
#define pb push_back
#define F first
#define S second
#define B begin()
#define E end()
const int N=2e5+3;
int main()
{
ft
int t,i,j,n,m=INT_MAX,l=0,r=0,a[105];
cin>>n;
for(i=0;i<n;i++)
{
cin>>a[i];
l+=a[i];
}
for(i=0;i<n-1;i++)
{
r+=a[i];
l-=a[i];
m=min(m,abs(l-r));
}
cout<<m<<"\n";
return 0;
}
|
#include <bits/stdc++.h>
#define db1(x) cout<<#x<<"="<<x<<'\n'
#define db2(x,y) cout<<#x<<"="<<x<<","<<#y<<"="<<y<<'\n'
#define db3(x,y,z) cout<<#x<<"="<<x<<","<<#y<<"="<<y<<","<<#z<<"="<<z<<'\n'
#define rep(i,n) for(int i=0;i<(n);++i)
#define repA(i,a,n) for(int i=a;i<=(n);++i)
#define repD(i,a,n) for(int i=a;i>=(n);--i)
using namespace std;
using ll = long long;
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string t;
long long sum=0;
cin>>t;
for (int i = 0; i <t.length(); ++i)
{
sum+=(t[i]-'0');
}
if (sum%3==0)
{
puts("Yes");
}
else
puts("No");
return 0;
}
| 0
| 80,996,474
|
#include<iostream>
using namespace std;
int main(){
int i,j;
for(i = 1;i <= 9;i++){
for(j = 1;j <= 9;j++){
cout << i << "x" << j << "="<<i*j<<"\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef pair<ll,ll> llP;
ll mod(ll a, ll b){
ll ret=a%b;
if(ret<0) ret+=b;
return ret;
}
ll modpow(ll a,ll b,ll c){
ll res=1;
while(b>0){
if(b&1) res=mod(res*a,c);
a=mod(a*a,c);
b>>=1;
}
return res;
}
vector<int> p;
vector<vector<int>> memo;
bool cur[10];
int ans,n,m;
void dfs(int a){
if(a==n){
bool temp=true;
for(int i=0;i<m;i++){
int sum=0;
for(int j=0;j<(int)memo[i].size();j++){
if(cur[memo[i][j]]) sum++;
}
if(sum%2!=p[i]) temp=false;
}
if(temp) ans++;
}
else{
for(int i=0;i<2;i++){
cur[a]=i;
dfs(a+1);
}
}
}
int main() {
cin>>n>>m;
memo.resize(m);
for(int i=0;i<m;i++){
int k;
cin>>k;
for(int j=0;j<k;j++){
int s;
cin>>s;
s--;
memo[i].push_back(s);
}
}
p.resize(m);
for(int i=0;i<m;i++){
int a;
cin>>a;
p[i]=a;
}
ans=0;
dfs(0);
cout<<ans<<endl;
return 0;
}
| 0
| 44,389,510
|
#include<bits/stdc++.h>
typedef long long int ll;
#define ull unsigned long long int
#define lld long double
#define endl "\n"
#define fi first
#define sec second
#define sp setprecision
#define lb lower_bound
#define ub upper_bound
#define For(i, a, b) for(long long int i = (a); i <= (b); i++)
#define Forr(i, a, b) for(long long int i = (a); i >= (b); i--)
#define pb(a) push_back(a)
#define mp(a,b) make_pair(a,b)
#define vll vector<ll>
#define vlld vector<lld>
#define vi vector<int>
#define vch vector<char>
#define sll set<ll>
#define sch set<ch>
#define vpll vector< pair<ll,ll> >
#define vpii vector< pair<int,int> >
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define mll map<ll, ll>
#define mcll map<char,ll>
#define sz(container) ll((container).size())
#define fill(a,b) memset(a, b, sizeof(a))
#define fast_io ios_base::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL)
using namespace std;
lld pi=3.1415926535897932;
const ll MOD=1e9+7;
const ll dx[4]={-1, 0, 1, 0} , dy[4]={0, 1, 0, -1};
const ll dxx[8]={-1, -1, 0, 1, 1, 1, 0, -1} , dyy[8]={0, 1, 1, 1, 0, -1, -1, -1};
ll lcm(ll a, ll b)
{
ll g=__gcd(a, b);
return a/g*b;
}
ll binpow(ll a, ll b,ll m)
{
a %= m;
ll res = 1;
while (b > 0)
{
if (b & 1)
res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
ll fact[20];
void solve()
{
fact[0]=1;
For(j,1,19) fact[j]=j*fact[j-1];
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
fast_io;
ll T=1;
For(i,1,T)
{
solve();
ll n;cin>>n;
vll p(n),q(n);
For(j,0,n-1) cin>>p[j];
For(j,0,n-1) cin>>q[j];
ll ans1=0,ans2=0;ll ch=0;
For(j,0,n-1)
{
ch=0;
For(k,0,j-1)
{
if(p[k]<p[j]) ch++;
}
ans1+=(p[j]-1-ch)*fact[n-(j+1)];
}
ch=0;
For(j,0,n-1)
{
ch=0;
For(k,0,j-1)
{
if(q[k]<q[j]) ch++;
}
ans2+=(q[j]-1-ch)*fact[n-(j+1)];
}
cout<<abs(ans1-ans2);
}
}
|
#include <iostream>
int main(int argc, char **argv){
int a = 0;
int b = 0;
int c = 0;
int n = 0;
std::cin >> a >> b >> c;
for(int i = a; i <= b; i++){
if(c % i == 0){n++;}
}
std::cout << n << std::endl;
return 0;
}
| 0
| 76,810,747
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define vi vector<int>
#define vl vector<ll>
#define pii pair<int,int>
#define pll pair<ll,ll>
#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 FORR(i,a,b) for(ll (i)=(b)-1;(i)>=(a);(i)--)
#define DEBUG(x) cout << #x << ": " << x << endl
#define CHMAX(a,b) a=max((a),(b))
#define CHMIN(a,b) a=min((a),(b))
int main() {
ll k;
cin >> k;
vector<bool> visited(k,false);
auto c = [](pll a,pll b){return a.first>b.first;};
priority_queue<pll,vector<pll>,decltype(c)> cost(c);
cost.push(make_pair(1ll,1ll));
ll ans;
while(!cost.empty()){
pll nx = cost.top();
cost.pop();
if(nx.second==0){
ans = nx.first;
break;
}
if(visited[nx.second]) continue;
else visited[nx.second] = true;
if(!visited[(nx.second * 10ll)%k]) cost.push(make_pair(nx.first, (nx.second * 10ll)%k));
if(!visited[(nx.second + 1ll)%k]) cost.push(make_pair(nx.first+1, (nx.second + 1ll)%k));
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <math.h>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <iomanip>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vb = vector<bool>;
using vll = vector<long long>;
using pii = pair<int, int>;
using psi = pair<string, int>;
int main() {
string S;
cin >> S;
int ans = 0, N = S.size();
for (int i = 1; i < N; i++) {
if (S[i] != S[i - 1]) {
ans++;
}
}
cout << ans << endl;
}
| 0
| 13,297,215
|
#include <stdio.h>
#include <vector>
using namespace std;
struct Node{
Node(){
parent = -1;
depth = num_of_children = 0;
}
int parent;
int depth;
vector<int> children;
int num_of_children;
};
void calcDepth(Node nodes[],int root_id){
for(int i = 0;i < nodes[root_id].num_of_children;i++){
nodes[nodes[root_id].children[i]].depth = nodes[root_id].depth+1;
calcDepth(nodes,nodes[root_id].children[i]);
}
}
int main(){
int n,id,k,child_id,root_id;
scanf("%d",&n);
Node nodes[n];
for(int i = 0; i < n; i++){
scanf("%d %d",&id,&k);
for(int j = 0; j < k; j++){
scanf("%d",&child_id);
nodes[id].children.push_back(child_id);
nodes[id].num_of_children++;
nodes[child_id].parent = id;
}
}
for(root_id = 0; root_id < n; root_id++){
if(nodes[root_id].parent == -1) break;
}
calcDepth(nodes,root_id);
for(int i = 0; i < n; i++){
if(nodes[i].parent == -1){
printf("node %d: parent = -1, depth = 0, root, ",i);
}else if(nodes[i].num_of_children == 0){
printf("node %d: parent = %d, depth = %d, leaf, ",i,nodes[i].parent,nodes[i].depth);
}else{
printf("node %d: parent = %d, depth = %d, internal node, ",i,nodes[i].parent,nodes[i].depth);
}
printf("[");
for(int j = 0; j < nodes[i].num_of_children-1; j++){
printf("%d, ",nodes[i].children[j]);
}
if(nodes[i].num_of_children > 0){
printf("%d",nodes[i].children[nodes[i].num_of_children-1]);
}
printf("]\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin>>n;
int k=1,x=0,count=0;
for(int i=0;i<n;i++){
cin>>x;
if(x==k){
k++;
}
}
if(k==1) cout <<-1 << endl;
else cout<<n-k+1<<endl;
return 0;
}
| 0
| 76,169,542
|
#include <bits/stdc++.h>
using namespace std;
long long dp[310][610];
int main() {
int n, k; cin >> n >> k;
vector<long long> h(n+1, 0);
for (int i = 0; i <= n+1; i++) {
for (int j = 0; j <= 2*n; j++) dp[i][j] = 1e16;
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) cin >> h[i+1];
for (int i = 0; i <= n; i++) {
for (int z = 0; z <= n; z++) {
for (int j = i+1; j <= n; j++) {
dp[j][z+1] = min(dp[j][z+1], dp[i][z] + max(0LL, h[j]-h[i]));
}
dp[n+1][z] = min(dp[n+1][z], dp[i][z]);
}
}
long long ans = 1e18;
for (int i = 0; i <= k; i++) ans = min(ans, dp[n+1][n-i]);
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <numeric>
#include <cmath>
#include <limits>
#include <stdio.h>
#include <iomanip>
#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>
using namespace std;
using ll = long long;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
ll Max(ll(a), ll(b), ll(c)) {
return max(max(a, b), c);
}
ll Min(ll(a), ll(b), ll(c)) {
return min(min(a, b), c);
}
int main() {
ll n;
cin >> n;
string an = "";
vector<string> S(n);
rep(i, n) {
cin >> S.at(i);
}
rep(j, 26) {
char k = 'a' + j;
ll M = 99;
rep(i, n) {
ll co = 0;
rep(h, S.at(i).size()) {
if (S.at(i).at(h) == k) {
co++;
}
}
M = min(M, co);
}
rep(i, M) {
an += k;
}
}
cout << an << endl;
}
| 0
| 1,243,983
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define all(v) (v).begin(), (v).end()
#define rep(i,n) for(ll i=0;i<n;i++)
#define reps(i,n) for(ll i=0;i<=n;i++)
ll MOD = 1000000007;
const long long L_INF = 1LL << 60;
const int INF = 2147483647;
const double PI = acos(-1);
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int main(){
ios_base::sync_with_stdio(false);
ll k;
string s;
cin >> k >> s;
if(s.size()<=k){
cout << s << endl;
}else{
cout << s.substr(0,k)+"..." << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, j) for (int i = 0; i < j; i++)
#define all(obj) (obj).begin(), (obj).end()
#define rall(obj) (obj).rbegin(), (obj).rend()
typedef long long int ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<pii> vpii;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
ll w, h;
cin>>w>>h;
vpii p(w + h);
rep(i, w) {
cin >> p[i].first;
}
rep(i, h){
cin>>p[i + w].first;
p[i + w].second = 1;
}
sort(all(p));
ll ans = 0;
h++; w++;
rep(i, p.size()) {
if (p[i].second == 1) {
ans += w * p[i].first;
h--;
} else {
ans += h * p[i].first;
w--;
}
}
cout << ans << endl;
return 0;
}
| 0
| 13,979,695
|
#include<iostream>
#include<queue>
using namespace std;
int main(){
int x,y,a,b,c;
cin>>x>>y>>a>>b>>c;
priority_queue<long long> rap,gap,tap;
for(int i=0;i<a;++i){
long long r;
cin>>r;
rap.push(r);
}
for(int i=0;i<b;++i){
long long g;
cin>>g;
gap.push(g);
}
for(int i=0;i<c;++i){
long long t;
cin>>t;
tap.push(t);
}
for(int i=0;i<x;++i){
tap.push(rap.top());
rap.pop();
}
for(int i=0;i<y;++i){
tap.push(gap.top());
gap.pop();
}
long long res=0;
for(int i=0;i<x+y;++i){
res+=tap.top();
tap.pop();
}
cout<<res<<endl;
}
|
#include<stdio.h>
int main(void){
int i,n,k,sum,max;
int N[150000];
while(0==0){
scanf("%d %d",&n,&k);
sum=0;
if(n==0 && k==0) break;
for(i=0;i<n;i++)
scanf("%d",&N[i]);
for(i=0;i<k;i++)
sum+=N[i];
max=sum;
for(i=k;i<n;i++){
sum+=N[i];
sum-=N[i-k];
if(sum>max)max=sum;
}
printf("%d\n",max);
}
return 0;
}
| 0
| 12,506,089
|
#include <bits/stdc++.h>
using namespace std;
#define loop(i, n) for(int i = 0;i < int(n);i++)
#define rloop(i, n) for(int i = int(n);i >= 0;i--)
#define range(i, a, b) for(int i = int(a);i <= int(b);i++)
#define SZ(c) int(c.size())
#define ALL(c) c.begin(), c.end()
#define RALL(c) c.rbegin(), c.rend()
#define PI acos(-1)
#define pb push_back
#define mp make_pair
#define fr first
#define sc second
#define sfi1(v) scanf("%d",&v)
#define sfi2(v1, v2) scanf("%d %d",&v1,&v2)
#define sfi3(v1, v2, v3) scanf("%d %d %d",&v1,&v2,&v3)
#define sfll1(v) scanf("%I64d",&v);
#define sfll2(v1, v2) scanf("%I64d %I64d",&v1,&v2)
#define sfll3(v1, v2, v3) scanf("%I64d %I64d %I64d",&v1,&v2,&v3)
#define endl '\n'
typedef vector<int> vi;
typedef vector<pair<int, int> > vii;
typedef long long ll;
typedef pair<int, int> pii;
const int MX = 1e9 + 5;
const int N = 18;
const int SZ = (1 << 18) + 5;
int dp[N + 2][SZ][2];
int arr[SZ];
int n;
int solve(int idx, int msk, int have) {
if (idx == -1) {
if (have == 1)return arr[msk];
return -MX;
}
int &ret = dp[idx][msk][have];
if (~ret)return ret;
if ((msk >> idx) & 1) {
if (have == 1) {
ret = max(solve(idx - 1, msk - (1 << idx), have), solve(idx - 1, msk, have));
} else {
ret = solve(idx - 1, msk, have);
ret = max(ret, solve(idx - 1, msk - (1 << idx), have));
ret = max(ret, solve(idx - 1, msk - (1 << idx), 1) + solve(idx - 1, msk, 1));
}
} else {
ret = solve(idx - 1, msk, have);
}
return ret;
}
int main() {
#ifndef ONLINE_JUDGE
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
loop(i, (1 << n)) {
cin >> arr[i];
}
int mx = 0;
memset(dp, -1, sizeof dp);
range(i, 1, (1 << n) - 1) {
mx = max(mx, solve(n - 1, i, 2));
cout << mx << endl;
}
return 0;
}
|
#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 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(n) begin(n), end(n)
using ll = long long;
using namespace std;
int fc(vector<int> &v,int k, int lc, int rc){
if(k < lc + rc) return -1e9;
int n = v.size();
vector<bool> chk(n, false);
vector<int> now;
rep(i, lc){
now.push_back(v.at(i));
k--;
chk.at(i) = true;
}
rep(i, rc){
if(chk.at(n-i-1) == false){
k--;
now.push_back(v.at(n-i-1));
}else break;
}
sort(now.begin(), now.end());
int ret = accumulate(now.begin(), now.end(), 0);
rep(i, k){
if(i >= now.size() || now.at(i) >= 0) break;
ret -= now.at(i);
}
return ret;
}
int main(){
int n, k;
cin >> n >> k;
vector<int> v(n);
rep(snip_i, n) cin >> v.at(snip_i);
int ans = -1e9-5;
rep(i, n+1){
rep(j, n+1){
ans = max(ans, fc(v, k, i, j));
}
}
cout << ans << endl;
return 0;
}
| 0
| 17,684,594
|
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<math.h>
using namespace std;
int main()
{
int n,k; cin>>n>>k;
int a[n];
for(int i=0;i<n;i++) a[i]=0;
while(k--)
{
int d; cin>>d;
for(int i=0;i<d;i++)
{
int x; cin>>x;
a[x-1]++;
}
}
int ans=0;
for(int i=0;i<n;i++) if(a[i]==0) ans++; cout<<ans;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const long long INF = 1LL<<60;
ll GCD(ll x,ll y){
if(y == 0) return x;
else return GCD(y,x%y);
}
ll LCM(ll a,ll b){
return a / GCD(a,b) * b;
}
const int MOD = 1000000007;
int main() {
string s; cin >> s;
ll cnt = 0,ans = 0;
for(int i = 0;i < s.length();i++){
if(s[i] == 'B'){
cnt++;
}else{
ans += cnt;
}
}
cout << ans;
}
| 0
| 80,042,656
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<VI> VVI;
typedef vector<VL> VVL;
typedef pair<int, int> P;
typedef pair<ll, ll> PL;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) for (int i = 0; i < (n); i++)
#define fst first
#define snd second
#define ALL(obj) (obj).begin(), (obj).end()
#define debug(x) cout << #x << ": " << x << endl
#define out(x) cout << x << endl
const int MOD = 1000000007;
const ll LINF = (ll)1e18 - 1;
const int INF = 1e9 - 1;
const double EPS = 0.000000001;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
signed main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
VL a(n), d(n);
ll sum = 0;
rep(i, n)
{
cin >> a[i];
sum += a[i];
}
ll de = (n * (n + 1) / 2);
ll k = sum / de;
rep(i, n - 1) d[i] = a[i + 1] - a[i] - k;
d[n - 1] = a[0] - a[n - 1] - k;
bool ans = true;
if (sum % de != 0)
{
ans = false;
}
rep(i, n)
{
if (d[i] < 0 && d[i] % n == 0)
{
k -= -d[i] / n;
}
else if (d[i] == 0)
{
continue;
}
else
{
ans = false;
}
}
puts(ans && (k == 0) ? "YES" : "NO");
return 0;
}
|
#include<bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (int)n; i++)
#define repa(i, s, n) for(int i = s; i < (int)n; i++)
using namespace std;
using ll = long long;
typedef vector<int> vi;
int main(){
int n, a, b;
cin >> n >> a >> b;
int ans = 0;
rep(i, n){
int tmp = i+1;
int sum = 0;
while(tmp > 0){
sum += tmp % 10;
tmp /= 10;
}
if(sum >= a && sum <= b) ans += i + 1;
}
cout << ans << endl;
return 0;
}
| 0
| 79,476,899
|
#include <bits/stdc++.h>
using namespace std;
#define INF (1LL << 31 - 1)
#define MOD int(1e9+7)
#define repi(i,j,n) for(int i = (j); i < (n); ++i)
#define rep(i,n) repi(i,0,n)
#define fi first
#define se second
#define all(v) (v).begin(), (v).end()
inline void init() {
cin.tie(0);
ios::sync_with_stdio(false);
}
using ll = long long;
ll n;
int main() {
init();
cin >> n;
ll sum = 0, p;
for (int i = 1; sum < n; ++i) {
p = i;
sum += i;
}
int k = sum - n;
if (sum == n) {
for (int i = 1; i <= p; ++i) {
cout << i << endl;
}
}
else {
for (int i = 1; i <= p; ++i) {
if (i != k) cout << i << endl;
}
}
return 0;
}
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
int main()
{
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
int count = 0;
for (int i = c; i < d; i++)
{
for (int j = a; j < b; j++)
{
if(i == j) count++;
}
}
printf("%d\n", count);
return 0;
}
| 0
| 49,953,900
|
#include <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <math.h>
#include <cmath>
#include <limits.h>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <functional>
#include <stdio.h>
using namespace std;
long long MOD = 1000000007;
int main() {
char C[1000][1000];
char color[2][2] = { {'R', 'Y'}, {'G', 'B'} };
int H,W,D;
cin >> H >> W >> D;
for ( int i = 0; i < H+W; i++ ) {
for ( int j = 0; j < H+W; j++ ) {
C[i][j] = color[ (i/D)%2 ][ (j/D)%2 ];
}
}
for ( int i = 0; i < H; i++ ) {
for ( int j = 0; j < W; j++ ) {
cout << C[i+j][i-j+W];
}
cout << endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
#include <sstream>
#include <iterator>
#include <utility>
#include <unordered_map>
using namespace std;
vector<string> splitString(const string& str, const string& separator = " ") {
vector<string> ret;
std::size_t bp, ep;
bp = ep = 0;
while((ep = str.find_first_of(separator, bp)) != string::npos){
if(bp != ep){
ret.push_back(string(str.begin() + bp, str.begin() + ep));
}
bp = ep + 1;
}
if(bp <= str.size() - 1){
ret.push_back(string(str.begin() + bp, str.end()));
}
return ret;
}
class ConversionTable {
public:
ConversionTable(const std::vector<std::string>& data_set) {
for(auto ite = std::begin(data_set); ite != std::end(data_set); ++ite) {
auto data = splitString(*ite);
table[data[0][0]] = data[1][0];
}
}
char convertData(char data) {
return (table.find(data) != std::end(table) ? table[data] : data);
}
private:
std::unordered_map<char, char> table;
};
template <class T>
T convertStringToNumber(const string& str) {
stringstream ss;
T ret;
ss << str;
ss >> ret;
return ret;
}
vector<vector<string>> inputData() {
vector<vector<string>> data_set;
string buffer;
while(true){
getline(cin, buffer);
int n = convertStringToNumber<int>(buffer);
if(!n)
break;
vector<string> temp;
for(int i = 0; i < n; ++i) {
getline(cin, buffer);
temp.push_back(buffer);
}
data_set.push_back(temp);
}
return data_set;
}
void one_process(const vector<string>& table, const vector<string>& data) {
ConversionTable ct(table);
for(auto ite = begin(data); ite != end(data); ++ite) {
cout << ct.convertData((*ite)[0]);
}
cout << endl;
}
void doAllProcess() {
auto data_set = inputData();
for(auto ite = begin(data_set); ite != end(data_set); ite+=2)
one_process(*ite, *(ite+1));
}
int main() {
doAllProcess();
return 0;
}
| 0
| 5,760,652
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define mod 1000000007
int solve(vector<int>& vec, int n, int k)
{
int dp[n + 2][k + 2];
for(int j = 0; j <= k; j++)dp[1][j] = (j > vec[1])?0:1;
for(int i = 2; i <= n ;i++){
for(int j = 0; j <= k; j++){
if(j == 0)dp[i][j] = dp[i-1][j];
else{
dp[i][j] = (mod+dp[i][j-1]+dp[i-1][j] - ((j-vec[i]-1 >= 0)?dp[i-1][j-vec[i]-1]:0))%mod;
}
}
}
return dp[n][k];
}
signed main()
{
int n, k;
cin >> n >> k;
vector<int> vec(n + 1);
for(int i = 1; i <= n; i++)cin >> vec[i];
cout << solve(vec, n, k);
}
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repo(i,n) for(int i = 1; i < (int)(n); i++)
#define pb push_back
#define mp make_pair
#define np next_permutation
#define lb lower_bound
#define ub upper_bound
#define fi first
#define se second
#define all(x) (x).begin(),(x).end()
#define mod 1000000007
#define pi acos(-1.0)
const ll INF = 1LL<<61;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
ll jou(ll N, ll P){if(P==0) return 1;
if(P%2==0){ll t = jou(N, P/2);return t*t % mod;
}return (N * jou(N, P-1)) % mod;}
int main() {
ll n,h;
cin >> n >> h;
vector<ll> p(n);
vector<ll> q(n);
rep(i,n){
cin>>p[i]>>q[i];
}
sort(all(p));
reverse(all(p));
sort(all(q));
reverse(all(q));
ll now=0;
ll nage=n;
rep(i,n){
if(p[0]>=q[i]) {
nage=i;
break;
}
now+=q[i];
if(now>=h){
cout << i+1 << endl;
return 0;
}
}
cout << nage+(h-now+p[0]-1)/p[0] << endl;
}
| 0
| 90,827,739
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
signed main(){
int n;
cin >> n;
vector<int> a(n), b(n), c(n);
vector<vector<int>> edge(n, vector<int>());
vector<vector<int>> weight(n, vector<int>());
for(int i=0; i<n-1; i++){
cin >> a[i] >> b[i] >> c[i];
a[i]--; b[i]--; c[i];
edge[a[i]].push_back(b[i]);
edge[b[i]].push_back(a[i]);
weight[a[i]].push_back(c[i]);
weight[b[i]].push_back(c[i]);
}
int q, k;
cin >> q >> k;
k--;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
pq.push(make_pair(0, k));
vector<int> dis(n, -1);
while(!pq.empty()){
int d = pq.top().first;
int p = pq.top().second;
pq.pop();
if(dis[p] != -1) continue;
dis[p] = d;
for(int i=0; i<edge[p].size(); i++){
int next = edge[p][i];
if(dis[next] == -1){
pq.push(make_pair(d + weight[p][i], next));
}
}
}
for(int i=0; i<q; i++){
int x, y;
cin >> x >> y;
x--; y--;
cout << dis[x] + dis[y] << endl;
}
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
int main() {
int n; cin >> n;
map<int, int> mp;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
}
sort(a.begin(), a.end());
if (a[a.size() - 1] != a[a.size() - 2]) {
puts("Impossible");
return 0;
}
else if ((a[a.size() - 1] & 1) && !(a[0] == a[1] && a[0] == a[a.size() - 1] / 2 + 1 && mp[a[0]] == 2)) {
puts("Impossible");
return 0;
}
else if (!(a[a.size() - 1] & 1) && !(a[0] == a[a.size() - 1] / 2 && mp[a[0]] == 1)) {
puts("Impossible");
return 0;
}
if (n & 1) {
for (int i = a[a.size() - 1] / 2 + 2; i < a[a.size() - 1]; i++) {
if (mp.find(i) == mp.end() || mp[i] < 2) {
puts("Impossible");
return 0;
}
}
}
else {
for (int i = a[a.size() - 1] / 2 + 1; i < a[a.size() - 1]; i++) {
if (mp.find(i) == mp.end() || mp[i] < 2) {
puts("Impossible");
return 0;
}
}
}
puts("Possible");
return 0;
}
| 0
| 18,902,407
|
#include <iostream>
#include <string.h>
#include <stdio.h>
#include <math.h>
#include <list>
#include <set>
#include <queue>
#include <iterator>
#include <bitset>
#include <bits/stdc++.h>
#include <vector>
#include <algorithm>
#define ll long long
#define _ ios_base::sync_with_stdio(0);cin.tie(0);
#define loop for(i=0;i<n;i++)
#define pb push_back
#define tc() int t;cin>>t;while(t--)
using namespace std;
ll i,j,temp;
int main()
{_
char name1[4];
char name2[4];
char name3[4],x;
int flag=0;
cin>>name1>>name2;
for(i=0,j=2;i<3;i++,j--){
if(name1[i]!=name2[j]){
flag = 0;
break;
}
else{
flag = 1;
}
}
if(flag){
cout<<"YES"<<endl;
}
else{
cout<<"NO"<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const ll N=1e5+5;
int main(){
ios_base:: sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
ll n;cin>>n;
ll a[n],sum=0;
for(ll i=0;i<n;i++)cin>>a[i],sum+=a[i];
ll tot = (n*(n+1))/2;
if(sum%tot)return cout<<"NO" , 0;
ll k = sum/tot;
for(ll i=0;i<n;i++){
ll diff = a[(i+1)%n] - a[i];
ll val = k - diff;
if(val>=0 && val%n==0)continue;
return cout<<"NO" , 0;
}
cout<<"YES";
}
| 0
| 92,577,472
|
#include <iostream>
#include <string>
int main()
{
std::string s;
std::cin >> s;
for (const char c : s)
{
if (c == ',')
{
std::cout << ' ';
}
else
{
std::cout << c;
}
}
std::cout << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define countof(array) (sizeof(array) / sizeof(array[0]))
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = (n)-1; i >= 0; --i)
#define rep2(i,n) for(int i = 1; i <= (n); ++i)
#define rrep2(i,n) for(int i = (n); i > 0; --i)
#define srep(i,s,n) for(int i = s; i < (n); ++i)
#define rsrep(i,s,n) for(int i = (n)-1; i >= s; --i)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define aall(a) (a), (a)+countof(a)
#define raall(a) (a), (a)+countof(a), greater<>()
#define show(x) cout<<#x<<" = "<<(x)<<endl;
#define vfind(v, a) find(all(v), a) != v.end()
#define yn(f) { if (f) puts("YES"); else puts("NO"); }
#define yns(f) { if (f) puts("Yes"); else puts("No"); }
#define show_ary(...) { cout<<#__VA_ARGS__<<" = "; for (const auto& x : (__VA_ARGS__)) { cout<<x<<" "; } cout<<endl; }
#define show_pair(...) cout<<#__VA_ARGS__<<" = "<<endl; for (const auto& x : (__VA_ARGS__)) { cout<<" "<<x.fi<<" : "<<x.se<<endl; }
#define out_ary(...) { int n = (__VA_ARGS__).size(); rep(i, n) printf("%d%s", (__VA_ARGS__)[i], i != n-1 ? " " : "\n"); }
#define argmax(v) distance((v).begin(), max_element(all(v)))
#define argmin(v) distance((v).begin(), min_element(all(v)))
#define vmax(v) *max_element(all(v))
#define vmin(v) *min_element(all(v))
typedef long long int ll;
typedef pair<int, ll> P;
typedef vector<P> vpair;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef vector<double> vdouble;
typedef vector<string> vstr;
typedef vector<bool> vbool;
typedef vector<vint> vvint;
typedef vector<vll> vvll;
typedef vector<vstr> vvstr;
typedef vector<vbool> vvbool;
const ll LINF = 2000000000000000000ll;
const int INF = 1000000100;
const ll MOD = 1e9+7;
vpair edges[100005];
vll d;
void dijkstra(int s) {
priority_queue<P, vector<P>, greater<P>> que;
d[s] = 0;
que.push(P(0, s));
while (que.size()) {
P p = que.top();
que.pop();
int v = p.se;
if (d[v] < p.fi) continue;
for (auto e : edges[v]) {
if (d[e.fi] > d[v] + e.se) {
d[e.fi] = d[v] + e.se;
que.push(P(d[e.fi], e.fi));
}
}
}
}
int main() {
int n;
cin >> n;
d.resize(n, LINF);
rep(i, n-1) {
int a, b, c;
cin >> a >> b >> c;
--a;
--b;
edges[a].emplace_back(b, c);
edges[b].emplace_back(a, c);
}
int q, k;
cin >> q >> k;
--k;
dijkstra(k);
rep(i, q) {
int x, y;
cin >> x >> y;
--x;
--y;
cout << d[x]+d[y] << endl;
}
return 0;
}
| 0
| 6,474,330
|
#include <bits/stdc++.h>
using namespace std;
int main(){
vector<string> s(3);
for(int i=0; i<3; i++){
cin >> s.at(i);
}
string ans;
string sam="abcdefghijklmnopqrstuvwxyz";
string res="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
for(int i=0; i<3; i++){
for(int j=0; j<26; j++){
if(s.at(i).at(0)==sam.at(j)) ans+=res.at(j);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define FOR(i, m, n) for(int i = m; i <= n; i++)
using namespace std;
int main(){
int n, x;
while (true) {
cin >> n >> x;
if (n == 0 && x == 0) break;
int cnt = 0;
FOR(i, 1, n) FOR(j, i+1, n) FOR(k, j+1, n){
if (i+j+k == x) cnt++;
}
cout << cnt << endl;
}
return 0;
}
| 0
| 21,623,736
|
#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 <iomanip>
#include<math.h>
#include <functional>
#include<climits>
using namespace std;
#define rep(i, n) for(int i=0; i<(int)(n); ++i)
int sub(int a,vector<char>b,int c,int d){
if(c%2019==0&&c!=0)return 1;
return sub(a+1,b,c+b[d]*a,d+1);
}
int main(){
int a;cin>>a;
cout<<a*(a+1)/2;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define vec vector
#define rep(i,n) for (int i=0; i<(n); i++)
#define reps(i,s,n) for (int i=(s); i<(n); i++)
#define rep1(i,n) for (int i=1; i<=(n); i++)
#define repr(i,s,n) for (int i=(s)-1; i>=(n); i--)
#define print(a) cout << a << endl
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
int main() {
ll N;
cin >> N;
vec<ll> a(N);
ll sum = 0;
rep(i,N) {
cin >> a[i];
sum += a[i];
}
sum -= N*(N-1);
sum = max(sum,(ll)0);
ll ans = sum;
rep(i,N) a[i] += sum;
rep(i,N) {
ll t = a[i]/(N+1);
t = min(t,sum);
a[i] -= t*(N+1);
sum -= t;
}
while (1) {
ll cnt = 0;
rep(i,N) {
cnt += a[i]/N;
}
if (cnt == 0)
break;
ans += cnt;
rep(i,N) {
if (a[i]<N)
a[i] += cnt;
else {
ll t = a[i]/N;
a[i] -= t*(N+1);
a[i] += cnt;
}
}
}
print(ans);
return 0;
}
| 0
| 93,162,614
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define REP(i,s,n) for(int i=(s);i<=(n);i++)
#define repr(i,n) for(int i=n-1;i>=0;i--)
#define REPR(i,s,n) for(int i=(s);i>=(n);i--)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define Eunique(v) v.erase(unique(all(v)),v.end())
#define Eback(s) s.erase(s.end()-1,s.end())
#define rev(v) reverse(all(v))
#define minvec(v) *min_element(all(v))
#define maxvec(v) *max_element(all(v))
#define sumvec(v) accumulate(all(v),0LL)
#define mapmax(v) v.rbegin()->first
#define mapmin(v) v.begin()->first
#define pb push_back
#define pf push_front
#define m_p make_pair
#define DOUBLE fixed << setprecision(15)
#define OK puts("OK")
#define OK1 puts("OK1")
#define OK2 puts("OK2")
#define SIZE(s) (int)s.size()
#define INF ((1LL<<62)-(1LL<<31))
#define zero(x,n) setw(x) << setfill('0') << n
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<long long> vll;
typedef vector<vll> vvll;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<string> vs;
typedef pair<ll,ll> pll;
typedef pair<int,int> pii;
typedef vector<pair<int,int>> vpii;
typedef vector<pair<ll,ll>> vpll;
const double pi = acos(-1.0);
const int mod=1000000007;
const int mod2=998244353;
template<class A, class B>
ostream& operator<<(ostream& ost, const pair<A, B>&p) {
ost << "{" << p.first << ", " << p.second << "} ";
return ost;
}
template<class T>
ostream& operator<<(ostream& ost, const vector<T>&v) {
ost << "{";
for (int i = 0; i<(int)v.size(); i++) {
if (i)ost << " ";
ost << v[i];
}
ost << "} \n";
return ost;
}
template<class A, class B>
ostream& operator<<(ostream& ost, const map<A, B>&v) {
ost << "{";
for (auto p:v) {
ost << "{" << p.first << ", " << p.second << "} ";
}
ost << "} ";
return ost;
}
template<class T>
inline bool chmax(T& a, T b){if(a<b){a=b;return true;} return false;}
template<class T>
inline bool chmin(T& a, T b){if(a>b){a=b;return true;} return false;}
void YES(bool b) {cout << (b?"YES\n":"NO\n");}
void Yes(bool b) {cout << (b?"Yes\n":"No\n");}
void yes(bool b) {cout << (b?"yes\n":"no\n");}
void Yay(bool b) {cout << (b?"Yay!\n":":(\n");}
long long powmod(long long a,long long b){
long long c=1;
while(b>0){
if(b&1) c=a*c%mod;
a=a*a%mod;
b>>=1;
}
return c;
}
ll gcd(ll x, ll y) {return __gcd(x,y);}
ll lcm(ll x, ll y) {return x/__gcd(x,y)*y;}
int main()
{
ll n,m,ans=0;
cin >> n >> m;
vll x(n),y(n),z(n);
rep(i,n) cin >> x[i] >> y[i] >> z[i];
rep(i,1<<3){
vll v;
rep(j,n){
ll tmp=0;
if(i&(1<<0)) tmp-=x[j];
else tmp+=x[j];
if(i&(1<<1)) tmp-=y[j];
else tmp+=y[j];
if(i&(1<<2)) tmp-=z[j];
else tmp+=z[j];
v.pb(tmp);
}
sort(rall(v));
ll sum=0;
rep(j,m) sum+=v[j];
chmax(ans,sum);
}
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main () {
int N;
cin >> N;
vector<ll>A(N);
vector<ll>B(N);
vector<pair<ll, int>>C(N);
for (int i = 0; i < N; i ++) {
cin >> A[i] >> B[i];
C[i] = make_pair(A[i] + B[i], i);
}
sort(C.begin(), C.end());
ll ans = 0;
for (int i = 0; i < N; i ++) {
int k = N - i - 1;
int j = C[k].second;
if (i % 2 == 0) {
ans += A[j];
}
else {
ans -= B[j];
}
}
cout << ans << endl;
}
| 0
| 24,652,578
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
using Graph = vector<vector<ll>>;
using P = pair<int,int>;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
#define MOD 1000000007
#define INF 1000000
#define PI 3.14159265358979323846264338327950L
#define MAX_N 200010
#define lb lower_bound
int main()
{
int K;cin>>K;
ll b[100040];
queue<ll> q;
ll count=1;
for (ll i=1;i<=9;i++)
{
q.push(i);
b[count]=i;
count++;
}
while (!q.empty())
{
ll v = q.front();
q.pop();
for (ll i=-1;i<=1;i++)
{
ll nv = 10*v + (v%10+i);
if (v%10+i>=0 && v%10+i<=9)
{
q.push(nv);
b[count]=nv;
count++;
}
}
if (count>K+1) break;
}
cout<<b[K]<<endl;
}
|
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main(){
vector<vector<char> > v;
vector<char> mv;
mv.push_back(' ');mv.push_back('.');mv.push_back(',');mv.push_back('!');mv.push_back('?');
v.push_back(mv);
mv.clear();
mv.push_back('c');mv.push_back('a');mv.push_back('b');
v.push_back(mv);
mv.clear();
mv.push_back('f');mv.push_back('d');mv.push_back('e');
v.push_back(mv);
mv.clear();
mv.push_back('i');mv.push_back('g');mv.push_back('h');
v.push_back(mv);
mv.clear();
mv.push_back('l');mv.push_back('j');mv.push_back('k');
v.push_back(mv);
mv.clear();
mv.push_back('o');mv.push_back('m');mv.push_back('n');
v.push_back(mv);
mv.clear();
mv.push_back('s');mv.push_back('p');mv.push_back('q');mv.push_back('r');
v.push_back(mv);
mv.clear();
mv.push_back('v');mv.push_back('t');mv.push_back('u');
v.push_back(mv);
mv.clear();
mv.push_back('z');mv.push_back('w');mv.push_back('x');mv.push_back('y');
v.push_back(mv);
mv.clear();
string s;
int a,i,cou,n,cou2,b;
cin >>b;
for(int j=0;j<b;j++){
cin>>s;
a=s.size();
i=0;
cou2=0;
while(i<a){
cou=0;
n=0;
while(s[i]!='0'&&i<a){
if(n!=s[i]-'0')cou=0;
n=s[i]-'0';
i++;
cou++;
}
i++;
if(cou!=0&&i<=a){
if(n==8||n==2||n==3||n==4||n==5||n==6)cou=cou%3;
else if(n==7||n==9)cou=cou%4;
else if(n==1)cou=cou%5;
cout<<v[n-1][cou];
cou2++;
}
}
if(cou2!=0)cout<<endl;
}
return 0;
}
| 0
| 51,125,040
|
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> P;
typedef tuple<int,int,int> tpl;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define SORT(c) sort((c).begin(),(c).end())
#define REVERSE(c) reverse((c).begin(),(c).end())
#define LB(a,x) lower_bound((a).begin(), (a).end(), x) - (a).begin()
#define UB(a,x) upper_bound((a).begin(), (a).end(), x) - (a).begin()
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define RFOR(i,a,b) for(int i=(a)-1;i>=(b);--i)
#define RREP(i,n) RFOR(i,n,0)
#define en "\n"
const double EPS = 1e-9;
const double PI = acos(-1.0);
const int INT_INF = 2147483647;
const long long LL_INF = 1LL<<60;
const long long MOD = 1000000007;
#define CLR(a) memset((a), 0, sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
int main(void){
ll N,K; cin >> N >> K;
vector<ll> a(N); REP(i,N) cin >> a[i];
ll ans = LL_INF;
REP(i,1<<N){
int n = 0;
REP(j,N) if(i & 1<<j) n++;
if(n < K) continue;
ll tmp = 0;
ll h = 0;
REP(j,N){
if(i & 1<<j){
if(a[j] <= h){
tmp += h+1-a[j];
h++;
}
else{
h = a[j];
}
}
else{
h = max(h, a[j]);
}
}
chmin(ans, tmp);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i,n)for(long long i=0;i<(long long)(n);i++)
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
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=1e9+7;
const ll INF=1e18;
const int MAX=510000;
const double pi=acos(-1);
int dx[8] = {1,0,-1,0,1,1,-1,-1};
int dy[8] = {0,1,0,-1,-1,1,1,-1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
int n = s.size();
rep(i,n-1){
if(s[i] == s[i+1]){
cout << i+1 << " " << i+2 << endl;
return 0;
}
}
rep(i,n-2){
if(s[i] == s[i+2]){
cout << i+1 << " "<< i+3 << endl;
return 0;
}
}
cout << -1 << " "<< -1 << endl;
return 0;
}
| 0
| 51,081,213
|
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<vector>
#include<map>
#include<set>
#include<string>
#include<queue>
#include<stack>
#include<cassert>
#include<numeric>
#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)
using namespace std;
const int INF = 1001001001;
const long long LINF = 1001002003004005006ll;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
typedef long long ll;
typedef pair<int,int> P;
int main(){
int n;
cin >> n;
int p[n];
rep(i,n)cin >> p[i];
rep(i,n)p[i]--;
int ind[n];
rep(i,n)ind[p[i]]=i;
set<int> s;
ll ans = 0;
drep(i,n){
s.insert(ind[i]);
auto it = s.find(ind[i]);
ll c = 0;
{
vector<ll> l(2,-1);
vector<ll> r(2,n);
auto itl = it;
auto itr = it;
rep(j,2){
if(itl==s.begin())break;
itl--;
l[j]=*itl;
}
rep(j,2){
itr++;
if(itr==s.end())break;
r[j]=*itr;
}
c = (l[0]-l[1])*(r[0]-*it)+(*it-l[0])*(r[1]-r[0]);
}
ans += c*(i+1);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main()
{
int n;
cin >> n;
vector<int> a(n + 1);
for (int i = 1; i < n + 1; i++)
{
int x;
cin >> x;
a[x] = i;
}
for (int i = 1; i < n + 1; i++)
{
if (i > 1)
cout << " ";
cout << a[i];
}
cout << endl;
return 0;
}
| 0
| 58,392,244
|
#include <bits/stdc++.h>
using namespace std;
#define pi acos(-1)
#define IOS ios_base::sync_with_stdio(0); cin.tie(); cout.tie();
#define fi first
#define se second
#define pf push_front
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define debug(val) cerr << "Value " << #val << " : " << val << '\n';
typedef long double ld;
typedef long long ll;
typedef unsigned long long ull;
const ll mod = 1e9 + 7;
const ll inf = 0x3f3f3f3f;
const ld epsilon = 10e-9;
const ll nax = 0;
ll s, c;
int main(void){
IOS
cin >> s >> c;
ll ans;
if(c>2*s){
s+=c/2;
ans=s/2;
}
else{
ans=min(c/2, s);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<n;++i)
#define all_map(pos,mp) for(ll pos=mp.begin();pos!=mp.end();pos -++)
#define ALL(a) (a).begin(),(a).end()
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
const ll MOD = 1e9 + 7;
const ll LINF = 1LL << 62;
const int INF = 1e9 + 7;
int main(){
ll n, k;
cin >> n >> k;
if(k > (n-1)*(n-2)/2){
cout << -1 << endl;
return 0;
}
cout << n*(n-1)/2 - k << endl;
for(ll i = 1; i <=n; ++i){
for(ll j = i+1; j <=n; ++j){
if(i != 1 && k > 0){
k--;
continue;
}
cout << i << " " << j << endl;
}
}
}
| 0
| 62,114,597
|
#include<bits/stdc++.h>
using namespace std;
#define Fast_as_duck ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define pb push_back
#define forn(i,st,n) for(int i = st; i < n ; i++)
#define rev(i,st,n) for(int i = st; i >= n ; i--)
#define ss second
#define ff first
#define ll long long
typedef pair <int , int> pii;
const int N = 1e5 + 10 , mod = 1000000007;
int visited[2*N];
void dfs(std::vector<int> path[] , int u , int val , int visited[] ){
visited[u] = val;
forn(i,0,(int)path[u].size()){
if(visited[path[u][i]]== 0){
dfs(path , path[u][i] , val , visited );
}
}
}
void solve(){
int n , m ; cin >> n >> m;
std::vector<int> frnd[n+1];
int x , y;
forn(i,0,m){
cin >> x >> y;
frnd[x].pb(y);
frnd[y].pb(x);
}
int val = 0;
forn(i,0,n){
if(visited[i+1] == 0){
val++;
visited[i+1] = val;
dfs(frnd , i+1 , val , visited);
}
}
std::vector<int> ans(val+1 , 0);
forn(i,1,n+1){
ans[visited[i]]++;
}
sort(ans.begin() , ans.end());
cout << ans.back() << "\n";
}
int main(){
Fast_as_duck;
int t = 1;
while(t--){
solve();
}
return 0;
}
|
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <cassert>
#include <algorithm>
#include <functional>
#include <iostream>
#include <iomanip>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <unordered_map>
#include <utility>
#include <limits.h>
#include <bitset>
#include <set>
using namespace std;
#define LL long long int
const LL INF = (1LL<<60);
const int INF_INT = 2147483647-1e6-1;
const LL mod = 1000000007ll;
const int mod_int = 1000000007;
LL N,K;
LL P[5001],C[5001];
LL ans = -INF;
void solve(){
vector<LL> loop(N+1);
vector<LL> score_per_loop(N+1);
for(int i=1;i<=N;i++){
LL score = 0;
LL point = i;
LL numof_loop = 0;
while(1){
point = P[point];
score += C[point];
numof_loop++;
if(i==point) break;
}
loop[i] = numof_loop;
score_per_loop[i] = max(0LL,score);
}
for(int i=1;i<=N;i++){
LL point = i;
LL score = 0;
for(int operation=1;operation<=min(K,loop[i]);operation++){
point = P[point];
score += C[point];
ans = max(ans,score + max(0LL,((K-operation)/loop[i]))*score_per_loop[i]);
}
}
}
int main(){
cin >> N >> K;
for(int i=1;i<=N;i++) cin >> P[i];
for(int i=1;i<=N;i++) cin >> C[i];
solve();
cout << ans << endl;
return 0;
}
| 0
| 15,165,587
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define lvector vector<ll>
#define cvector vector<char>
#define svector vector<string>
#define lque queue<ll>
#define lpque priority_queue<ll>
#define dlpque priority_queue<ll,lvector,greater<ll>>
#define P pair<ll,ll>
#define ALL(a) a.begin(),a.end()
#define RALL(a) a.rbegin(),a.rend()
#define rep(i,n) for(ll i=0; i<n; ++i)
#define print(a) cout << (a) << endl
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll h,w;cin>>h>>w;
vector<string> G(h);rep(i,h) cin>>G[i];
vector<lvector> V(h,lvector(w,0)),W(w,lvector(h,0));
rep(i,h) {
ll v=0,pos=0;
rep(j,w) {
if(G[i][j]=='.') v++;
else {
fill(V[i].begin()+pos,V[i].begin()+pos+v,v);
pos=j+1,v=0;
}
}
if(v>0) fill(V[i].begin()+pos,V[i].end(),v);
}
rep(i,w) {
ll v=0,pos=0;
rep(j,h) {
if(G[j][i]=='.') v++;
else {
fill(W[i].begin()+pos,W[i].begin()+pos+v,v);
pos=j+1,v=0;
}
}
if(v>0) fill(W[i].begin()+pos,W[i].end(),v);
}
ll ans=-1;
rep(i,h)rep(j,w) ans=max(ans,V[i][j]+W[j][i]);
print(ans-1);
return 0;
}
|
#include <stdio.h>
int main(){
int n,m;
int i,j;
scanf("%d",&n);
while(n!=0){
char before[n],after[n];
for(i=0;i<n;i++){
scanf(" %c %c",&before[i],&after[i]);
}
scanf("%d",&m);
char data[m];
for(i=0;i<m;i++){
scanf(" %c",&data[i]);
for(j=0;j<n;j++){
if(data[i]==before[j]){
data[i]=after[j];
break;
}
}
}
for(i=0;i<m;i++){
printf("%c",data[i]);
}
printf("\n");
scanf("%d",&n);
}
return 0;
}
| 0
| 89,285,852
|
#include <iostream>
using namespace std;
int main(){
while(1) {
int price;
cin >> price;
if (price == 0) break;
int otsuri = 1000 - price;
int nCoin = 0;
nCoin += otsuri/500;
otsuri = otsuri % 500;
nCoin += otsuri/100;
otsuri = otsuri % 100;
nCoin += otsuri/50;
otsuri = otsuri % 50;
nCoin += otsuri/10;
otsuri = otsuri % 10;
nCoin += otsuri/5;
otsuri = otsuri % 5;
nCoin += otsuri;
cout << nCoin << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define fi0 for(ll i=0;i<n;i++)
string s;
string strd(int n){
string x;
while(n){
int d=n%10;
x+=(d+'0');
n/=10;
}
reverse(x.begin(),x.end());
return x;
}
void digit()
{
cin>>s;
ll sum=0;
for(int i=0;i<s.size();i++){
char a=(char)s[i];
int d=(int) a-'0';
sum+=d;
}
if(sum%9==0)cout<<"Yes\n";
else cout<<"No\n";
}
int main()
{
string s;
cin>>s;
ll n=s.size()+1;
int cnt=0,maxi=0;
s+='S';
fi0 {
if(s[i]=='R')cnt++;
else{
maxi=max(cnt,maxi);
cnt=0;
}
}
cout<<maxi<<endl;
}
| 0
| 48,340,367
|
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int main (void) {
int arr[100001];
int size,
rem, coun, res;
cin >> size;
for (int it = 0; it < size; ++it) cin >> arr[it];
sort(arr, arr + size);
rem = arr[0];
coun = 1;
res = 0;
for (int it = 1; it < size; ++it) {
if (arr[it] != rem) {
if (coun - rem >= 0) res += coun - rem;
else res += coun;
rem = arr[it];
coun = 1;
} else ++coun;
}
if (coun - rem >= 0) res += coun - arr[size - 1];
else res += coun;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
using P = pair<i64, i64>;
#define overload3(_1, _2, _3, name, ...) name
#define rep1(i, n) for(i64 i = 0LL; i < (n); ++i)
#define rep2(i, a, b) for(i64 i = (a); i < (b); ++i)
#define rep(...) overload3(__VA_ARGS__, rep2, rep1)(__VA_ARGS__)
#define all(v) v.begin(), v.end()
void solve(std::string S, std::string T) {
i64 ans = T.length();
rep(i, S.length() - T.length() + 1) {
i64 cost = 0;
rep(j, T.length()) {
if(S[i + j] != T[j]) ++cost;
}
ans = min(ans, cost);
}
cout << ans << endl;
}
struct IoSetup {
IoSetup() {
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
}
} iosetup;
int main() {
std::string S;
std::cin >> S;
std::string T;
std::cin >> T;
solve(S, T);
return 0;
}
| 0
| 97,027,596
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define ALL(x) (x).begin(),(x).end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
typedef pair<int,int> PI;
typedef pair<int,pair<int,int>> PII;
static const int INF=1010000000000000017LL;
static const double eps=1e-12;
static const double pi=3.14159265358979323846;
static const int dx[4]={1,-1,0,0};
static const int dy[4]={0,0,1,-1};
static const int ddx[8]={1,-1,0,0,1,1,-1,-1};
static const int ddy[8]={0,0,1,-1,1,-1,1,-1};
template<class T> inline bool chmin(T& a,T b){if(a>b){a=b;return true;}return false;}
template<class T> inline bool chmax(T& a,T b){if(a<b){a=b;return true;}return false;}
int N,M;
int A[100005];
signed main(){
cin>>N>>M;
priority_queue<int> pq;
for(int i=0;i<N;++i){
int a;
cin>>a;
pq.push(a);
}
for(int i=0;i<M;++i){
int p=pq.top();
pq.pop();
p/=2;
pq.push(p);
}
int ans=0;
while(pq.size()){
ans+=pq.top();
pq.pop();
}
cout<<ans<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
const int MAX =200005;
const int MOD =1000000007;
signed main(){
int n;
cin>>n;
int x,y,p[n],q[n];
for(int i=0;i<n;i++){
cin>>x>>y;
p[i]=x+y;
q[i]=x-y;
}
for(int i=1;i<n;i++)if(abs(p[i])%2!=abs(p[0])%2){
cout<<-1<<endl;
return 0;
}
if(p[0]%2==0){
cout<<32<<endl;
for(int i=30;i>=0;i--)cout<<(1ll<<i)<<' ';
cout<<1<<endl;
for(int j=0;j<n;j++){
for(int i=30;i>=0;i--){
if(p[j]>=0){
p[j]-=(1ll<<i);
if(q[j]>=0){
cout<<'R';
q[j]-=(1ll<<i);
}else{
cout<<'U';
q[j]+=(1ll<<i);
}
}else{
p[j]+=(1ll<<i);
if(q[j]>=0){
cout<<'D';
q[j]-=(1ll<<i);
}else{
cout<<'L';
q[j]+=(1ll<<i);
}
}
}
if(p[j]>=0){
p[j]-=(1ll<<0);
if(q[j]>=0){
cout<<'R';
q[j]-=(1ll<<0);
}else{
cout<<'U';
q[j]+=(1ll<<0);
}
}else{
p[j]+=(1ll<<0);
if(q[j]>=0){
cout<<'D';
q[j]-=(1ll<<0);
}else{
cout<<'L';
q[j]+=(1ll<<0);
}
}
cout<<endl;
}
}else{
cout<<31<<endl;
for(int i=30;i>=0;i--)cout<<(1ll<<i)<<' ';
cout<<endl;
for(int j=0;j<n;j++){
for(int i=30;i>=0;i--){
if(p[j]>=0){
p[j]-=(1ll<<i);
if(q[j]>=0){
cout<<'R';
q[j]-=(1ll<<i);
}else{
cout<<'U';
q[j]+=(1ll<<i);
}
}else{
p[j]+=(1ll<<i);
if(q[j]>=0){
cout<<'D';
q[j]-=(1ll<<i);
}else{
cout<<'L';
q[j]+=(1ll<<i);
}
}
}
cout<<endl;
}
}
}
| 0
| 27,705,997
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
#define FOR(i, n, m) for(ll (i)=(m);(i)<(n);++(i))
#define REP(i, n) FOR(i,n,0)
#define OF64 std::setprecision(10)
const ll MOD = 1000000007;
const ll INF = (ll) 1e15;
struct Edge {
ll to;
ll cost;
ll index;
};
struct Vertex {
vector<Edge> node;
};
Vertex V[105];
bool U[1005];
ll C[105];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, M;
cin >> N >> M;
REP(i, M) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
V[a].node.push_back(Edge{b, c, i});
V[b].node.push_back(Edge{a, c, i});
}
REP(i, N) {
priority_queue<Edge, vector<Edge>, function<bool(Edge, Edge)>> q(
[](Edge a, Edge b) { return a.cost > b.cost; });
q.push(Edge{i, 0, -1});
REP(j, N) {
C[j] = INF;
}
C[i] = 0;
while (!q.empty()) {
auto e = q.top();
q.pop();
if (C[e.to] < e.cost)
continue;
if (e.index >= 0)
U[e.index] = true;
REP(j, V[e.to].node.size()) {
auto &n = V[e.to].node[j];
ll cost = n.cost + e.cost;
if (C[n.to] <= cost)
continue;
C[n.to] = cost;
q.push(Edge{n.to, cost, n.index});
}
}
}
ll ans = 0;
REP(i, M) {
if (U[i])
continue;
ans++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <iostream>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define speed \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define ll long long
#define pb push_back
#define mem1(a) memset(a, -1, sizeof(a))
#define mem0(a) memset(a, 0, sizeof(a))
#define endl "\n"
#define mod 1000000007
#define mod1 998244353
#define ff first
#define ss second
#define MAX 500005
#define N 10004
#define INF 1000000009
#define all(v) v.begin(), v.end()
#define sbit(a) __builtin_popcount(a)
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef pair<ll, ll> pll;
typedef pair<pll, ll> ppl;
typedef map<ll, ll> mpll;
typedef map<vector<ll>, ll> mpvl;
ll power(ll x, ll y, ll p)
{
ll res = 1;
x = x % p;
if (x == 0)
return 0;
while (y > 0)
{
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void solve()
{
ll n, x, m;
cin >> n >> x >> m;
ll ans = x;
ll t = x * x;
ll c = 0;
map<ll, ll> mp;
n--;
ll s[m + 1];
mem0(s);
ll tans = 0;
ll tmp;
for (ll i = 1; i <=m + 1; i++)
{
ll md = t % m;
if (!mp.count(md))
{
tans += md;
t = md * md;
}
else
{
c = i - mp[md];
tmp = mp[md];
break;
}
mp[md] = i;
s[i] = tans;
}
tmp--;
n -= tmp;
ll div = n / c;
ll md = n % c;
ans += (div * (s[c + tmp] - s[tmp]));
ans += s[tmp];
ans += s[tmp + md] - s[tmp];
cout << ans << endl;
}
int main()
{
speed;
ll kk;
kk = 1;
while (kk--)
{
solve();
}
return 0;
}
| 0
| 41,738,358
|
#include <bits/stdc++.h>
#define SIZE 10000
using namespace std;
vector<pair<double, double> > vertex;
void koch_curve(const pair<double, double> &p1, const pair<double, double> &p2, int n)
{
if (n == 0)
{
return;
}
double ax = p1.first * 2 / 3 + p2.first / 3, ay = p1.second * 2 / 3 + p2.second / 3;
double bx = p1.first / 3 + p2.first * 2 / 3, by = p1.second / 3 + p2.second * 2 / 3;
double x = bx - ax, y = by - ay;
double cx = ax + x * cos(M_PI / 3) - y * sin(M_PI / 3), cy = ay + x * sin(M_PI / 3) + y * cos(M_PI / 3);
pair<double, double> a1 = make_pair(ax, ay), a2 = make_pair(cx, cy), a3 = make_pair(bx, by);
koch_curve(p1, a1, n - 1);
vertex.push_back(a1);
koch_curve(a1, a2, n - 1);
vertex.push_back(a2);
koch_curve(a2, a3, n - 1);
vertex.push_back(a3);
koch_curve(a3, p2, n - 1);
}
int main()
{
int n;
cin >> n;
vertex.push_back(make_pair(0, 0));
koch_curve(make_pair(0, 0), make_pair(100, 0), n);
vertex.push_back(make_pair(100, 0));
for (int i = 0; i < vertex.size(); ++i)
printf("%.8f %.8f\n", vertex[i].first, vertex[i].second);
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
#define LLINF 9223372036854775807
#define MOD ll(1e9+7)
int main(){
ll n, k;
cin >> n >> k;
int max_bit = 31;
vector<ll> a(n);
vector<ll> b(n);
for(int i = 0; i < n; i++){
cin >> a[i] >> b[i];
}
vector<ll> candidates;
candidates.push_back(k);
for(int i = 1; i < max_bit; i++){
if(k&(1<<i)){
ll tmp = k;
tmp -= 1<<i;
tmp |= (1<<i)-1;
candidates.push_back(tmp);
}
}
ll ans = -1;
for(int i = 0; i < candidates.size(); i++){
ll tmpsum = 0;
for(int j = 0; j < n; j++){
bool isOK = true;
for(int bit = 0; bit < max_bit; bit++){
if(!(candidates[i]&(1<<bit)) && a[j]&(1<<bit)){
isOK = false;
break;
}
}
if(isOK){
tmpsum += b[j];
}
}
ans = max(ans,tmpsum);
}
cout << ans << endl;
}
| 0
| 12,835,137
|
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
#define pcnt(bit) __builtin_popcountll(bit)
template<class T> bool chmax(T &a, const T &b) {if (a < b) {a = b; return 1;} return 0;}
template<class T> bool chmin(T &a, const T &b) {if (b < a) {a = b; return 1;} return 0;}
const long double pi = acos(-1.0);
const int MAX = 1000010;
const int INF = 1LL << 60;
const int MOD = 1000000007;
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int n; cin >> n;
int x = 800 * n;
int y = 200 * (n / 15);
cout << x - y << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define fastio ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define int long long
#define ll long long
#define ld long double
#define pr pair<int,int>
#define prr pair<pr,int>
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define fow(i,a,b,c) for(int i=a;i<=b;i+=c)
#define bck(i,a,b,c) for(int i=a;i>=b;i-=c)
#define fi first
#define se second
#define loop int tests;cin>>tests;while(tests--)
signed main()
{
fastio;
double n,m,d,ans;
cin>>n>>m>>d;
if(d==0)
ans=(m-1)/n;
else
ans=2*(n-d)*(m-1)/(n*n);
cout<<fixed<<setprecision(7)<<ans<<"\n";
}
| 0
| 27,506,311
|
#include <stdio.h>
typedef long long ll;
int main(void) {
ll i, j, k, h, w, ans = 3, now;
scanf("%lld%lld", &h, &w);
char s[h][w + 10];
ll cnt[4][h][w];
for(i = 0; i < h; ++i) scanf("%s", s[i]);
for(i = 0; i < h; ++i) for(j = 0; j < w; ++j) {
cnt[0][i][j] = cnt[1][i][j] = 1;
if(s[i][j] == '#') cnt[0][i][j] = cnt[1][i][j] = 0;
else {
if(i) cnt[0][i][j] = cnt[0][i - 1][j] + 1;
if(j) cnt[1][i][j] = cnt[1][i][j - 1] + 1;
}
}
for(i = h - 1; i >= 0; --i) for(j = w - 1; j >= 0; --j) {
cnt[2][i][j] = cnt[3][i][j] = 1;
if(s[i][j] == '#') cnt[2][i][j] = cnt[3][i][j] = 0;
else {
if(i != h - 1) cnt[2][i][j] = cnt[2][i + 1][j] + 1;
if(j != w - 1) cnt[3][i][j] = cnt[3][i][j + 1] + 1;
}
}
for(i = 0; i < h; ++i) for(j = 0; j < w; ++j) {
now = 0;
for(k = 0; k < 4; ++k) now += cnt[k][i][j];
if(ans < now) ans = now;
}
printf("%lld", ans - 3);
return 0;
}
|
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
static const int INF = 1e9;
static const int SIZE = 101;
typedef pair<int, int> P;
int d[SIZE];
vector<int> G[SIZE];
void solve()
{
int n;
cin >> n;
for (int i = 0; i < n; ++i)
{
int u, k;
cin >> u >> k;
for (int j = 0; j < k; ++j)
{
int v;
cin >> v;
G[u].push_back(v);
}
}
for (int i = 0; i < SIZE; ++i)
{
d[i] = INF;
}
d[1] = 0;
queue<P> que;
que.push(P(0, 1));
while (!que.empty())
{
P p = que.front();
que.pop();
int v = p.second;
for (int i = 0; i < G[v].size(); ++i)
{
int to = G[v][i];
if (d[to] > p.first + 1)
{
d[to] = p.first + 1;
que.push(P(d[to], to));
}
}
}
for (int i = 1; i <= n; ++i)
{
if (d[i] == INF)
{
cout << i << " " << -1 << endl;
}
else
{
cout << i << " " << d[i] << endl;
}
}
}
int main()
{
solve();
return(0);
}
| 0
| 62,497,615
|
#include<iostream>
#include<stdio.h>
#include<math.h>
#include<vector>
using namespace std;
int main() {
vector<int> s,t;
int a,i,j,k,l,len;
int max = 0;
for (i = 0; i <= 100; i++) {
s.push_back(0);
}
while (cin >> a) {
s[a] += 1;
}
for (j = 0; j <= 100; j++) {
if (max < s[j]) {
max = s[j];
}
}
for (k = 0; k <= 100; k++) {
if (s[k] == max) {
t.push_back(k);
}
}
len = t.size();
for (l = 0; l < len; l++) {
cout << t[l] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {int to,cost;};
typedef long long ll;
typedef pair<int,int> P;
typedef vector<int> VI;
typedef vector<edge> VE;
static const long long INF = 9223372000000000000/2;
static const int NIL = -1;
static const int MOD = 1000000007;
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define np next_permutation
#define pq priority_queue
#define itn int
#define scnaf scanf
#define reutnr return
#define scamf scanf
#define int ll
const int NMAX = 100;
int n,m;
int d[NMAX+10][NMAX+10];
void intialize(){
for(int i=0;i<NMAX;i++){
for(int j=0;j<NMAX;j++) d[i][j] = INF;
}
for(int i=0;i<NMAX;i++) d[i][i] = 0;
}
void WF(){
for(int k=0;k<n;k++){
for(int i=0;i<n;i++){
for(int j=0;j<n;j++) if(d[i][k] != INF && d[k][j] != INF) d[i][j] = min(d[i][j],d[i][k]+d[k][j]);
}
}
}
void output(){
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(d[i][j]==INF) printf("INF");
else printf("%d",d[i][j]);
if(j!=n-1) printf(" ");
}
printf("\n");
}
}
void input(){
for(int i=0;i<m;i++){
int tmp1,tmp2,tmp3;
scanf("%lld %lld %lld",&tmp1,&tmp2,&tmp3);
d[tmp1][tmp2] = tmp3;
}
}
void solve(){
for(int i=0;i<n;i++){
if(d[i][i]<0){
printf("NEGATIVE CYCLE\n");
return;
}
}
output();
return;
}
signed main(){
scanf("%lld %lld",&n,&m);
intialize();
input();
WF();
solve();
return 0;
}
| 0
| 77,656,384
|
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
const long long INF = 1000000000000;
const long long N = 10000;
long long n,m;
struct edge{
long long from,to,cost;
}w[N];
long long d[N];
void path(long long s){
for(long long i=0;i<n;i++) d[i]=INF;
d[s] = 0;
while(true){
bool u = false;
for(long long i=0;i<m;i++){
edge e = w[i];
if(d[e.from]!=INF&&d[e.to]>d[e.from]+e.cost){
d[e.to] = d[e.from]+e.cost;
u = true;
}
}
if(!u) break;
}
}
bool f(){
memset(d,0,sizeof(d));
for(long long i=0;i<n;i++){
for(long long j=0;j<m;j++){
edge e = w[j];
if(d[e.to]>d[e.from]+e.cost){
d[e.to]=d[e.from]+e.cost;
if(i==n-1) return true;
}
}
}
return false;
}
int main(){
while((scanf("%lld%lld",&n,&m))!=EOF){
for(long long i=0;i<m;i++){
scanf("%lld%lld%lld",&w[i].from,&w[i].to,&w[i].cost);
}
if(f()) {
printf("NEGATIVE CYCLE\n");
continue;
}
for(long long i=0;i<n;i++){
path(i);
for(long long j=0;j<n;j++){
if(d[j]==INF&&j!=n-1) printf("INF ");
else if(d[j]==INF&&j==n-1) printf("INF");
else if(d[j]!=INF&&j==n-1)printf("%lld",d[j]);
else if(d[j]!=INF&&j!=n-1)printf("%lld ",d[j]);
}
printf("\n");
}
}
}
|
#include <cstdio>
#include <algorithm>
using namespace std;
int main(){
int n;
scanf("%d", &n);
int a;
long sum = 0;
int m = 1000000, M = -1000000;
for(int i = 0; i < n; i++){
scanf("%d", &a);
M = max(M, a);
m = min(m, a);
sum += a;
}
printf("%d %d %ld\n", m, M, sum);
return 0;
}
| 0
| 35,993,912
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int c=0;
double a=0,b=0,x=0;
cin >> a;
cin >> b;
x = (a + b)/2 + 0.5;
c = x;
cout << c << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,d;
cin >> n >> d;
vector<vector<int>> x(n,vector<int>(d));
for(int i=0; i<n; i++){
for(int j=0; j<d; j++){
cin >> x.at(i).at(j);
}
}
double dis = 0;
int ans = 0;
for(int i=0; i<=n; i++){
for(int j=1; j<i; j++){
for(int k=0; k<d; k++){
dis += abs((x.at(i-1).at(k) - x.at(j-1).at(k))*(x.at(i-1).at(k) - x.at(j-1).at(k)));
}
dis = sqrt(dis);
int nbool = dis;
if(dis == nbool){
ans += 1;
}
dis = 0;
}
}
cout << ans << endl;
}
| 0
| 18,146,864
|
#include <bits/stdc++.h>
using namespace std;
#define maxn 100010
#define ll long long
#define db double
#define vi vector<int>
#define pb push_back
#define mod 998244353
ll ksm(ll a, ll b) {
if (!b) return 1;
ll ns = ksm(a, b >> 1);
ns = ns * ns % mod;
if (b & 1) ns = ns * a % mod;
return ns;
}
int a[maxn], b[maxn], p[maxn], q[maxn];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> p[i], q[p[i]] = i;
int mn = 0;
for (int i = 1; i <= n; i++) {
int ea = a[i - 1] + 1, eb = b[i - 1] - 1;
if (ea + eb < q[i]) ea = q[i] - eb;
else eb = q[i] - ea;
a[i] = ea, b[i] = eb;
mn = min(mn, b[i]);
}
for (int i = 1; i <= n; i++)
b[i] += -mn + 1;
for (int i = 1; i <= n; i++)
printf("%d ", a[i]);
printf("\n");
for (int i = 1; i <= n; i++)
printf("%d ", b[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int h, w; cin >> h >> w;
int field[1010][1010] = {0};
queue<pair<int, int>> que;
for(int i=0; i<h; i++){
string s; cin >> s;
for(int j=0; j<w; j++)
if(s[j] == '#') que.push({i+1, j+1});
else field[i+1][j+1] = 1e9;
}
int d[] = {1, 0, -1, 0, 1}, ans = 0;
while(!que.empty()){
auto now = que.front(); que.pop();
for(int i=0; i<4; i++)
if(field[now.first][now.second] + 1 < field[now.first+d[i]][now.second+d[i+1]]){
field[now.first+d[i]][now.second+d[i+1]] = field[now.first][now.second] + 1;
ans = max(ans, field[now.first+d[i]][now.second+d[i+1]]);
que.push({now.first+d[i], now.second+d[i+1]});
}
}
cout << ans << endl;
return 0;
}
| 0
| 93,588,483
|
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
#include <queue>
#include <map>
using namespace std;
typedef long long LL;
LL n,k,a[200005];
LL pre[200005] = {0};
map <LL,LL> mp;
LL tot = 0;
int main(){
ios::sync_with_stdio(false);
cin >> n >> k;
for(LL i = 1;i <= n;i ++){
cin >> a[i]; a[i] --; a[i] %= k;
pre[i] = pre[i - 1] + a[i]; pre[i] %= k;
}
mp[pre[0]] = 1;
for(LL i = 1;i <= n;i ++){
if(i >= k) mp[pre[i - k]] --;
tot += mp[pre[i]];
mp[pre[i]] ++;
}
cout << tot << endl;
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() {
ll N, K;
cin >> N >> K;
vector<pair<ll, ll>> ab(N);
ll a, b;
for (int i = 0; i < N; i++) {
cin >> a >> b;
ab[i] = {a, b};
}
sort(ab.begin(), ab.end());
ll cnt = 0;
for (int i = 0; i < N; i++) {
a = ab[i].first;
b = ab[i].second;
cnt += b;
if (K <= cnt) {
cout << a << endl;
return 0;
}
}
return 0;
}
| 0
| 17,535,430
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pp pair<int,int>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define ld long double
#define al(a) (a).begin(),(a).end()
#define mk make_pair
#define check cout<<"?"<<endl;
ll MOD=1000000007;
ll mod=998244353;
int inf=1000001000;
ll INF=1e18+5;
int main(){
int a,b,c; cin>>a>>b>>c;
if(a+b>=c) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
|
#include <iostream>
#include <cstdio>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <string>
#include <cstring>
#include <cmath>
#include <complex>
#include <map>
#include <climits>
#include <sstream>
using namespace std;
#define reep(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) reep((i),0,(n))
#define ALL(v) (v).begin(),(v).end()
#define PB push_back
#define EPS 1e-8
#define F first
#define S second
#define mkp make_pair
static const double PI=6*asin(0.5);
typedef long long ll;
typedef complex<double> CP;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vint;
static const int INF=1<<24;
template <class T>
void initvv(vector<vector<T> > &v,int a,int b, const T &t = T()){
v.assign(a,vector<T>(b,t));
}
int main(){
int n,m,p;
while(cin>>n>>m>>p,n||m||p){
vint v(n);
rep(i,n) cin>>v[i];
int s=0;
rep(i,n) s+=v[i];
s*=(100-p);
if(v[m-1]==0){
cout<<0<<endl;
continue;
}
s/=v[m-1];
cout<<s<<endl;
}
}
| 0
| 3,909,227
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.