code1
stringlengths 54
12k
| code2
stringlengths 65
12k
| similar
int64 0
1
| __index_level_0__
int64 32
101M
|
|---|---|---|---|
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
int n,m,i,j,d[100005];
int main()
{
scanf("%d%d",&n,&m);
while(m--)
{
scanf("%d%d",&i,&j);
++d[i],++d[j];
}
for(i=1;i<=n;++i)
if(d[i]&1)
{
printf("NO");
return 0;
}
printf("YES");
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <cstring>
#include <math.h>
#include <bitset>
#include <queue>
#include <set>
#include <iomanip>
#include <assert.h>
#include <cstdio>
using namespace std;
typedef long long ll;
constexpr long long int INFLL = 1001001001001001LL;
constexpr long long int infll = 1001001001001001LL;
constexpr int INF = 1000000007;
constexpr int inf = 1000000007;
const int mod = 1000000007;
inline bool chmin(ll &a, ll b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
inline bool chmax(ll &a, ll b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
template <typename T>
T seinomi(T a)
{
if (a > 0)
{
return a;
}
else
{
return 0;
}
}
template <typename T>
T ketasuu(T num)
{
return std::to_string(num).length();
}
ll llpow(ll a, ll n)
{
if (n == 0)
{
return 1;
}
else
{
ll rep = a;
for (ll i = 1; i < n; i++)
{
rep *= a;
}
return rep;
}
}
template <class ForwardIt, class T>
void iota(ForwardIt first, ForwardIt last, T value)
{
while (first != last)
{
*first++ = value;
++value;
}
}
template <typename T>
T amarinasi(T a, T b)
{
if (a % b == 0)
{
return a / b;
}
else if (a % b > 0)
{
return a / b + 1;
}
else
{
return a / b - 1;
}
}
const double pi = 3.14159265358979323846264;
int main()
{
ll h, w;
cin >> h >> w;
if (h % 3 == 0 || w % 3 == 0)
{
cout << 0 << endl;
}
else
{
ll ans = infll;
for (ll i = 0; i < w - 2; i++)
{
ll s1 = i * h;
ll s2 = ((w - i) / 2) * h;
ll s3 = ((w - i + 2 - 1) / 2) * h;
chmin(ans, max({s1, s2, s3}) - min({s1, s2, s3}));
}
for (ll i = 0; i < h - 2; i++)
{
ll s1 = i * w;
ll s2 = ((h - i) / 2) * w;
ll s3 = ((h - i + 2 - 1) / 2) * w;
chmin(ans, max({s1, s2, s3}) - min({s1, s2, s3}));
}
for (ll i = 1; i < w; i++)
{
ll s1 = i * h;
ll s2 = (w - i) * (h / 2);
ll s3 = (w - i) * ((h + 2 - 1) / 2);
chmin(ans, max({s1, s2, s3}) - min({s1, s2, s3}));
}
for (ll i = 1; i < h; i++)
{
ll s1 = i * w;
ll s2 = (h - i) * (w / 2);
ll s3 = (h - i) * ((w + 2 - 1) / 2);
chmin(ans, max({s1, s2, s3}) - min({s1, s2, s3}));
}
cout << ans << endl;
}
} | 0 | 61,693,225 |
#include <algorithm>
#include <iostream>
#include <vector>
int main() {
uint32_t n = 0;
std::cin >> n;
std::vector<uint32_t> mat(n + 1);
for (uint32_t i = 0; i < n; i++) {
std::cin >> mat[i] >> mat[i + 1];
}
std::vector<std::vector<uint32_t>> dp(n + 1,
std::vector<uint32_t>(n + 1, -1));
for (size_t i = 0; i < dp.size(); i++) dp[i][i] = 0;
for (size_t d = 1; d < n; d++) {
for (size_t i = 1; i < dp.size() - d; i++) {
for (size_t j = 0; j < d; j++) {
dp[i][i + d] =
std::min(dp[i][i + d], mat[i - 1] * mat[i + j] * mat[i + d] +
dp[i][i + j] + dp[i + j + 1][i + d]);
}
}
}
std::cout << dp[1][n] << std::endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define int long long
const int N = 1e3 + 5, MOD = 1e9 + 7;
int a[N][N], h, w, dp[N][N];
void solve(){
cin >> h >> w;
string a[h] = {string(w, '_')};
for(int i = 0; i < h; ++i){
cin >> a[i];
}
memset(dp, 0, sizeof dp);
dp[0][0] = 1;
for(int i = 1; i < h; ++i){
if(a[i - 1][0] != '#')
dp[i][0] = 1;
else
break;
}
for(int j = 1; j < w; ++j){
if(a[0][j - 1] != '#')
dp[0][j] = 1;
else
break;
}
for(int i = 1; i < h; ++i){
for(int j = 1; j < w; ++j){
if(a[i - 1][j] != '#' && a[i][j - 1] != '#')
dp[i][j] = ((dp[i - 1][j] % MOD) + (dp[i][j - 1] % MOD)) % MOD;
else if(a[i - 1][j] != '#')
dp[i][j] = dp[i - 1][j];
else if(a[i][j - 1] != '#')
dp[i][j] = dp[i][j - 1];
}
}
cout << dp[h - 1][w - 1];
}
int32_t main(){
IOS;
int t = 1;
bool test = 0;
if(test) cin >> t;
for(int i = 1; i <= t; ++i)
solve();
return 0;
} | 0 | 47,666,764 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n, k; cin >> n >> k;
vector<long long int> v;
for (int x = 0; x < n; ++x){
long long int q; cin >> q;
v.push_back(q);
}
sort(v.begin(), v.end());
if (k >= v.size()){
cout << 0 << endl;
return 0;
}
long long int ans = 0;
for (int x = 0; x < n-k; ++x){
ans += v[x];
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <stdio.h>
#include <vector>
#include <queue>
using namespace std;
static const int MAX = 100000;
static const int WHITE = 0;
static const int GRAY = 1;
vector<int> adjList[MAX];
vector<int> out;
int colors[MAX];
int indeg[MAX];
void bfs(int vertexInd, int numVertex){
queue<int> Q;
Q.push(vertexInd);
colors[vertexInd] = GRAY;
while(!Q.empty()){
int u = Q.front();
Q.pop();
out.push_back(u);
for(int i = 0; i < adjList[u].size(); i++ ){
int adjInd = adjList[u][i];
indeg[adjInd]--;
if(indeg[adjInd] == 0 && colors[adjInd] == WHITE){
colors[adjInd] = GRAY;
Q.push(adjInd);
}
}
}
}
void topologicalSort(int numVertex){
for(int i = 0; i < numVertex; i++){
colors[i] = WHITE;
indeg[i] = 0;
}
for(int i = 0; i < numVertex; i++){
for (int j = 0; j < adjList[i].size(); j++) {
int temp = adjList[i][j];
indeg[temp]++;
}
}
for(int i = 0; i < numVertex; i++){
if (indeg[i] == 0 && colors[i] == WHITE){
bfs(i, numVertex);
}
}
}
int main(int argc, const char * argv[]) {
int numVertex, numEdge;
scanf("%d %d", &numVertex, &numEdge);
int x, y;
for (int i = 0; i < numEdge; i ++){
scanf("%d %d", &x, &y);
adjList[x].push_back(y);
}
topologicalSort(numVertex);
for(int i = 0; i < out.size(); i ++){
cout << out[i] << endl;
}
return 0;
} | 0 | 59,393,079 |
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<(n); ++i)
#define chmin(x,y) x = min(x,y)
#define chmax(x,y) x = max(x,y)
using namespace std;
using Graph = vector<vector<int>>;
typedef long long ll;
typedef pair<int, int> P;
const int inf = 1 << 21;
const ll INF = 1LL << 60;
const ll mod = 1e9+7;
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, -1, 0, 1};
int main(){
ll n, k;
cin >> n >> k;
if (k%2){
ll tmp = n/k;
cout << tmp*tmp*tmp << endl;
}else{
ll htmp = 2 * n/k;
ll tmp = n/k;
cout << tmp*tmp*tmp + (htmp-tmp)*(htmp-tmp)*(htmp-tmp) << endl;
}
return 0;
} | #include <stdio.h>
#include <string.h>
int main()
{
char S[255], T[255];
scanf("%s%s", S, T);
int A,B;
scanf("%d%d", &A, &B);
char U[20];
scanf("%s", U);
int result1 = strcmp(S,U);
int result2 = strcmp(T,U);
if (result1 == 0)
{
A = A - 1;
}
if (result2 == 0)
{
B = B - 1;
}
printf("%d%s%d", A," ", B);
return 0;
} | 0 | 75,973,181 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
#define rep1(i,n) for(int i=1;i<n+1;i++)
#define sort(A) sort(A.begin(),A.end())
#define reverse(A) reverse(A.begin(),A.end())
typedef long long ll;
int main(){
int n;
cin >> n;
vector<pair<int,int>> r(n);
vector<pair<int,int>> b(n);
rep(i,n){
int x,y;
cin >> x >> y;
auto tmp = make_pair(y,x);
r[i] = (tmp);
}
sort(r);
reverse(r);
rep(i,n){
int x,y;
cin >> x >> y;
auto tmp = make_pair(x,y);
b[i] = (tmp);
}
sort(b);
vector<bool> seen(n,0);
int ans = 0;
rep(i,n){
int x = b[i].first;
int y = b[i].second;
rep(j,n){
if(r[j].second < x){
if(seen[j]) continue;
if(r[j].first < y){
seen[j] = 1;
ans ++;
break;
}
}
}
}
cout << ans << endl;
} | #include <algorithm>
#include <complex>
#include <cstdlib>
#include <ctime>
#include <time.h>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <numeric>
#include <limits>
#include <type_traits>
using namespace std;
#define SAY_YES cout << "YES" << endl;
#define SAY_Yes cout << "Yes" << endl;
#define SAY_NO cout << "NO" << endl;
#define SAY_No cout << "No" << endl;
#define IFYES(TRUE_OR_FALSE) \
if (TRUE_OR_FALSE) \
{ \
cout << "YES" << endl; \
} \
else \
{ \
cout << "NO" << endl; \
}
#define IFYes(TRUE_OR_FALSE) \
if (TRUE_OR_FALSE) \
{ \
cout << "Yes" << endl; \
} \
else \
{ \
cout << "No" << endl; \
}
#define IFyes(TRUE_OR_FALSE) \
if (TRUE_OR_FALSE) \
{ \
cout << "yes" << endl; \
} \
else \
{ \
cout << "no" << endl; \
}
#define DEBUG_OUTPUT_ARRAY(XXX, ONE) \
for (int i = 0; i < (ONE); i++) \
{ \
cout << "DEBUG: i = " << i << " -> " << XXX[i] << endl; \
}
#define DEBUG_OUTPUT_ARRAY2(XXX, ONE, TWO) \
for (int i = 0; i < (ONE); i++) \
{ \
cout << "<<< i = " << i << " >>>" << endl; \
for (int j = 0; j < (TWO); j++) \
{ \
cout << "DEBUG: j = " << j << " -> " << XXX[i][j] << endl; \
} \
}
#define DEBUG_OUTPUT_ARRAY2_BOX(XXX, ONE, TWO) \
for (int i = 0; i < (ONE); i++) \
{ \
cout << i << " "; \
for (int j = 0; j < (TWO); j++) \
{ \
cout << XXX[i][j] << " "; \
} \
cout << endl; \
}
typedef pair<long long int, long long int> pll;
const long long int mod = 1000000007;
const long long int INF = 1e18;
const long double PI=3.14159265358979323;
long long int mi=0;
long long int N,res=0,abssum=0;
long long int A,B,C,K;
string S;
pll clo[200020],revclo[200020];
int main()
{
cout << fixed << setprecision(18);
cin>>K>>A>>B;
if(A+2>=B){
cout<<K+1<<endl;
return 0;
}else{
K-=(A-1);
res=A;
res+=(K/2)*(B-A)+K%2;
}
cout<<res<<endl;
} | 0 | 19,667,427 |
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cmath>
#include<iomanip>
typedef std::pair<double, double> point;
point hoge(point q2, point q4){
point q3;
point r = std::make_pair((q2.first + q4.first)/2, (q2.second + q4.second)/2);
point vec = std::make_pair(-(q4.second - q2.second), q4.first - q2.first);
q3 = std::make_pair(r.first + vec.first * sqrt(3)/2, r.second + vec.second * sqrt(3)/2);
return q3;
}
void kochCurve(point p1, point p2, int i, int n){
if(i == n){
std::cout << std::setprecision(8) << p1.first << " " << p1.second << std::endl;
return;
}
if(i > n){
std::cout << "something wrong";
return;
}
point q1 = std::make_pair(p1.first, p1.second);
point q2 = std::make_pair(p1.first * 2/3 + p2.first * 1/3, p1.second * 2/3 + p2.second * 1/3);
kochCurve(q1, q2, i + 1, n);
point q4 = std::make_pair(p1.first * 1/3 + p2.first * 2/3, p1.second * 1/3 + p2.second * 2/3);
point q3 = hoge(q2, q4);
kochCurve(q2, q3, i + 1, n);
kochCurve(q3, q4, i + 1, n);
kochCurve(q4, p2, i + 1, n);
}
int main(){
int n;
scanf("%d", &n);
int i = 0;
std::cout << std::fixed;
point start = std::make_pair(0.0, 0.0);
point end = std::make_pair(100.0, 0.0);
kochCurve(start, end, i, n);
std::cout << end.first << " " << end.second << std::endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, srt, end) for (long long i = (srt); i < (long long)(end); i++)
ll gcd(ll a, ll b){
if(a < b) return gcd(b, a);
ll r = a % b;
while(r != 0){
a = b;
b = r;
r = a % b;
}
return b;
}
ll lcm(ll a, ll b){
ll ret = a / gcd(a,b) * b;
return ret;
}
int main(){
ll a, b, c, d;
cin >> a >> b >> c >> d;
ll numc = (b / c) - ((a + c - 1) / c) + 1;
ll numd = (b / d) - ((a + d - 1) / d) + 1;
ll l = lcm(c, d);
ll numl = (b / l) - ((a + l - 1) / l) + 1;
cout << b - a + 1 - numc - numd + numl << endl;
return 0;
} | 0 | 29,464,581 |
#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 _GLIBCXX_DEBUG
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using vd = vector<double>;
using vvi = vector<vi>;
using vvll = vector<vll>;
using vvd = vector<vd>;
using vvvi = vector<vvi>;
using vvvll = vector<vvll>;
using vvvd = vector<vvd>;
const double pi=3.141592653589793;
const ll MOD=1e9+7;
int main() {
int x,y,z,k;
cin>>x>>y>>z>>k;
ll a[x],b[y],c[z];
rep(i,x){
cin>>a[i];
}
rep(i,y){
cin>>b[i];
}
rep(i,z){
cin>>c[i];
}
priority_queue<ll> q1;
rep(i,x){
rep(j,y){
q1.push(a[i]+b[j]);
}
}
priority_queue<ll> q2;
for (int i=0;i<min(3000,x*y);i++){
auto s=q1.top();
q1.pop();
for (int j=0;j<z;j++){
q2.push(c[j]+s);
}
}
rep(i,k){
auto s=q2.top();
q2.pop();
cout<<s<<endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int A,B,K;
cin >> A >> B >> K;
for(int k=0; k<K; k++){
if(k%2==0){
if(A%2 != 0){ A--; }
int diff= A/2;
A-= diff;
B+= diff;
}
else{
if(B%2 != 0){ B--; }
int diff= B/2;
B-= diff;
A+= diff;
}
}
cout << A <<" "<< B << endl;
} | 0 | 52,554,656 |
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<string.h>
using namespace std;
int main() {
long long a,b;
cin >> a >> b;
if (a == 1 || b == 1) {
cout << "1";
}
else {
cout << (a * b + 1) / 2;
}
} | #include<iostream>
#include<string.h>
using namespace std;
int main(){
char s[205], p[105];
char a[10000];
cin >> s;
cin >> p;
strcat(a, s);
strcat(a, s);
if (strstr(a, p) != NULL){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
return 0;
} | 0 | 20,435,877 |
#include<iostream>
#include<vector>
using namespace std;
int main(){
int n,m; cin >> n >> m;
vector<int>k(m);
vector<vector<int> >s(n);
vector<int>p(m);
for(int i=0;i<m;i++){
cin >> k.at(i);
for(int j=0;j<k.at(i);j++){
int S;
cin >> S;
s.at(S - 1).push_back(i);
}
}
for(int i=0;i<m;i++){
cin >> p.at(i);
}
long long ans = 0;
for(int bit=0;bit<(1<<n);bit++){
vector<int>sw(m);
for(int i=0;i<n;i++){
if(bit & (1<<i)){
for(int j : s.at(i)) sw.at(j)++;
}
}
int count = 0;
for(int i=0;i<m;i++){
sw.at(i) %= 2;
if(sw.at(i) == p.at(i)) count++;
}
if(count == m) ans++;
}
cout << ans << endl;
} | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <cmath>
#include <map>
int main(){
std::string s; std::cin >> s;
int K; std::cin >> K;
for (int i = 0; i < K; ++i) {
if (s[i] != '1') {
std::cout << s[i] - '0' << std::endl;
return 0;
}
}
std::cout << 1 << std::endl;
return 0;
} | 0 | 52,824,662 |
#define _GIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main(void) {
int n, k;
cin >> n >> k;
vector<int> l(n);
rep(i, n) {
cin >> l[i];
}
sort(l.rbegin(), l.rend());
int ans = 0;
rep(i, k) {
ans += l[i];
}
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define mp make_pair
#define pb push_back
#define rep(i,n) for(int i=0;i<n;i++)
#define rep1(i,n) for(int i=1;i<=(int)(n);i++)
int main(){
int n;
cin >> n;
int a[n];
int c[n];
rep(i,n) c[i]=0;
rep(i,n){
cin >> a[i];
c[--a[i]]++;
}
int pa[n+1];
rep(i,n+1) pa[i]=0;
rep(i,n){
pa[c[i]]++;
}
ll s[n+1];
ll pn[n+1];
pn[0]=0;
s[0]=0;
rep1(i,n){
s[i]=s[i-1];
s[i]+=pa[i]*i;
pn[i]=pn[i-1];
pn[i]+=pa[i];
}
ll ss[n+1];
rep(i,n+1){
ss[i]=s[i];
ss[i]+=(pn[n]-pn[i])*i;
}
rep1(i,n){
ll lb=0;
ll ub=n+1;
while(ub-lb>1){
ll mid=(lb+ub)/2;
if(i*1LL*mid<=ss[mid]){
lb=mid;
}
else{
ub=mid;
}
}
cout << lb << endl;
}
return 0;
} | 0 | 69,258,049 |
#include<iostream>
#include<cmath>
using namespace std;
const long long size=2e5+1;
long long a[size],x[size];
long long n,s;
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>a[i];
x[i]=x[i-1]+a[i];
s+=a[i];
}
long long min=2e10+5,result;
for(int i=1;i<n;i++)
{
result=abs(2*x[i]-s);
if(min>result)
min=result;
}
cout<<min;
return 0;
} | #include <iostream>
#include <math.h>
using namespace std;
bool p[1000000];
void primes() {
for (int i = 0; i < 1000000; i++) {
p[i] = true;
}
p[0] = p[1] = false;
for (int i = 2; i < sqrt(999999); i++) {
if (p[i]) {
for (int j = i * 2; j < 1000000; j += i) {
p[j] = false;
}
}
}
}
int main() {
primes();
int n;
while (cin >> n) {
int ans = 0;
for (int i = 2; i <= n; i++) {
if (p[i]) {
ans += 1;
}
}
cout << ans << endl;
}
return 0;
} | 0 | 59,316,742 |
#include<bits/stdc++.h>
#define rep(i,N) for(ll (i)=0;(i)<(N);(i)++)
#define chmax(x,y) x=max(x,y)
#define chmin(x,y) x=min(x,y)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
const int mod = 1000000007;
int main() {
int n;
cin >> n;
string s;
cin >> s;
vector<ll> ch(26);
rep(i, n) {
ch[s[i] - 'a']++;
}
ll ans = 1;
rep(i, 26) {
(ans *= ch[i] + 1) %= mod;
}
ans--;
cout << ans << endl;
} | #include <stdio.h>
#include <iostream>
using namespace std;
long long a[100010];
long long mask[61];
int main()
{
int n;scanf("%d",&n);
for (int i=0;i<n;++i)
scanf("%lld",&a[i]);
long long ans=0;
long long tmp=0;
for (int i=0;i<n;++i)
tmp^= a[i];
ans=tmp;
tmp= (1LL << 61)-1-tmp;
for (int i=0;i<n;++i)
a[i]&=tmp;
tmp=0;
for (int i=0;i<n;++i)
{
for (int j=60;j>=0;--j)
{
if ( (a[i]&(1LL<<j))==0 ) continue;
if ( !mask[j] ){
mask[j]=a[i];
break;
}
a[i]^=mask[j];
}
}
for (int i=59;i>=0;--i)
{
if (mask[i] && (tmp^mask[i])>tmp)
tmp^=mask[i];
}
printf("%lld\n",ans+(tmp*2));
} | 0 | 16,495,576 |
#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, B, a, b;
cin >> A >> B >> a >> b;
cout << a-(b-B) << endl;
cout << b+(a-A) << endl;
cout << a-(b-B)-(a-A) << endl;
cout << b+(a-A)-(b-B) << endl;
} | #include <bits/stdc++.h>
const int MAXN = 100010;
int head[MAXN], to[MAXN << 1], nxt[MAXN << 1], tot;
void addedge(int b, int e) {
nxt[++tot] = head[b]; to[head[b] = tot] = e;
nxt[++tot] = head[e]; to[head[e] = tot] = b;
}
int dfs(int u, int b = 0, int fa = 0) {
int sc = 0;
for (int i = head[u]; i; i = nxt[i]) if (to[i] != fa)
sc += dfs(to[i], fa == 0, u);
if (sc + b > 1) std::cout << "First\n" << std::endl, exit(0);
return sc ^ 1;
}
int main() {
std::ios_base::sync_with_stdio(false), std::cin.tie(0);
int n; std::cin >> n;
for (int i = 1, t1, t2; i < n; ++i)
std::cin >> t1 >> t2, addedge(t1, t2);
for (int i = 1; i <= n; ++i) if (!nxt[head[i]]) { dfs(i); break; }
std::cout << "Second" << std::endl;
return 0;
} | 0 | 47,583,431 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
typedef long long ll;
static const int INF (1<<30);
ll get_min(ll h, ll w) {
ll y = INF;
for (int x = 1; x <= w-2; x++) {
ll s1 = x * h;
ll s2, s3;
if (w-x % 2 == 0) {
s2 = s3 = h * ((w-x) / 2);
} else {
s2 = h * ((w-x) / 2);
s3 = h * (1 + (w-x) / 2);
}
ll t2, t3;
if (h % 2 == 0) {
t2 = t3 = (h / 2) * (w-x);
} else {
t2 = (h / 2) * (w-x);
t3 = (1 + h / 2) * (w-x);
}
ll d1 = max(s1, max(s2, s3)) - min(s1, min(s2, s3));
ll d2 = max(s1, max(t2, t3)) - min(s1, min(t2, t3));
y = min(y, min(d1, d2));
}
return y;
}
int main() {
ll H, W; cin >> H >> W;
if (H % 3 == 0 || W % 3 == 0) {
cout << 0 << endl;
return 0;
}
if (H == 2 && W == 2) {
cout << 1 << endl;
return 0;
}
ll ans = min(get_min(H, W), get_min(W, H));
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
typedef long long ll;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ordered_set tree<int, null_type,less_equal<int>, rb_tree_tag,tree_order_statistics_node_update>
#define pb push_back
#define ff first
#define ss second
#define gcd(a, b) __gcd(a, b)
#define lcm(a, b) ((a)*((b)/gcd(a,b)))
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define lllim 2147483648
#define Pi 2*acos(0.0)
#define pii pair<int,int>
#define pll pair<ll,ll>
#define mem(a,b) memset(a, b, sizeof(a))
#define fill_(a,b) fill(a,a+n,b);
#define mod 1000000007
#define fast_cin ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define filein freopen("input.txt","r", stdin)
#define D(x) cerr << __LINE__ << ": " << #x << " = " << (x) << '\n'
#define case int t,cas=1;cin>>t;while(t--)
#define rep(i,a,n) for(int i=a;i<n;i++)
#define rev(i,n,a) for(int i=n;i>=a;i--)
#define sim template<class T
sim > void ckmin(T& a, const T& b) {
a= b < a? b:a;
}
sim > void ckmax(T& a, const T& b) {
a= b > a? b:a;
}
sim > void read(T& a) {
std::cin>>a;
}
sim > void read(T& a, T& b) {
std::cin>>a>>b;
}
sim > void read(T& a,T& b, T& c) {
std::cin>>a>>b>>c;
}
sim > void readara(T& ara,const int sidx, const int eidx) {
for(int i=sidx; i<eidx; i++) std::cin>>ara[i];
}
sim > void readvec( std::vector<T>& v, const int n) {
rep(i,0,n) {
T p;
std::cin>>p;
v.pb(p);
}
}
using namespace std;
using namespace __gnu_pbds;
const int maxn=1e5+6;
vector<int>pr;
ll bigmod(ll a, ll b, ll m);
void si();
vector<ll>v;
void make()
{
v.pb(1);
rep(i,2,1004)
{
v.pb(v.back()+i);
}
}
void solve()
{
int n,m;
read(n,m);
vector<pii>ans;
int k=m;
int tot = (n*(n-1))/2 - (n-1);
if(k>tot)
{
cout<<-1<<endl;
}
else
{
int cnt=(n*(n-1))/2-(n-1);
for(int i=1; i<n; i++)
{
ans.pb({i,n});
}
for(int i=1;i<n;i++)
{
for(int j=i+1;j<n && cnt>k;j++)
{
cnt--;
ans.pb({i,j});
}
}
cout<<ans.size()<<endl;
rep(i,0,ans.size())
{
cout<<ans[i].ff<<" "<<ans[i].ss<<endl;
}
}
}
int main()
{
fast_cin;
make();
{
solve();
}
return 0;
}
bool mark[maxn];
void si()
{
mem(mark,0);
for(int i=4; i<maxn; i+=2) mark[i]=1;
for(int i=3; i*i<maxn; i+=2)
{
if(!mark[i])
for(int j=i*i; j<maxn; j+=2*i)
mark[j]=1;
}
pr.pb(2);
for(int i=3; i<maxn; i+=2)
if(!mark[i])
pr.pb(i);
}
ll bigmod(ll a, ll b, ll m)
{
if(b==0) return 1;
if(b==1) return a;
if(b%2)
{
ll res=bigmod(a,b/2,m)%m;
return ((((res%m)*(res%m))%m)*(a))%m;
}
else
{
ll res=bigmod(a,b/2,m)%m;
return (((res%m)*(res%m))%m);
}
} | 0 | 55,996,555 |
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <unordered_set>
#include <queue>
#include <deque>
#include <string>
#include <sstream>
#include <iomanip>
#include <map>
#include <unordered_map>
#include <stack>
#include <cstdio>
#include <climits>
#include <tuple>
#include <ctime>
#define FOR(i,a,n) for (int i = a; i < n; i++)
#define IFOR(i,n,a) for (int i = n; i >= a; i--)
#define mp make_pair
#define full(a) a.begin(), a.end()
#define SZ(x) ((int)(x).size())
#define VI vector<int>
#define PII pair<int, int>
#define trav(a,x) for (auto& a : x)
typedef unsigned long long ull;
typedef long long ll;
typedef long double ld;
using namespace std;
const int mod = 1e9 + 7;
int main()
{
ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
int k; cin >> k;
int a, b; cin >> a >> b;
FOR(i, a, b + 1)
{
if (i % k == 0)
{
cout << "OK\n";
return 0;
}
}
cout << "NG\n";
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
int N; cin >> N;
int cnt = 1;
int now = 10;
int n = N;
int ans = 0;
while(n / now != 0){
if(cnt % 2 == 1){
int x = pow(10,cnt) - pow(10,cnt-1);
ans += x;
}
cnt++;
now *= 10;
}
if(cnt % 2 == 1){
int x = N - pow(10,cnt-1) + 1;
ans += x;
}
cout << ans << endl;
return 0;
} | 0 | 24,438,525 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef pair<ll, P> PP;
static const double EPS = 1e-8;
static const double PI = 4.0 * atan(1.0);
static const ll INF = 1023456789;
#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,s,n) for(int i=s;i<n;++i)
#define FORR(i,s,n) for(int i=n-1;i>=s;--i)
#define ALL(c) (c).begin(),(c).end()
#define CLEAR(v) memset(v,0,sizeof(v))
#define MP(a,b) make_pair((a),(b))
#define ABS(a) ((a)>0?(a):-(a))
#define F first
#define S second
int main(int argc, char **argv) {
string s;
cin >> s;
ll res = 0;
REP(i, s.length()-2) {
ll v = (s[i]-'0') * 100 + (s[i+1]-'0') * 10 + s[i+2]-'0';
if (abs(v - 753) < abs(res - 753)) res = v;
}
cout << abs(res - 753) << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define f first
#define s second
#define go ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
int main()
{
ll t;
map<string,ll>mp;
cin>>t;
t--;
string str;
cin>>str;
char ch=str[str.size()-1];
mp[str]++;
ll cnt=0;
while(t--)
{
cin>>str;
if(str[0]!=ch || mp[str]>0)
cnt=10;
ch=str[str.size()-1];
mp[str]++;
}
if(cnt==10)
cout<<"No"<<endl;
else
cout<<"Yes"<<endl;
} | 0 | 62,418,447 |
#include <bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
const ll MOD = 1e9 + 7;
int n, x, y;
vector<int> G[100009];
ll dp[100009][2];
int vis[100009];
void solve(int v)
{
vis[v] = 1;
dp[v][0] = 1;
dp[v][1] = 1;
for (int i = 0; i < G[v].size(); i++)
{
int w = G[v][i];
if (vis[w] == 0)
{
solve(w);
dp[v][0] *= (dp[w][0] + dp[w][1]);
dp[v][1] *= (dp[w][0]);
dp[v][0] %= MOD;
dp[v][0] += MOD;
dp[v][0] %= MOD;
dp[v][1] %= MOD;
dp[v][1] += MOD;
dp[v][1] %= MOD;
}
}
return;
}
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n - 1; i++)
{
cin >> x >> y;
G[x].pb(y);
G[y].pb(x);
}
solve(1);
ll ans = dp[1][0] + dp[1][1];
ans += MOD;
ans %= MOD;
cout << ans << "\n";
} | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <functional>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
using namespace std;
using llong = long long;
llong n;
llong ans = 0;
int main() {
cin >> n;
llong ans = 0;
for (llong i = 1; i * i <= n; i++) {
if (n % i == 0) {
llong d = i - 1;
if (d != 0 && n / d == n % d) {
ans += d;
}
d = n / i - 1;
if (d != 0 && n / d == n % d) {
ans += d;
}
}
}
cout << ans << endl;
return 0;
} | 0 | 41,371,232 |
#include<stdio.h>
int main(){
int a;
scanf("%d",&a);
long long int b=1;
for(int i=0;i<a;)b*=++i;
printf("%lld\n",b);
} | #include <bits/stdc++.h>
using namespace std;
#define LL long int
#define ULL unsigned long int
#define LD long double
LL MOD = 1000000007;
int main(){
int n;
cin >> n;
vector<int> a(n);
for(int i = 0; i < n; ++i) cin >> a[i];
sort(a.begin(),a.end());
int ans = 0;
vector<int> num(a.back() + 1);
for(int i = 0; i < n; ++i){
num[a[i]]++;
}
vector<bool> f(a.back() + 1, true);
for(int i = 0; i < n; ++i){
if(f[a[i]]){
if(num[a[i]] == 1){
ans++;
}
for(int j = a[i]; j <= a.back(); j = j + a[i]){
f[j] = false;
}
}
}
cout << ans << endl;
return 0;
} | 0 | 33,509,266 |
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#pragma GCC optimize("Ofast")
using namespace __gnu_pbds;
using namespace std;
#define int long long int
#define endl '\n'
#define mod 1000000007
#define inf 1e18
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
const int N = 300005;
void solve() {
string s, t; cin >> s >> t;
if (t.length() == 1 + s.length() && t.substr(0, s.length()) == s) cout << "Yes\n";
else cout << "No\n";
}
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
int t = 1, z = 1;
while (t--) {
solve();
}
return 0;
} | #include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#include<vector>
#include<deque>
#include<map>
#include<queue>
using namespace std;
#define rep(i,s,n) for(int i = s;i<n;i++)
#define repe(i,s,n) for(int i = s;i<=n;i++)
#define pb push_back
#define fi first
#define se second
typedef long long ll;
typedef pair<int,int>pint;
typedef vector<int>vint;
typedef vector<pint>vpint;
static const ll maxLL = (ll)1 << 62;
const int mod=1000000007;
int dy[]={-1,0,1,0};
int dx[]={0,1,0,-1};
#define int ll
signed main(){
int n;
cin>>n;
rep(i,0,n){
int x,y;
cin>>x>>y;
if(x<y)swap(x,y);
int r=floor(sqrt(x*y));
if(r*(r+1)<x*y)cout<<2*r-1<<endl;
else if(r*r<x*y)cout<<2*r-2<<endl;
else cout<<2*r-3+(r==x)<<endl;
}
return 0;
} | 0 | 35,118,527 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
#define debug(x) cerr<<#x<<'='<<x<<'\n'
long long a[66];
const long long n=50;
int main(void) {
long long k;
cin>>k;
for (int i=1; i<=n; i++) {
a[i]=i+k/n-1;
}
k%=50;
for (int i=1; i<=k; i++) {
a[i]+=n+1;
}
puts("50");
for (int i=1; i<=n; i++) {
cout<<a[i]-k<<' ';
}
return 0;
} | #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 ordered_set tree<ll, null_type,less<ll>, rb_tree_tag,tree_order_statistics_node_update>
using namespace std;
using namespace __gnu_pbds;
const ll Mod = (int)1e9;
ll CaseN=1;
ll fast_power(ll a,ll b,ll mod){
ll ans=1;
while(b>0){
if(b&1){
ans=(a*ans)%mod;
}
b=b>>1;
a=(a*a)%mod;
}
return ans;
}
ll nCr(ll n ,ll r)
{
ll p= n;
r = min(r,n-r);
ll a =1;
ll b=1;
while(r)
{
a = a*p;
b = b*r;
ll g = __gcd(a,b);
a = a/g;
b = b/g;
p--;
r--;
}
return a;
}
void solve()
{
ll h,w;
cin>>h>>w;
vector<string> v;
v.push_back("Shivam");
for(ll i=1;i<=h;i++)
{
string s,t;
s+='0';
cin>>t;
s = s+t;
v.push_back(s);
}
for(ll i=1;i<=2*h;i++)
{
for(ll j = 1;j<=w;j++)
{
char ch ;
{
ch = v[(i+1)/2][j] ;
}
cout<<ch;
}
cout<<endl;
}
CaseN++;
return ;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t=1;
while(t--)
{
solve();
}
} | 0 | 36,503,125 |
#include <cstdio>
using namespace std;
int main()
{
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++){
char mcxi_a[128];
char mcxi_b[128];
int sum = 0;
scanf("%s %s", mcxi_a, mcxi_b);
int i = 0;
while (mcxi_a[i] != '\0'){
switch (mcxi_a[i]){
case 'i':
if (i > 0 && mcxi_a[i - 1] >= '2' && mcxi_a[i - 1] <= '9'){
sum += mcxi_a[i - 1] - '0';
}
else {
sum += 1;
}
break;
case 'x':
if (i > 0 && mcxi_a[i - 1] >= '2' && mcxi_a[i - 1] <= '9'){
sum += (mcxi_a[i - 1] - '0') * 10;
}
else {
sum += 10;
}
break;
case 'c':
if (i > 0 && mcxi_a[i - 1] >= '2' && mcxi_a[i - 1] <= '9'){
sum += (mcxi_a[i - 1] - '0') * 100;
}
else {
sum += 100;
}
break;
case 'm':
if (i > 0 && mcxi_a[i - 1] >= '2' && mcxi_a[i - 1] <= '9'){
sum += (mcxi_a[i - 1] - '0') * 1000;
}
else {
sum += 1000;
}
break;
}
i++;
}
i = 0;
while (mcxi_b[i] != '\0'){
switch (mcxi_b[i]){
case 'i':
if (i > 0 && mcxi_b[i - 1] >= '2' && mcxi_b[i - 1] <= '9'){
sum += mcxi_b[i - 1] - '0';
}
else {
sum += 1;
}
break;
case 'x':
if (i > 0 && mcxi_b[i - 1] >= '2' && mcxi_b[i - 1] <= '9'){
sum += (mcxi_b[i - 1] - '0') * 10;
}
else {
sum += 10;
}
break;
case 'c':
if (i > 0 && mcxi_b[i - 1] >= '2' && mcxi_b[i - 1] <= '9'){
sum += (mcxi_b[i - 1] - '0') * 100;
}
else {
sum += 100;
}
break;
case 'm':
if (i > 0 && mcxi_b[i - 1] >= '2' && mcxi_b[i - 1] <= '9'){
sum += (mcxi_b[i - 1] - '0') * 1000;
}
else {
sum += 1000;
}
break;
}
i++;
}
if (sum / 1000 > 0){
if (sum / 1000 >= 2 && sum / 1000 <= 9){
printf("%d", sum / 1000);
}
printf("m");
}
sum %= 1000;
if (sum / 100 > 0){
if (sum / 100 >= 2 && sum / 100 <= 9){
printf("%d", sum / 100);
}
printf("c");
}
sum %= 100;
if (sum / 10 > 0){
if (sum / 10 >= 2 && sum / 10 <= 9){
printf("%d", sum / 10);
}
printf("x");
}
sum %= 10;
if (sum > 0){
if (sum >= 2 && sum <= 9){
printf("%d", sum);
}
printf("i");
}
puts("");
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,N) for(int i=0;i<int(N);++i)
using ll = long long;
const int INF = 2147483647;
const ll MOD = 1000000007;
int main(){
ll n,k;
cin >> n >> k;
double sum;
for(int i=1;i<=n;i++){
ll now = i;
double p;
if(now>=k) p=1;
else{
p=1;
while(now<k){
now*=2;
p/=2;
}
}
sum+=p;
}
double ans = sum/n;
printf("%.10lf",ans);
return 0;
} | 0 | 35,123,692 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define fbo find_by_order
#define ook order_of_key
typedef long long ll;
typedef pair<ll,ll> ii;
typedef vector<int> vi;
typedef long double ld;
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
const long long mod = 1000000007;
const long long inf = 1e18;
int n;
vector<ld> v;
vector<pair<ld,ld>> t;
ld fm(ld x){
ld ansv=inf;
for(int i=0;i<n+2;i++){
ld l=t[i].fi;
l*=1.00000;
ld r=t[i].se;
r*=1.00000;
ld sa;
if(x>=0 && x<=l){
sa=v[i]+(l-x)*1.000000;
}
else if(x>=l && x<=r){
sa=v[i];
sa*=1.000000;
}
else{
sa=v[i]+(x-r)*1.000000;
}
if(sa<ansv)
ansv=sa;
}
return ansv;
}
int main(){
ios_base::sync_with_stdio(0); cin.tie(0);
cin>>n;
ld count=0.00000;
t.pb(mp(0.00000,0.00000));
for(int i=0;i<n;i++){
ld k;
cin>>k;
t.pb(mp(count,count+k));
count+=k;
}
t.pb(mp(count,count));
v.pb(0.000);
for(int i=0;i<n;i++){
ld k;
cin>>k;
v.pb(k);
}
v.pb(0.000);
vector<ld> ans;
for(ld i=0;i<=count;i+=0.500000){
ld k=fm(i);
ans.pb(k);
}
ld countans=0.00000;
for(int i=0;i<ans.size()-1;i++){
ld sa=0.25000*(ans[i]+ans[i+1]);
countans+=sa;
}
cout<<setprecision(9)<<countans<<endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define ANSWER(x) cout<<x<<endl
#define debug(x) cout<<#x<<": "<<x
typedef pair<int,int> P;
void bfs(int sx,int sy);
int H,W,N,a;
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
int cheese_x[10];
int cheese_y[10];
char ch[1001][1001];
int al[1001][1001];
int S_x,S_y,hp = 1,dis;
int main(){
cin >> H >> W >> N;
for(int i=0;i<H;i++){
for(int j=0;j<W;j++){
cin >> ch[i][j];
if(ch[i][j] == 'S'){
S_x = j;
S_y = i;
}
}
}
for(int i=0;i<N;i++){
bfs(S_x,S_y);
}
cout << a << endl;
}
void bfs(int sx,int sy){
queue<P> que;
que.push(P(sx,sy));
al[sy][sx] = a;
while(!que.empty()){
P now = que.front();que.pop();
int x = now.first;
int y = now.second;
if(ch[y][x] - '0' == hp){
hp++;
S_x = x;
S_y = y;
a = al[y][x];
memset(al,0,sizeof(al));
break;
}
for(int i=0;i<4;i++){
int mx = x + dx[i];
int my = y + dy[i];
if(mx < 0 || my < 0 || mx >= W || my >= H)continue;
if(ch[my][mx] != 'X' && al[my][mx] == false){
que.push(P(mx,my));
al[my][mx] = al[y][x] + 1;
}
}
}
} | 0 | 47,992,819 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <cmath>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
ll n, k, a, b;
cin >> n >> k;
a = n / k;
b = (n + k / 2) / k;
if (k % 2) cout << a * a * a;
else cout << a * a * a + b * b * b;
} | #include <bits/stdc++.h>
#define ll long long int
#define rep(i,a,b) for(long long i=a; i<b; i+=1)
#define repr(i,a,b) for(long long i=a; i<=b; i+=1)
#define vec vector<ll>
#define map map<char,int>
#define repa(p,A) for(auto p:A)
#define pb push_back
#define sort(a) sort(a.begin(),a.end())
#define reverse(a) reverse(a.begin(),a.end())
const double PI=acos(-1);
using namespace std;
int main( ) {
ll N;
cin>>N;
ll count=1;
vec A(N);
rep(i,0,N) {
cin>>A[i];
if(A[i]==0) {
cout<<"0"<<endl;
return 0;
}
}
sort(A);
rep(i,0,N) {
if(A[i]<=1000000000000000000/count) {
count*=A[i];
}
else {
cout<<"-1"<<endl;
return 0;
}
}
cout<<count<<endl;
} | 0 | 21,054,816 |
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <queue>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define For(i, a, b) for(int i = (a); i < (b); i++)
#define Rep(i, n) For(i, 0, (n))
const int inf = 999999999;
const ll mod = 1000000007;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int main(){
ll n, m; cin >> n >> m;
ll a = 0, b = 0, x[n], y[m];
Rep(i, n){
cin >> x[i];
if(i > 0){
ll s = x[i] - x[i - 1]; s %= mod;
s *= (n - i) * i; s %= mod;
a += s; a %= mod;
}
}
Rep(i, m){
cin >> y[i];
if(i > 0){
ll s = y[i] - y[i - 1]; s %= mod;
s *= (m - i) * i; s %= mod;
ll t = (a * s) % mod;
b += t; b %= mod;
}
}
cout << b << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int n,m;
cin >> n >> m;
vector<pair<int,int>> work;
for(int i=0; i<n; i++){
int a,b;
cin >> a >> b;
pair<int, int> p = make_pair(a,b);
work.push_back(p);
}
sort(work.begin(), work.end());
priority_queue<ll> money;
int count=0;
ll ans=0;
for(int i=1; i<=m; i++){
if(count < n){
while(work.at(count).first==i){
money.push((ll)work.at(count).second);
count++;
if(count == n) break;
}
}
if(money.empty()) continue;
ans += money.top();
money.pop();
}
cout << ans << endl;
} | 0 | 12,697,627 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll GCD(ll x,ll y){
if(y == 0) return x;
else return GCD(y,x%y);
}
const int MOD = 1000000007;
int main() {
string s; cin >> s;
for(int i = 0; i < s.length();i++){
if(i % 2 == 0){
cout << s[i];
}
}
} | #include <bits/stdc++.h>
using namespace std;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
#ifdef __LOCAL
#define debug(x) cerr << __LINE__ << ": " << #x << " = " << x << endl
#define debugArray(x, n) \
cerr << __LINE__ << ": " << #x << " = {"; \
for (long long hoge = 0; (hoge) < (n); ++(hoge)) \
cerr << ((hoge) ? "," : "") << x[hoge]; \
cerr << "}" << endl
#else
#define debug(x) (void(0))
#define debugArray(x, n) (void(0))
#endif
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int y, m, d;
scanf("%d/%d/%d", &y, &m, &d);
cout << (m <= 4 ? "Heisei" : "TBD") << '\n';
return 0;
} | 0 | 28,608,004 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
#define repr(i, n) for(int i = n; i >= 0; i--)
#define reprl(i, n) for(ll i = n; i >= 0; i--)
#define all(v) v.begin(), v.end()
const ll mod=1000000007;
int countBits(int in){
int res=0;
for(int i=0;i<10;i++){
int msk=1<<i;
if((in&msk)!=0){
res++;
}
}
return res;
}
template<typename T>
void show2dVector(vector<vector<T>>& v){
for(int i=0;i<v.size();i++){
int m=v[i].size();
cout<<i<<" : ";
for(int j=0;i<m;i++){
cout<<v[i][j]<<" ";
}
cout<<endl;
}
}
void bfs(const vector<vector<int>>&g, int v, vector<bool>& seen){
seen[v]=true;
cout<<v<<" ";
for(auto next: g[v]){
if(seen[next]){
continue;
}
bfs(g,next,seen);
}
}
bool dfs(vector<vector<int>> &g,int start,int goal,vector<bool>&seen){
bool res=false;
seen[start]=true;
if(start==goal){
return true;
}
for(auto next: g[start]){
if(seen[next]){
continue;
}
res=dfs(g,next,goal,seen);
if(res){
break;
}
}
return res;
}
ll gcd(ll a,ll b) {
return b? gcd(b,a%b): a;
}
ll lcm(ll a,ll b) {
return a*b/gcd(a,b);
}
bool isLowerCase(char c){
return (c>='a'&&c<='z');
}
const string outputYesNo(bool ans){
return (ans?"Yes":"No");
}
int main() {
int x;cin>>x;
string ans;
if(x<1200)ans="ABC";
else ans="ARC";
cout<<ans<<endl;
return 0;
} | #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()
const int inf = 1e9+7;
const ll longinf = 1LL<<60;
const ll mod = 1e9+7;
const ld eps = 1e-10;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n; cin >> n;
vector<ll> A(n), B(n);
rep(i, n) cin >> A[i];
rep(i, n) cin >> B[i];
ll mx = accumulate(all(B), 0LL) - accumulate(all(A), 0LL);
ll cnt1 = 0, cnt2 = 0;
rep(i, n) if(A[i]<B[i]) {
cnt2 += (B[i]-A[i])/2;
if((B[i]-A[i])%2) cnt2++, cnt1++;
A[i] = B[i];
}
rep(i, n) if(A[i]>B[i]) {
cnt1 += A[i]-B[i];
B[i] = A[i];
}
cout << (cnt2<=mx&&cnt1<=mx ? "Yes" : "No") << "\n";
return 0;
} | 0 | 4,365,450 |
#include<iostream>
using namespace std;
int main(){
string s;
cin>>s;
for(int i=0;i<s.length();i++){
if(s[i]=='1') s[i]='9';
else if (s[i]=='9') s[i]='1';
}
cout<<s<<endl;
} | #include<iostream>
#include<vector>
#include<cmath>
using namespace std;
int main(){
int N, A, B_prev, B;
long long ans = 0;
std::cin >> N;
vector<int> Bs(N);
for(int i = 0; i < N-1; i++){
std::cin >> B;
if(i == 0){
ans = ans + B;
}else{
ans = ans + min(B, B_prev);
}
B_prev = B;
}
ans = ans + B;
std::cout << ans;
} | 0 | 75,762,720 |
#pragma GCC optimize ("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse4")
#include"bits/stdc++.h"
using namespace std;
typedef long long ll;
#define int ll
#define sz(x) (int)(x).size();
#define all(x) x.begin(), x.end()
#define trav(i,a) for(auto &i:a)
inline int in(){int x;scanf("%lld",&x);return x;}
int h[10]={0,2,5,5,4,5,6,3,7,6};
int32_t main()
{
int n=in();int m=in();
vector<char> a(m);
trav(i,a)cin>>i;
vector<string> dp(n+10);
dp[0]="";
for(int i=0;i<m;i++)
{
dp[h[a[i]-'0']]=max(dp[h[a[i]-'0']],(string)""+a[i]);
}
for(int i=0;i<=n;i++)
{
for(int j=0;j<m;j++)
{
if(dp[i]=="")continue;
if((i+h[a[j]-'0'])>n)continue;
if(dp[i+h[a[j]-'0']].size()>dp[i].size()+1)continue;
if(dp[i+h[a[j]-'0']].size()<dp[i].size()+1)
{
dp[i+h[a[j]-'0']]=dp[i]+a[j];
}
else
dp[i+h[a[j]-'0']]=max(dp[i]+a[j],dp[i+h[a[j]-'0']]);
}
}
cout<<dp[n];
} | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <numeric>
#include <cmath>
#include <iomanip>
#include <cstdio>
#include <set>
#include <map>
#include <list>
#include <cstdlib>
#include <queue>
#include <stack>
#include <bitset>
using namespace std;
#define MOD 1000000007
#define PI 3.1415926535897932
#define rep(i, n) for (int i = 0; i < n; i++)
#define repe(i, j, n) for (int i = j; i < n; i++)
#define repi(i, n) for (int i = 0; i <= n; i++)
#define repie(i, j, n) for (int i = j; i <= n; i++)
#define all(x) x.begin(), x.end()
#define println() cout << endl
#define P pair<int, int>
#define fi first
#define se second
typedef long long ll;
long long modinv(long long a, long long m)
{
long long b = m, u = 1, v = 0;
while (b)
{
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
void solve1()
{
int n, k; cin >> n >> k;
vector<int> h(n); rep(i, n) cin >> h[i];
int dp[n]; dp[0] = 0;
for(int i = 1; i < n; i++) {
int minval = dp[i-1] + abs(h[i]-h[i-1]);
for(int j = 1; j <= k && j - i <= 0; j++ ) {
minval = min(minval, dp[i - j] + abs(h[i] - h[i - j]));
}
dp[i] = minval;
}
cout << dp[n-1] << endl;
}
int main()
{
solve1();
} | 0 | 79,814,521 |
#include <bits/stdc++.h>
using namespace std;
const long long md=1e9+7;
long long a[505][505],n,h,w;
void show(){
for(int i=0;i<h;++i,cout<<'\n')
for(int j=0;j<w;++j)
if(a[i][j]==1) cout<<'R';
else if(a[i][j]==2) cout<<'Y';
else if(a[i][j]==3) cout<<'G';
else if(a[i][j]==0) cout<<'B';
}
int main(){
long long d,p,x=0,y=0,dx=0,dy=0,xx=0,yy=0;
cin>>h>>w>>d;
if(d%2){
for(int i=0;i<h;++i){
for(int j=0;j<w;++j)
a[i][j]=(i+j)%2;
}
}
else{
for(int i=0;i<h;++i){
for(int j=0;j<w;++j){
if(((i+j)/d)%2){
a[i][j]=2;
}
if(((i-j+w)/d)%2)
a[i][j]++;
}
}
}
show();
} | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int A[n];
for (int i = 0; i < n; ++i) {
int v;
scanf("%d", &v);
A[i] = v;
}
int L[n];
L[0] = A[0];
int length = 1;
for (int i = 1; i < n; ++i) {
if (L[length - 1] < A[i]) {
L[length++] = A[i];
} else {
for (int j = 0; j < length; ++j) {
if (L[j] >= A[i]) {
L[j] = A[i];
break;
}
}
}
}
cout << length << endl;
return 0;
} | 0 | 45,743,561 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr long long MOD = 1000000007;
constexpr long long INF = 1LL << 60;
const long double PI = acosl(-1.0);
constexpr long double EPS = 1e-11;
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main(){
ll h, w;
cin >> h >> w;
vector<string> grid(h);
for (ll i = 0; i < h; i++) cin >> grid[i];
vector<vector<ll>> left(h, (vector<ll>(w, 0))), right(h, (vector<ll>(w, 0))), up(h, (vector<ll>(w, 0))), down(h, (vector<ll>(w, 0)));
for (ll i = 0; i < h;i++){
for (ll j = 0; j < w;j++){
if (grid[i][j] == '#') left[i][j] = 0;
else if(j>0)
left[i][j] = left[i][j - 1] + 1;
else
left[i][j] = 1;
}
}
for (ll i = 0; i < h;i++){
for (ll j = w-1; j >=0;j--){
if (grid[i][j] == '#') right[i][j] = 0;
else if(j<w-1)
right[i][j] = right[i][j + 1] + 1;
else
right[i][j] = 1;
}
}
for (ll j = 0; j < w;j++){
for (ll i = 0; i < h;i++){
if(grid[i][j]=='#')up[i][j]=0;
else if(i>0)
up[i][j] = up[i - 1][j] + 1;
else
up[i][j] = 1;
}
}
for (ll j = 0; j < w;j++){
for (ll i = h-1; i >= 0;i--){
if(grid[i][j]=='#')down[i][j]=0;
else if(i<h-1)
down[i][j] = down[i + 1][j] + 1;
else
down[i][j] = 1;
}
}
ll ans = 0;
for (ll i = 0; i < h; i++) {
for (ll j = 0; j < w;j++){
chmax(ans, left[i][j] + right[i][j] + up[i][j] + down[i][j]);
}
}
cout << ans - 3 << endl;
} | #include <iostream>
#include <string>
#include <string.h>
using namespace std;
int main(){
int n;
cin >> n;
for(int i=0;i<n;i++){
string str1, str2;
string ans;
cin >> str1 >> str2;
int str_i=0, str_x=0, str_c=0, str_m=0;
char c1[9],c2[9];
strcpy(c1, str1.c_str());
strcpy(c2, str2.c_str());
for(int j=str1.size()-1;j>=0;j--){
if(c1[j]=='m'||c1[j]=='c'||c1[j]=='x'||c1[j]=='i') {
if(j>0){
if(c1[j-1]>='2'&&c1[j-1]<='9'){
if(c1[j]=='i') str_i+=(int)(c1[j-1]-'0');
if(c1[j]=='c') str_c+=(int)(c1[j-1]-'0');
if(c1[j]=='x') str_x+=(int)(c1[j-1]-'0');
if(c1[j]=='m') str_m+=(int)(c1[j-1]-'0');
}else{
if(c1[j]=='i') str_i++;
if(c1[j]=='c') str_c++;
if(c1[j]=='x') str_x++;
if(c1[j]=='m') str_m++;
}
}else{
if(c1[j]=='i') str_i++;
if(c1[j]=='c') str_c++;
if(c1[j]=='x') str_x++;
if(c1[j]=='m') str_m++;
}
}
}
for(int j=str2.size()-1;j>=0;j--){
if(c2[j]=='m'||c2[j]=='c'||c2[j]=='x'||c2[j]=='i') {
if(j>0){
if(c2[j-1]>='2'&&c2[j-1]<='9'){
if(c2[j]=='i') str_i+=(int)(c2[j-1]-'0');
if(c2[j]=='c') str_c+=(int)(c2[j-1]-'0');
if(c2[j]=='x') str_x+=(int)(c2[j-1]-'0');
if(c2[j]=='m') str_m+=(int)(c2[j-1]-'0');
}else{
if(c2[j]=='i') str_i++;
if(c2[j]=='c') str_c++;
if(c2[j]=='x') str_x++;
if(c2[j]=='m') str_m++;
}
}else{
if(c2[j]=='i') str_i++;
if(c2[j]=='c') str_c++;
if(c2[j]=='x') str_x++;
if(c2[j]=='m') str_m++;
}
}
}
if(str_i>=10){
str_i-=10;
str_x++;
}
if(str_x>=10){
str_x-=10;
str_c++;
}
if(str_c>=10){
str_c-=10;
str_m++;
}
if(str_m==1) ans = ans + 'm';
else if(str_m!=0) ans=ans+to_string(str_m)+'m';
if(str_c==1) ans = ans + 'c';
else if(str_c!=0) ans=ans+to_string(str_c)+'c';
if(str_x==1) ans = ans + 'x';
else if(str_x!=0) ans=ans+to_string(str_x)+'x';
if(str_i==1) ans = ans + 'i';
else if(str_i!=0) ans=ans+to_string(str_i)+'i';
cout << ans << endl;
}
return 0;
} | 0 | 90,925,461 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
int main() {
int N, M;
cin >> N >> M;
vector<bool> broken(N + 1);
for (int i = 0; i < M; i++) {
int a;
cin >> a;
broken[a] = true;
}
vector<int> dp(N + 2);
dp[N] = 1;
for (int i = N - 1; i >= 0; i--) {
if (broken[i]) {
dp[i] = 0;
continue;
}
dp[i] = (dp[i + 1] + dp[i + 2]) % MOD;
}
cout << dp[0] << endl;
} | #include <bits/stdc++.h>
#define irep(i,n) for(int i = 0; i < (int)(n); i++)
#define irep2(i,a,n) for(int i = (int)(a); i <= (int)(n); i++)
#define irrep(i,n) for(int i = (int)(n-1); i > -1; i--)
#define irrep2(i,n,a) for(int i = (int)(n); i >= (int)(a); i--)
#define fi first
#define se second
using ll = long long;
using v_int = std::vector<int>;
using v2_int = std::vector<v_int>;
using v_ll = std::vector<ll>;
using v2_ll = std::vector<v_ll>;
using v_string = std::vector<std::string>;
using v_bool = std::vector<bool>;
using v2_bool = std::vector<v_bool>;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;
using mii = std::map<int, int>;
using mll = std::map<ll, ll>;
const double PI = 3.1415926535897932;
const int INF = 2*(int)1e9;
const ll LINF = (ll)1e18;
const ll MOD = 1000000007;
const int dc[4] = {1, -1, 0, 0};
const int dr[4] = {0, 0, 1, -1};
using namespace std;
template<typename T, typename U> inline
ostream& operator<<(ostream &o, pair<T,U> &p)
{
return o << "{" << p.first << "," << p.second << "}";
}
template<typename T> inline
istream& operator>>(istream &is, vector<T> &v)
{
int len = (int)v.size();
for(int i = 0; i < len; i++) {
is >> v[i];
}
return is;
}
template<typename T> inline
ostream& operator<<(ostream &os, vector<T> &v)
{
int len = (int)v.size();
for(int i = 0; i < len; i++) {
os << v[i];
if(i != len-1) { os << ","; }
}
return os;
}
template<typename T> inline
void chmin(T &a, T b) { a = min(a, b); }
template<typename T> inline
void chmax(T &a, T b) { a = max(a, b); }
int main(void)
{
int n;
cin >> n;
string s;
cin >> s;
map<char,int> mp;
irep(i,n) {
mp[s[i]]++;
}
ll ans = 1;
for(auto c : mp) {
ans *= c.se+1;
ans %= MOD;
}
cout << ans - 1 << endl;
return 0;
} | 0 | 3,840,890 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string str[10] = {
".,!? ","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"
};
int n;
cin >> n;
while( n-- ){
string s;
cin >> s;
for(int i = 0; i < s.size(); i++){
if(s[i] == '0') continue;
int j = 0;
while( s[i+j] != '0' ) j++;
cout << str[ (int)s[i+j-1]-'1' ][ (j-1)%str[ (int)s[i]-'1' ].size()];
i += j;
}
cout << endl;
}
return 0 ;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = 1e9;
const ll LINF = ll(1e18);
const int MOD = 1000000007;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const int Dx[8] = {0, 1, 1, 1, 0, -1, -1, -1}, Dy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
#define yes cout << "Yes" << endl
#define YES cout << "YES" << endl
#define no cout << "No" << endl
#define NO cout << "NO" << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define ALL(v) v.begin(), v.end()
#define debug(v) \
cout << #v << ":"; \
for (auto x : v) \
{ \
cout << x << ' '; \
} \
cout << endl;
template <class T>
bool chmax(T &a, const T &b)
{
if (a < b)
{
a = b;
return 1;
}
return 0;
}
template <class T>
bool chmin(T &a, const T &b)
{
if (b < a)
{
a = b;
return 1;
}
return 0;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
string a,b,c;
cin>>a>>b>>c;
if(a.back()==b[0]&&b.back()==c[0])YES;
else NO;
} | 0 | 73,242,281 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(i=0;i<n;i++)
#define ll long long
#define all(v) v.begin(), v.end()
int main()
{
string s;cin>>s;
int i,j;
if(s.size()==26)
{
bool ok=false;
vector<char> suf(0);
suf.emplace_back(s[25]);
for(i=24;i>=0;i--)
{
if(s[i]<s[i+1])
{
char k=s[i+1];
rep(j,suf.size())
{
if(suf[j]>s[i]&&suf[j]<k)
{
k=suf[j];
}
}
cout<<s.substr(0,i)<<k<<endl;
ok=true;
break;
}
suf.emplace_back(s[i]);
}
if(!ok)cout<<-1<<endl;
}
else
{
char c;
for(c='a';c<='z';c++)
{
bool used=false;
rep(i,s.size())
{
if(s[i]==c)used=true;
}
if(used)continue;
cout<<s<<c<<endl;
break;
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define REPD(i, n) for (ll i = n - 1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (ll)(b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (ll)(b); i--)
int main()
{
cin.tie(0);
ios_base::sync_with_stdio(false);
int n;
ll y;
bool flg = false;
cin >> n >> y;
FOR(i, 0, n)
{
FOR(j, 0, n - i)
{
if (i * 10000 + j * 5000 + (n - i - j) * 1000 == y)
{
cout << i << " " << j << " " << n - i - j << endl;
flg = true;
i = j = n;
}
}
}
if (!flg)
{
cout << "-1 -1 -1" << endl;
}
return 0;
} | 0 | 13,603,261 |
#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++)
typedef long long ll;
using namespace std;
ll gcd(ll a, ll b) {
if (b==0) return a;
else return gcd(b, a%b);
}
ll lcm(ll a, ll b) {
return a * b / gcd(a, b);
}
ll digit_sum(ll a){
ll ans=0;
while(a>0){
ans+=a%10;
a/=10;
}
return ans;
}
int main()
{
ll n,a[110],max=0,min=1e15;
cin>>n;
rep(i,n){
cin>>a[i];
if(a[i]>max)max=a[i];
if(a[i]<min)min=a[i];
}
cout<<max-min<<endl;
return 0;
} | #include<stdio.h>
int main(void)
{
int mansions[4][3][10];
int m,w,h,d;
int n;
int i,j,k;
for(m = 0;m < 4;m++){
for(h = 0;h < 3;h++){
for(w = 0;w < 10;w++){
mansions[m][h][w] = 0;
}
}
}
scanf("%d",&n);
for(i = 0;i < n;i++){
scanf("%d %d %d %d",&m,&h,&w,&d);
if(0<m&&m<5&&0<h&&h<4&&0<w&&w<11)
mansions[m-1][h-1][w-1] += d;
}
for(m = 0;m < 4;m++){
for(h = 0;h < 3;h++){
for(w = 0;w < 10;w++){
printf(" %d",mansions[m][h][w]);
}
printf("\n");
}
if(m != 3)printf("####################\n");
}
return 0;
} | 0 | 41,337,143 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
#include <string>
#include <queue>
#include <cmath>
#include <numeric>
#include <list>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <climits>
#include <memory.h>
#include <memory>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <map>
#define _USE_MATH_DEFINES
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> PP;
typedef vector<int> vec;
typedef vector<vec> mat;
const int INF = 1 << 30;
const double EPS = 1e-9;
int nums[10000];
int main(){
int n, m, p;
while(cin >> n >> m >> p && (n || m || p)){
m--;
int sum = 0;
for(int i = 0; i < n; i++){
cin >> nums[i];
sum += 100 * nums[i];
}
if(nums[m] == 0) cout << 0 << endl;
else cout << (int)((double)sum / (double)100 * (100 - p) / nums[m]) << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define vec vector<int>
#define map map<int,int>
#define scn(t) scanf("%d",&t);
#define lscn(t) scanf("%lld",&t);
#define mod 1000000007
#define rep(i,a,b) for(int i=a;i<b;i++)
#define endl "\n"
using namespace std;
const int N=2e5+5;
int main()
{
string s;
cin>>s;
int l=s.length();
for(int i=0;i<l-1;i++)
{
if(s[i]==s[i+1])
{
cout<<i+1<<" "<<i+2<<endl;
return 0;
}
}
for(int i=0;i<l-2;i++)
{
if(s[i]==s[i+2])
{
cout<<i+1<<" "<<i+3<<endl;
return 0;
}
}
cout<<-1<<" "<<-1<<endl;
} | 0 | 98,005,456 |
#include <iostream>
using namespace std;
int main() {
int X;
cin >> X;
int kyu[] = {2000, 1800, 1600, 1400, 1200, 1000, 800, 600, 400};
for (int i = 0; i < 9; i++) {
if (X >= kyu[i]) {
cout << i << endl;
break;
}
}
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 | 58,407,887 |
#include<iostream>
#include<cmath>
using namespace std;
typedef long long ll;
const ll mod = 1e9+7;
const int maxn=2e5+10;
int f[maxn];
int q(int a, int b){
int ans = 1;
while(b){
if(b&1)ans = 1ll*ans*a%mod;
a=1ll*a*a%mod;
b>>=1;
}
return ans;
}
int main(){
ll ans, n, k;
cin >> n >> k;
ans=0;
for(ll i=k;i>=1;i--){
f[i]=q(k/i,n);
for(ll j=2*i;j<=k;j+=i){
f[i]=(f[i]-f[j]+mod)%mod;
}
}
for(ll i=1;i<=k;i++){
ans+=i*f[i]%mod;
ans%=mod;
}
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
int main()
{
long long int n,i,j,k=0,l,x;
scanf("%lld\n",&n);
x=n+1;
for(i=0;i<n;i++)
{
scanf("%lld",&j);
if(j<x)
{
k++;
x=j;
}
}
printf("%lld",k);
return 0;
} | 0 | 96,462,024 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string szo;
cin >> szo;
if (szo[2] == szo[3]) {
if (szo[4] == szo[5]) {
cout << "Yes";
} else {
cout << "No";
}
} else {
cout << "No";
}
return 0;
} | #include <iostream>
#define rep(i, n) for(int i=0; i<n; i++)
using namespace std;
int main(){
int x, y;
cin >> x >> y;
int firstB[2] = {-1, 1}, secondB[2] = {-1, 1};
int ans = 2000000000;
int tmpx, tmpy;
rep(i, 2){
rep(j, 2){
int tmp = 0;
tmpx = x*firstB[i];
if(firstB[i] == -1)
tmp++;
tmpy = y*secondB[j];
if(secondB[j] == -1)
tmp++;
if(tmpx > tmpy)
continue;
tmp = tmp + tmpy - tmpx;
ans = min(ans, tmp);
}
}
cout << ans << endl;
return 0;
} | 0 | 94,540,531 |
#include <cstdio>
#include <string>
using namespace std;
int main(void){
int n, m, i, j;
char org[257], x, y;
while(1){
scanf("%d%*c",&n);
if(!n){
break;
}
for(i = 0;i < 256;i++){
org[i] = (char)i;
}
for(i = 0;i < n;i++){
scanf("%c%*c%c%*c",&x,&y);
org[x] = y;
}
scanf("%d%*c",&m);
for(i = 0;i < m;i++){
x = getchar();
getchar();
printf("%c",org[x]);
}
printf("\n");
}
return 0;
} | #include<stdio.h>
int main()
{
int N;
scanf("%d",&N);
char S[100];
int total;
scanf("%s",&S);
for (int i=0;i< N/2;i++){
if (S[i] == S[i + N/2]){
total++;
}
}
if (N % 2 == 1) {
printf("No");
return 0;
}
total == N/2 ? printf ("Yes\n") : printf ("No\n");
return 0;
} | 0 | 66,421,930 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define trav(a, x) for (auto& a : x)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
int main() {
cin.sync_with_stdio(false); cin.tie(0);
cin.exceptions(cin.failbit);
int R, G, B, N; cin >> R >> G >> B >> N;
int acc = 0;
for (int r = 0; r * R <= N; r++)
for (int b = 0; r * R + b * B <= N; b++)
if ((N - r * R - b * B) % G == 0)
acc++;
cout << acc << endl;
} | #define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<vector>
#include<functional>
#include<algorithm>
#include<stdlib.h>
#include<string>
#include<string.h>
#define _USE_MATH_DEFINES
#include<math.h>
#include<deque>
#include<set>
#include<map>
#include<queue>
#include<list>
#include<iostream>
#include <bitset>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(auto i=a;i<b;i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x *= x; p /= 2; } else { a *= x; p--; } }return a; }
ll mpower(ll x, ll p) { ll a = 1; while (p > 0) { if (p % 2 == 0) { x = x * x % mod; p /= 2; } else { a = a * x % mod; p--; } }return a; }
ll ac(ll n, ll k) { ll a = 1; rep(i, 1, k) { a *= n - i + 1; a /= i; }return a; }
ll mc(ll n, ll m) { ll k = 1, l = 1; rep(i, n - m + 1, n + 1) k = k * i % mod; rep(i, 1, m + 1) l = l * i % mod; l = mpower(l, mod - 2); return k * l % mod; }
vector<int> ans, f;
set<int> k;
vector<vector<int>> G;
void dfs(int v) {
ans.push_back(v);
for (auto n : G[v]) {
if (f[n] == 0) {
f[n] = 1;
k.insert(n);
}
}
if (k.size()) {
int nv = *k.begin();
k.erase(*k.begin());
dfs(nv);
}
}
int main()
{
int n;
cin >> n;
vector<int> a(n), b(n);
rep(i, 0, n)cin >> a[i];
sort(all(a));
rep(i, 0, n)b[i] = a[i];
int k;
auto it = lower_bound(all(a), 0);
if (it == a.end()) {
it = a.end() - 1;
}
k = it - a.begin();
if (k == 0)k++;
rep(i, k, n - 1) {
b[0] -= b[i];
}
rep(i, 1, k) {
b[n - 1] -= b[i];
}
printf("%d\n", b[n - 1] - b[0]);
rep(i, k, n - 1){
printf("%d %d\n", a[0], a[i]);
a[0] -= a[i];
}
rep(i, 1, k) {
printf("%d %d\n", a[n - 1], a[i]);
a[n - 1] -= a[i];
}
printf("%d %d\n", a[n - 1], a[0]);
return 0;
} | 0 | 9,710,070 |
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep(i,n) for(ll i=0;i<(n);i++)
#define pll pair<ll,ll>
#define pq priority_queue
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define ios ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define lb(c,x) distance(c.begin(),lower_bound(all(c),x))
#define ub(c,x) distance(c.begin(),upper_bound(all(c),x))
using namespace std;
template<class T> inline bool chmax(T& a,T b){if(a<b){a=b;return 1;}return 0;}
template<class T> inline bool chmin(T& a,T b){if(a>b){a=b;return 1;}return 0;}
const ll INF=1e18;
int main(){
string s,t;
cin >> s >> t;
ll i=0;
while(true){
if(i%2==0 && i/2==s.length()) break;
if(i%2==1 && i/2==t.length()) break;
if(i%2==0) cout << s[i/2];
else cout << t[i/2];
i++;
}
cout << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <numeric>
#include <string>
#include <vector>
#define fastio \
ios_base::sync_with_stdio(false); \
cin.tie(0);
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> a(3, vector<int>(n));
for (int t = 0; t < n; t++) cin >> a[0][t] >> a[1][t] >> a[2][t];
vector<vector<int>> dp(3, vector<int>(n, numeric_limits<int>::min()));
dp[0][0] = a[0][0];
dp[1][0] = a[1][0];
dp[2][0] = a[2][0];
for (int t = 1; t < n; t++) {
for (int s = 0; s < 3; s++) {
for (int r = 0; r < 3; r++) {
if (s == r) continue;
dp[s][t] = max(dp[s][t], dp[r][t - 1] + a[s][t]);
}
}
}
cout << max(dp[0][n - 1], max(dp[1][n - 1], dp[2][n - 1]));
return 0;
} | 0 | 62,964,470 |
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int n, x;
bool a[105];
int main() {
cin >> x >> n;
for (int i=0; i<n; i++) {
int t; cin >> t; a[t]=1;
}
int d=0;
while (true) {
if (!a[x-d]) {cout << x-d; return 0;}
if (!a[x+d]) {cout << x+d; return 0;}
d++;
}
} | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const ll mod = 1000000007;
const int INF = 1001001001;
const ll LINF = 1001001001001001001;
int main(){
ll n ; cin >> n;
vector<ll> a(n);
rep(i,n) cin >> a.at(i);
ll ans = 0;
bool flag = false;
rep(i,n){
ll x = a.at(i);
ans += x/2;
bool flag2 = false;
if(x==1 && flag) flag2 = true;
if(i<(n-1) && x%2 && !flag2){
a.at(i+1)++;
flag = true;
}else{
flag = false;
}
}
cout << ans << endl;
} | 0 | 79,934,027 |
#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 A, B;
cin >> A >> B;
int ans = -1;
rep(i,1500) {
int tax8 = i * 8 / 100.0;
int tax10 = i * 10 / 100.0;
if (tax8 == A && tax10 == B) {
ans = i;
break;
}
}
cout << ans << endl;
} | #include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
const long long MOD = 1000000007;
#define SET(x) memset(x, 0, sizeof(x))
#define SET2d(x,m,n) memset(x, 0, sizeof(x[0][0]) * m * n)
#define SETBOOL(x) memset(x,false,sizeof(x))
#define CLR(x) memset(x, -1, sizeof(x))
#define CLR2d(x,m,n) memset(x, -1, sizeof(x[0][0]) * m * n)
#define mp make_pair
#define PII pair<int, int>
#define pf printf
#define sf scanf
#define ALL(x) x.begin(),x.end()
#define pb push_back
#define IOS ios::sync_with_stdio(false); cin.tie(0);
#define np std::string::npos
#define highest(x) numeric_limits<x>::max()
#define lowest(x) numeric_limits<x>::min()
#define Inf INFINITY
#define minv(v) *min_element(v.begin(),v.end())
#define maxv(v) *max_element(v.begin(),v.end())
#define cases(cs,t) for(int cs=1;cs<=t;cs++)
#define PI acos(-1)
#define no1 __builtin_popcount
#define BOUNDARY(i, j) ((i >= 0 && i < row) && (j >= 0 && j < column))
#define uniq(vec) vec.resize(distance(vec.begin(),unique(vec.begin(),vec.end())))
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define sz(a) int(a.size())
#define ff first
#define ss second
#define endl "\n"
#define forch(it,s) for(auto it:s)
#define each(it,s) for(auto it = s.begin(); it != s.end(); ++it)
#define rep(i,a) for(int i=0; i<a;i++)
#define rep1(i,a,b) for(int i=(a);i<=(b);++i)
#define irep(i,b,a) for(int i=(b);i>=(a);--i)
#define bits(n) __builtin_popcount(n)
#define maxpq priority_queue<int>
#define minpq priority_queue<int, vector<int>, greater<int> >
int gcd(int a, int b) { if (a == 0) return b; return gcd(b % a, a);}
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pair<int,int>> vpii;
typedef tree<pair<int, int>,null_type,less<pair<int, int>>,rb_tree_tag,tree_order_statistics_node_update> ordered_multiset;
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1,-1, 1, -1, 0, 0, -1, 1};
int dx4[] = {0, 0, 1, -1};
int dy4[] = {1, -1, 0, 0};
const int maxx=100005;
bool sortinrev(const pair<int,int> &a,const pair<int,int> &b)
{
return a.first>b.first;
}
template<typename T>inline T Bigmod(T base, T power, T MOD){
T ret=1;
while(power)
{
if(power & 1)ret=(ret*base)%MOD;
base=(base*base)%MOD;
power>>=1;
}
return ret;
}
double sq(double x) {return x*x;}
ll po(ll b,ll p){
ll res=1;
while(p){
res*=b;
p--;
}
return res;
}
ll lg2(ll x){
ll res=0;
while(x>1){
res++;
x/=2ll;
}
return res;
}
void solve(){
int n;
cin>>n;
vi vec(n);
rep(i,n){
cin>>vec[i];
}
int cnt=0;
int j=1;
int i=0;
while(i<n){
if(vec[i]==j){
i++;
j++;
cnt++;
}
else{
i++;
}
}
if(cnt==0){
cout<<-1<<endl;
return;
}
cout<<n-cnt<<endl;
}
signed main()
{
IOS;
int t;
t=1;
while(t--){
solve();
}
return 0;
} | 0 | 68,359,052 |
#include <iostream>
#include <vector>
using namespace std;
int main()
{
const int INF = 1e9+7;
int n;
cin>>n;
vector<vector<int>> inp(n,vector<int>(3)), dp(n,vector<int>(3,0));
for(int i=0;i<n;++i){
cin>>inp[i][0]>>inp[i][1]>>inp[i][2];
}
dp[0][0] = inp[0][0];
dp[0][1] = inp[0][1];
dp[0][2] = inp[0][2];
for(int i=1;i<n;++i){
dp[i][0] = inp[i][0]+max(dp[i-1][1],dp[i-1][2]);
dp[i][1] = inp[i][1]+max(dp[i-1][0],dp[i-1][2]);
dp[i][2] = inp[i][2]+max(dp[i-1][0],dp[i-1][1]);
}
cout<<max(dp[n-1][0],max(dp[n-1][1],dp[n-1][2]));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define MOD 1000000007
#define rep(i, n) for(ll (i) = 0LL;(i) < (ll)(n);(i)++)
#define rep2(i, s, e) for(ll (i) = (ll)(s);(i) < (ll)(e);(i)++)
#define repi(i, n) for(ll (i) = 0LL;(i) <= (ll)(n);(i)++)
#define repi2(i, s, e) for(ll (i) = (ll)(s);(i) <= (ll)(e);(i)++)
#define per(i, n) for(ll (i) = (ll)(n) - 1LL;(i) >= 0LL;(i)--)
#define per2(i, s, e) for(ll (i) = (ll)(s) - 1LL;(i) >= (ll)(e);(i)--)
#define peri(i, n) for(ll (i) = (ll)(n);(i) >= 0LL;(i)--)
#define peri2(i, s, e) for(ll (i) = (ll)(s);(i) >= (ll)(e);(i)--)
#define iter(i, it) for(auto &(i): (it))
template<typename T, typename U> ostream& operator<<(ostream &s, const pair<T, U> m) {
cout << "(" << m.first << ", " << m.second << ")";
return s;
}
template<typename T, typename U> ostream& operator<<(ostream &s, const map<T, U> m) {
ll c = 0;
cout << "{ ";
iter(i, m) cout << i << (c++ == m.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const vector<T> &v) {
cout << "{ ";
rep(i, v.size()) cout << v[i] << (i == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const list<T> &v) {
ll c = 0;
cout << "{ ";
iter(i, v) cout << i << (c++ == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
int main(void) {
ll N;
ll prev = 0;
ll count = 0;
map<ll, ll> S;
cin >> N;
S[0]++;
rep(i, N) {
ll temp;
cin >> temp;
prev += temp;
S[prev]++;
}
iter(i, S) count += i.second * (i.second - 1) / 2;
cout << count << endl;
return 0;
} | 0 | 14,218,372 |
#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define rep(i,n) for(int i=0;i<n;i++)
#define pb push_back
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
using namespace std;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
ll x;
ll a = 0, b = 0;
map<ll, int> m;
cin >> n;
rep(i,n){
cin >> x;
m[x]++;
}
map<ll, int>::reverse_iterator it = m.rbegin();
for(it; it!=m.rend(); it++){
if(it -> second > 1){
if(a==0 && b == 0 && it->second >= 4){
a = it->first;
b = it->first;
break;
}
else if(a == 0 && it->second >= 2){
a = it->first;
}
else if(a != 0 && b==0 && it->second >=2){
b = it->first;
break;
}
}
}
cout << a*b;
return 0;
} | # include <bits/stdc++.h>
typedef long long lint;
using namespace std;
lint gcd(lint x, lint y) {
if(x == 0) { return y; }
else { return gcd(y%x,x); }
}
lint lcm(lint x, lint y) { return x/gcd(x,y)*y; }
lint C(lint n, lint k) {
if(n == k) { return 1; }
else if(n < k) { return 0; }
else if(k == 0) { return 1; }
else if(k == 1) { return n; }
else return C(n-1,k-1) + C(n-1,k);
}
lint P(lint n, lint k) {
if(k == 1) { return n; }
return (n*(P(n-1,k-1)%1000000007)%1000000007);
}
int main() {
lint n; cin >> n;
vector<lint> a(n),b(n);
for(lint i=0;i<n;i++) { cin >> a[i]; }
for(lint i=0;i<n;i++) { cin >> b[i]; }
vector<lint> d(n);
for(lint i=0;i<n;i++) { d[i] = a[i]-b[i]; }
sort(d.begin(),d.end());
lint sum=0, cnt=0;
for(lint i=0;i<n;i++) {
if(d[i] < 0) {
cnt++;
sum += d[i];
}
}
for(lint i=n-1;i>=0;i--) {
if(sum < 0 && d[i] > 0) {
sum += d[i];
cnt++;
}
if(sum >= 0) {
cout << cnt << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
} | 0 | 74,751,802 |
#include <stdio.h>
#include <algorithm>
#include <utility>
#include <functional>
#include <cstring>
#include <queue>
#include <stack>
#include <cmath>
#include <iterator>
#include <vector>
#include <string>
#include <set>
#include <iostream>
#include <random>
#include <map>
#include <iomanip>
#include <stdlib.h>
#include <list>
#include <typeinfo>
#include <list>
#include <set>
#include <cassert>
#include <fstream>
#include <unordered_map>
#include <cstdlib>
#include <complex>
#include <cctype>
#include <bitset>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using pll = pair<ll, ll>;
using qll = queue<ll>;
using vb = vector<bool>;
using mll = map<ll, ll>;
using sll = stack<ll>;
#define REP(i,n) for(ll i(0);(i)<(n);(i)++)
#define rep(i,n) for(ll i(0);(i)<(n);(i)++)
#define ALL(a) a.begin(), a.end()
#define elnd endl
const ll INF = 1LL << 60;
void add_edge(vector<vll> &G, ll u, ll v){
G[u].push_back(v); G[v].push_back(u);
}
bool dfs(vector<vll> &G, vb &checked, vll &match, ll v){
checked[v] = true;
REP(i, G[v].size()){
ll u = G[v][i], w = match[u];
if(w < 0 || !checked[w] && dfs(G, checked, match, w)){
match[v] = u;
match[u] = v;
return true;
}
}
return false;
}
ll BipartiteMatching(vector<vll> &G){
ll N = G.size();
vb checked(N, false);
vll match(N, -1);
ll res = 0;
REP(v, N){
if(match[v] < 0){
fill(ALL(checked), false);
if(dfs(G, checked, match, v)){
res++;
}
}
}
return res;
}
void solve(long long N, std::vector<long long> a, std::vector<long long> b, std::vector<long long> c, std::vector<long long> d){
vector<vll> G(2*N);
REP(i, N){
REP(j, N){
if(a[i] < c[j] && b[i] < d[j]){
add_edge(G, i, j+N);
}
}
}
ll m = 0;
m = BipartiteMatching(G);
cout<<m<<endl;
}
void solve_old(long long N, std::vector<long long> a, std::vector<long long> b, std::vector<long long> c, std::vector<long long> d){
map<pll, bool> points;
int cnt = 0;
for (int i = 0; i < N; i++)
{
points[pll(a[i], b[i])] = true;
points[pll(c[i], d[i])] = false;
}
map<pll, bool>::iterator it, it_inner;
while(true){
bool pairFound = false;
for(it = points.begin(); it != points.end(); it++){
if(it->second){
for(it_inner = points.begin(); it_inner != it; it_inner ++){
if(it_inner->second == false && it->first < it_inner->first){
pairFound = true;
break;
}
}
}
if(pairFound) break;
}
if(pairFound){
cnt ++;
points.erase(it);
points.erase(it_inner);
}
else{
break;
}
}
cout << cnt << endl;
}
int main(){
long long N;
scanf("%lld",&N);
std::vector<long long> a(N);
std::vector<long long> b(N);
for(int i = 0 ; i < N ; i++){
scanf("%lld",&a[i]);
scanf("%lld",&b[i]);
}
std::vector<long long> c(N);
std::vector<long long> d(N);
for(int i = 0 ; i < N ; i++){
scanf("%lld",&c[i]);
scanf("%lld",&d[i]);
}
solve(N, std::move(a), std::move(b), std::move(c), std::move(d));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int H,W;
cin >> H >> W;
char a[H][W];
for ( int i = 0; i < H; ++i){
for ( int j = 0; j < W; ++j){
cin >> a[i][j];
}
}
int hcount = 0;
bool flg = true;
vector<int> h(H,0);
for ( int i = 0; i < H; ++i){
flg = true;
for ( int j = 0; j < W; ++j){
if ( a[i][j] == '#' ) {
flg = false;
h[i] = 1;
}
}
if ( flg ) ++ hcount;
}
char a2[H-hcount][W];
int idx = 0;
for ( int i = 0; i < H; ++i){
if ( h[i] == 0 ) continue;
for ( int j = 0; j < W; ++j){
a2[idx][j] = a[i][j];
}
++idx;
}
int wcount = 0;
vector<int> w(W,0);
for ( int i = 0; i < W; ++i){
flg = true;
for ( int j = 0; j < H-hcount; ++j){
if ( a2[j][i] == '#' ){
flg = false;
w[i] = 1;
}
}
if ( flg ) ++ wcount;
}
char a3[H-hcount][W-wcount];
idx = 0;
for ( int i = 0; i < W; ++i){
if ( w[i] == 0 ) continue;
for ( int j = 0; j < H-hcount; ++j){
a3[j][idx] = a2[j][i];
}
++idx;
}
for ( int i = 0; i < H-hcount; ++i){
for ( int j = 0; j < W-wcount; ++j){
cout << a3[i][j];
}
cout << endl;
}
return 0;
} | 0 | 70,186,722 |
#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
#define MAX_C 1000000001
int main() {
int n, k;
cin >> n >> k;
vector<ll> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
ll cost = 1000000000LL * 30;
for (int i = 0; i < (1 << (n-1)); i++) {
ll temp_cost = 0;
bitset<14>b(i);
if (b.count() != k-1) continue;
ll height = a[0];
for (int j = 0; j < n-1; j++) {
if (i & (1 << j)) {
height++;
if (height < a[j+1]) height = a[j+1];
temp_cost += (height - a[j+1]);
}
else if (height < a[j+1]) height = a[j+1];
}
if (cost > temp_cost) cost = temp_cost;
}
cout << cost << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define MOD 1000000007
#define rep(i, n) for(ll (i) = 0LL;(i) < (ll)(n);(i)++)
#define rep2(i, s, e) for(ll (i) = (ll)(s);(i) < (ll)(e);(i)++)
#define repi(i, n) for(ll (i) = 0LL;(i) <= (ll)(n);(i)++)
#define repi2(i, s, e) for(ll (i) = (ll)(s);(i) <= (ll)(e);(i)++)
#define per(i, n) for(ll (i) = (ll)(n) - 1LL;(i) >= 0LL;(i)--)
#define per2(i, s, e) for(ll (i) = (ll)(s) - 1LL;(i) >= (ll)(e);(i)--)
#define peri(i, n) for(ll (i) = (ll)(n);(i) >= 0LL;(i)--)
#define peri2(i, s, e) for(ll (i) = (ll)(s);(i) >= (ll)(e);(i)--)
#define iter(i, it) for(auto &(i): (it))
template<typename T, typename U> ostream& operator<<(ostream &s, const pair<T, U> m) {
cout << "(" << m.first << ", " << m.second << ")";
return s;
}
template<typename T, typename U> ostream& operator<<(ostream &s, const map<T, U> m) {
ll c = 0;
cout << "{ ";
iter(i, m) cout << i << (c++ == m.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const vector<T> &v) {
cout << "{ ";
rep(i, v.size()) cout << v[i] << (i == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const list<T> &v) {
ll c = 0;
cout << "{ ";
iter(i, v) cout << i << (c++ == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
int main(void) {
ll X;
cin >> X;
repi2(i, 1, 1000) {
ll temp = i * 100;
if(temp > X) break;
if(X % temp <= (5 * i)) {
cout << 1 << endl;
return 0;
}
}
cout << 0 << endl;
return 0;
} | 0 | 59,656,768 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int,int>;
constexpr ll INF = 9e18;
constexpr int inf = 1e9;
const double INFD = 1e100;
const ll mod = 1000000007;
const double PI = 3.1415926535897932384626433832795028841971;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -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;
};
template<typename T> inline string toString(const T &a){
ostringstream oss;
oss << a;
return oss.str();
};
int main(){
int N;
cin >> N;
vector<ll> A(N+1),B(N+1);
ll a=N+1,b=(N+1)*N;
for(int i=1; i<=N; i++){
A[i] = a;
B[i] = b;
a += N+1;
b -= N+1;
}
int cnt = 0;
for(int i=0; i<N; i++){
int p;
cin >> p;
A[p] += cnt;
cnt++;
}
for(int i=1; i<=N; i++){
cout << A[i];
if(i != N){
cout << " ";
}else{
printf("\n");
}
}
for(int i=1; i<=N; i++){
cout << B[i];
if(i != N){
cout << " ";
}else{
cout << '\n';
}
}
return 0;
} | #include <iostream>
#include <algorithm>
#include <complex>
#include <utility>
#include <vector>
#include <string>
#include <queue>
#include <tuple>
#include <cmath>
#include <bitset>
#include <cctype>
#include <set>
#include <map>
#include <numeric>
#include <functional>
#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(ll i=ll(a);i<ll(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define PRINT(V) cout << V << "\n"
#define SORT(V) sort((V).begin(),(V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
using namespace std;
using ll = long long;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
inline void Yes(bool condition){ if(condition) PRINT("Yes"); else PRINT("No"); }
template<class itr> void cins(itr first,itr last){
for (auto i = first;i != last;i++){
cin >> (*i);
}
}
template<class itr> void array_output(itr start,itr goal){
string ans = "",k = " ";
for (auto i = start;i != goal;i++) ans += to_string(*i)+k;
if (!ans.empty()) ans.pop_back();
PRINT(ans);
}
ll gcd(ll a, ll b) {
return a ? gcd(b%a,a) : b;
}
const ll INF = 1e18;
const ll MOD = 1000000007;
typedef pair<ll,ll> P;
const ll MAX = 100005;
constexpr ll nx[8] = {1,0,-1,0,-1,-1,1,1};
constexpr ll ny[8] = {0,1,0,-1,-1,1,-1,1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<ll> a(n);
cins(all(a));
RSORT(a);
ll cnt = 0,k = 0;
rep(i,n) k += a[i];
if (k > n*(n-1)) k -= n*(n-1);
else k = 0;
cnt += k;
if (k > 0){
rep(i,n) a[i] += k;
}
rep(i,n){
if (k > 0 && a[i] > n-1){
ll c = (a[i]-(n-1))/(n+1);
if ((a[i]-(n-1))%(n+1)) c++;
a[i] -= min(c,k)*(n+1);
k -= min(c,k);
}
}
while(*max_element(all(a)) >= n){
RSORT(a);
a[0] -= n;
rep(i,1,n) a[i]++;
cnt++;
}
PRINT(cnt);
} | 0 | 51,296,839 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
long long n, r1, r2, r3, r4, r5, r6, r7, r8, r9, sum;
cin >> n;
r1 = n%10;
r2 = (n%100)/10;
r3 = (n%1000)/100;
r4 = (n%10000)/1000;
r5 = (n%100000)/10000;
r6 = (n%1000000)/100000;
r7 = (n%10000000)/1000000;
r8 = (n%100000000)/10000000;
r9 = (n%1000000000)/100000000;
sum = r1+r2+r3+r4+r5+r6+r7+r8+r9;
if((n % sum) == 0) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, from, to) for (int i = from; i < (to); ++i)
#define mp(x,y) make_pair(x,y)
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
#define pb push_back
using ll = long long;
using vin=vector<int>;
using vll=vector<ll>;
using vst=vector<string>;
using P = pair<int, int>;
const int inf=1e9+7;
const ll INF=9e18;
template <typename T> bool chmin(T &a, const T& b){if(a > b){a = b;return true;}return false;}
template <typename T> bool chmax(T &a, const T& b){if(a < b){a = b;return true;}return false;}
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
template<class T> inline void YES(T condition){ if(condition) cout << "YES" << endl; else cout << "NO" << endl; }
const int dx[4] = { 1, 0, -1, 0 };
const int dy[4] = { 0, 1, 0, -1 };
int main(){cout<<fixed<<setprecision(20);
int n,m;
cin>>n>>m;
vin a(n),b(n);
vin c(m),d(m);
rep(i,0,n)cin>>a[i]>>b[i];
rep(i,0,m)cin>>c[i]>>d[i];
rep(i,0,n){
int ans=0;
int cnt=inf;
rep(j,0,m){
if(chmin(cnt,abs(a[i]-c[j])+abs(b[i]-d[j]))){
ans=j+1;
}
}
cout<<ans<<endl;
}
} | 0 | 91,203,850 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(ll i = 0, i##_len = (n); i < i##_len; ++i)
#define rep2(i, x, n) for(ll i = x, i##_len = (n); i < i##_len; ++i)
#define all(n) begin(n), end(n)
using ll = long long;
using P = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vs = vector<string>;
using vc = vector<char>;
using vb = vector<bool>;
using vd = vector<double>;
vi dir = {-1, 0, 1, 0, -1, -1, 1, 1, -1};
int main() {
ll k, n;
cin >> k >> n;
vl a(n);
rep(i, n) cin >> a[i];
ll ans = a[n - 1] - a[0];
rep(i, n - 1) ans = min(ans, k - a[i + 1] + a[i]);
cout << ans << endl;
} | #include <iostream>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <cmath>
#include <ctime>
#include <queue>
#include <map>
#include <set>
#include <tuple>
#include <functional>
#include <cassert>
#include <bitset>
#include <numeric>
using namespace std;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
#define ALL(x) (x).begin(),(x).end()
#define RALL(x) (x).rbegin(),(x).rend()
#define SIZE(x) (int)(x).size()
#define SIZEL(x) (ll)(x).size()
#define MSG(a) cout << #a << " " << a << endl;
using ll = long long;
using ld = long double;
using Graph = vector<vector<int>>;
const double PI = 3.14159265358979323846;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll gcd(ll x, ll y) { return (x % y)? gcd(y, x % y): y; }
ll lcm(ll x, ll y) { return x / gcd(x, y) * y; }
int main()
{
string s, t;
cin >> s >> t;
vector<int> sCnt(26, 0);
vector<int> tCnt(26, 0);
REP(i, s.size()){
sCnt[s[i]-'a']++;
tCnt[t[i]-'a']++;
}
sort(ALL(sCnt));
sort(ALL(tCnt));
REP(i, sCnt.size()){
if (sCnt[i]!=tCnt[i]){
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
} | 0 | 29,678,560 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using db = double;
using ld = long double;
template<typename T> using V = vector<T>;
template<typename T> using VV = vector<vector<T>>;
#define fs first
#define sc second
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define eb emplace_back
#define lb lower_bound
#define ub upper_bound
#define all(v) (v).begin(),(v).end()
#define siz(v) (ll)(v).size()
#define rep(i,a,n) for(ll i=a;i<(ll)(n);++i)
#define repr(i,a,n) for(ll i=n-1;(ll)a<=i;--i)
#define ENDL '\n'
typedef pair<int,int> Pi;
typedef pair<ll,ll> PL;
constexpr ll mod = 1000000007;
constexpr ll INF = 1000000099;
constexpr ll LINF = (ll)(1e18 +99);
const vector<ll> dx={-1,1,0,0},dy={0,0,-1,1};
template<typename T,typename U> inline bool chmin(T& t, const U& u){if(t>u){t=u;return 1;}return 0;}
template<typename T,typename U> inline bool chmax(T& t, const U& u){if(t<u){t=u;return 1;}return 0;}
template<typename T> inline T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<typename T,typename Y> inline T mpow(T a, Y n) {
T res = 1;
for(;n;n>>=1) {
if (n & 1) res = res * a;
a = a * a;
}
return res;
}
template<typename T,typename Y>
ostream& operator<<(ostream& os,const pair<T,Y>& p){
return os<<"{"<<p.fs<<","<<p.sc<<"}";
}
template<typename T> ostream& operator<<(ostream& os,const V<T>& v){
os<<"{";
for(auto e:v)os<<e<<",";
return os<<"}";
}
template<typename ...Args>
void debug(Args&... args){
for(auto const& x:{args...}){
cerr<<x<<' ';
}
cerr<<ENDL;
}
VV<int> e;
V<ll> v;
bool dfs(int now,int pre){
if(siz(e[now])==1)return true;
ll sum=0,nex,rem;
V<ll> c(0);
for(auto&& to:e[now]){
if(to==pre)continue;
if(!dfs(to,now))return false;
c.pb(v[to]);
sum+=v[to];
}
if(sum<v[now])return false;
nex=2*v[now]-sum;
if(pre==-1 && nex!=0)return false;
rem=(sum-nex);
v[now]=nex;
rep(i,0,siz(c)){
if(c[i]>rem/2)nex-=c[i]-(rem/2);
}
if(nex<0)return false;
else return true;
}
signed main(){
cin.tie(0);cerr.tie(0);ios::sync_with_stdio(false);
cout<<fixed<<setprecision(20);
ll n;cin>>n;
e.assign(n,V<int>(0));
v.resize(n);
rep(i,0,n)cin>>v[i];
rep(i,0,n-1){
int a,b;cin>>a>>b;
a--;b--;
e[a].pb(b);
e[b].pb(a);
}
if(n==2){
if(v[0]==v[1])cout<<"YES"<<ENDL;
else cout<<"NO"<<ENDL;
return 0;
}
rep(i,0,n){
if(siz(e[i])>1){
if(dfs(i,-1))cout<<"YES"<<ENDL;
else cout<<"NO"<<ENDL;
return 0;
}
}
} | #include<bits/stdc++.h>
#include<vector>
#include<string>
#include<algorithm>
#include<cmath>
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define int long long int
#define mod 1000000007
#define inf 1e18+42
#define endl "\n"
#define pi 3.1415926535897932384626433832795028841971693993751058
#define maxn 100005
#define out1(a) cout<<#a<<" "<<a<<endl
#define out2(a,b) cout<<#a<<" "<<a<<" "<<#b<<" "<<b<<endl
#define out3(a,b,c) cout<<#a<<" "<<a<<" "<<#b<<" "<<b<<" "<<#c<<" "<<c<<endl
#define rep(i,a,b) for(int i=a;i<b;i++)
#define repr(i,a,b) for(int i=a;i>=b;i--)
#define fori(it,A) for(auto it=A.begin();it!=A.end();it++)
#define ft first
#define sd second
#define pb push_back
#define mp make_pair
#define pq priority_queue
#define all(x) (x).begin(),(x).end()
#define zero(x) memset(x,0,sizeof(x));
#define ceil(a,b) (a+b-1)/b
using namespace std;
int binpow(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1)
res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
void solve()
{
int r,d,x;
cin>>r>>d>>x;
rep(i,0,10){
cout<<r*x - d<<endl;
x = r*x - d;
}
}
signed main()
{
fast;
int t = 1;
while(t--)
{
solve();
}
return 0;
} | 0 | 68,224,174 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF 1e9
typedef long long ll;
int main() {
ll A,B; cin >> A >> B;
if(A%2==0 && B%2!=0){
if((B-A+1)%4 == 0){
cout << 0 << endl;
}else{
cout << 1 << endl;
}
}else if(A%2==0 && B%2==0){
if((B-A)%4 == 0){
cout << B << endl;
}else{
cout << (B^1) << endl;
}
}else if(A%2!=0 && B%2!=0){
if((B-A)%4 == 0){
cout << A << endl;
}else{
cout << (A^1) << endl;
}
}else if(A%2!=0 && B%2==0){
if((B-A-1)%4 == 0){
cout << (A^B) << endl;
}else{
cout << ((A^B)^1) << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
#define WHOLE(v) (v).begin(), (v).end()
#define REV_WHOLE(v) (v).rbegin(), (v).rend()
using i64 = int64_t;
using namespace std;
template<typename T>
using vector2d = vector<vector<T>>;
template <typename X>
X BinSearch(X left, X right, function<bool(X)> judge, bool lower = true, X eps = 1) {
while (right - left > eps) {
X mid = (right + left) / 2;
if (judge(mid) == lower) {
right = mid;
} else {
left = mid;
}
}
return lower ? right : left;
}
int main() {
i64 N, K;
cin >> N >> K;
vector<i64> a(N);
for(auto &x : a) cin >> x;
sort(WHOLE(a));
auto f = [&](int x) -> bool {
vector<bool> dp[2] = {vector<bool>(K, false), vector<bool>(K, false)};
dp[0][0] = true;
for (i64 i = 0; i < N; i++) {
int b = i & 1;
for (i64 s = 0; s < K; s++) {
if(i != x && s - a[i] >= 0) {
dp[!b][s] = dp[b][s] | dp[b][s - a[i]];
} else {
dp[!b][s] = dp[b][s];
}
}
}
bool retval = false;
for(i64 s = max<i64>(0, K - a[x]); s < K; s++) {
retval |= dp[N & 1][s];
}
return !retval;
};
int ans = BinSearch<int>(-1, a.size(), f, false);
cout << ans + 1 << endl;
return 0;
} | 0 | 20,083,847 |
#include<iostream>
using namespace std;
#include <ctype.h>
int main(){
char c; cin >> c;
if (isupper(c)) c = 'A';
else c = 'a';
cout << c << endl;
} | #include <iostream>
#include <algorithm>
#include <tuple>
#include <vector>
#include <string>
#include <queue>
#include <cmath>
#include <set>
#include <map>
using namespace std;
using ll = long long;
int main()
{
int n, k;
cin >> n;
string s;
cin >> s;
cin >> k;
for(int i = 0; i < s.size(); i++){
if(s[k-1] != s[i]){
s[i] = '*';
}
}
cout << s << endl;
return 0;
} | 0 | 53,887,426 |
#include <bits/stdc++.h>
const int INF = 1e9;
const int MOD = 1e9+7;
const long long LINF = 1e18;
#define dump(x) cout << 'x' << ' = ' << (x) << ` `;
#define FOR(i,a,b) for(ll i=(a);i<(b);++i)
#define rep(i,n) for(ll i=0;i<(n);++i)
#define REPR(i,n) for(ll i=n;i>=0;i--)
#define FOREACH(x,a) for(auto& (x) : (a) )
typedef long long ll;
using namespace std;
typedef pair<ll, ll> P;
template<typename T>
void print(const vector<T> &x) {
int n = x.size();
rep(i,n) {
cout << x[i];
if (i!=n-1) cout<<" ";
else cout << endl;
}
}
template<typename T>
void print(const vector<vector<T>> &x) {
int n = x.size();
rep(i,n) {
rep(j,x[i].size()) {
cout << x[i][j] << " ";
}
cout << endl;
}
}
template<typename T>
void print(const vector<T> &x, int n) {
rep(i,n) {
cout << x[i];
if (i!=n-1) cout<<" ";
else cout << endl;
}
}
template<typename T>
void print(const vector<vector<T>> &x, int n, int m) {
rep(i,n) {
rep(j,m) {
cout << x[i][j] << " ";
}
cout << endl;
}
}
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
void input_init() {
cin.tie(0); ios::sync_with_stdio(false);
}
int main(int argc, char const *argv[]) {
ll x,y,a,b,c; cin>>x>>y>>a>>b>>c;
vector<ll> p(a),q(b),r(c);
rep(i,a) cin>>p[i];
rep(i,b) cin>>q[i];
rep(i,c) cin>>r[i];
priority_queue<ll, vector<ll>, greater<ll>> pq;
sort(p.begin(), p.end(), greater<>());
sort(q.begin(), q.end(), greater<>());
sort(r.begin(), r.end(), greater<>());
rep(i,x) pq.push(p[i]);
rep(i,y) pq.push(q[i]);
rep(i,c) {
if (pq.top() < r[i]) {
pq.pop();
pq.push(r[i]);
}
}
ll ans = 0;
while (!pq.empty()) {
ans += pq.top(); pq.pop();
}
cout << ans << '\n';
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int n,b[105];
int ans;
int main()
{
scanf("%d",&n);
for(int i=1;i<=n-1;++i)
scanf("%d",&b[i]);
for(int i=2;i<=n-1;++i)
ans+=min(b[i-1],b[i]);
ans+=b[1]+b[n-1];
printf("%d\n",ans);
return 0;
} | 0 | 27,319,371 |
#include <bits/stdc++.h>
using namespace std;
long long x[10000010], y[10000010];
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, n) for (int i = 1; i < (n)i++)
#define all(x) (x).begin(), (x).end()
#define pii pair<int, int>
#define int long long
#define setout(n, x) setw(n) << setfill(x)
#define Fixed fixed << setprecision(10);
const long long mod = 1e9 + 7;
signed main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
cout << (n - 2) * 180 << '\n';
} | #include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep1(i, n) for (ll i = 1; i <= (ll)(n); i++)
#define INF 10000000000
#define MOD 1000000007
using ll = long long;
using pint = pair<int,int>;
using pll = pair<ll,ll>;
using Graph = vector<vector<int>>;
int main(){
int H,W; cin>>H>>W;
vector<string> S(H);
rep(i,H)cin>>S[i];
vector<vector<ll>> dp(H,vector<ll>(W,0));
dp[0][0] = 1;
rep(i,H){
rep(j,W){
if(S[i][j]=='#')continue;
if(i>0&&S[i-1][j]=='.') (dp[i][j] += dp[i-1][j])%=MOD;
if(j>0&&S[i][j-1]=='.') (dp[i][j] += dp[i][j-1])%=MOD;
}
}
cout<<dp[H-1][W-1]%MOD<<endl;
} | 0 | 21,486,324 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,a,ma,mi; cin>>n>>a;
ma=a; mi=a;
for(int i=1; i<n; i++){
cin>>a;
ma=max(ma,a),mi=min(mi,a);
}
cout<<ma-mi;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i,a) for(int i = 0; i < (a); i++)
#define ALL(a) (a).begin(),(a).end()
typedef long long ll;
typedef pair<int, int> P;
const int INF = 1e9;
const long long LINF = 1e18;
const long long MOD = 1e9 + 7;
int d[] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
signed main(){
int n,m;
cin >> n >> m;
bool use[10] = {};
REP(i,m){
int a;
cin >> a;
use[a] = true;
}
vector<int> dp(n + 1, -INF);
int prev[n + 1];
dp[0] = 0;
for(int i = 0; i <= n; i++){
for(int j = 9; j >= 1; j--){
if(!use[j]) continue;
if(i - d[j] < 0) continue;
if(dp[i - d[j]] + 1 > dp[i]){
dp[i] = dp[i - d[j]] + 1;
prev[i] = j;
}
}
}
vector<int> ans;
int i = n;
while(i != 0){
ans.emplace_back(prev[i]);
i -= d[prev[i]];
}
REP(i,ans.size()){
cout << ans[i];
}
cout << endl;
return 0;
} | 0 | 49,904,738 |
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep(i,n) for(ll i=0;i<(n);i++)
#define pll pair<ll,ll>
#define pq priority_queue
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define ios ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define lb(c,x) distance(c.begin(),lower_bound(all(c),x))
#define ub(c,x) distance(c.begin(),upper_bound(all(c),x))
using namespace std;
template<class T> inline bool chmax(T& a,T b){if(a<b){a=b;return 1;}return 0;}
template<class T> inline bool chmin(T& a,T b){if(a>b){a=b;return 1;}return 0;}
const ll INF=1e18;
int main()
{
ll n;
cin >> n;
for(ll i=0;i*7<=n;i++){
if((n-i*7)%4==0){
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
} | #include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>
#include <cstring>
#include <map>
#include <queue>
#include <cmath>
#include <complex>
using namespace std;
#define MOD 1000000007
#define ll long long
#define ld long double
#define FOR(i,a,b) for(ll i=(ll)a;i<(ll)b;i++)
#define rep(i,n) FOR(i,0,n)
#define pb push_back
#define mp make_pair
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define rmsame(a) sort(all(a)),a.erase(unique(all(a)), a.end())
#define rmvector(a,b) rep(i,a.size())rep(j,b.size())if(a[i]==b[j]){a.erase(a.begin()+i);i--;break;}
template<typename X> bool exist(vector<X> vec, X item){return find(all(vec), item)!=vec.end();}
ll gcd(ll a, ll b){if(b==0)return a;return gcd(b,a%b);}
ll lcm(ll a, ll b){return a/gcd(a,b)*b;}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll N; cin >> N;
ll sum = 0;
vector<ll> ans;
ll cnt = 1;
while(sum < N){
sum += cnt;
ans.pb(cnt);
cnt++;
}
if(sum == N){
rep(i,ans.size()){
cout << ans[i] << endl;
}
return 0;
}
else{
ll mi = sum -N;
rep(i,ans.size()){
if(ans[i] == mi) continue;
cout << ans[i] << endl;
}
}
return 0;
} | 0 | 68,817,652 |
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <string>
#include <vector>
#include <random>
#include <bitset>
#include <queue>
#include <cmath>
#include <stack>
#include <set>
#include <map>
#define rep(i,n) for (int i=0; i<n;++i)
using namespace std;
int N, i;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> N >> i;
cout << N - i + 1<< endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using pii = pair<int, int>;
#define rep(i,n) for(int i=0; i<(int)(n); i++)
int GCD(ll a, ll b){
if(a<b){swap(a,b);}
if(a%b==0){return b;}
else{return GCD(a%b,b);}
}
int main(){
ll n;cin>>n;
vector<ll> vec(n+1);
rep(i,n+1){cin>>vec.at(i);}
sort(vec.begin(),vec.end());
if(n==1){cout<<vec.at(1)-vec.at(0);}
else{
vector<ll> v(n);
rep(i,n){
v.at(i)=vec.at(i+1)-vec.at(i);
}
ll G=GCD(v[0],v[1]);
ll g=G;
ll i=1;
while(i<=G){
if(G%i!=0){i++;}
else{
g=G/i;
bool b=true;
rep(j,n){
if(v.at(j)%g!=0){b=false;}
}
if(b){cout<<g;break;}
i++;
}
}
}
} | 0 | 61,284,521 |
#include <bits/stdc++.h>
const double PI = acos(-1);
#define rep(i, n) for (int i = 0; i < (int)(n); i++ )
using namespace std;
int main(){
long long n;
cin >> n;
long long m = n;
int sum = 0;
while(true){
sum += n % 10;
n /= 10;
if(n == 0) break;
}
if( m % sum == 0) cout << "Yes" << endl;
else cout << "No" << endl;
} | #include <iostream>
#include <math.h>
#include <numeric>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <queue>
#include <queue>
#include <stack>
#include <sstream>
#include <set>
typedef long long ll;
const int dx[8]={1,0,-1,0,1,-1,-1,1};
const int dy[8]={0,1,0,-1,1,1,-1,-1};
const int dr[4] = {-1, 0, 1, 0};
const int dc[4] = { 0, 1, 0,-1};
const int INF = 1e9;
#define FOR(i, a, n) for(int i = (int)(a); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define SORT(a) sort(a.begin(),a.end())
#define REVERSE(a) reverse(a.begin(),a.end())
int guki (int a){
if(a%2==0) return 0;
else return 1;
}
int gcd(int a, int b){
if(a%b==0){
return b;
}else{
return (gcd(b,a%b));
}
}
int lcm(int a, int b){
int x = gcd(a,b);
return (a*b/x);
}
ll nCr (ll n, ll r){
ll ans = 1;
for(ll i = n ; i > n-r ; i --){
ans *= i;
}
for(ll i = 1 ; i<= r; i ++){
ans /= i;
}
return ans ;
}
int nPr (int n,int r){
int ans = 1;
for(int i = n ; i > n-r ; i --){
ans *= i;
}
return ans ;
}
using namespace std;
int main(){
int n;
cin >> n;
vector<int> a(n),b(n),c(n);
REP(i,n){
cin >> a[i] >> b[i] >> c[i];
}
vector<vector<int>> dp(n,vector<int>(3));
dp[0][0] = a[0];
dp[0][1] = b[0];
dp[0][2] = c[0];
FOR(i,1,n){
dp[i][0] = max(dp[i-1][1]+a[i], dp[i-1][2] + a[i]);
dp[i][1] = max(dp[i-1][0]+b[i], dp[i-1][2] + b[i]);
dp[i][2] = max(dp[i-1][1]+c[i], dp[i-1][0] + c[i]);
}
cout << max({dp[n-1][0],dp[n-1][1],dp[n-1][2]}) <<endl;
} | 0 | 35,731,495 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;i++)
#define pii pair<int,int>
#define data pair<int,pii>
int N;
vector<data> V;
signed main()
{
cin >> N;
rep(i, N)
{
int a, b;
cin >> a >> b;
V.push_back({a + b, {a, b}});
}
sort(V.rbegin(), V.rend());
int ans = 0;
rep(i, N)
{
if(i & 1)ans -= V[i].second.second;
else ans += V[i].second.first;
}
cout << ans << endl;
return 0;
} | #include<algorithm>
using namespace std;
#define MAXN 100000
int AC[MAXN] = {};
int WA[MAXN] = {};
int main()
{
int ACCount = 0;
int WACount = 0;
int n,m;
scanf("%d %d",&n,&m);
for(int i = 0; i < m; i++)
{
int curNum;
char first, second;
scanf("%d %c%c", &curNum, &first, &second);
if(AC[curNum - 1] != 0)
{
continue;
}
if(first == 'A')
{
AC[curNum - 1] = 1;
WACount += WA[curNum - 1];
ACCount += 1;
}
else
{
WA[curNum - 1] += 1;
}
}
printf("%d %d",ACCount, WACount);
} | 0 | 41,267,289 |
#include<bits/stdc++.h>
#define watch(x) cout << (#x) << " is " << (x) << endl
typedef long long ll;
using namespace std;
int static fast = [](){
ios::sync_with_stdio(false);
cin.tie(0); cout.tie(0); return 0;
}();
int main() {
int n;
cin >> n;
vector<ll> T(n, 0);
vector<ll> A(n, 0);
for(ll& val: T)
cin >> val;
for(ll& val: A)
cin >> val;
ll M = T.back();
if (A[0] != M) {
cout << 0 << endl;
return 0;
}
ll ans = 1;
ll mod = 1e9 + 7;
int T_idx = -1, A_idx = n;
for(int i = 0; i < n; i++) {
if (T[i] == M && T_idx == -1)
T_idx = i;
}
for(int i = n-1; i >= 0; i--) {
if (A[i] == M && A_idx == n)
A_idx = i;
}
if (T_idx > A_idx) {
cout << 0 << endl;
return 0;
}
for(int i = 1; i < n-1; i++) {
if (i < T_idx && T[i] == T[i-1])
ans *= T[i];
else if (i > A_idx && A[i] == A[i+1])
ans *= A[i];
else if (i > T_idx && i < A_idx)
ans *= T.back();
ans %= mod;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
string S,T;
cin>>S>>T;
for(int i=S.size()-T.size();i>=0;i--){
bool bo=false;
for(int j=0;j<T.size();j++)
if(T[j]!=S[i+j] && S[i+j]!='?'){
bo=true;
break;
}
if(bo)
continue;
for(int j=0;j<S.size();j++){
if(j<i || j>i+T.size()-1){
if(S[j]=='?')
cout<<'a';
else
cout<<S[j];
}else
cout<<T[j-i];
}
cout<<endl;
return 0;
}
cout<<"UNRESTORABLE"<<endl;
} | 0 | 96,399,898 |
#include <iostream>
#include<queue>
#include<vector>
#include<set>
#include<map>
#include<algorithm>
#include<cstring>
#include<string>
#include<cassert>
#include<cmath>
#include<climits>
#include<iomanip>
#include<bitset>
using namespace std;
#define MOD 1000000007
#define REP(i,n) for(ll (i)=0;(i)<(n);(i)++)
#define FOR(i,c) for(decltype((c).begin())i=(c).begin();i!=(c).end();++i)
#define ll long long
#define ull unsigned long long
#define all(hoge) (hoge).begin(),(hoge).end()
typedef pair<ll, ll> P;
const long long INF = 1LL << 60;
typedef vector<ll> Array;
typedef vector<Array> Matrix;
template<class T> inline bool chmin(T & a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T & a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
struct Edge {
ll to, cap, rev;
Edge(ll _to, ll _cap, ll _rev) {
to = _to; cap = _cap; rev = _rev;
}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
void add_edge(Graph& G, ll from, ll to, ll cap, bool revFlag, ll revCap) {
G[from].push_back(Edge(to, cap, (ll)G[to].size()));
if (revFlag)G[to].push_back(Edge(from, revCap, (ll)G[from].size() - 1));
}
ll max_flow_dfs(Graph & G, ll v, ll t, ll f, vector<bool> & used)
{
if (v == t)
return f;
used[v] = true;
for (int i = 0; i < G[v].size(); ++i) {
Edge& e = G[v][i];
if (!used[e.to] && e.cap > 0) {
ll d = max_flow_dfs(G, e.to, t, min(f, e.cap), used);
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
ll max_flow(Graph & G, ll s, ll t)
{
ll flow = 0;
for (;;) {
vector<bool> used(G.size());
REP(i, used.size())used[i] = false;
ll f = max_flow_dfs(G, s, t, INF, used);
if (f == 0) {
return flow;
}
flow += f;
}
}
void BellmanFord(Graph& G, ll s, Array& d, Array &negative) {
d.resize(G.size());
negative.resize(G.size());
REP(i, d.size())d[i] = INF;
REP(i, d.size())negative[i] = false;
d[s] = 0;
REP(k, G.size() - 1) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
}
}
}
}
REP(k, G.size() - 1) {
REP(i, G.size()) {
REP(j, G[i].size()) {
if (d[i] != INF && d[G[i][j].to] > d[i] + G[i][j].cap) {
d[G[i][j].to] = d[i] + G[i][j].cap;
negative[G[i][j].to] = true;
}
if (negative[i] == true)negative[G[i][j].to] = true;
}
}
}
}
void Dijkstra(Graph& G, ll s, Array& d) {
d.resize(G.size());
REP(i, d.size())d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, s));
while (!q.empty()) {
P a = q.top();
q.pop();
if (d[a.second] < a.first)continue;
REP(i, G[a.second].size()) {
Edge e = G[a.second][i];
if (d[e.to] > d[a.second] + e.cap) {
d[e.to] = d[a.second] + e.cap;
q.push(make_pair(d[e.to], e.to));
}
}
}
}
void WarshallFloyd(Graph& G, Matrix& d) {
d.resize(G.size());
REP(i, d.size())d[i].resize(G.size());
REP(i, d.size()) {
REP(j, d[i].size()) {
d[i][j] = INF;
}
}
REP(i, G.size()) {
REP(j, G[i].size()) {
d[i][G[i][j].to] = G[i][j].cap;
}
}
REP(i, G.size()) {
REP(j, G.size()) {
REP(k, G.size()) {
chmin(d[j][k], d[j][i] + d[i][k]);
}
}
}
}
class UnionFind {
vector<int> data;
int num;
public:
UnionFind(int size) : data(size, -1), num(size) { }
bool unionSet(int x, int y) {
x = root(x); y = root(y);
if (x != y) {
if (data[y] < data[x]) swap(x, y);
data[x] += data[y]; data[y] = x;
num--;
}
return x != y;
}
bool findSet(int x, int y) {
return root(x) == root(y);
}
int root(int x) {
return data[x] < 0 ? x : data[x] = root(data[x]);
}
int size(int x) {
return -data[root(x)];
}
int numSet() {
return num;
}
};
class Combination {
public:
Array fact;
Array inv;
ll mod;
Combination(ll n, ll _mod) {
mod = _mod;
fact.resize(n + 1);
fact[0] = 1;
REP(i, n) {
fact[i + 1] = (fact[i] * (i + 1LL)) % mod;
}
inv.resize(n + 1);
REP(i, n + 1) {
inv[i] = mod_inv(fact[i]);
}
}
ll mod_inv(ll x) {
ll n = mod - 2;
ll res = 1LL;
while (n > 0) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n >>= 1;
}
return res;
}
ll nCr(ll n, ll r) {
return ((fact[n] * inv[r] % mod) * inv[n - r]) % mod;
}
ll nPr(ll n, ll r) {
return (fact[n] * inv[n - r]) % mod;
}
ll nHr(ll n, ll r) {
return nCr(r + n - 1, r);
}
};
void divisor(ll n, vector<ll>& ret) {
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end(), greater<ll>());
}
void factoring(ll i, map<ll, ll> &mp) {
ll x = i;
for (int j = 2; j <= i; j++) {
if (x%j == 0) {
if (mp.find(j) == mp.end()) {
mp[j] = 0;
}
while (x%j == 0 && x > 1) {
mp[j]++;
x /= j;
}
}
if (x == 1) break;
}
}
ll gcd(ll m, ll n) {
if (n == 0)return m;
return gcd(n, m % n);
}
ll lcm(ll m, ll n) {
return m / gcd(m, n) * n;
}
ll pow2(ll x, ll n, ll mod) {
ll ans = 1ll;
while (n > 0) {
if ((n & 1) == 1) {
ans = ans * x %mod;
}
x = x * x%mod;
n >>= 1;
}
return ans;
}
vector<ll> lis_fast(const vector<ll>& a) {
const ll n = a.size();
vector<ll> A(n, INT_MAX);
vector<ll> id(n);
for (int i = 0; i < n; ++i) {
id[i] = distance(A.begin(), lower_bound(A.begin(), A.end(), a[i]));
A[id[i]] = a[i];
}
ll m = *max_element(id.begin(), id.end());
vector<ll> b(m + 1);
for (int i = n - 1; i >= 0; --i)
if (id[i] == m) b[m--] = a[i];
return b;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
ll n;
cin >> n;
string s;
cin >> s;
ll con = 0;
ll ans = 1;
REP(i, 2 * n) {
if (s[i] == 'B') {
if ((con+1) % 2 == 0) {
(ans *= con)%=MOD;
con--;
}
else {
con++;
}
}else{
if ((con+1) % 2 != 0) {
(ans *= con)%=MOD;
con--;
}
else {
con++;
}
}
}
if (con == 0) {
REP(i, n) {
(ans*=(i+1))%=MOD;
}
cout << ans << endl;
}
else {
cout << 0 << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < n; i++)
typedef long long ll;
using namespace std;
int mod = 1000000007;
const int MAX = 1000001;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main(void){
int N; cin >> N;
int ans = 0;
int A[N][N];
rep(i, N){
string S; cin >> S;
rep(j, N){
A[i][j] = S[j] - 'a';
}
}
int B[N][N];
for(int b = 0; b < N; b++){
bool ok = true;
rep(i, N){
rep(j, N){
int x1 = i, y1 = (j+b) % N;
int x2 = j, y2 = (i+b) % N;
if(A[x1][y1] != A[x2][y2]) ok = false;
}
}
if(ok) ans += N;
}
cout << ans << endl;
return 0;
} | 0 | 95,624,744 |
#include <bits/stdc++.h>
using namespace std;
#define INF (1<<31)-1
#define LINF (1LL<<63)-1LL
#define MOD 1000000007
#define MOD2 998244353
template<class T,class U>bool chmax(T &a, const U &b){if(a<b){a=b;return 1;}return 0;}
template<class T,class U>bool chmin(T &a, const U &b){if(b<a){a=b;return 1;}return 0;}
#define rep(i,n) for(int i=0,_i=(n);i<_i;++i)
#define rep1(i,a,b) for(int a_=(a),b_=(b),i=a_;i<b_;++i)
#define repr(i,n) for(int _i=(n),i=_i;i>0;--i)
#define db(x) cerr<<#x<<" = "<<x<<" ";
#define db2(x,y) cerr<<"("<<#x<<", "<<#y<<") = ("<<x<<", "<<y<<") ";
#define db3(x,y,z) cerr<<"("<<#x<<", "<<#y<<", "<<#z<<") = ("<<x<<", "<<y<<", "<<z<<") ";
#define ln cout<<endl;
#define all(a) (a).begin(),(a).end()
#define dig(n) to_string(n).length()
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define se second
#define fi first
typedef long long ll;
typedef pair<int,int> P;
typedef pair<int,P> iP;
typedef pair<P,P> PP;
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b){return (a*b)/gcd(a,b);}
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
int main(){
bool flag=false;
ll ans=0,sum=0;
int n,p;
cin>>n>>p;
ll dp[n][2]={};
vector<int> a(n);
int piv = (p+1)%2;
rep(i,n)cin>>a[i];
if(a[0]%2==0){
if(p == 1){
dp[0][1]=2;
}else{
dp[0][0]=2;
}
}else{
dp[0][0]=1;
dp[0][1]=1;
}
rep1(i,1,n){
if(a[i]%2 == 0){
dp[i][0] = dp[i-1][0]*2;
dp[i][1] = dp[i-1][1]*2;
}else{
dp[i][0] = dp[i-1][1]+dp[i-1][0];
dp[i][1] = dp[i-1][0]+dp[i-1][1];
}
}
cout<<dp[n-1][0]<<endl;
return 0;
} | #include<iostream>
#include<iomanip>
#include<vector>
#include<map>
#include<stack>
#include<queue>
#include<string>
#include<utility>
#include<numeric>
#include<algorithm>
#include<cmath>
#include<climits>
using namespace std;
using ll = long long;
class Stream{
public:
Stream(){
}
void read(){
}
template<typename First, typename... Rest>
void read(First& first, Rest&... rest){
cin >> first;
read(rest...);
}
template<typename T>
void write_vec(vector<T>& v, char divider){
for(size_t i = 0; i < v.size(); i++){
cout << v[i] << divider;
}
}
};
int main(){
Stream io;
string n;
io.read(n);
for(int i = 0; i < n.size(); i++){
switch(n[i]){
case '1':
n[i] = '9';
break;
case '9':
n[i] = '1';
break;
}
}
cout << n;
return 0;
} | 0 | 20,126,838 |
#include <iostream>
#include <cstdio>
#include <deque>
#define int long long
using namespace std;
bool vis[100005];
signed main() {
int n; cin >> n;
deque<pair<int, int> > q; q.push_front(make_pair(1, 1));
while (!q.empty()) {
pair<int, int> p = q.front(); q.pop_front();
if (vis[p.first]) continue; vis[p.first] = 1;
if (!p.first) { cout << p.second << endl; return 0; }
q.push_front(make_pair((p.first * 10) % n, p.second));
q.push_back(make_pair((p.first + 1) % n, p.second + 1));
}
return 0;
} | #include<iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;
int main()
{
long long int a,b,k;
cin>>a>>b>>k;
for(int i=1;i<=k;i++)
{
if(i%2==0)
{
if(b%2==0)
{
a=a+(b/2);
b=b-(b/2);
}
else
{
a=a+(b/2);
b=b-1-(b/2);
}
}
else
{
if(a%2==0)
{
b=b+(a/2);
a=a/2;
}
else
{
b=b+(a/2);
a=a-1-(a/2);
}
}
}
cout<<a<<" "<<b<<endl;
return 0;
} | 0 | 43,959,940 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define rep1(i,n) for(int i=1;i<=(int)n;i++)
#define sp(n) cout << fixed << setprecision(n)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
typedef long long ll;
using namespace std;
int main(void){
ll n,x;cin>>n>>x;
vector<ll> a(n);
ll tot=0;
ll maxi=0;
int y=-1;
rep(i,n){
cin>>a[i];
tot+=a[i];
}
rep(i,n-1){
ll buf=a[i]+a[i+1];
if(chmax(maxi,buf))y=i;
}
if(maxi<x){
cout<<"Impossible"<<endl;
return 0;
}
vector<int> t;
rep(i,y){
t.push_back(i+1);
}
for(int i=n-1;i>y;i--){
t.push_back(i);
}
cout<<"Possible"<<endl;
rep(i,n-1){
cout<<t[i]<<endl;
}
} | #include <bits/stdc++.h>
#define rep(i,n) for (long long i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
ll n;
cin >> n;
map<ll,ll> rec;
vector<ll> c(n);
vector<ll> v(0);
for(long long i = 0; i < n; i++){
cin >> c[i];
}
for(long long i = 0; i < n; i++){
if(rec.count(c[i])){
rec.at(c[i]) = rec.at(c[i]) + 1;
if(rec.at(c[i]) == 2){
v.push_back(c[i]);
}
if(rec.at(c[i]) == 4){
v.push_back(c[i]);
}
}
else{
rec[c[i]] = 1;
}
}
if(v.size() == 0 || v.size() == 1){
cout << 0;
return 0;
}
sort(v.begin(), v.end());
reverse(v.begin(), v.end());
cout << v[0] * v[1];
return 0;
} | 0 | 32,101,640 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<cmath>
#include<cstdio>
#include<queue>
#include<deque>
#include<map>
#include<stack>
#include<set>
#include<utility>
using namespace std;
typedef pair<int,int> ii;
typedef long long ll;
typedef pair<ll,ll> p;
typedef unsigned long long int ull;
const ll MOD=998244353;
int dy[]={1,0,-1,0};
int dx[]={0,1,0,-1};
const int MAXN=100000;
const int MAXE=100000;
const int MAXV=10000;
const ll INF=2e18;
int main(){
int n,m;cin>>n>>m;
vector<ii> c(n);
for(int i=0;i<n;i++){
int a,b;cin>>a>>b;
c[i]=ii(a,b);
}
sort(c.begin(),c.end());
int i=0;
int ans=0;
priority_queue<int> que;
for(int d=1;d<=m;d++){
while(c[i].first<=d&&i<n){
que.push(c[i].second);
i++;
}
if(que.empty()) continue;
int mx=que.top();que.pop();
ans+=mx;
}
cout<<ans<<endl;
return 0;
} | #include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
int main() {
int N; cin >> N;
for (int i = N; i <= 999; i++) {
int num = i;
int a = num / 100;
num = num % 100;
int b = num / 10;
num = num % 10;
if (a == b && b == num) {
printf("%d\n", i);
return 0;
}
}
return 0;
} | 0 | 61,222,335 |
#include <bits/stdc++.h>
#define pb push_back
#define ff first
#define ss second
#define all(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
using vi = vector<int>;
using pii = pair<ll, ll>;
const int INF = 0x3f3f3f3f;
int main() {
int k, x;
cin >> k >> x;
if (k * 500 < x)
cout << "No" << endl;
else
cout << "Yes" << endl;
} | #include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <utility>
#include <cmath>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <numeric>
#include <functional>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll, ll> P;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define exrep(i, a, b) for(ll i = a; i <= b; i++)
#define out(x) cout << x << endl
#define exout(x) printf("%.10f\n", x)
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define pb push_back
#define re0 return 0
const ll mod = 1000000007;
const ll INF = 1e16;
const ll MAX_N = 100010;
int main() {
ll n, z, w;
cin >> n >> z >> w;
vl a(n);
rep(i, n) {
cin >> a[i];
}
if(n == 1) {
out(abs(a[0] - w));
}
else {
out(max(abs(a[n-1] - w), abs(a[n-2] - a[n-1])));
}
re0;
} | 0 | 35,814,963 |
#include <bits/stdc++.h>
#define all(x) (x).begin(), (x).end()
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
int main() {
string s;
ll k;
cin >> s >> k;
for (ll i = 0; i < k; i++) {
if (s[i] != '1') {
cout << s[i] << endl;
return 0;
}
}
cout << 1 << endl;
return 0;
} | #include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <string>
using namespace std;
typedef long long ll;
#define rept(_i,iv,n,type) for(type _i=(type)(iv);_i<(type)(n);++_i)
#define rept0(_i,n,type) rept(_i,0,n,type)
#define repi0(_i,n) rept(_i,0,n,int)
#define repl0(_i,n) rept(_i,0,n,ll)
#define REPT(_i,iv,_l,n,type) for(type _i=(type)(iv),_l=(type)(n);_i<_l;++_i)
#define REPT0(_i,_l,n,type) REPT(_i,0,_l,n,type)
#define REPI0(_i,_l,n) REPT(_i,0,_l,n,int)
#define REPL0(_i,_l,n) REPT(_i,0,_l,n,ll)
#define REPV(v,_itr,_end) for(auto _itr=(v).begin(),_end=(v).end();_itr!=_end;++_itr)
#define REPVC(v,_itr,_end) for(auto _itr=(v).cbegin(),_end=(v).cend();_itr!=_end;++_itr)
#define td typedef
#define tdv(type,name) typedef vector<type > name;
typedef vector<bool> vb;
typedef vector<vb > vvb;
typedef vector<int> vi;
typedef vector<vi > vvi;
typedef vector<ll> vll;
#define mod99 998244353
int main(int argc, const char * argv[]) {
int N;
cin>>N;
for(int i=0,len=N/7;i<=len;++i){
if((N-i*7)%4==0){
cout<<"Yes"<<endl;
return 0;
}
}
cout<<"No"<<endl;
return 0;
} | 0 | 99,566,349 |
#include <iostream>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <string>
using namespace std;
int main() {
long long L,R;
cin >> L>>R;
long long min = 2019;
for(long long i = L;i<=R;i++){
for(long long j = L;j<=R;j++){
if(i==j) continue;
if((i*j)%2019== 0){
cout<<0;
return 0;
}
if(min >= (i*j)%2019) min = (i*j)%2019;
}
}
cout<<min;
return 0;
} | #include <bits/stdc++.h>
#include <vector>
#include <cmath>
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REP2(i, m, n) for (int i = (m); i < (int)(n); ++i)
#define REPR(i, n) for (int i = (n)-1; i >= 0; --i)
#define REPR2(i, m, n) for (int i = (n)-1; i >= (m); --i)
#define REPx(x, a) for(auto x : a)
#define ALL(a) a.begin(), a.end()
#define SORT(a) sort(ALL(a))
#define SORTG(a) sort(ALL(a), greater<int>())
#define REVERSE(a) reverse(ALL(a))
#define bit_search(bit, n) REP(bit, 1<<(n))
#define bit_check(bit, i) (bit>>(i)) & 1
#define setpre(n) fixed << setprecision((n))
#define UNIQUE(a) do {SORT(a); (a).erase(unique(ALL(a)), (a).end());} while(0)
#define MAX(a) *max_element(ALL(a))
#define MIN(a) *min_element(ALL(a))
#define bisect_left(a, x) lower_bound(ALL(a), (x)) - a.begin()
#define bisect_right(a, x) upper_bound(ALL(a), (x)) - a.begin()
#define INPUT(a) REP(i, a.size()) cin >> a[i];
#define INPUTP(a) REP(i, a.size()) cin >> a[i].first >> a[i].second;
#define ENDL cout << endl;
using namespace std;
using ll = long long;
using ld = long double;
using PII = pair<int, int>;
using VPII = vector<PII>;
using VI = vector<int>;
using VVI = vector<VI>;
using Vll = vector<ll>;
using VVll = vector<Vll>;
using VC = vector<char>;
using VS = vector<string>;
using VB = vector<bool>;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
int main()
{
int N;
cin >> N;
Vll T(N), A(N);
INPUT(T); INPUT(A);
ll max_h = MAX(T);
if (max_h != MAX(A))
{
cout << 0 << endl;
return 0;
}
Vll H(N, 0);
REP(i, N) H[i] = min(T[i], A[i]);
VB fixed(N, false);
fixed[0] = true;
fixed[N-1] = true;
REP2(i, 1, N)
{
if (T[i] > T[i-1])
{
if (T[i] > A[i])
{
cout << 0 << endl;
return 0;
}
fixed[i] = true;
}
if (T[i] == max_h) break;
}
REPR(i, N-1)
{
if (A[i] > A[i+1])
{
if (A[i] > T[i])
{
cout << 0 << endl;
return 0;
}
fixed[i] = true;
}
if (A[i] == max_h) break;
}
ll ans = 1;
REP(i, N)
{
if (!fixed[i])
{
ans *= H[i];
ans %= MOD;
}
}
cout << ans << endl;
return 0;
} | 0 | 46,029,839 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < n; i++)
using ll = long long;
int main() {
ll s,c; cin >> s >> c;
ll a = min(s, c / 2);
ll b = (c - (a*2)) / 4;
cout << a+b << endl;
return 0;
} | #include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
int main()
{
for(;;){
int d;
if(!(cin >> d))
return 0;
int ret = 0;
for(int i=d; i<600; i+=d)
ret += d * i * i;
cout << ret << endl;
}
} | 0 | 53,277,719 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main(){
int n; cin >> n;
long long L[100];
L[0] = 2; L[1] = 1;
for(int i=2;i<=n;++i) {
L[i] = L[i-1] + L[i-2];
}
cout << L[n] << endl;
} | #include <iostream>
#include <cstdint>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cctype>
#include <cassert>
#include <climits>
#include <string>
#include <bitset>
#include <cfloat>
#include <unordered_set>
#pragma GCC optimize("Ofast")
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
typedef vector<vector<ll>> vvll;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rrep(i, n) for (ll i = 1; i <= (n); ++i)
#define irep(it, stl) for (auto it = stl.begin(); it != stl.end(); it++)
#define drep(i, n) for (ll i = (n)-1; i >= 0; --i)
#define mes(a) cout << (a) << endl
#define dmes(a, b) cout << (a) << " " << (b) << endl
#define re0 return 0
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define rSort(a) sort(a.rbegin(), a.rend())
#define Rev(a) reverse(a.begin(), a.end())
#define MATHPI acos(-1)
#define itn int
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
template <class T>
inline bool chmax(T &a, T b)
{
if (a < b)
{
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T &a, T b)
{
if (a > b)
{
a = b;
return 1;
}
return 0;
}
struct io
{
io()
{
ios::sync_with_stdio(false);
cin.tie(0);
}
};
const int INF = INT_MAX;
const ll LLINF = 1LL << 60;
const ll MOD = 1000000007;
const double EPS = 1e-19;
signed main() {
ll n, k, r, s, p;
cin >> n >> k >> r >> s >> p;
string t;
cin >> t;
vb prwin(k, false);
ll sum = 0;
rep(i, n) {
if (t[i] == t[i-k] && prwin[i%k] == true) {
prwin[i%k] = false;
} else {
if (t[i] == 'r') {
sum += p;
prwin[i%k] = true;
}
if (t[i] == 's') {
sum += r;
prwin[i%k] = true;
}
if (t[i] == 'p') {
sum += s;
prwin[i%k] = true;
}
}
}
mes(sum);
} | 0 | 62,111,845 |
#include <iostream>
#include <string>
#include <algorithm>
#include <utility>
#include <unordered_set>
#include <vector>
#include <list>
#include <string>
#include <iterator>
#include <deque>
#include <array>
#include <forward_list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <cmath>
#include <climits>
#include <bitset>
#include <numeric>
using namespace std;
const long double PI = 3.14159265358979323846264338327950;
const int N = 1e5+5;
template <class T>
T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int ac[N], wa[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
int a, b;
string s;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> k >> s;
if (s[0] == 'W' && ac[k] == 0) {
wa[k]++;
} else {
ac[k]++;
}
}
a = b = 0;
for (int i = 0; i <= n; ++i) {
if (ac[i]) {
++a;
if (wa[i]) b += wa[i];
}
}
cout << a << ' ' << b << '\n';
} | #include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, from, to) for (int i = from; i < (to); ++i)
#define mp(x,y) make_pair(x,y)
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
#define pb push_back
using ll = long long;
using vin=vector<int>;
using vll=vector<ll>;
using P = pair<int, int>;
const int inf=1e9+7;
const ll INF=1e18;
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
int dy[4] = {0, 0, 1, -1};
int dx[4] = {1, -1, 0, 0};
int main() {
int h,w;
cin>>h>>w;
vector<vector<int>> dist(h,vin(w,0));
vector<string> a(h);
rep(i,0,h)cin>>a[i];
queue<pair<int, int>> que;
rep(i,0,h){
rep(j,0,w){
if(a[i][j]=='#'){
que.push(mp(i,j));
}
}
}
while (que.size() != 0) {
pair<int, int> now = que.front();
que.pop();
for (int i = 0; i < 4; i++) {
int ny = now.first + dy[i];
int nx = now.second + dx[i];
if (ny < 0 || h <= ny || nx < 0 || w <= nx) continue;
if (a[ny][nx] == '#') continue;
if (dist[ny][nx] != 0) continue;
que.push(make_pair(ny, nx));
dist[ny][nx] = dist[now.first][now.second] + 1;
}
}
int ans=0;
rep(i,0,h){
rep(j,0,w){
chmax(ans,dist[i][j]);
}
}
cout<<ans<<endl;
} | 0 | 89,120,152 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,x) for(int i=0;i<x;i++)
#define put(ans) cout << ans << endl;
int enum_divisors(int N)
{
vector<int> res;
for (int i = 1; i * i <= N; ++i)
{
if (N % i == 0)
{
res.push_back(i);
if (N / i != i)
res.push_back(N / i);
}
}
return res.size();
}
int main(){
int a,b,c;
cin >> a >> b >> c;
if(a+b>=c) puts("Yes");
else puts("No");
return 0;
} | #include <stdio.h>
#include <string.h>
#include <limits.h>
#include <math.h>
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <queue>
typedef unsigned long long ULLONG;
typedef long long LLONG;
static const LLONG MOD_NUM = 1000000007;
template<class _T> static void get(_T& a) {
std::cin >> a;
}
template<class _T> static void get(_T& a, _T& b) {
std::cin >> a >> b;
}
template<class _T> static void get(_T& a, _T& b, _T& c) {
std::cin >> a >> b >> c;
}
template<class _T> static void getint(_T& a) {
if (sizeof(_T) > sizeof(int)) {
scanf("%lld", &a);
}
else {
scanf("%d", &a);
}
}
template <class _T> static _T tp_abs(_T a) {
if (a < (_T)0) {
a *= (_T)-1;
}
return a;
}
static void exec();
int main()
{
exec();
fflush(stdout);
return 0;
}
static void exec()
{
LLONG N;
get(N);
LLONG ans = 0;
LLONG mod = 1;
LLONG div = 2;
while (div * mod <= N) {
if (((N - mod) % mod) == 0) {
div = (N - mod) / mod;
if (N % div == mod) {
ans += div;
}
}
mod++;
div = mod + 1LL;
}
printf("%lld\n", ans);
} | 0 | 50,016,002 |
#include <iostream>
template<class T> T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a%b);
}
int main() {
long long a, b; std::cin >> a >> b;
long long g = gcd(a, b);
long long ans = a * b / g;
std::cout << ans << std::endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll=long long;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define inf 1001001001
#define mod 1000000007
#define mod2 998244353
#define pi acos(-1)
#define all(v) v.begin(),v.end()
int dx[4] = {0,-1,0,1};
int dy[4] = {-1,0,1,0};
ll gcd(ll a,ll b){
if(b>a) swap(a,b);
if(b==0) return a;
return gcd(b,a%b);
}
ll lcm(ll a,ll b){
ll g=gcd(a,b);
return a/g*b;
}
ll rep_jijo(ll n,ll x){
if(x==0) return 1;
if(x%2==0){
ll t=rep_jijo(n,x/2);
return t*t%mod;
}
return n*rep_jijo(n,x-1)%mod;
}
int main(){
int n;
const int A = 1000005;
cin >> n;
vector<int>a(A,0);
vector<int>b(n);
rep(i,n){
int x;
cin >> x;
b[i] = x;
a[x]++;
}
bool flag = true;
for(int i = 2; i < A; i++){
int cnt = 0;
for(int j = i; j < A; j+=i){
cnt += a[j];
if(cnt > 1){
flag = false;
}
}
}
if(flag){
cout << "pairwise coprime" << endl;
return 0;
}
int x = 0;
rep(i,n){
x = gcd(x,b[i]);
}
if(x == 1){
cout << "setwise coprime" << endl;
return 0;
}
cout << "not coprime" << endl;
return 0;
} | 0 | 88,070,069 |
#include<bits/stdc++.h>
using namespace std;
int main() {
priority_queue<int>num;
string command;
int n;
while(1){
cin>>command;
if(command.compare("insert") == 0){
cin>>n;
num.push(n);
}
if(command.compare("extract") == 0){
cout<<num.top()<<endl;
num.pop();
}
if(command.compare("end") == 0){
break;
}
}
return 0;
} | #include <bits/stdc++.h>
using ll = long long;
using namespace std;
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) for(int i = int(a); i < int(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, )(__VA_ARGS__)
#define all(x) (x).begin(), (x).end()
template <typename T> bool chmax(T &a, const T &b) {
if(a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> bool chmin(T &a, const T &b) {
if(a > b) {
a = b;
return 1;
}
return 0;
}
const long long INFLL = 1LL << 60;
const long long MOD = 1e9 + 7;
int main() {
int K;
cin >> K;
vector<int> A = {1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14,
1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
cout << A[K - 1] << endl;
} | 0 | 89,786,834 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<string.h>
#include<math.h>
#include<map>
using namespace std;
const long long MOD = 1000000007;
struct WBK {
int x;
int y;
int m;
};
int main(){
int A,B,M;
cin >> A >> B >> M;
vector<int> a(A),b(B);
WBK m[M];
int a_min=999999;
for(int i=0;i<A;i++){
cin >> a[i];
a_min=min(a_min,a[i]);
}
int b_min=999999;
for(int i=0;i<B;i++){
cin >> b[i];
b_min=min(b_min,b[i]);
}
for(int i=0;i<M;i++){
cin >> m[i].x >> m[i].y >> m[i].m;
}
int ans_1=a_min+b_min;
int ans_2=999999;
for(int i=0;i<M;i++){
int now_cost=a[m[i].x-1]+b[m[i].y-1]-m[i].m;
ans_2=min(ans_2,now_cost);
}
cout << min(ans_1,ans_2) << endl;
return 0;
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define ll long long
#define db long double
#define pb push_back
#define eb emplace_back
#define pii pair<int,int>
#define vi vector<int>
#define vii vector<pii>
#define mi map<int,int>
#define mii map<pii,int>
#define fi first
#define se second
#define all(a) (a).begin(),(a).end()
#define sz(x) (int)x.size()
#define mod 1000000007
#define EPS 1e-9
#define io ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define inf 1e10
#define PI acos(-1.0)
#define int long long
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define N 100005
void solve(){
int n;
cin>>n;
vi a(n);
for(int i=0;i<n;i++) cin>>a[i];
int ans = 0;
for(int bit=0;bit<61;bit++){
int z = 0, o = 0;
for(int i=0;i<n;i++){
if((a[i]>>bit)&1) o++;
else z++;
}
int cur = (o*z)%mod;
cur = (cur*((1LL<<bit)%mod))%mod;
ans = (ans+cur)%mod;
}
cout<<ans<<endl;
}
signed main(){
io;
int tests;
tests = 1;
while(tests--){
solve();
}
return 0;
} | 0 | 18,693,077 |
#include <algorithm>
#include <iostream>
#include <stdio.h>
using namespace std;
int X[3];
int main() {
for (int i = 0; i < 3; ++i) {
cin >> X[i];
}
sort(X, X + 3);
int ba = X[1] - X[0];
int ca = X[2] - X[0];
int cb = X[2] - X[1];
if (cb % 2 == 0 && ca % 2 == 0) {
printf("%d\n", (ca + cb) / 2);
} else if (ba % 2 == 0) {
printf("%d\n", 1 + (ca - 1 + cb - 1) / 2);
} else {
printf("%d\n", (cb + ca + 1) / 2 + 1);
}
} | #include<bits/stdc++.h>
using namespace std;
#define rg register
#define rep(i,a,b) for (rg int i=(a);i<=(b);i++)
#define per(i,a,b) for (rg int i=(b);i>=(a);i--)
#define pb push_back
#define lowbit(x) (x&(-x))
#define replow(i,a,b) for(rg int i = (a);i<=(b);i+=lowbit(i))
#define perlow(i,a,b) for(rg int i = (b);i>=(a);i-=lowbit(i))
#define mk make_pair
#define VI vector<int>
#define pii pair<int,int>
#define pLL pair<long long,long long>
#define fi first
#define se second
#define il inline
#define ll long long
#define ull unsigned long long
#define db double
#define ld long double
#define inf 0x3f3f3f3f
#define getc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<15,stdin),p1==p2)?EOF:*p1++)
char buf[1<<15],*p1 = buf,*p2 = buf;
inline ll read(){
#define num ch-'0'
char ch;bool flag=0;ll res;
while(!isdigit(ch=getc()))
(ch=='-')&&(flag=true);
for(res=num;isdigit(ch=getc());res=res*10ll+num);
(flag)&&(res=-res);
#undef num
return res;
}
inline void write(ll x){
if (x < 0) x = ~x + 1ll, putchar('-');
if (x > 9) write(x / 10ll);
putchar(x % 10ll + '0');
}
#define mid ((l + r)>>1)
#define ls (x<<1)
#define rs ((x<<1)|1)
#undef mid
#undef ls
#undef rs
const ll maxn = 1e9;
void solve()
{
ll S = read();
ll t = S / 1e9;
ll tmp = S % (ll)(1e9);
if(S % maxn == 0) printf("0 0 %lld %lld %lld %lld\n",maxn,0,1,t);
else
printf("0 0 %lld %lld %lld %lld\n",maxn,(maxn -tmp),1,t+1);
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("data.txt","r",stdin);
#endif
solve();
} | 0 | 95,832,346 |
#include <iostream>
#include <vector>
#define VERTEX_NUM_MAX 101
using namespace std;
typedef vector<int> Vertex;
int n;
Vertex vs[VERTEX_NUM_MAX];
int ds[VERTEX_NUM_MAX];
void _bfs(vector<int>& targets, int distance) {
vector<int> next_targets;
for(auto it = targets.begin(); it != targets.end(); it++) {
if(ds[*it] == -1) {
ds[*it] = distance;
auto& t = vs[*it];
for(auto itt = t.begin(); itt != t.end(); itt++)
next_targets.push_back(*itt);
}
}
if(next_targets.empty())
return;
_bfs(next_targets, distance+1);
}
void bfs() {
vector<int> targets;
targets.push_back(1);
_bfs(targets, 0);
}
int main() {
for(int i=0; i<VERTEX_NUM_MAX; i++) {
ds[i] = -1;
}
cin >> n;
int u, k, p;
for(int i=1; i<=n; i++) {
cin >> u >> k;
for(int j=0; j<k; j++) {
cin >> p;
vs[i].push_back(p);
}
}
bfs();
for(int i=1; i<=n; i++) {
cout << i << " " << ds[i] << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> VI;
typedef vector<VI> VVI;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const int INF = numeric_limits<int>::max() / 2;
const int NEG_INF = numeric_limits<int>::min() / 2;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
string s;
while(true){
getline(cin,s);
if(s==".") break;
int len=s.length();
std::vector<char> v;
for(int i=0;i<len;i++){
if(s[i]=='(' || s[i]==')' || s[i]=='[' || s[i]==']'){
v.push_back(s[i]);
}
}
bool update=true;
while(update){
update=false;
int le=v.size();
for(int i=0;i<le-1;i++){
if((v[i]=='(' && v[i+1]==')') || (v[i]=='[' && v[i+1]==']')){
v.erase(v.begin()+i,v.begin()+i+2);
update=true;
i=le;
}
}
}
if(v.empty()) cout << "yes" << endl;
else cout << "no" << endl;
}
} | 0 | 46,600,379 |
#include <string.h>
#include <iostream>
#include <string>
using namespace std;
int main()
{
int n = 0, taro_point = 0, hanako_point = 0;
char taro_card[100 + 1] = { 0 },
hanako_card[100 + 1] = { 0 };
cin >> n;
for (int i = 0; i < n; i++) {
cin >> taro_card >> hanako_card;
int result = strcmp(taro_card, hanako_card);
if (result > 0) {
taro_point += 3;
}
else if (result < 0) {
hanako_point += 3;
}
else {
taro_point++;
hanako_point++;
}
}
cout << taro_point << " " << hanako_point << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int n;
while(cin>>n,n){
vector<pair<string,bool> >v;
string a,b;
for(int i=0;i<n;i++){
cin>>a>>b;
v.push_back(make_pair(a,1));
v.push_back(make_pair(b,0));
}
sort(v.begin(),v.end());
int ans=0,k=0;
string ts;
for(int i=0;i<v.size();i++){
if(!k)ts=v[i].first;
if(v[i].second)k++;
else k--;
ans=max(k,ans);
}
cout<<ans<<endl;
}
return 0;
} | 0 | 36,899,891 |
#include <bits/stdc++.h>
using namespace std;
#define froop1(a,n) for(int i = a;i < n;i++)
#define froop2(a,n) for(int i = a;i > n;i--)
int main(){
long long N;
cin >> N;
vector<long long> a;
froop1(1,sqrt(N) + 1){
if(N % i == 0){
a.push_back(N / i);
}
}
sort(a.begin(),a.end());
int count = 0,c = a.at(0);
while(c > 0){
c /= 10;
count++;
}
cout << count << endl;
} | #include <bits/stdc++.h>
typedef long long int ll;
typedef long double ld;
using namespace std;
const long long int INF = 1e9;
const long long int mod = 1e9+7;
typedef pair<ll,ll> pairs;
vector<pairs> p;
ll gcd(ll a,ll b){
if (a%b==0)return(b);
else return(gcd(b,a%b));
}
ll keta(ll N){
int tmp{};
while( N > 0 ){
tmp += ( N % 10 );
N /= 10;
}
N = tmp;
return N;
}
vector<vector<ll>> combination(ll n, ll r){
vector<vector<ll>> v(n + 1, vector<ll>(n + 1, 0));
for(ll i=0;i<v.size();++i){
v[i][0] = 1;
v[i][i] = 1;
}
for(ll i=1;i<v.size();++i){
for(ll j=0;j<i;++j){
v[i][j] = (v[i - 1][j - 1] + v[i - 1][j]);
}
}
return v;
}
int main(){
ll n;
cin>>n;
ll a[n];
for(ll i=0;i<n;++i){
cin>>a[i];
}
ll ans=0;
for(ll i=0;i<n;++i){
if(i+1 == a[a[i]-1]){
ans++;
}
}
ans /= 2;
cout<<ans<<endl;
return 0;
} | 0 | 18,383,389 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 1e5 + 5, mod = 1e9 + 7;
int N;
vector<int> adj[MAXN];
ll dp[MAXN][2];
ll rec(int u, int p, int c)
{
if (dp[u][c] != -1)
return dp[u][c];
ll tot = 0, ways = 1;
for (int v : adj[u])
{
if (v == p)
continue;
ways = ways * rec(v, u, 0) % mod;
}
tot = ways;
if (c == 0)
{
ways = 1;
for (int v : adj[u])
{
if (v == p)
continue;
ways = ways * rec(v, u, 1) % mod;
}
tot = (tot + ways) % mod;
}
return dp[u][c] = tot;
}
int main()
{
ios_base::sync_with_stdio(0);
cin >> N;
for (int i = 0; i < N - 1; i++)
{
int x, y;
cin >> x >> y;
x--, y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
memset(dp, -1, sizeof(dp));
ll ans = rec(0, -1, 0);
cout << ans;
return 0;
} | #include<bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
int N;
cin>>N;
vector<int> A(N);
int a=0,b=0;
for(int &i:A){
cin>>i;
if(i>0)a++;
else b++;
}
sort(A.begin(),A.end());
vector<pair<int,int>> B;
if(a==N){
for(int i=2;i<N;i++){
B.push_back({A[0],A[i]});
A[0]-=A[i];
}
B.push_back({A[1],A[0]});
A[1]-=A[0];
cout<<A[1]<<endl;
for(pair<int,int> p:B)cout<<p.first<<' '<<p.second<<endl;
return 0;
}
if(b==N){
for(int i=0;i<N-1;i++){
B.push_back({A[N-1],A[i]});
A[N-1]-=A[i];
}
cout<<A[N-1]<<endl;
for(pair<int,int> p:B)cout<<p.first<<' '<<p.second<<endl;
return 0;
}
for(int i=1;i<a;i++){
B.push_back({A[b-1],A[N-i]});
A[b-1]-=A[N-i];
}
for(int i=0;i<b;i++){
B.push_back({A[b],A[i]});
A[b]-=A[i];
}
cout<<A[b]<<endl;
for(pair<int,int> p:B)cout<<p.first<<' '<<p.second<<endl;
} | 0 | 89,169,077 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <list>
using namespace std;
int main() {
list<int> ls; char c[21];
int n; cin >> n;
while (n--) {
scanf("%s", c);
if (c[0] == 'i') { int t; scanf("%d", &t); ls.push_front(t); }
else if (c[6] == 'F') ls.pop_front();
else if (c[6] == 'L') ls.pop_back();
else {
int t; scanf("%d", &t);
auto ite = find(ls.begin(), ls.end(), t);
if (ite != ls.end()) ls.erase(ite);
}
}
int cnt = 0;
for (auto ite : ls) {
if (cnt) cout << ' ';
cout << ite; cnt++;
}
cout << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
int N;
cin >> N;
vector<string> S(N);
for (int i = 0; i < N; i++) cin >> S[i];
int ans = 0;
for (int i = 0; i < N; i++) {
bool check = true;
for (int j = 0; j < N; j++) {
for (int k = j; k < N; k++) {
if (S[(j-i+N)%N][k] != S[(k-i+N)%N][j]){
check = false;
break;
}
}
if (!check)break;
}
if (check) ans += N;
}
cout << ans << endl;
return 0;
} | 0 | 89,079,322 |
#include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i, s, n) for (int i = (s); i < (n); ++i)
#define rrep(i, n, g) for (int i = (n)-1; i >= (g); --i)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define len(x) (int)(x).size()
#define dup(x, y) (((x) + (y)-1) / (y))
#define pb push_back
#define Field(T) vector<vector<T>>
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
vector<vector<int>> a(3, vector<int>(3));
rep(i, 0, 3) rep(j, 0, 3) cin >> a[i][j];
int n;
cin >> n;
rep(i, 0, n) {
int b;
cin >> b;
rep(j, 0, 3) rep(k, 0, 3) {
if (b == a[j][k]) a[j][k] = 0;
}
}
bool ans = false;
rep(i, 0, 3) {
if (a[i][0] == 0 && a[i][1] == 0 && a[i][2] == 0) ans = true;
}
rep(i, 0, 3) {
if (a[0][i] == 0 && a[1][i] == 0 && a[2][i] == 0) ans = true;
}
if (a[0][0] == 0 && a[1][1] == 0 && a[2][2] == 0) ans = true;
if (a[0][2] == 0 && a[1][1] == 0 && a[2][0] == 0) ans = true;
if (ans)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#pragma region
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << (#x) << "] = [", _print(x)
#else
#define debug(x...)
#endif
#pragma endregion
typedef long long ll;
#define forn(i, n) for (int i = 0; i < int(n); ++i)
#define sz(v) int((v).size())
#define int ll
#pragma region
#define f first
#define s second
#define mp make_pair
#define mt make_tuple
#define pb push_back
#pragma endregion
int n, p;
string s;
void solve()
{
cin>>n>>p>>s;
int ans = 0;
if (p == 2)
{
forn(i, n)
{
if ((s[i] - '0')%2 == 0) ans += i+1;
}
cout << ans << '\n';
return;
}
if (p == 5)
{
forn(i, n)
{
if ((s[i] - '0')%5==0) ans += i+1;
}
cout << ans << '\n';
return;
}
map<int,int> cnt;
cnt[0] = 1;
int now = 0;
int p2 = 1;
for(int i=n-1;i>=0;--i)
{
now = (now + (s[i] - '0')*p2)%p;
p2 = p2*10%p;
ans += cnt[now];
cnt[now]++;
}
cout << ans << '\n';
}
signed main()
{
int T = 1;
ios_base::sync_with_stdio(0); cin.tie(0);
cout << fixed << setprecision(22);
for(int i=1;i<=T;++i)
{
solve();
}
return 0;
} | 0 | 65,965,544 |
#include <bits/stdc++.h>
int main(){
int N;
std::cin >> N;
std::vector< int > cnt(N+1, 0);
for(int i=2; i<=N; i++){
int cur = i;
for(int j=2; j*j<=N; j++){
while(cur % j == 0){
cur /= j;
cnt[j]++;
}
if(cur == 1){
break;
}
}
cnt[cur]++;
}
cnt[1] = 1;
int ans = 0;
std::deque< int > num;
std::deque< int > next;
num.push_back(1);
next.push_back(2);
while(!num.empty()){
int cur_num = num[0];
int cur_next = next[0];
num.pop_front();
next.pop_front();
if(cur_num == 75){
ans++;
}
if(cur_num >= 75){
continue;
}
if(cur_next > N){
continue;
}
for(int i=0; i<=cnt[cur_next]; i++){
int tmp = cur_num * (i+1);
if(tmp > 75){
break;
}
num.push_back(cur_num * (i+1));
next.push_back(cur_next+1);
}
}
std::cout << ans << std::endl;;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define MOD 1000000007
int main(void) {
ll N, K;
vector<ll> gems;
ll maxi = 0;
cin >> N >> K;
gems.resize(N);
for(ll i = 0;i < N;i++) cin >> gems[i];
for(ll a = 0;a <= min(N, K);a++) {
for(ll b = 0;b <= min(N, K);b++) {
vector<ll> v;
ll count = 0;
if(a + b > min(N, K)) break;
for(ll i = 0;i < a;i++) v.push_back(gems[i]), count += gems[i];
for(ll i = 0;i < b;i++) v.push_back(gems[gems.size() - 1 - i]), count += gems[gems.size() - 1 - i];
sort(v.begin(), v.end());
for(ll i = 0;i < min((ll)v.size(), K - (a + b));i++) {
if(v[i] >= 0) break;
count -= v[i];
}
maxi = max(maxi, count);
}
}
cout << maxi << endl;
return 0;
} | 0 | 40,560,799 |
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<vector>
#include<string.h>
#include<math.h>
using namespace std;
int syc(long i,long Min,long Max){
if(Min <= i && i <= Max){
return 1;
}else{
exit(1);
}
}
int main(){
int n,m,x,y;
cin >> n >> m >> x >> y;
syc(n,1,100);
syc(m,1,100);
syc(x,-100,100);
syc(y,-100,100);
int a[n],b[m];
int temp;
for(int i=0;i<n;i++){
cin >> a[i];
}
for(int i=0;i<m;i++){
cin >> b[i];
}
for(int i=0;i<n-1;i++){
for(int j=i+1;j<n;j++){
if(a[i]>a[j]){
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
for(int i=0;i<m-1;i++){
for(int j=i+1;j<m;j++){
if(b[i]>b[j]){
temp=b[i];
b[i]=b[j];
b[j]=temp;
}
}
}
if(a[n-1]<b[0] && x<b[0] && b[0]<=y){
cout << "No War" << endl;
}else{
cout << "War" << endl;
}
return 0;
} | #include<bits/stdc++.h>
#define ll long long
using namespace std;
#define mx 100009
ll ar[mx][3];
ll mem[mx][3];
ll n;
ll dp(ll ind,ll f){
if(ind>=n) return 0;
else if(mem[ind][f]!=-1) return mem[ind][f];
ll ans=0;
if(f==0){
ll x=ar[ind+1][1]+dp(ind+1,1);
ll y=ar[ind+1][2]+dp(ind+1,2);
ans=max(x,y);
}
else if(f==1){
ll x=ar[ind+1][0]+dp(ind+1,0);
ll y=ar[ind+1][2]+dp(ind+1,2);
ans=max(x,y);
}
else{
ll x=ar[ind+1][1]+dp(ind+1,1);
ll y=ar[ind+1][0]+dp(ind+1,0);
ans=max(x,y);
}
return mem[ind][f]=ans;
}
int main()
{
memset(mem,-1,sizeof(mem));
cin>>n;
for(ll i=1;i<=n;i++){
cin>>ar[i][0]>>ar[i][1]>>ar[i][2];
}
ll a=ar[1][0]+dp(1,0);
ll b=ar[1][1]+dp(1,1);
ll c=ar[1][2]+dp(1,2);
cout<<max(a,max(b,c))<<endl;
return 0;
} | 0 | 64,331,426 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
bool alphabets[26];
fill(alphabets, alphabets + 26, false);
for (int i = 0; S[i] != '\0'; i++) alphabets[S[i] - 'a'] = true;
for (int i = 0; i < 26; i++) {
if (alphabets[i] == false) {
cout << (char)(i + 'a') << endl;
return 0;
}
}
cout << "None" << endl;
return 0;
} | #include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <set>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
#define mp(a,b) make_pair(a,b)
#define pb(a) push_back(a)
#define dbg(x) cout<<#x"="<<x<<endl
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<pii, int> ppi;
#define INF 1000000000
int dc(char *n){
int idx=0;
int res=0;
int sz=strlen(n);
while(idx<sz){
int current=1;
if(n[idx]>='2' && n[idx]<='9'){
current = n[idx] - '0';
idx++;
}
switch(n[idx]){
case 'm': current*=1000; break;
case 'c': current*=100; break;
case 'x': current*=10; break;
}
idx++;
res+=current;
}
return res;
}
int main(){
int n;
cin >> n;
while(n-->0){
char n1[10], n2[10];
scanf("%s %s", n1, n2);
int num= dc(n1)+dc(n2);
string res;
rep(i,4){
int k[]={1000,100,10,1};
string c[]={"m","c","x","i"};
if(num>=2*k[i]){
res += (num/k[i]+'0');
res += c[i];
num%=k[i];
}
else if(num>=k[i]){
res += c[i];
num%=k[i];
}
}
cout << res<<endl;
}
} | 0 | 82,408,696 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using LL = long long;
using P = pair<int,int>;
int main(){
int A, B, C;
cin >> A >> B >> C;
for(int i = 0; i < B; ++i){
if((A*i)%B==C) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define pb push_back
const int N = 102, K = 4;
ll dp[N][K][2];
char s[N];
int k, n;
ll rec(int x, int cnt, int f) {
if (x == n) {
return cnt == k;
}
if (cnt > k) return 0;
ll &ret = dp[x][cnt][f];
if (ret != -1) return ret;
ret = 0;
if (f) {
for (int i = 0; i < s[x] - '0'; i++) {
ret += rec(x + 1, cnt + (i != 0), 0);
}
ret += rec(x + 1, cnt + (s[x] != '0'), 1);
} else {
for (int i = 0; i < 10; i++) {
ret += rec(x + 1, cnt + (i != 0), 0);
}
}
return ret;
}
int main() {
scanf("%s\n%d", s, &k);
n = strlen(s);
memset(dp, -1, sizeof dp);
printf("%lld", rec(0, 0, 1));
return 0;
} | 0 | 83,235,047 |
#include <stdio.h>
int main(){
int array[10][10];
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
scanf("%d", &array[i][j]);
}
}
int brpKali;
scanf("%d", &brpKali);
int percobaan[100];
for(int k=0;k<brpKali;k++){
scanf("%d", &percobaan[k]);
}
for(int l=0;l<brpKali;l++){
for(int m=0;m<3;m++){
for(int n=0;n<3;n++){
if(percobaan[l]==array[m][n]){
array[m][n]=0;
}
}
}
}
if(array[0][0]+array[1][1]+array[2][2]==0){
printf("Yes\n");
}
else if(array[0][2]+array[1][1]+array[2][0]==0){
printf("Yes\n");
}
else if(array[0][0]+array[0][1]+array[0][2]==0){
printf("Yes\n");
}
else if(array[1][0]+array[1][1]+array[1][2]==0){
printf("Yes\n");
}
else if(array[2][0]+array[2][1]+array[2][2]==0){
printf("Yes\n");
}
else if(array[0][0]+array[1][0]+array[2][0]==0){
printf("Yes\n");
}
else if(array[0][1]+array[1][1]+array[2][1]==0){
printf("Yes\n");
}
else if(array[0][2]+array[1][2]+array[2][2]==0){
printf("Yes\n");
}
else{
printf("No\n");
}
return 0;
} | #include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#define ffor(_a,_f,_t) for(int _a=(_f),__t=(_t);_a<__t;_a++)
#define all(_v) (_v).begin() , (_v).end()
#define sz size()
#define pb push_back
#define SET(__set, val) memset(__set, val, sizeof(__set))
#define FOR(__i, __n) ffor (__i, 0, __n)
typedef long long LL;
using namespace std;
LL A, B;
LL mysqrt(LL x) {
LL y = sqrt(x);
if (y * y > x)
y--;
if ((y + 1LL) * (y + 1LL) <= x)
return y + 1;
return y;
}
int main() {
int tests;
cin >> tests;
FOR (test, tests) {
cin >> A >> B;
if (A * B <= 1000) {
LL ret = 0LL;
bool usedi[A * B + 1];
bool usedj[A * B + 1];
SET(usedi, 0);
SET(usedj, 0);
ffor (i, 1, A * B + 1)
for (int j = A * B; j > 0; j--) {
if (usedi[i] || usedj[j])
continue;
if (i == A || j == B)
continue;
if (i * j < A * B) {
usedi[i] = true;
usedj[j] = true;
ret++;
}
}
cout << ret << endl;
continue;
}
LL ret = 0LL;
LL mm = A * B - 1;
LL s = mysqrt(mm);
ret += 2 * s;
if (s * (s + 1) > mm)
ret--;
if (s >= min(A, B))
ret--;
cout << ret << endl;
}
return 0;
} | 0 | 56,308,221 |
#include<bits/stdc++.h>
#define rep(i,n) for (long long i = 0; i < (n); ++i)
using namespace std;
long gcd(long a,long b){
if (a%b==0){
return(b);
}
else{
return(gcd(b,a%b));
}
}
long lcm( long m, long n ){
if ( ( 0 == m ) || ( 0 == n ) )
return 0;
return ((m / gcd(m, n)) * n);
}
int main(){
long long A, B;
cin >> A >> B;
cout << lcm(A, B) << endl;
} | #include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define ll long long
#define pb push_back
#define mp make_pair
#define endl "\n"
#define int long long
#define f0(n) for(int i=0;i<n;i++)
#define ms(x) memset(x,0,sizeof(x))
#define ms2d(x,m,n) memset(x, 0, sizeof(x[0][0]) * m * n)
#define uniq(vec) vec.resize(distance(vec.begin(),unique(vec.begin(),vec.end())))
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define pi pair<int,int>
#define tc(t) int t;cin>>t;while(t--)
#define bits(n) __builtin_popcount(n)
#define maxpq priority_queue<int>
#define minpq priority_queue<int, vector<int>, greater<int> >
#define ins insert
#define ALL(v) v.begin(),v.end()
#define highest(x) numeric_limits<x>::max()
#define lowest(x) numeric_limits<x>::min()
#define Inf INFINITY
#define minv(v) *min_element(v.begin(),v.end())
#define maxv(v) *max_element(v.begin(),v.end())
#define fi first
#define se second
#define PI acos(-1)
#define sz(a) (int)a.size();
#define IOS ios::sync_with_stdio(false);
using namespace std;
int gcd(int a, int b) { if (a == 0) return b; return gcd(b % a, a);}
typedef tree<pair<int, int>,null_type,less<pair<int, int>>,rb_tree_tag,tree_order_statistics_node_update> ordered_multiset;
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1,-1, 1, -1, 0, 0, -1, 1};
int dx4[] = {0, 0, 1, -1};
int dy4[] = {1, -1, 0, 0};
const long long MOD = 1000000007;
double sq(double x) {return x*x;}
template<typename T>inline T Bigmod(T base, T power, T MOD){
T ret=1;
while(power)
{
if(power & 1)ret=(ret*base)%MOD;
base=(base*base)%MOD;
power>>=1;
}
return ret;
}
bool sortinrev(const pair<int,int> &a,
const pair<int,int> &b)
{
return (a.first > b.first);
}
signed main()
{
IOS
int a,b;
while(cin>>a>>b){
bool got=0;
for(int i=1;i<=10000;i++){
int ta=(i)*0.08;
int tb=(i)*0.1;
if(a==ta && b==tb){
cout << i << endl;
got=1;
break;
}
}
if(!got)cout << -1 << endl;
}
return 0;
} | 0 | 62,486,634 |
#include<iostream>
using namespace std;
int main()
{
string s,t;
cin>>s>>t;
int c=0;
for(int i=0;i<s.length();i++)
{
if(s[i]==t[i])
c++;
}
cout<<c;
} | #include<bits/stdc++.h>
using namespace std;
#pragma GCC target ("avx2")
#pragma GCC optimization ("unroll-loops")
#pragma GCC optimize("O2")
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define all(v) v.begin(),v.end()
#define prec(n) fixed<<setprecision(n)
#define n_l '\n'
#define gcd __gcd
#define append push_back
#define str to_string
#define max3(a,b,c) max(a,max(b,c))
#define min3(a,b,c) min(a,min(b,c))
#define sswap(a,b) {a=a^b;b=a^b;a=a^b;}
#define swap(a,b) {auto temp=a; a=b; b=temp;}
#define init(dp) memset(dp,-1,sizeof(dp));
#define set0(dp) memset(dp,0,sizeof(dp));
#define bits(x) __builtin_popcount(x)
#define SORT(v) sort(all(v))
#define endl "\n"
#define forr(i,n) for(ll i=0;i<n;i++)
typedef long long int ll;
#define int ll
constexpr int dx[] = {-1, 0, 1, 0, 1, 1, -1, -1};
constexpr int dy[] = {0, -1, 0, 1, 1, -1, 1, -1};
constexpr ll INF = 1999999999999999997;
constexpr int inf= INT_MAX;
constexpr int MAXSIZE = int(1e6)+5;
constexpr auto PI = 3.14159265358979323846L;
constexpr auto oo = numeric_limits<int>::max() / 2 - 2;
constexpr auto eps = 1e-6;
constexpr auto mod = 1000000007;
constexpr auto MOD = 1000000007;
constexpr auto MOD9 = 1000000009;
constexpr auto maxn = 100006;
void fastio(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
int cnt[maxn];
int is[maxn];
int32_t main(){
fastio();
int n,m;
cin >> n >> m;
for(int i = 1; i <= m; i++){
int x;
cin >> x;
is[x] = 1;
}
cnt[0] = 1;
for(int i = 1; i <= n; i++){
if(is[i]) continue;
if(i - 1 >= 0) cnt[i] += cnt[i - 1];
cnt[i] %= mod;
if(i - 2 >= 0) cnt[i] += cnt[i - 2];
cnt[i] %= mod;
}
cout <<cnt[n];
} | 0 | 92,141,981 |
#include <bits/stdc++.h>
using namespace std;
typedef long lint;
typedef long long llint;
bool compPair(const pair<int, int>& arg1, const pair<int, int>& arg2) { return arg1.first > arg2.first; }
template<class T> void chmax(T& a, T b) { if (a < b) { a = b; } }
template<class T> void chmin(T& a, T b) { if (a > b) { a = b; } }
int main(void) {
int n;
cin >> n;
int ans;
ans = n/111;
ans *= 111;
if(n%111!=0&&n!=111) ans += 111;
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <climits>
#include <cstdio>
#include <cctype>
#include <queue>
#include <cmath>
#include <stack>
using namespace std;
const int inf = 0x3f3f3f3f, N = 20;
int e[N][N];
void floyd(int n)
{
for(int k = 0; k <= n; k++)
for(int i = 0; i <= n; i++)
for(int j = 0; j <= n; j++)
e[i][j] = min(e[i][k] + e[k][j], e[i][j]);
}
int main()
{
int m;
while(cin >> m, m) {
for(int i = 0; i < 10; i++)
for(int j = 0; j < 10; j++) {
if(i == j) e[i][j] = 0;
else e[i][j] = e[j][i] = inf;
}
int Max = 0;
while(m--) {
int x, y, l;
scanf("%d%d%d", &x, &y, &l);
if(x > Max) Max = x;
if(y > Max) Max = y;
e[x][y] = e[y][x] = l;
}
floyd(Max);
int msum = inf, mp;
int ms = 0;
for(int i = 0; i <= Max; i++) {
ms = 0;
for(int j = 0; j <= Max; j++) {
ms += e[i][j];
}
if(ms < msum) {
msum = ms;
mp = i;
}
}
printf("%d %d\n", mp, msum);
}
return 0;
} | 0 | 8,892,146 |
#include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define rep2(i, s, n) for (ll i = s; i < (ll)(n); i++)
#define repr(i, n) for (ll i = n; i >= 0; i--)
#define pb push_back
#define COUT(x) cout << (x) << endl
#define COUTF(x) cout << setprecision(15) << (x) << endl
#define ENDL cout << endl
#define DF(x) x.erase(x.begin())
#define ALL(x) x.begin(), x.end()
#define SORT(x) sort(ALL(x))
#define REVERSE(x) reverse(ALL(x))
#define init() \
cin.tie(0); \
ios::sync_with_stdio(false)
#define debug(x) cerr << "[debug] " << #x << ": " << x << endl;
#define debugV(v) \
cerr << "[debugV] " << #v << ":"; \
rep(i, v.size()) cerr << " " << v[i]; \
cerr << endl;
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using P = pair<ll, ll>;
constexpr ll INF = 0x3f3f3f3f3f3f3f3f;
constexpr double PI = 3.141592653589793238462643383279;
ll getDigit(ll x) {
return x == 0 ? 1 : log10(x) + 1;
}
ll gcd(ll x, ll y) {
return y ? gcd(y, x % y) : x;
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b;
}
vector<P> factorize(ll n) {
vector<P> result;
for (ll i = 2; i * i <= n; ++i) {
if (n % i == 0) {
result.pb({i, 0});
while (n % i == 0) {
n /= i;
result.back().second++;
}
}
}
if (n != 1) {
result.pb({n, 1});
}
return result;
}
vll divisor(ll n) {
vll ret;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
SORT(ret);
return (ret);
}
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;
}
signed main() {
init();
ll N;
cin >> N;
vector<vector<pair<ll, ll>>> to(N);
rep(i, N - 1) {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
to[a].pb({b, c});
to[b].pb({a, c});
}
ll Q, K;
cin >> Q >> K;
K--;
vector<P> q(Q);
rep(i, Q) {
ll x, y;
cin >> x >> y;
x--;
y--;
q[i] = {x, y};
}
vll dp(N, -1);
queue<pair<ll, ll>> que;
que.push({K, 0});
while (!que.empty()) {
pair<ll, ll> p = que.front();
que.pop();
if (dp[p.first] != -1) {
continue;
}
dp[p.first] = p.second;
rep(i, to[p.first].size()) {
pair<ll, ll> a = to[p.first][i];
que.push({a.first, p.second + a.second});
}
}
rep(i, Q) {
ll ans = dp[q[i].first] + dp[q[i].second];
COUT(ans);
}
return 0;
} | #include<cstdio>
#include<queue>
#include<algorithm>
using namespace std;
char c[1001][1002];
int d[1000001];
int main(){
int n,m;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
scanf("%s",c[i]+1);
queue<int>q;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
if(c[i][j]=='#'){
q.push((i-1)*m+j);
d[(i-1)*m+j]=1;
}
int ans=0;
while(!q.empty()){
int u=q.front();
q.pop();
ans=max(ans,d[u]);
for(int i=0;i<4;i++){
int v=u;
if(i==0&&u<=m||i==1&&u%m==1%m||i==2&&u>=(n-1)*m+1||i==3&&u%m==0)
continue;
if(i==0)v-=m;
else if(i==1)v--;
else if(i==2)v+=m;
else v++;
if(!d[v]){
d[v]=d[u]+1;
q.push(v);
}
}
}
printf("%d\n",ans-1);
} | 0 | 75,176,590 |
#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() {
ll n, c, k;
cin >> n >> c >> k;
vector<ll> t(n);
rep(i, n) cin >> t[i];
sort(t.begin(), t.end());
vector<bool> done(n, false);
ll cnt = 0;
rep(i, n) {
if (done[i]) continue;
ll idx = i;
ll departure = t[idx] + k;
ll capacity = c;
while (t[idx] <= departure && capacity != 0) {
done[idx] = true;
capacity--;
idx++;
if (idx >= n) break;
}
cnt++;
}
cout << cnt << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
vector<int> a(n);
for(int i=0; i<n; i++){
cin >> a[i];
}
sort(a.begin(),a.end());
int x = 1;
vector<int> cards;
for(int i=0; i<n; i++){
if(a[i] == a[i+1]) x += 1;
if(a[i] != a[i+1]){
cards.push_back(x);
x = 1;
}
}
int m = cards.size();
cout << m - (1 - m % 2) << endl;
return 0;
} | 0 | 76,019,556 |
#include <bits/stdc++.h>
using namespace std;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
using ll = long long;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
ll N,M;
cin>>N>>M;
vector<ll> mo(N);
for(ll i = 0LL; i < N; i++) {
ll x;
cin>>x;
if(i==0LL) mo[i]=x%M;
else mo[i]=(mo[i-1]+x)%M;
}
sort(mo.begin(),mo.end());
ll ans = 0LL;
ll k = 0LL;
for(ll i = 0LL; i < N;i++){
k++;
if(i==N-1LL||mo[i]!=mo[i+1LL]){
if(mo[i]==0LL)ans+=(k+k*(k-1LL)/2LL);
else ans+=(k*(k-1LL)/2LL);
k=0LL;
}
}
cout<<ans<<endl;
} | #include<iostream>
#include<stdio.h>
#include<vector>
#include<float.h>
#include<iomanip>
#include<algorithm>
#include<string>
#include<cstring>
#include<math.h>
#include<cmath>
#include<sstream>
#include<set>
#include<map>
#include<queue>
#include<cassert>
#include<cmath>
#include<cstdint>
#define INF 1e9
#define rep(i,n)for(int i=0;(i)<(int)(n);i++)
#define REP(i,a,b)for(int i=(int)(a);(i)<=(int)(b);i++)
#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;
#define vec(type,n) vector<type>(n)
#define vvec(m,n) vector<vector<int>> (int(m),vector<int>(n))
#define ALL(a) (a).begin(),(a).end()
#define chmin(a, b) a = min(a, b)
#define chmax(a, b) a = max(a, b)
#define pb push_back
#define sz size()
using namespace std;
using ll = long long int;
using Graph = vector<vector<int>>;
using P = pair<ll, ll>;
using Vl = vector<ll>;
const int MOD = 1e9 + 7;
const ll ZER = 0;
ll gcd(ll a, ll b){
if(a % b == 0)return b;
else return gcd(b, a % b);
}
int main(){
ll n, a, b;
cin >> n >> a >> b;
if(a > b || (n == 1 && a != b)){
cout << 0 << endl;
return 0;
}
cout << b * (n - 1) + a - (b + a * (n - 1)) + 1 << endl;
} | 0 | 80,480,389 |
#include <bits/stdc++.h>
using namespace std;
#define all(v) v.begin(), v.end()
using in = int64_t;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define Yes cout<<"Yes"<<endl
#define No cout<<"No"<<endl
#define yes cout<<"yes"<<endl
#define no cout<<"no"<<endl
const double PI=3.14159265358979323846;
const in MOD = 1000000007ll;
const in INF=1e18+7;
const int inf=1e9+7;
using P=pair<int,int>;
vector<int> dx={0,1,-1,0};
vector<int> dy={1,0,0,-1};
int main(){
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
cout << fixed << setprecision(10);
string s;
cin>>s;
int n=s.size();
vector<vector<vector<in>>> dp(n,vector<vector<in>>(2,vector<in>(2,0ll)));
dp[0][0][0]=0ll;
dp[0][0][1]=1ll;
dp[0][1][0]=2ll;
dp[0][1][1]=0ll;
REP(i,1,n){
if(s[i]=='1'){
dp[i][0][0]=0ll;
dp[i][0][1]=dp[i-1][0][0]+dp[i-1][0][1]+dp[i-1][1][0]+dp[i-1][1][1];
dp[i][0][1] %=MOD;
dp[i][1][0]=dp[i-1][0][0]*2ll+dp[i-1][1][0]*2ll;
dp[i][1][0] %= MOD;
dp[i][1][1]=dp[i-1][0][1]*2ll+dp[i-1][1][1]*2ll;
dp[i][1][1] %= MOD;
}
else{
dp[i][0][0]=dp[i-1][0][0]+dp[i-1][1][0];
dp[i][0][0] %= MOD;
dp[i][0][1]=dp[i-1][0][1]+dp[i-1][1][1];
dp[i][0][1] %= MOD;
dp[i][1][0]=0ll;
dp[i][1][1]=dp[i-1][0][1]*2ll+dp[i-1][1][1]*2ll;
dp[i][1][1] %=MOD;
}
}
in ans=dp[n-1][0][0]+dp[n-1][0][1]+dp[n-1][1][0]+dp[n-1][1][1];
ans %= MOD;
cout<<ans<<endl;
} | #include<bits/stdc++.h>
#include<iostream>
#include<algorithm>
#include<vector>
#include<cmath>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
#define MAX 505
typedef long long ll;
int main(int, char**)
{
int n, m;
cin >> n >> m;
int ofs = 0;
int fst, snd;
rep(i,m) {
fst = i + 1;
snd = n - i;
if (fst > n / 4 && n % 2 == 0) snd -= 1;
cout << fst << " " << snd << endl;
}
return 0;
} | 0 | 64,345,015 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a , b ,c, d ;
cin >> a >> b >> c >> d ;
if ( abs(a-c)< abs(c-b)){
cout << " Yes";
}
else if ( abs(a-b)<= d && abs( b-c)<=d ) {
cout<<"Yes";
}
else {
cout<< "No";
}
return 0 ;
} | #include <bits/stdc++.h>
#define rep(i, n) for(long long int i = 0; i < n; i++)
#define _rep(i, m, n) for(long long int i = m; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll mod = 1000000007;
using Graph = vector<vector<int>>;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll gcd(ll A, ll B){
if(B == 0)return A;
return gcd(B, A % B);
}
ll lcm(ll A, ll B){
return A * (B / gcd(A, B));
}
int main(){
char b; cin >> b;
if(b == 'A')cout << 'T' << endl;
else if(b == 'T')cout << 'A' << endl;
else if(b == 'C')cout << 'G' << endl;
else cout << 'C' << endl;
} | 0 | 49,715,143 |
#include<stdio.h>
int N,S;
int f(int n,int m,int s){
if(m==10){
if(S==s&&N==n)return 1;
return 0;
}
return f(n,m+1,s)+f(n+1,m+1,s+m);
}
int main(void){
while(1){
scanf("%d%d",&N,&S);
if(N==0&&S==0)break;
printf("%d\n",f(0,0,0));
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for(int i = n-1; i >= 0; i--)
#define all(x) (x).begin(),(x).end()
#define rall(v) (v).rbegin(), (v).rend()
#define FastIO ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define sz(x) ((int)(x).size())
typedef long long ll;
using P = pair<int,int>;
using VI = vector<int>;
using VVI = vector<vector<int>>;
using VL = vector<ll>;
using VVL = vector<vector<ll>>;
using VP = vector<P>;
template<typename T> void view(T e){std::cout << e << std::endl;}
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return true; } return false; }
const int inf = 1 << 29;
const ll INF = 1LL << 61;
int main(){
int N, M, R;
cin >> N >> M >> R;
VI r(R);
rep(i, R) cin >> r[i];
rep(i, R) r[i]--;
VVI dist(N, VI(N, inf));
rep(i,M){
int a, b, c;
cin >> a >> b >> c;
a--; b--;
dist[a][b] = c;
dist[b][a] = c;
}
rep(k ,N) rep(i, N) rep(j, N){
chmin(dist[i][j], dist[i][k] + dist[k][j]);
}
VI rp(R);
rep(i, R) rp[i] = i;
int ans = inf;
do {
VI seq(R);
rep(i,R) seq[rp[i]] = r[i];
int sum = 0;
rep(i,R-1){
int st = seq[i];
int next = seq[i+1];
sum += dist[st][next];
}
ans = min(ans, sum);
} while(next_permutation(all(rp)));
cout << ans << endl;
return 0;
} | 0 | 79,345,961 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x,vector<x>,greater<x>>
#define all(x) (x).begin(),(x).end()
#define CST(x) cout<<fixed<<setprecision(x)
#define vtpl(x,y,z) vector<tuple<x,y,z>>
#define rev(x) reverse(x);
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
using pl=pair<ll,ll>;
using vpl=vector<pl>;
using vvpl=vector<vpl>;
const ll MOD=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main(){
ll n,k;cin >> n >>k;
vl v(n);rep(i,n)cin >> v[i];
vl pat;
ll sum=0;rep(i,n)sum+=v[i],pat.pb(sum);
ll subsum=0;
rep(i,n){
subsum+=v[i];
repl(j,i+1,n)pat.pb(pat[j]-subsum);
}
per(i,60){
ll cnt=0;
rep(j,pat.size()){
if((1LL<<i)&pat[j])cnt++;
}
if(cnt>=k){
vl p;
rep(j,pat.size()){
if((1LL<<i)&pat[j])p.pb(pat[j]);
}
pat=p;
}
}
ll ans=pat[0];
rep(i,k)ans=ans&pat[i];
cout <<ans <<endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n; cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int prev = 0; long long ans = 0;
for (int i = 0; i < n; i++) {
int t = prev + 1;
int s = v[i] - t;
if (s > 0) {
ans += (s + t-1) / t;
v[i] = 1;
}
prev = max(v[i], prev);
}
cout << ans << endl;
return 0;
} | 0 | 76,843,007 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,k;
cin >> n >> k;
int ans =1;
while(n>0){
if(ans > k){
ans += k;
}else{
ans *=2;
}
n--;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using ll = long long;
#include<bits/stdc++.h>
void solve(long long N, long long K, std::vector<long long> A){
for(int i = 0;i < K;i++){
vector<ll> B(N);
for(int i = 0;i < N;i++){
int l = max(0LL, i - A[i]);
int r = min(N - 1, i + A[i]);
B[l]++;
if(r+1 < N)B[r+1]--;
}
for(int i = 1;i < N;i++)B[i] += B[i - 1];
if(A == B){
break;
}else{
A = B;
}
}
for(int i = 00;i < N;i++){
cout<<A[i]<<" ";
}
cout<<endl;
}
int main(){
long long N;
scanf("%lld",&N);
long long K;
scanf("%lld",&K);
std::vector<long long> A(N);
for(int i = 0 ; i < N ; i++){
scanf("%lld",&A[i]);
}
solve(N, K, std::move(A));
return 0;
} | 0 | 58,298,207 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int k,n;
cin >> k >> n;
vector<int> l(k);
int i;
for(i=0;i<k;i++) cin >> l[i];
sort(l.begin(),l.end());
int cnt = 0;
for(i=0;i<n;i++) cnt += l[k-i-1];
cout << cnt << "\n";
return 0;
} | #include <bits/stdc++.h>
#define int long long
#define N 200010
using namespace std;
inline int read()
{
int x=0,f=1; char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1; ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0'; ch=getchar();}
return x*f;
}
int n,m,v,p;
int a[N],tmp[N],add[N];
inline int check(int x)
{
memset(add,0,sizeof add);
memset(tmp,0,sizeof tmp);
for(int i=1;i<=n;i++) if(i!=x)
tmp[++tmp[0]]=a[i];
int ts=a[x]+m,tp=p;
int sum=(v-1)*m;
for(int i=n-1;tmp[i]>ts;i--,tp--) sum-=m;
for(int i=1;tmp[i]<ts&&i<n;i++)
{
add[i]+=min(m,ts-tmp[i]);
sum-=add[i];
}
for(int i=n-1;sum>0&&tp>0&&i>=1;i--) if(tmp[i]<=ts&&add[i]<m)
{
sum-=m-add[i]; tp--;
}
return (tp>0)&&(sum<=0);
}
signed main()
{
scanf("%lld%lld%lld%lld",&n,&m,&v,&p);
for(int i=1;i<=n;i++) scanf("%lld",&a[i]);
sort(a+1,a+1+n);
int l=1,r=n,ans=n;
while(l<=r)
{
int mid=(l+r)>>1;
if(check(mid)) ans=mid,r=mid-1;
else l=mid+1;
}
cout << n-ans+1 << endl;
return 0;
} | 0 | 74,859,182 |