code1
stringlengths 54
12k
| code2
stringlengths 71
12k
| similar
int64 0
1
| __index_level_0__
int64 0
101M
|
|---|---|---|---|
#include "bits/stdc++.h"
using namespace std;
#define ll long long int
#define rep(i,n) for( int i = 0; i < n; i++ )
#define rrep(i,n) for( int i = n; i >= 0; i-- )
#define REP(i,s,t) for( int i = s; i <= t; i++ )
#define RREP(i,s,t) for( int i = s; i >= t; i-- )
#define dump(x) cerr << #x << " = " << (x) << endl;
#define INF 2000000000
#define mod 1000000007
#define INF2 1000000000000000000
#define int long long
int dp[100010][2];
string L;
int calc(int x, int smaller) {
if (x == L.length()) return dp[x][smaller] = 1;
else if (dp[x][smaller] > 0) return dp[x][smaller];
if(!smaller) {
if (L[x] == '0')
return dp[x][smaller] = (calc(x + 1, 0)) % mod;
else
return dp[x][smaller] = (calc(x + 1, 0) * 2 + calc(x + 1, 1)) % mod;
} else {
return dp[x][smaller] = (calc(x + 1, 1) * 3) % mod;
}
}
signed main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> L;
cout << (calc(0, 0)) % mod << endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i=0; i<n; i++)
#define rrep(i, n) for(int i=n-1; i>=0; i--)
#define FOR(i, a, b) for(int i=a; i<b; i++)
#define ALL(v) v.begin(),v.end()
#define pb push_back
#define eb emplace_back
#define mp make_pair
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int, ll> pil;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LLINF = 1e18;
const ll MOD = 1e9+7;
const double EPS = 1e-10;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main() {
string s; cin >> s;
bool ok = false;
for (int i = 1; i < s.size(); i++) {
if (s[i] == s[i-1]) {
cout << i << " " << i+1 << endl;
return 0;
}
if (i > 1 && s[i] == s[i-2]) {
cout << i-1 << " " << i+1 << endl;
return 0;
}
}
cout << "-1 -1" << endl;
return 0;
}
| 0
| 9,762,934
|
#include <stdio.h>
int main(){
int x,sum;
sum=1;
while(sum!=0){
sum=0;
while((x=getchar())!='\n'){
sum+=x-'0';
}
if(sum==0){
break;
}
printf("%d\n",sum);
}
return 0;
}
|
#include<iostream>
#include<math.h>
#include<stdlib.h>
using namespace std;
#define MAX_N 1000001
int main(){
int *count;
count=(int *)malloc(sizeof(int)*MAX_N);
int cnt=0;
bool *a;
a= (bool *)malloc(sizeof(bool)*MAX_N);
a[1]=true;
for(int i=2;i<MAX_N;i++){
count[i]=cnt;
if(a[i])continue;
cnt++;
count[i]++;
long int k=i;
while(i*k<MAX_N){
a[i*k]=true;
k++;
}
}
int n;
while(cin >> n){
cout << count[n] << endl;
}
return 0;
}
| 0
| 78,819,225
|
#include <iostream>
#include <map>
#include <vector>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <climits>
#include <stack>
#include <queue>
#include <set>
#include <cctype>
#include <bitset>
#include <type_traits>
#include <list>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define rep(i, a, b) for (int i = a; i < (b); ++i)
#define YES(j) cout << (j ? "YES" : "NO") << endl;
#define Yes(j) std::cout << (j ? "Yes" : "No") << endl;
#define yes(j) std::cout << (j ? "yes" : "no") << endl;
int main(void)
{
const int INF = 100000000;
int n, m;
cin >> n >> m;
int a[1000], b[1000], c[1000];
int dist[100][100];
REP(i, m)
{
cin >> a[i] >> b[i] >> c[i];
a[i]--;
b[i]--;
}
REP(i, n)
{
REP(j, n)
{
if (i == j)
dist[i][j] = 0;
else
{
dist[i][j] = INF;
}
}
}
REP(i, m)
{
dist[a[i]][b[i]] = min(dist[a[i]][b[i]], c[i]);
dist[b[i]][a[i]] = min(dist[b[i]][a[i]], c[i]);
}
REP(k, n)
{
REP(i, n)
{
REP(j, n)
{
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
}
}
int ans = m;
REP(i, m)
{
bool shortest = false;
REP(j, n)
{
if (dist[j][a[i]] + c[i] == dist[j][b[i]])
shortest = true;
}
if (shortest)
ans--;
}
cout << ans << endl;
}
|
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <chrono>
#include <ctime>
#include <queue>
#include <math.h>
#include <deque>
#include <stack>
#include <iomanip>
#include <assert.h>
#include <stdio.h>
#include <cstring>
#include <random>
using namespace std;
#define int long long
#define ll long long
#define ull unsigned long long
#define ld long double
#define pii pair<int, int>
#define pld pair<ld, ld>
#define ti tuple<int, int, int>
#define vi vector <int>
#define vpi vector <pii>
#define vld vector <ld>
#define try tr
#define left left11
#define right right11
#define lb lower_bound
#define ub upper_bound
#define sz(c) (int)(c).size()
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define pf push_front
#define sqr(a) ((a) * (a))
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define x first
#define y second
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
clock_t START;
inline ld TIME() {
return (ld) (clock() - START) / CLOCKS_PER_SEC;
}
void SHOW() {
cout << fixed << setprecision(10);
cout << TIME() << " SECONDS FROM START\n";
}
ld TL = 2.0;
int calls = 0;
inline bool IS() {
if(++calls == 1000) {
calls = 0;
if(TL - TIME() < 0.1)
return true;
}
return false;
}
template<typename T1, typename T2>
inline bool amin(T1 &a, T2 b) { if (a > b) { a = b; return true;} return false; }
template<typename T1, typename T2>
inline bool amax(T1 &a, T2 b) { if (a < b) {a = b; return true;} return false; }
template<typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << p.first << ' ' << p.second;
return os;
}
template<typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template<typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &u : v) is >> u;
return is;
}
template<typename T>
ostream &operator<<(ostream &os, vector<T> &v) {
for (auto &u : v) os << u << ' ';
return os;
}
int hash_mod[4] = {1000000007, 998244353, 1000000009, 999999937}, mod = hash_mod[rnd() % 4];
int hash_pows[4] = {179, 239, 1007, 2003}, P = hash_pows[rnd() % 4];
int binpow(int x, int p) {
int res = 1;
while(p) {
if(p % 2)
res = (res * x) % mod;
x = (x * x) % mod;
p /= 2;
}
return res;
}
const int N = 1e6 + 7, NS = 2e3 + 7, lg = 20, sq = 550, inf = 2e9 + 7, SM = 1e2 + 7;
const ld eps = 1e-9;
void e() {
cout << "Impossible";
exit(0);
}
void solve() {
int n;
cin >> n;
vi a(n); cin >> a;
vi cnt(n);
int r = 0;
for (auto u : a) {
amax(r, u);
cnt[u]++;
}
int took = 0;
for (int i = r; i >= (r + 1) / 2; i--) {
if(cnt[i] == 0)
e();
if(cnt[i] == 1 && (i * 2 != r))
e();
cnt[i] -= 2;
if(i * 2 == r)
cnt[i]++;
}
for (int i = 0; i <= (r + 1) / 2; i++) {
if(cnt[i])
e();
}
cout << "Possible";
}
signed main() {
fast
solve();
}
| 0
| 73,060,732
|
#include <bits/stdc++.h>
using namespace std;
#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++)
using pii = pair<int, int>;
using vi = vector<int>;
using vii = vector<vi>;
using ll = long long;
int main() {
int n; cin >> n;
vector<ll> a(n);
rep(i, n) cin >> a.at(i);
ll ans;
ll p = pow(10, 18);
rep(i, n) {
if (a.at(i) == 0) {
cout << 0 << endl;
return 0;
}
}
ll prod = 1;
rep(i, n) {
if (a.at(i) <= p /prod) prod *= a.at(i);
else {
cout << -1 << endl;
return 0;
}
}
cout << prod << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define INFTY 10000000000
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
const int MOD=1000000007;
const int di[4] = {-1,0,1,0};
const int dj[4] = {0,-1,0,1};
ll gcd(ll a, ll b) { return b?gcd(b,a%b):a;}
int main(){
int n,k;cin>>n>>k;
int num[n][2];
string s;cin>>s;
int mx = 0;
int ch=1;
int cnt = 0;
rep(i,n){
if(s[i]=='0'){
if(ch)num[cnt][0]=i;
ch = 0;
if(s[i+1]=='1'||i==n-1){
num[cnt][1]=i;
cnt++;
}
}
if(s[i]=='1'){
ch = 1;
}
}
if(cnt<k){
cout<<n<<endl;
return 0;
}
mx =max(num[k][0]-1,mx);
for (int i = 0; i < cnt; i++)
{
int r,l;
if(i>0)l = num[i-1][1]+1;
else l = 0;
if(k+i<cnt){
r = num[i+k][0]-1;
}else{
r = n-1;
}
mx = max(mx,r-l+1);
}
cout<<mx<<endl;
return 0;
}
| 0
| 91,368,449
|
#include <iostream>
#include <stdio.h>
#include <string>
#include <math.h>
#include <vector>
#include <algorithm>
#include <iomanip>
#include <set>
#include <queue>
#include <map>
#include <stack>
using namespace std;
#define mod 1000000007
#define ten5 100005
#define ten52 200005
#define ten6 1000005
#define PI 3.1415926
#define pb(x) push_back(x)
#define mkpr(x,y) make_pair(x,y)
#define all(x) x.begin(),x.end()
typedef long long int ll;
vector<ll> num(26),num2(26);
int main()
{
long long int m,n,o,i,j,k=1;
string s,s1;
cin>>s;
cin>>s1;
for(i=0;i<s.size();i++)
{
num[s[i]-'a']++;
num2[s1[i]-'a']++;
}
sort(all(num));
sort(all(num2));
cout<<(num==num2?"Yes":"No");
return 0;
}
|
#include<iostream>
#include<vector>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> vec(n);
for ( int i = 0; i < n; ++i) {
cin >> vec.at(i);
}
long long count1 = 0;
for ( int i = 0; i < n; ++i) {
for ( int j = i+1; j < n; ++j) {
if ( vec.at(i) > vec.at(j)) {
count1++;
}
}
}
long long count2 = 0;
for ( int i = 0; i < n; ++i ) {
for (int j = 0; j < n; ++j ) {
if ( i != j && vec.at(i) > vec.at(j)) {
count2++;
}
}
}
count2 *= k;
count2 %= 1000000007;
count2 *= (k-1);
count2 %= 1000000007;
count2 *= 500000004;
count2 %= 1000000007;
long long ans = count1 * k;
ans %= 1000000007;
ans += count2;
ans %= 1000000007;
cout << ans << endl;
}
| 0
| 6,096,057
|
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
const double PI = 3.14159265358979323846;
int map[16][16];
inline int get(int x, int y) {
if (map[x][y] == -1) {
return -1;
}
int r = 0;
if ((0 < x) && (map[x - 1][y] != -1)) {
r += map[x - 1][y];
}
if ((0 < y) && (map[x][y - 1] != -1)) {
r += map[x][y - 1];
}
return r;
}
int main() {
while (true) {
int n, w, h;
cin >> w >> h >> n;
if ((w == 0) && (h == 0)) {
return 0;
}
for (int i = 0; i < w; ++i) {
for (int j = 0; j < h; ++j) {
map[i][j] = 0;
}
}
for (int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
map[x - 1][y - 1] = -1;
}
map[0][0] = 1;
for (int mw = 1; mw < w; ++mw) {
for (int mh = 1; mh < h; ++mh) {
for (int x = 0; x < mw; ++x) {
map[x][mh] = get(x, mh);
}
for (int y = 0; y < mh; ++y) {
map[mw][y] = get(mw, y);
}
map[mw][mh] = get(mw, mh);
}
}
cout << map[w - 1][h - 1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main()
{
long n, x, m;
cin >> n >> x >> m;
vector<long> ids(m, -1);
vector<long> xs;
long len = 0;
long tot = 0;
while (ids[x] == -1)
{
xs.push_back(x);
ids[x] = len;
len++;
tot += x;
x = (x * x) % m;
}
long loop_len = len - ids[x];
long loop_sum = 0;
for (long i = ids[x]; i < len; i++)
{
loop_sum += xs[i];
}
long ans = 0;
if (n < len)
{
for (long i = 0; i < n; i++)
{
ans += xs[i];
}
}
else
{
ans += tot;
n -= len;
ans += (n / loop_len) * loop_sum;
n %= loop_len;
for (long i = 0; i < n; i++)
{
ans += xs[ids[x] + i];
}
}
cout << ans << endl;
return 0;
}
| 0
| 40,290,829
|
#include <bits/stdc++.h>
using namespace std;
#ifndef aa
#define trace(...)
#define endl '\n'
#endif
#define pb push_back
#define ub upper_bound
#define lb lower_bound
#define fi first
#define se second
#define int long long
typedef long long ll;
typedef long double ld;
#define double long double
#define pii pair<int,int>
#define pdd pair<double,double>
#define pll pair<ll,ll>
#define sz(x) ((long long)x.size())
#define fr(a,b,c) for(int a=b; a<=c; a++)
#define frev(a,b,c) for(int a=c; a>=b; a--)
#define rep(a,b,c) for(int a=b; a<c; a++)
#define trav(a,x) for(auto &a:x)
#define all(con) con.begin(),con.end()
#define deb(x) cout << x << endl
#define done(x) {cout << x << endl;return;}
const ll infl = 0x3f3f3f3f3f3f3f3fLL;
const int infi = 0x3f3f3f3f;
mt19937_64 mt(chrono::steady_clock::now().time_since_epoch().count());
const int mod = 1e9 + 7;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<pair<int, int>> vpii;
typedef map<int, int> mii;
typedef set<int> si;
typedef set<pair<int,int>> spii;
typedef queue<int> qi;
const int N = 1e7+5;
int dp[N];
void solve() {
int n,ans=0;
cin>>n;
fr(i,1,n){
for(int j = i; j <= n; j+=i)
dp[j]++;
ans+=i*dp[i];
}
cout<<ans;
}
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
int t = 1;
while (t--)
solve();
#ifdef aa
cout << endl << endl << endl << endl << "Time elapsed: " << (double)(clock() - clk) / CLOCKS_PER_SEC << endl;
#endif
return 0;
}
int powm(int a, int b) {
int res = 1;
while (b) {
if (b & 1)
res = (res*a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
int divide(int a, int b) {
return (a % mod) * powm(b, mod - 2) % mod;
}
int norm(int a) {
while (a >= mod) a -= mod;
while (a < 0) a += mod;
return a;
}
int gcd(int a, int b) {
return b ? gcd(b, a % b) : a;
}
|
#include <iostream>
using namespace std;
int main(){
int n;
int a , b , c , d;
int ans , count;
while(cin >> n){
if(n == 0) break;
count = 0;
for(a = 0; a <= 9; a++){
for(b = 0; b <= 9; b++){
for(c = 0; c <= 9; c++){
for(d = 0; d <= 9; d++){
ans = a + b + c + d;
if(ans == n){
count++;
}
}
}
}
}
cout << count << endl;
}
return 0;
}
| 0
| 11,100,411
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
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());
double ans = (A[0] + A[1]) / 2.0;
for(int i=2; i<N; i++) {
ans = ans / 2.0 + A[i] / 2.0;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
int main() {
int n;
cin >> n;
vi a(n+1);
rep(i, n) cin >> a.at(i+1);
vector<ll> dp(n+1);
dp.at(0) = 1000;
for (int k = 1; k <= n; k++) {
dp.at(k) = 0;
for (int i = 0; i < k-1; i++) {
int m = 99999;
for (int j = i+1; j < k; j++){
m = min(m, a.at(j));
}
dp.at(k) = max(dp.at(k), dp.at(i)/m*a.at(k)+dp.at(i)%m);
}
}
ll x = 0;
rep(i, n+1) x = max(x, dp.at(i));
cout << x << endl;
return 0;
}
| 0
| 89,135,362
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, Y;
cin >> N >> Y;
vector<int> ijk(3);
int res1k = -1, res5k = -1, res10k = -1;
for (int i = 0; i <= N; i++) {
for (int j = 0; i + j <= N; j++) {
int k = N - i - j; int money = 10000 * i + 5000 * j + 1000 * k;
if (Y == money) {
res1k = i, res5k = j, res10k = k;
}
}
}
cout << res1k << " " << res5k << " " << res10k << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<ll, ll>;
const int MAXE { 3 }, MAXN { 110 }, MAXK { 4 };
const ll MOD { 1000000007 }, oo { 1LL << 62 };
ll st[MAXN][MAXE][MAXK];
ll solve(const string& s, int K)
{
int N = s.size();
vector<int> ds(N);
for (int i = 0; i < N; ++i)
ds[i] = (s[i] - '0');
memset(st, 0, sizeof st);
for (int d = 1; d < ds[0]; ++d)
st[0][0][1]++;
st[0][0][0] = 1;
st[0][1][1] = 1;
for (int i = 1; i < N; ++i)
{
st[i][0][0] = 1;
for (int k = 1; k <= 3; ++k)
{
st[i][0][k] = st[i - 1][0][k];
st[i][0][k] += 9*st[i - 1][0][k - 1];
st[i][0][k] += (ds[i] ? st[i - 1][1][k] : 0);
for (int d = 1; d < ds[i]; ++d)
st[i][0][k] += st[i - 1][1][k - 1];
st[i][1][k] += (ds[i] == 0 ? st[i - 1][1][k] : 0);
st[i][1][k] += (ds[i] ? st[i - 1][1][k - 1] : 0);
}
}
#ifdef DEBUG
for (int i = 0; i < N; ++i)
for (int k = 0; k <= 3; ++k)
for (int e = 0; e < 2; ++e)
cout << "st[" << i << "][" << e << "][" << k << "] = " << st[i][e][k] << endl;
#endif
ll ans = st[N - 1][0][K] + st[N - 1][1][K];
return ans;
}
int main()
{
ios::sync_with_stdio(false);
string N;
int K;
cin >> N >> K;
auto ans = solve(N, K);
cout << ans << '\n';
return 0;
}
| 0
| 29,696,435
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < n; i++)
using namespace std;
using ll = long long;
using ull = unsigned long long;
using P = pair<int, int>;
int main() {
int n, ans, mini = 100000000;
cin >> n;
vector<int> x(n);
rep(i, n) cin >> x[i];
rep(i, 100) {
int dist = 0;
rep(j, n) { dist += (i - x[j]) * (i - x[j]); }
if(mini > dist) {
mini = dist;
ans = i;
}
}
cout << mini << endl;
return 0;
}
|
#include<iostream>
using namespace std;
typedef struct{
char mark;
int value;
int order;
}t;
int main(){
int N,minj,f=0;
t C1[36],C2[36],a;
cin>>N;
if(N>0 && N<37){
for(int i=0;i<=N-1;i++){
while(1){
cin>>C1[i].mark;
if(C1[i].mark!='D'&&C1[i].mark!='C'&&C1[i].mark!='S'&&C1[i].mark!='H')continue;
cin>>C1[i].value;
break;
}
C1[i].order=i+1;
C2[i]=C1[i];
}
for(int i=0;i<=N-1;i++)
for(int j=N-1;j>=i+1;j--)
if(C1[j].value < C1[j-1].value){
a=C1[j];
C1[j]=C1[j-1];
C1[j-1]=a;
}
for(int i=0;i<N-1;i++) cout<<C1[i].mark<<C1[i].value<<' ';
cout<<C1[N-1].mark<<C1[N-1].value<<endl;
for(int i=0;i<=N-1;i++)
if(C1[i].value==C1[i-1].value && C1[i].order-C1[i-1].order<0)f=1;
if(f==0) cout<<"Stable"<<endl;
else cout<<"Not stable"<<endl;
f=0;
for(int i=0;i<=N-1;i++){
minj=i;
for(int j=i;j<=N-1;j++)
if(C2[j].value < C2[minj].value)minj=j;
a=C2[i];
C2[i]=C2[minj];
C2[minj]=a;
}
for(int i=0;i<N-1;i++)cout<<C2[i].mark<<C2[i].value<<' ';
cout<<C2[N-1].mark<<C2[N-1].value<<endl;
for(int i=1;i<N;i++)
if(C2[i].value==C2[i-1].value && C2[i].order-C2[i-1].order<0)f=1;
if(f==0)cout<<"Stable"<<endl;
else cout<<"Not stable"<<endl;
}
return 0;
}
| 0
| 83,211,873
|
#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
#include <cmath>
#include <string>
#include <map>
#define pb push_back
#define mp make_pair
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> ii;
typedef vector<ii> vii;
typedef unsigned long long ull;
typedef long long ll;
int main() {
vi d;
for (int i = 0; i < 5; ++i) {
int t;
cin >> t;
d.pb(t);
}
sort(d.begin(), d.end());
int min_res = 100000;
do {
int t = 0;
for (int i = 0; i < 5; ++i) {
t += d.at(i);
if (i != 4) {
if (t % 10 != 0) {
t += (10-(d.at(i)%10));
}
}
}
min_res = min(min_res, t);
} while (next_permutation(d.begin(), d.end()));
cout << min_res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
vector <string> w(n,"");
for(int i = 0; i < n; i++){
cin >> w[i];
if(i!=0){
if(w[i-1].back()!=w[i][0]){
cout << "No" << endl;
return 0;
}
}
}
sort(w.begin(),w.end());
for(int i = 1; i < n; i++){
if(w[i-1].compare(w[i])==0){
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
return 0;
}
| 0
| 71,574,346
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
int x;
cin >> x;
queue<ll> q;
for(int i = 1; i < 10; i++) {
q.push(i);
}
if(x<10){
cout << x << endl;
return 0;
}
x -= 9;
ll ans=0;
while(1) {
ll s=q.front();
q.pop();
int y=s%10;
if(y==9) {
x-=2;
q.push(s*10+8);
q.push(s*10+9);
if(x==0){
ans=s*10+9;
break;
}
if(x==-1){
ans=s*10+8;
break;
}
}
else if(y==0){
x-=2;
q.push(s*10);
q.push(s*10+1);
if(x==0){
ans=s*10+1;
break;
}
if(x==-1){
ans=s*10;
break;
}
}
else {
x-=3;
q.push(s*10+y-1);
q.push(s*10+y);
q.push(s*10+y+1);
if(x==0){
ans=s*10+y+1;
break;
}
if(x==-1){
ans=s*10+y;
break;
}
if(x==-2){
ans=s*10+y-1;
break;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
int main(){
string card[36],card2[36],tem;
int n,ans=0;
cin>>n;
for(int i=0;i<n;i++){
cin>>card[i];
card2[i]=card[i];
}
for(int i=0;i<=n-1;++i){
for(int j=n-1;j>=i+1;j--){
if(card[j][1]-'0'<card[j-1][1]-'0'){
swap(card[j],card[j-1]);
}
}
}
for(int i=0;i<=n-1;i++){
if(i!=n-1)cout<<card[i]<<" ";
else cout<<card[i]<<endl;
}
cout<<"Stable"<<endl;
int minj=0;
for(int i=0;i<=n-1;i++){
minj=i;
for(int j=i;j<=n-1;j++){
if(card2[j][1]-'0'<card2[minj][1]-'0'){
minj=j;
}
}
if(i!=minj){swap(card2[i],card2[minj]);}
}
for(int i=0;i<n;i++){
if(i!=n-1)cout<<card2[i]<<" ";
else cout<<card2[i]<<endl;
if(card[i]==card2[i]){
ans++;
}
}
ans==n ? cout<<"Stable"<<endl : cout<<"Not stable"<<endl;
string a;cin>>a;
return 0;
}
| 0
| 83,303,966
|
#include <bits/stdc++.h>
#define ll long long
#define pq priority_queue
using namespace std;
const ll INF=(ll)1e9;
const ll MOD=(ll)1e9+7;
const ll MAX=510000;
vector<int> dx={1,0,-1,0},dy={0,1,0,-1};
template<class T> inline bool chmax(T& a, T b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a>b) { a=b; return 1; } return 0; }
int main(){
ll N,K,ans=0;
cin>>N>>K;
if(K==1){
cout<<"0"<<endl;
return 0;
}
ll A[N+1];
A[0]=0;
map<ll,ll> m;
for(ll i=1;i<=N;i++){
cin>>A[i];
A[i]--;
A[i]+=A[i-1];
}
for(ll i=0;i<=N;i++){
ans+=m[A[i]%K];
m[A[i]%K]++;
if(i-K+1>=0) m[A[i-K+1]%K]--;
}
cout<<ans<<endl;
}
|
#include <iostream>
#include <limits>
#include <algorithm>
using namespace std;
int c[100][100];
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int n, t;
int M[101];
cin>>n;
cin>>M[0]>>M[1];
for(int i=2; i<=n; i++) {
cin>>t>>M[i];
}
for(int l=1; l<n; l++) {
for(int i=0; i+l<n; i++) {
int cost=numeric_limits<int>::max();
for(int j=i+1; j<=i+l; j++) {
cost=min(cost, c[i][j-1]+M[i]*M[j]*M[i+l+1]+c[j][i+l]);
}
c[i][i+l]=cost;
}
}
cout<<c[0][n-1]<<'\n';
}
| 0
| 82,697,301
|
#include<bits/stdc++.h>
using ll = long long;
const ll INF_LL = 1000000000000;
#define fir first
#define sec second
using namespace std;
int main()
{
int n,k;
cin >> n >> k;
vector<vector<int>> hen(n);
if(k > (n - 1) * (n - 2) / 2){cout << -1 << endl; return 0;}
for(int i = 1; i < n; i++){
hen[0].push_back(i);
hen[i].push_back(0);
}
int cnt = 0;
int lim = ((n - 1) * (n - 2) / 2) - k;
for(int i = 1; i < n && cnt < lim; i++){
for(int j = i + 1; j < n && cnt < lim; j++){
hen[i].push_back(j);
hen[j].push_back(i);
cnt++;
}
}
std::cout << lim + n - 1<< std::endl;
for(int i = 0; i < n; i++){
for(auto j : hen[i]){
if(i < j){
std::cout << i + 1<< " " << j + 1 << std::endl;
}
}
}
}
|
#include <iostream>
#include <numeric>
#include <cmath>
#include <limits>
#include <stdio.h>
#include <iomanip>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
using namespace std;
using ll = long long;
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
ll Max(ll(a), ll(b), ll(c)) {
return max(max(a, b), c);
}
ll Min(ll(a), ll(b), ll(c)) {
return min(min(a, b), c);
}
int main() {
ll N,an=0;
cin >> N;
for (ll i = 1; i * i <= N; i++) {
ll k = i;
if (N % k == 0) {
if (N / k - 1 > k)an += N / k - 1;
k = N / k;
if (N / k - 1 > k&&k*k!=N)an += N / k - 1;
}
}
cout << an << endl;
}
| 0
| 27,712,504
|
#include <iostream>
using namespace std;
static const int MAX=100;
static const long long INFTY=(1LL<<32);
int n;
long long d[MAX][MAX];
void floyd()
{
for(int k=0;k<n;k++)
{
for(int i=0;i<n;i++)
{
if(d[i][k]==INFTY) continue;
for(int j=0;j<n;j++)
{
if(d[k][j]==INFTY) continue;
d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
}
}
}
}
int main()
{
int e;
cin>>n>>e;
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
d[i][j]=((i==j)?0:INFTY);
}
int s,t,dt;
for(int i=0;i<e;i++)
{
cin>>s>>t>>dt;
d[s][t]=dt;
}
floyd();
bool negative=false;
for(int i=0;i<n;i++) if(d[i][i]<0) {negative=true;break;}
if(negative) cout<<"NEGATIVE CYCLE"<<endl;
else
{
for(int i=0;i<n;i++)
{
for(int j=0;j<n;j++)
{
if(j) cout<<' ';
if(d[i][j]==INFTY) cout<<"INF";
else cout<<d[i][j];
}
cout<<endl;
}
}
return 0;
}
|
#include<iostream>
using namespace std;
int main()
{
int g[100][100];
int n;
for(int i=0; i<100; i++)
{
for(int j=0; j<100; j++)
{
g[i][j]=0;
}
}
cin>>n;
int x,y,z;
for(int i=0; i<n; i++)
{
cin>>x>>y;
for(int j=0; j<y; j++)
{
cin>>z;
g[x-1][z-1]=1;
}
}
for(int i=0; i<n; i++)
{
for(int j=0; j<n; j++)
{
if(j!=0) cout<<" ";
cout<<g[i][j];
}
cout<<'\n';
}
return 0;
}
| 0
| 1,291,250
|
#include <bits/stdc++.h>
#define F first
#define S second
#define MP make_pair
#define pb push_back
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define LCM(a, b) (a) / __gcd((a), (b)) * (b)
#define CEIL(a, b) (a)/(b)+(((a)%(b))?1:0)
#define log_2(a) (log((a)) / log(2))
#define ln '\n'
using namespace std;
using LL = long long;
using ldouble = long double;
using P = pair<int, int>;
using LP = pair<LL, LL>;
static const int INF = INT_MAX;
static const LL LINF = LLONG_MAX;
static const int MIN = INT_MIN;
static const LL LMIN = LLONG_MIN;
static const int MOD = 1e9 + 7;
static const int SIZE = 200005;
const int dx[] = {0, -1, 1, 0};
const int dy[] = {-1, 0, 0, 1};
vector<LL> Div(LL n) {
vector<LL> ret;
for(LL i = 1; i * i <= n; ++i) {
if(n % i == 0) {
ret.pb(i);
if(i * i != n) ret.pb(n / i);
}
}
sort(all(ret));
return ret;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a[3][3];
for(int i = 0; i < 3; ++i) {
for(int j = 0; j < 3; ++j) {
cin >> a[i][j];
}
}
int N;
cin >> N;
for(int i = 0; i < N; ++i) {
int b;
cin >> b;
for(int j = 0; j < 3; ++j) {
for(int k = 0; k < 3; ++k) {
if(a[j][k] == b) a[j][k] = 0;
}
}
}
for(int i = 0; i < 3; ++i) {
int s = 0;
for(int j = 0; j < 3; ++j) {
s += a[i][j];
}
if(s == 0) {
cout << "Yes" << endl;
return 0;
}
}
for(int i = 0; i < 3; ++i) {
int s = 0;
for(int j = 0; j < 3; ++j) {
s += a[j][i];
}
if(s == 0) {
cout << "Yes" << endl;
return 0;
}
}
if(a[0][0] + a[1][1] + a[2][2] == 0 || a[2][0] + a[1][1] + a[2][0] == 0) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
#define Check system("pause")
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define IOS ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
int w[100005],d[100005];
int main()
{
ios::sync_with_stdio(false);
int a,b,m,ans=0,l,r,x,y,c,k;
cin>>a>>b>>m;
l=r=1e9;
for(int i=1;i<=a;i++)
{
cin>>w[i];
l=min(l,w[i]);
}
for(int i=1;i<=b;i++)
{
cin>>d[i];
r=min(r,d[i]);
}
ans=l+r;
for(int i=1;i<=m;i++)
{
cin>>x>>y>>c;
k=w[x]+d[y]-c;
ans=min(ans,k);
}
cout<<ans;
return 0;
}
| 0
| 33,226,676
|
#include <iostream>
#include <vector>
#include <string.h>
#include <stack>
#include <queue>
#include <algorithm>
#include <climits>
#include <cmath>
#include <map>
#include <set>
#include <assert.h>
#include <sstream>
#define REP(i,n) for(ll i=0;i<(n);i++)
#define MOD 1000000007
#define int long long
#ifdef int
const long long INF = LLONG_MAX / 10;
#else
const int INF = 1010101010;
#endif
using namespace std;
typedef long long ll;
typedef vector<vector<ll>> mat;
typedef pair<int, int> P;
#ifdef LOCAL
#define dump(...) \
do { \
std::ostringstream os; \
os << __LINE__ << ":\t" << #__VA_ARGS__ << " = "; \
print_to(os, ", ", "\n", __VA_ARGS__); \
std::cerr << os.str(); \
} while (0)
#define dump_(a) \
do { \
std::ostringstream os; \
os << __LINE__ << ":\t" << #a << " = ["; \
print_to_(os, ", ", "]\n", all(a)); \
std::cerr << os.str(); \
} while (0)
#else
#define dump(...)
#define dump_(...)
#endif
template <typename T>
void print_to(std::ostream &os, const char *, const char *tail, const T &fst) {
os << fst << tail;
}
template <typename Fst, typename... Rst>
void print_to(std::ostream &os, const char *del, const char *tail, const Fst &fst, const Rst &... rst) {
os << fst << del;
print_to(os, del, tail, rst...);
}
template <typename Iter>
void print_to_(std::ostream &os, const char *del, const char *tail, Iter bgn, Iter end) {
for (Iter it = bgn; it != end;) {
os << *it;
if (++it != end) {
os << del;
} else {
os << tail;
}
}
}
template <typename Fst, typename... Rst>
void println(const Fst &fst, const Rst &... rst) {
print_to(std::cout, "\n", "\n", fst, rst...);
}
template <typename Fst, typename... Rst>
void print(const Fst &fst, const Rst &... rst) {
print_to(std::cout, " ", "\n", fst, rst...);
}
template <typename Iter>
void println_(Iter bgn, Iter end) {
print_to_(std::cout, "\n", "\n", bgn, end);
}
template <typename Iter>
void print_(Iter bgn, Iter end) {
print_to_(std::cout, " ", "\n", bgn, end);
}
namespace trush {
int _ = (std::cout.precision(10), std::cout.setf(std::ios::fixed), std::cin.tie(0),
std::ios::sync_with_stdio(0), 0);
}
int n, m;
string S, T;
int dp[1010][1010];
signed main()
{
cin >> S >> T;
n = S.length();
m = T.length();
S = '-' + S;
T = '-' + T;
REP(i,m+1) dp[0][i] = i;
REP(i,n+1) dp[i][0] = i;
for (int i=1; i<n+1; i++) {
for (int j=1; j<m+1; j++) {
if (S[i] == T[j]) {
dp[i][j] = min(dp[i-1][j-1], min(dp[i][j-1] + 1, dp[i-1][j] + 1));
} else {
dp[i][j] = min(dp[i-1][j-1] + 1, min(dp[i][j-1] + 1, dp[i-1][j] + 1));
}
}
}
cout << dp[n][m] << endl;
}
|
#include<iostream>
#include<algorithm>
#include<cmath>
#include<map>
#include<stdio.h>
#include<vector>
#include<queue>
using namespace std;
#define int long long
#define double long double
#define rep(s,i,n) for(int i=s;i<n;i++)
#define c(n) cout<<n<<endl;
#define ic(n) int n;cin>>n;
#define sc(s) string s;cin>>s;
#define mod 1000000007
#define inf 1000000000000000007
#define f first
#define s second
#define mini(c,a,b) *min_element(c+a,c+b)
#define maxi(c,a,b) *max_element(c+a,c+b)
#define P pair<int,int>
int keta(int x){
rep(0,i,30){
if(x<10){
return i+1;
}
x=x/10;
}
}
int gcd(int x,int y){
int aa=x,bb=y;
rep(0,i,1000){
aa=aa%bb;
if(aa==0){
return bb;
}
bb=bb%aa;
if(bb==0){
return aa;
}
}
}
int lcm(int x,int y){
int aa=x,bb=y;
rep(0,i,1000){
aa=aa%bb;
if(aa==0){
return x/bb*y;
}
bb=bb%aa;
if(bb==0){
return x/aa*y;
}
}
}
bool p(int x){
if(x==1)return false;
rep(2,i,sqrt(x)+1){
if(x%i==0&&x!=i){
return false;
}
}
return true;
}
int max(int a,int b){
if(a>=b)return a;
else return b;
}
int min(int a,int b){
if(a>=b)return b;
else return a;
}
int n2[41];
int nis[41];
int nia[41];
int mody[41];
int nn;
int com(int n,int y){
int ni=1;
for(int i=0;i<41;i++){
n2[i]=ni;
ni*=2;
}
int bunsi=1,bunbo=1;
rep(0,i,y)bunsi=(bunsi*(n-i))%mod;
rep(0,i,y)bunbo=(bunbo*(i+1))%mod;
mody[0]=bunbo;
rep(1,i,41){
bunbo=(bunbo*bunbo)%mod;
mody[i]=bunbo;
}
rep(0,i,41)nis[i]=0;
nn=mod-2;
for(int i=40;i>=0;i-=1){
if(nn>n2[i]){
nis[i]++;
nn-=n2[i];
}
}
nis[0]++;
rep(0,i,41){
if(nis[i]==1){
bunsi=(bunsi*mody[i])%mod;
}
}
return bunsi;
}
int gyakugen(int n,int y){
int ni=1;
for(int i=0;i<41;i++){
n2[i]=ni;
ni*=2;
}
mody[0]=y;
rep(1,i,41){
y=(y*y)%mod;
mody[i]=y;
}
rep(0,i,41)nis[i]=0;
nn=mod-2;
for(int i=40;i>=0;i-=1){
if(nn>n2[i]){
nis[i]++;
nn-=n2[i];
}
}
nis[0]++;
rep(0,i,41){
if(nis[i]==1){
n=(n*mody[i])%mod;
}
}
return n;
}
int yakuwa(int n){
int sum=0;
rep(1,i,sqrt(n+1)){
if(n%i==0)sum+=i+n/i;
if(i*i==n)sum-=i;
}
return sum;
}
bool integer(double n){
if(n==long(n))return true;
else return false;
}
int poow(int y,int n){
n-=1;
int ni=1;
for(int i=0;i<41;i++){
n2[i]=ni;
ni*=2;
}
int yy=y;
mody[0]=yy;
rep(1,i,41){
yy=(yy*yy)%mod;
mody[i]=yy;
}
rep(0,i,41)nis[i]=0;
nn=n;
for(int i=40;i>=0;i-=1){
if(nn>=n2[i]){
nis[i]++;
nn-=n2[i];
}
}
rep(0,i,41){
if(nis[i]==1){
y=(y*mody[i])%mod;
}
}
return y;
}
int ketawa(int x,int sinsuu){
int sum=0;
rep(0,i,100)sum+=(x%poow(sinsuu,i+1))/(poow(sinsuu,i));
return sum;
}
int sankaku(int a){
return a*(a+1)/2;
}
bool search(int x){
int n;
int a[n];
int l=0,r=n;
while(r-l>=1){
int i=(l+r)/2;
if(a[i]==x)return true;
else if(a[i]<x)l=i+1;
else r=i;
}
return false;
}
using Graph=vector<vector<int>>;
int XOR(int a,int b){
int ni=1;
rep(0,i,41){
n2[i]=ni;
ni*=2;
}
rep(0,i,41)nis[i]=0;
for(int i=40;i>=0;i-=1){
if(a>=n2[i]){
nis[i]++;
a-=n2[i];
}
if(b>=n2[i]){
nis[i]++;
b-=n2[i];
}
}
int sum=0;
rep(0,i,41)sum+=(nis[i]%2*n2[i]);
return sum;
}
int a[1145],b[1145],c[1145];
int ab[1145810];
int abmax[3145];
int bc[3145810];
signed main(){
ic(x) ic(y) ic(z) ic(n)
rep(0,i,x)cin>>a[i];
rep(0,i,y)cin>>b[i];
rep(0,i,z)cin>>c[i];
rep(0,i,x)rep(0,j,y)ab[i*y+j]=a[i]+b[j];
sort(ab,ab+x*y);
reverse(ab,ab+x*y);
rep(0,i,n)abmax[i]=ab[i];
rep(0,i,n)rep(0,j,z)bc[i*z+j]=abmax[i]+c[j];
sort(bc,bc+n*z);
reverse(bc,bc+n*z);
rep(0,i,n)c(bc[i])
}
| 0
| 72,774,263
|
#include <cstdio>
#include <cstring>
int main() {
const int coin[] = { 500, 100, 50, 10, 5, 1};
int n = 0;
while (scanf("%d", &n)) {
if (n == 0) return 0;
int c = 0;
int o = 1000 - n;
while (o != 0) {
for (int i = 0; i < 6; ++i) {
if (coin[i] <= o) {
o -= coin[i];
c++;
break;
}
}
}
printf("%d\n", c);
}
return 0;
}
|
#include <bits/stdc++.h>
#include <ext/rope>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define pb push_back
#define x first
#define y second
#define mk(a,b) make_pair(a,b)
#define rr return 0
#define sqr(a) ((a)*(a))
#define all(a) (a).begin(), (a).end()
#define sz(a) (int)(a).size()
using namespace std;
using namespace __gnu_cxx;
using namespace __gnu_pbds;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template<class value, class cmp = less<value> >
using ordered_set = tree<value, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template<class value, class cmp = less_equal<value> >
using ordered_multiset = tree<value, null_type, cmp, rb_tree_tag, tree_order_statistics_node_update>;
template<class key, class value, class cmp = less<key> >
using ordered_map = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
inline int randll(int l = INT_MIN, int r = INT_MAX) {
return uniform_int_distribution<int>(l, r)(rng);
}
const int INF = 1e9, MOD = 1e9 + 7;
const ll LINF = 1e18;
const int dx[] = {0, 0, 1, -1}, dy[] = {1, -1, 0, 0};
inline bool inside (int x, int y, int n, int m) {
return 0 <= x && 0 <= y && x < n && y < m;
}
template<class T> bool umin (T &a, T b) {return a > b ? (a = b, true) : false; }
template<class T> bool umax (T &a, T b) {return a < b ? (a = b, true) : false; }
inline int mul (int a, int b, int m = MOD) {
return ((ll)a * b) % m;
}
inline int binpow (int a, int n, int m = MOD) {
int ans = 1;
for (; n; n >>= 1) {
if (n & 1) ans = mul(ans, a, m);
a = mul(a, a, m);
}
return ans;
}
inline void add (int &a, int x, int m = MOD) {
a += x;
if (a >= m) a -= m;
if (a < 0) a += m;
}
inline int sum (int a, int b, int m = MOD) {
a += b;
if (a >= m) a -= m;
if (a < 0) a += m;
return a;
}
inline int inv (int x, int m = MOD) {
return binpow(x, m - 2, m);
}
main()
{
ios::sync_with_stdio(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
int ans = 0;
vector <int> cnt(k + 1);
for (int i = 1; i <= k; i++) {
cnt[i] = binpow(k / i, n);
}
for (int i = k; i > 0; i--) {
for (int j = i + i; j <= k; j += i) {
add(cnt[i], -cnt[j]);
}
add(ans, mul(cnt[i], i));
}
cout << ans << '\n';
}
| 0
| 74,869,283
|
#include <bits/stdc++.h>
using namespace std;
typedef long int lint;
typedef long long int llint;
typedef pair<int, int> pii;
typedef pair<int, string> pis;
typedef pair<long, long> pll;
#define EACH(i, c) for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define FOR(i, s, e) for (int i = (s); i < (int)(e); ++i)
#define REP(i, n) FOR(i, 0, n)
#define endl "\n"
const int INF = 1000000;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
template<typename T>
void print(const std::vector<T>& v, char sep=' ') {
for (int i = 0; i < (int)v.size(); i++) {
if (i != 0) cout << sep;
cout << v[i];
}
cout << endl;
}
int prime[INF];
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n;
REP(i, INF) prime[i] = 1;
prime[0] = prime[1] = 0;
for (int i = 2; i * i <= INF; i++){
if (prime[i]){
for (int j = 2; i * j <= INF; j++){
prime[i * j] = 0;
}
}
}
while (cin >> n){
int ct = 0;
for (int i = 2; i <= n; i++){
if (prime[i]) ct++;
}
cout << ct << endl;
}
}
|
#include <iostream>
#include <stack>
#include <queue>
using namespace std;
#define MAX 100
#define WHITE 0
#define GRAY 1
#define BLACK 2
int T;
int N;
int M[MAX][MAX];
int C[MAX],D[MAX];
void bfs(int s)
{
queue<int> *q = new queue<int>;
q->push(s);
D[s] = 0;
C[s] = GRAY;
while(!q->empty())
{
int u = q->front();
q->pop();
for (int v = 0; v < N; v++)
{
if (M[u][v] && D[v] == -1)
{
C[u] = GRAY;
D[v] = D[u] + 1;
q->push(v);
}
}
C[u] = BLACK;
}
}
int main ()
{
cin >> N;
for (int i = 0; i < N; i++)
{
C[i] = WHITE;
D[i] = -1;
for (int j = 0; j < N; j++)
{
M[i][j] = 0;
}
}
for (int i = 0; i < N; i++)
{
int u, k;
cin >> u >> k;
u--;
for (int j = 0; j < k; j++)
{
int v;
cin >> v;
v--;
M[u][v] = 1;
}
}
bfs(0);
for (int i = 0; i < N; i++)
{
cout << i+1 << " " << D[i] << endl;
}
return 0;
}
| 0
| 87,575,337
|
#include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <deque>
#include <algorithm>
#include <cmath>
#include <cstring>
using namespace std;
#define REP(i,n) for(int i = 0; i < n; i++)
#define RREP(i,n) for(int i = n - 1; i >= 0; i--)
#define ALL(v) v.begin(),v.end()
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define UNIQUE(v) do{sort(v.begin(), v.end()); v.erase( unique(v.begin(), v.end()), v.end() );} while(0)
#define y0 y3487465
#define y1 y8687969
#define m0(x) memset(x,0,sizeof(x))
#define m1(x) memset(x,63,sizeof(x))
typedef long long ll;
typedef pair<int,int> pi;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pi> vpi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
double EPS = 1e-9;
int INFi = 1000000005;
long long INFll = 1000000000000000005ll;
double PI = acos(-1);
int dirx[8] = {-1,0,0,1,-1,-1,1,1};
int diry[8] = {0,1,-1,0,-1,1,-1,1};
ll MOD = 1000000007;
ll N, L, Q;
const ll MAX_N = 100000;
ll x[MAX_N];
const ll MAX_Q = 100000;
ll a[MAX_Q], b[MAX_Q];
ll dp[20][MAX_N];
void query(int l, int r) {
int crt = l;
int s = 0;
while(1) {
for(int i = 1; i < 20; i++) {
if(dp[i][crt] >= r) {
if(i == 1) {
s += 1;
cout << s << endl;
return;
} else {
s += int(pow(2, i - 2));
crt = dp[i - 1][crt];
break;
}
}
}
}
}
int main(){
cin >> N;
REP(i, N) cin >> x[i];
cin >> L;
cin >> Q;
REP(i, Q) cin >> a[i] >> b[i];
int dest = 0;
REP(j, N) {
while(dest != N && x[j] + L >= x[dest]) {
dest++;
}
dp[1][j] = dest - 1;
}
for(int i = 2; i < 20; i++) {
REP(j, N) {
dp[i][j] = dp[i - 1][dp[i - 1][j]];
}
}
REP(i, Q) {
int l = a[i], r = b[i];
if(a[i] > b[i]) swap(l, r);
query(l - 1, r - 1);
}
return 0;
}
|
#include<iostream>
using namespace std;
long int l[1000][3];
void swap(int a, int b, int c){
int buf = l[c][a];
l[c][a] = l[c][b];
l[c][b] = buf;
}
void sort(int c){
for(int i = 0; i < 2; i++){
for(int j = i; j < 2; j++){
if(l[c][j] > l[c][j+1]) swap(j,j+1,c);
}
}
}
int main(){
int buf;
cin >> buf;
for(int i = 0; i < buf; i++){
cin >> l[i][0] >> l[i][1] >> l[i][2];
sort(i);
}
for(int j = 0; j < buf; j++){
if(l[j][2]*l[j][2] == l[j][0]*l[j][0] +l[j][1]*l[j][1]){
cout << "YES" << endl;
}else{
cout << "NO" << endl;
}
}
return 0;
}
| 0
| 93,885,536
|
#include <iostream>
#include <iomanip>
#include <string>
#include <cmath>
#include <algorithm>
#include <cassert>
#include <vector>
#include <array>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <stack>
#include <queue>
#include <numeric>
using ll = long long;
using namespace std;
using pii = pair<int, int>;
using pdi = pair<double, int>;
int N, L, T;
vector<int> X;
vector<int> W;
int main() {
cin >> N >> L >> T;
for (int i = 0; i < N; i++)
{
int tmpX;
int tmpW;
cin >> tmpX >> tmpW;
X.push_back(tmpX);
W.push_back(tmpW);
}
vector<int> rX, lX;
for (int i = 0; i < N; i++)
{
if (W.at(i) == 1) {
rX.push_back(X.at(i));
}
else {
lX.push_back(X.at(i));
}
}
reverse(rX.begin(), rX.end());
const int q = T / L;
const int r = T % L;
int t;
int x;
int w;
int rcnt, lcnt;
const int rcnt_end = rX.size(), lcnt_end = lX.size();
t = 0;
x = X.at(0);
w = W.at(0);
rcnt = 0;
lcnt = 0;
if (w == 1) {
rcnt = rcnt_end - 1;
}
int x_final;
int kasanari = -1;
int kasanari_final = -1;
bool is_final = false;
while (true) {
int y;
int dt, dx;
if (w == 1) {
if (lcnt_end > 0) {
y = lX.at(lcnt) - t;
y += L;
y %= L;
if (x <= y) {
dt = (y - x + 1) / 2;
dx = (y - x) / 2;
}
else {
dt = (y + L - x + 1) / 2;
dx = (y + L - x) / 2;
}
}
else {
dt = L;
dx = 0;
}
if (!is_final && t + dt > r) {
x_final = x + r - t;
x_final %= L;
is_final = true;
}
if (t + dt > L) {
x += L - t;
x %= L;
break;
}
x += dx;
x %= L;
t += dt;
rcnt++;
rcnt %= rcnt_end;
if (lcnt_end > 0)
w = 2;
}
else {
if (rcnt_end > 0) {
y = rX.at(rcnt) + t;
y %= L;
if (y <= x) {
dt = (x - y + 1) / 2;
dx = -((x - y) / 2);
}
else {
dt = (x + L - y + 1) / 2;
dx = -((x + L - y) / 2);
}
if (!is_final && t + dt == r) {
if (y <= x) {
if ((x - y) % 2 == 0) {
kasanari_final = 1;
}
}
else {
if ((x + L - y) % 2 == 0) {
kasanari_final = 1;
}
}
}
if (t + dt == L) {
if (y <= x) {
if ((x - y) % 2 == 0) {
kasanari = 1;
}
}
else {
if ((x + L - y) % 2 == 0) {
kasanari = 1;
}
}
}
}
else {
dt = L;
dx = 0;
}
if (!is_final && t + dt > r) {
x_final = x - (r - t);
x_final %= L;
x_final += L;
x_final %= L;
is_final = true;
}
if (t + dt > L) {
x -= L - t;
x %= L;
x += L;
x %= L;
break;
}
x += dx;
x %= L;
x += L;
x %= L;
t += dt;
lcnt++;
lcnt %= lcnt_end;
if (rcnt_end > 0)
w = 1;
}
}
int did;
for (int i = 0; i < N; i++)
{
if (x == X.at(i)) {
did = i;
if (kasanari == 1) {
did++;
}
break;
}
}
vector<int> finalx;
for (int i = 0; i < N; i++)
{
int tmpfinalx;
if (W.at(i) == 1) {
tmpfinalx = X.at(i) + r;
}
else {
tmpfinalx = X.at(i) - r;
}
tmpfinalx %= L;
tmpfinalx += L;
tmpfinalx %= L;
finalx.push_back(tmpfinalx);
}
sort(finalx.begin(), finalx.end());
int did_final;
for (int i = 0; i < N; i++)
{
if (finalx.at(i) == x_final) {
did_final = i;
if (kasanari_final == 1) {
did_final++;
}
break;
}
}
const int id_final = (q*did + did_final) % N;
for (int i = id_final; i < N; i++)
{
cout << finalx.at(i) << endl;
}
for (int i = 0; i < id_final; i++)
{
cout << finalx.at(i) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define all(x) (x).begin(),(x).end()
using ll = long long;
using ld = long double;
#define vl vector<long long>
#define vvl vector<vector<long long>>
#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++)
using pll = pair<long long,long long>;
#define cY cout<<"Yes"<<endl
#define cN cout<<"No"<<endl
const long long INF = 1LL << 60;
const long long MOD = 1000000007;
const long double pi = (acos(-1));
#define pb push_back
#define vs vector<string>
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;
}
vector<long long> divisor(long long n) {
vector<long long> ret;
for (long long 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());
return ret;
}
ll nCr(ll n, ll r) {
ll ans = 1;
for (ll i = n; i > n - r; --i) {
ans = ans*i;
}
for (ll i = 1 ; i < r + 1; ++i) {
ans = ans / i;
}
return ans;
}
map< ll, ll > prime_factor(ll n) {
map< ll, ll > ret;
for(ll i = 2; i * i <= n; i++) {
while(n % i == 0) {
ret[i]++;
n /= i;
}
}
if(n != 1) ret[n] = 1;
return ret;
}
int main(){
ll N,M;
cin>>N>>M;
vector<tuple<ll,ll,ll>> vec(M);
rep(i,M){
ll p,y;
cin>>p>>y;
vec[i]=make_tuple(p,y,i);
}
sort(all(vec));
map<ll,ll> m;
vs Ans(M);
rep(i,M){
ll a=get<0>(vec[i]);
m[a]++;
ll b=m[a];
ll c=get<2>(vec[i]);
string F,L;
F=to_string(a);
L=to_string(b);
while(F.size()<6){
F='0'+F;
}
while(L.size()<6){
L='0'+L;
}
Ans[c]=F+L;
}
rep(i,M){
cout<<Ans[i]<<endl;
}
}
| 0
| 44,083,200
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,x,y) for(int i=x;i<y;i++)
#define print(A,x,n) rep(i,0,n){cout<<(i ? " ":"")<<A[i]x;}cout<<endl;
#define pprint(A,y,m,n) rep(j,0,m){print(A[j],y,n);}
const long mod=1e9+7;
const int size=1e5;
const int inf=1e9;
int main(){
int N,M;cin>>N>>M;
int s[N],t[M];
rep(i,0,N) cin>>s[i];
rep(i,0,M) cin>>t[i];
long dp[N+1][M+1] = {};
rep(i,1,N+1)rep(j,1,M+1){
if(s[i-1] == t[j-1]) dp[i][j] = (dp[i-1][j] + dp[i][j-1] + 1) % mod;
else dp[i][j] = (dp[i-1][j] + dp[i][j-1] - dp[i-1][j-1] + mod) % mod;
}cout<<(dp[N][M] + 1) % mod<<endl;
}
|
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define ld long double
#define MAX 1005
#define MOD 1000000007
#define fast ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define pi 3.14159265358979323846
#define Q ll _; cin >> _; while(_--)
#define endl "\n"
#define flush fflush(stdout);
int main(){
fast
ll i,n,k;
cin >> n >> k;
ll a[n+1];
for(i=1;i<=n;i++){
cin >> a[i];
}
ll dp[n+1];
for(i=1;i<=n;i++){
dp[i] = INT_MAX;
}
dp[1] = 0;
for(i=2;i<=n;i++){
ll x = max((ll)1,i-k);
for(ll j=x;j<i;j++){
dp[i] = min(dp[j]+abs(a[i]-a[j]),dp[i]);
}
}
cout << dp[n] << endl;
}
| 0
| 44,302,759
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int h,n;
cin >> h >> n;
vector<int>a(n);
for(int i = 0;i<n;i++) cin >> a.at(i);
int sum = 0;
for(int i = 0;i < a.size();i++) sum += a.at(i);
if(sum >= h) cout << "Yes" << endl;
else cout << "No" << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
#define M 1000000007
long long int power(int a,int b)
{
if(b==0)
return 1;
long long int k=power(a,b/2);
if(b%2==0)
return ((k%M)*(k%M))%M;
else
return ((k%M)*(k%M)*(a%M))%M;
}
long long int fact(long long int n)
{
if(n==1 || n==0)
return 1;
else
return ((n%M)*(fact(n-1)%M))%M;
}
int div(int n)
{ int c=0;
for(int i=1;i<sqrt(n);i++)
{
if(n%i==0)
{
c++;
}
}
c=c*2;
if(pow(sqrt(n),2)==(sqrt(n)*sqrt(n)))
c++;
return c;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
long long int n;
cin>>n;
long long int l[n+1];
l[0]=2;
l[1]=1;
for(long long int i=2;i<=n;i++)
l[i]=l[i-1]+l[i-2];
cout<<l[n];
return 0;
}
| 0
| 94,485,423
|
#include<iostream>
#include<string>
#include<cstdio>
#include<vector>
#include<cmath>
#include<algorithm>
#include<functional>
#include<iomanip>
#include<queue>
#include<ciso646>
#include<random>
#include<map>
#include<set>
#include<bitset>
#include<stack>
#include<unordered_map>
#include<utility>
#include<cassert>
#include<complex>
#include<numeric>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
typedef pair<int, int>P;
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
typedef vector<vector<ll>> mat;
typedef vector<ll> vec;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
#define all(v) (v).begin(),(v).end()
const ll mod = 1000000007;
const ll INF = mod * mod;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
ll qp(ll a,ll b,int mo){int ans=1;do{if(b&1)ans=1ll*ans*a%mo;a=1ll*a*a%mo;}while(b>>=1);return ans;}
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 dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };
template<typename T> istream &operator>>(istream &is, vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec){ os << "["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const deque<T> &vec){ os << "deq["; for (auto v : vec) os << v << ","; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_set<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ","; os << "}"; return os; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &pa){ os << "(" << pa.first << "," << pa.second << ")"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << "=>" << v.second << ","; os << "}"; return os; }
template<typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template<typename T, typename... Args> void ndarray(vector<T> &vec, int len, Args... args) { vec.resize(len); for (auto &v : vec) ndarray(v, args...); }
template<typename T> bool chmax(T &m, const T q) { if (m < q) {m = q; return true;} else return false; }
template<typename T> bool chmin(T &m, const T q) { if (q < m) {m = q; return true;} else return false; }
template<typename T1, typename T2> pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) { return make_pair(l.first + r.first, l.second + r.second); }
template<typename T1, typename T2> pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) { return make_pair(l.first - r.first, l.second - r.second); }
template<typename T1, typename T2> pair<T1, T2> operator<(const pair<T1, T2> l, const pair<T1, T2> r) { return (l.first < r.first); }
template<typename T1, typename T2> pair<T1, T2> operator>(const pair<T1, T2> l, const pair<T1, T2> r) { return (l.first > r.first); }
void solve() {
ll N; cin >> N;
string S; cin >> S;
string res = S;
stack<char> st;
rep(i,N){
char c = S[i];
if(c =='('){
st.push('(');
}
else{
if(st.empty()){
st.push(')');
}
else{
if(st.top()=='('){
st.pop();
}
else{
st.push(')');
}
}
}
}
while(!st.empty()){
char c = st.top(); st.pop();
if(c=='(') res.push_back(')');
else{
res = "(" + res;
}
}
cout << res << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
std::cout << fixed << setprecision(10);
solve();
return 0;
}
|
#include <bits/stdc++.h>
#define be(v) (v).begin(),(v).end()
#define pb(q) push_back(q)
typedef long long ll;
using namespace std;
const ll mod=1000000007;
#define doublecout(a) cout<<fixed<<setprecision(10)<<a<<endl;
ll n, m;
ll a[2005], b[2005];
ll dp[2005][2005], sum[2005][2005];
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
for(int i = 1; i <= n; i++) cin >> a[i];
for(int i = 1; i <= m; i++) cin >> b[i];
dp[0][0] = 1;
for(int i = 0; i <= n; i++) sum[i][0] = 1;
for(int i = 0; i <= m; i++) sum[0][i] = 1;
for(int i = 1; i <= n; i++){
for(int j = 1; j <=m; j++){
if(a[i] == b[j]) dp[i][j] = sum[i-1][j-1];
sum[i][j] = sum[i-1][j] + sum[i][j-1] - sum[i-1][j-1] + dp[i][j] + mod;
sum[i][j] %= mod;
}
}
cout << sum[n][m] << endl;
return 0;
}
| 0
| 60,795,894
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,m,n) for(int i=m;i<n;i++)
ll mod=1e9+7;
typedef pair<ll,int> P;
int main(){
int n,m,x,y;
cin>>n>>m>>x>>y;
int a=-100;
rep(i,0,n){
int cur;
cin>>cur;
a=max(a,cur);
}
int b=100;
rep(i,0,m){
int cur;
cin>>cur;
b=min(b,cur);
}
if(a>=b) cout<<"War"<<endl;
else if(b<=x || a>=y) cout<<"War"<<endl;
else cout<<"No War"<<endl;
}
|
#include "bits/stdc++.h"
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
#define ub upper_bound
#define lb lower_bound
#define isrt insert
#define clr clear
#define rsz resize
#define ff first
#define ss second
#define lli long long int
#define pb push_back
#define pf push_front
#define mkp make_pair
#define pii pair<int,int>
#define vi vector<int>
#define mii map<lli,lli>
#define pqb priority_queue<int>
#define pqs priority_queue<int,vi,greater<int> >
#define setbits(x) __builtin_popcountll(x)
#define zrobits(x) __builtin_ctzll(x)
#define mod 1000000007
#define INF 1e9
#define ps(x,y) fixed<<setprecision(y)<<x
#define mk(arr,n,type) type *arr=new type[n];
#define w(x) int x; cin>>x; while(x--)
#define all(v) v.begin(),v.end()
#define endl "\n"
typedef tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pbds;
lli maxm(lli a, lli b)
{
return (a >= b ? a : b);
}
lli minm(lli a, lli b)
{
return (a <= b ? a : b);
}
lli power(lli x, lli y, lli p)
{
lli res = 1;
x = x % p;
if (x == 0)
return 0;
while (y > 0)
{
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
lli nCrmodp(lli n, lli r, lli p)
{
if (r == 0)
return 1;
if (r == 1)
return n;
lli pro = 1, k = n;
while (k > r)
{
pro *= k;
pro %= p;
--k;
}
k = 2;
while (k <= (n - r))
{
pro *= power(k, (p - 2), p);
pro %= p;
++k;
}
return pro;
}
string num_str(lli n, lli k)
{
string str = "";
lli x = n;
while (x != 0)
{
string s = to_string(x % k);
str = s + str;
x /= k;
}
return str;
}
lli first_big(lli n, lli k, lli arr[])
{
lli l = 0;
lli r = n - 1;
lli leftGreater = n;
while (l <= r) {
lli m = l + (r - l) / 2;
if (arr[m] > k) {
leftGreater = m;
r = m - 1;
}
else
l = m + 1;
}
return leftGreater;
}
void c_p_c()
{
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
lli dp[110][100010];
vector<lli> arr;
vector<lli> pref_sum;
vector<lli> pr;
int main()
{
c_p_c();
lli n, k, s = 0, l, r;
memset(dp, -1, sizeof(dp));
cin >> n >> k;
arr.rsz(n + 1);
pref_sum.rsz(n + 1);
for (int i = 0; i <= n; ++i)
dp[i][0] = 1;
for (int i = 1; i <= k; ++i)
dp[0][i] = 0;
for (int i = 1; i <= n; ++i)
{
cin >> arr[i];
s += arr[i];
pref_sum[i] = s;
}
for (int i = 1; i <= n; ++i)
{
pr.clr();
pr.rsz(k + 1);
s = 0;
for (int j = 0; j <= k; ++j)
{
s += dp[i - 1][j];
s %= mod;
pr[j] = s;
}
for (int j = 0; j <= k; ++j)
{
if (j <= arr[i])
dp[i][j] = pr[j];
else
{
if (j > pref_sum[i])
dp[i][j] = 0;
else
{
l = (j - arr[i]);
r = j;
dp[i][j] = (pr[r] - pr[l - 1] + mod) % mod;
}
}
}
}
cout << dp[n][k] << endl;
return 0;
}
| 0
| 61,653,339
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repm(i,m,n) for(ll i=m;i<n;i++)
#define max(a,b) (((a)>(b))?(a):(b))
#define min(a,b) (((a)<(b))?(a):(b))
#define YesNo(a) (a)?cout<<"Yes"<<endl:cout<<"No"<<endl
#define YESNO(a) (a)?cout<<"YES"<<endl:cout<<"NO"<<endl
#define INF (2e9)
#define PI (acos(-1))
#define all(x) (x).begin(),(x).end()
#define MOD 1000000007
typedef long long ll;
int main(){
int n, k; cin >> n >> k;
vector<int> p(n); rep(i,n) cin >> p[i];
sort(all(p));
int ans = 0;
rep(i,k){
ans += p[i];
}
cout << ans << endl;
}
|
#include <iostream>
using namespace std;
int main(int argc, const char * argv[])
{
int a[10005];
int i,j;
i=0;
a[0] = 1;
while( a[i] != 0)
{
i += 1;
cin >> a[i];
}
for(j=1;j<i;j++)
{
cout << "Case " << j << ": " << a[j] << endl;
}
return 0;
}
| 0
| 8,495,472
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
typedef long long ll;
typedef long double ld;
int main()
{
ll x,y; cin >> x >> y;
vector<ll> a;
int p = 0;
while (x * (ll)pow(2 , p) <= y)
{
a.push_back(x * (ll)pow(2,p));
p++;
}
cout << a.size() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_temp>
using smaller_queue = priority_queue<Q_temp, vector<Q_temp>, greater<Q_temp>>;
const ll MOD = (ll)(1e9 + 7);
const int INF = (int)1e9;
const ll LINF = (ll)4e18;
const double PI = acos(-1.0);
#define REP(i, m, n) for (ll i = m; i < (ll)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
#define MT make_tuple
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << endl
#define all(v) v.begin(), v.end()
#define NP(v) next_permutation(all(v))
#define dbg(x) cerr << #x << ":" << x << endl;
vector<int> Dx = {0, 0, -1, 1, -1, 1, -1, 1, 0};
vector<int> Dy = {1, -1, 0, 0, -1, -1, 1, 1, 0};
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(50) << setiosflags(ios::fixed);
int n;
cin >> n;
struct vec
{
ld x, y;
};
vector<vec> v;
rep(i, n)
{
ld xi, yi;
cin >> xi >> yi;
if (xi == 0.0 && yi == 0.0)
n--, i--;
else
v.push_back({xi, yi});
}
auto comp = [](vec &v1, vec &v2) {
return atan2(v1.y, v1.x) < atan2(v2.y, v2.x);
};
sort(all(v), comp);
rep(i, n) cerr << v[i].x << " " << v[i].y << endl;
cerr << endl;
rep(i, n) v.push_back(v[i]);
ld Max = 0.0;
for (int choose = 1; choose <= n; ++choose)
{
rep(start, n)
{
ld x_sum = 0.0, y_sum = 0.0;
for (int i = start; i < start + choose; ++i)
{
x_sum += v[i].x;
y_sum += v[i].y;
}
Max = max(Max, sqrt(x_sum * x_sum + y_sum * y_sum));
}
}
cout << Max << endl;
return 0;
}
| 0
| 28,753,132
|
#include <bits/stdc++.h>
#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++)
using namespace std;
using P = pair<int, int>;
using ll = long long;
int main()
{
int n,m;
int x;
cin >> n >> m;
rep(i,m){
cin >> x;
if(n - x < 0) {
cout << -1 << endl;
return 0;
}
n -= x;
}
cout << n << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, a) for(int i=0; i<(int)(a); i++)
typedef long long ll;
template<typename T>
struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template<typename T>
using Edges = vector<edge<T>>;
template<typename T>
using WeightedGraph = vector<Edges<T>>;
using UnWeightedGraph = vector<vector<int>>;
template<typename T>
using Matrix = vector<vector<T>>;
const ll inf = 1LL<<60;
vector<int> tsort(vector<vector<int>> g) {
int n = g.size();
vector<int> ret;
vector<int> in(n, 0);
for (int i=0; i<n; i++) {
for (auto v : g[i]) in[v]++;
}
queue<int> que;
for (int i=0; i<n; i++) {
if (in[i] == 0) que.push(i);
}
while (!que.empty()) {
int v = que.front(); que.pop();
for (auto u : g[v]) {
in[u] -= 1;
if (in[u] == 0) que.push(u);
}
ret.push_back(v);
}
return ret;
}
int main()
{
int n,e; cin>>n>>e;
vector<vector<int>> g(n);
rep(i, e) {
int u,v; cin>>u>>v;
g[u].push_back(v);
}
vector<int> sv = tsort(g);
for (auto v : sv) cout << v << endl;
return 0;
}
| 0
| 42,291,328
|
#include <bits/stdc++.h>
#define FOR(i,l,r) for(size_t i=(l);i<(r);++i)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
using namespace std;
const ll INF=1ll<<32;
int main(){
ll v,e;
cin>>v>>e;
ll G[v][v];
rep(i,v){
rep(j,v){
G[i][j]=INF;
if(i==j)G[i][j]=0;
}
}
rep(i,e){
ll s,t,d;
cin>>s>>t>>d;
G[s][t]=d;
}
rep(k,v){
rep(i,v){
rep(j,v){
if(G[i][k]!=INF&&G[k][j]!=INF){
G[i][j]=min(G[i][j],G[i][k]+G[k][j]);
}
}
}
}
rep(i,v){
rep(j,v){
if(G[i][j]+G[j][i]<0){
cout<<"NEGATIVE CYCLE"<<endl;
return 0;
}
}
}
rep(i,v){
rep(j,v){
if(G[i][j]==INF){cout<<"INF";}
else cout<<G[i][j];
if(j==v-1){
cout<<endl;
}
else cout<<' ';
}
}
}
|
#include <iostream>
#include <fstream>
#include "bits/stdc++.h"
#define REP(i,x,y) for(int i=(x);i<(y);i++)
#define RREP(i,x,y) for(int i=(y)-1;i>=(x);i--)
#define all(x) (x).begin(),(x).end()
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
#define dump(x) cerr << #x << " = " << (x) << endl
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl
typedef long long ll;
const ll MOD = 1e9 + 7;
class FEngines {
public:
void solve(std::istream& in, std::ostream& out) {
int N;
in >> N;
vector<int> X(N), Y(N);
REP(i,0,N) in >> X[i] >> Y[i];
vector<tuple<double,int,int>> xy(N);
REP(i,0,N) {
tuple<double,int,int> t{atan2((double)Y[i], (double)X[i]), X[i], Y[i]};
xy[i] = move(t);
}
sort(all(xy));
ll answer = 0;
REP(length,1,N+1) {
int x = 0, y = 0;
REP(i,0,length) {
x += get<1>(xy[i]);
y += get<2>(xy[i]);
}
answer = max(answer, ((ll)x * x + (ll)y * y));
REP(left, 1, N) {
int plus = (left + length - 1) % N;
int minus = (left - 1 + N) % N;
x -= get<1>(xy[minus]);
y -= get<2>(xy[minus]);
x += get<1>(xy[plus]);
y += get<2>(xy[plus]);
answer = max(answer, ((ll)x * x + (ll)y * y));
}
}
out << setprecision(20) << pow(answer, 0.5) << "\n";
}
};
int main() {
FEngines solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 0
| 41,949,859
|
#include <iostream>
#include <algorithm>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <string.h>
#include <vector>
#include <queue>
#include <cmath>
#include <bitset>
#include <complex>
#include <functional>
#include <numeric>
#include <iomanip>
#define SPBR(w, n) std::cout<<(w + 1 == n ? '\n' : ' ');
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
#define ALL(i) (i).begin(), (i).end()
#define FOR(i, a, n) for(int i=(a);i<(n);++i)
#define RFOR(i, a, n) for(int i=(n)-1;i>=(a);--i)
#define REP(i, n) for(int i=0;i<int(n);++i)
#define RREP(i, n) for(int i=int(n)-1;i>=0;--i)
#define IN(a, x, b) (a<=x && x<b)
#define OUT(a, x, b) (x<a || b<=x)
template<class T> inline T chmax(T & a, const T b) { return a = (a < b) ? b : a; }
template<class T> inline T chmin(T& a, const T b) { return a = (a > b) ? b : a; }
#define int ll
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const int MOD = 1000000007;
const int INF = 1e18;
const double PI = acos(-1);
using namespace std;
struct INIT { INIT(){
cin.tie(0); ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
}}INIT;
signed main() {
int M;
cin >> M;
int keta = 0;
int sum = 0;
REP(i, M){
int d, c;
cin >> d >> c;
keta += c;
sum += d*c;
}
cout << keta-1+(sum-1)/9 << "\n";
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
using vl = vector<ll>;
using Map = map<P,ll>;
using T = tuple<ll,ll,ll>;
using vvl = vector<vector<ll>>;
#define all(v) v.begin(), v.end()
#define print(v) cout<<v<<endl;
#define fi(v) get<0>(v)
#define se(v) get<1>(v)
#define th(v) get<2>(v)
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 ll INF=1LL<<60;
const ll MOD=1000000007;
int main(){
ll N;
cin >> N;
ll M;
cin >> M;
vector<ll> A(N,0);
vector<ll> B(N,0);
for(ll i=0;i<N;i++){
cin>>A[i]>>B[i];
}
priority_queue<P, vector<P>, greater<P>> pq;
for(ll i=0;i<N;i++)pq.emplace(P(A[i],B[i]));
ll nokori=M;
ll ans=0;
while(nokori>0){
P x=pq.top();
pq.pop();
if(nokori>=x.second){
ans+=x.second*x.first;
nokori-=x.second;
}
else {
ans+=x.first*nokori;
nokori=0;
break;
}
}
print(ans)
return 0;
}
| 0
| 11,020,219
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define MAX 9223372036854775807
#define MOD 1000000007
int main(void)
{
int a, b, m;
cin >> a >> b >> m;
vector<int> A(a), B(b);
rep(i, a) cin >> A.at(i);
rep(i, b) cin >> B.at(i);
int minA = *min_element(A.begin(), A.end());
int minB = *min_element(B.begin(), B.end());
int min_cost = minA+minB;
rep(i,m){
int x, y, c;
cin >> x >> y >> c;
x--;
y--;
min_cost =min(min_cost,A.at(x) + B.at(y) - c);
}
cout << min_cost << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, s, e) for (int i = s; i < e; ++i)
#define sort_(a) stable_sort(a.begin(), a.end())
#define rsort(a) stable_sort(a.rbegin(), a.rend())
#define sum(a) accumulate(a.begin(), a.end(), 0LL)
#define join(a, d) accumulate(a.begin() + 1, a.end(), a[0], [](string s, string t) {return s + d + t;})
#define all(a) a.begin(), a.end()
#define PI 3.141592653589793
#define degrees(a) a * 180.0 / PI;
typedef long long ll;
const long mod = 1e9 + 7;
int main(void) {
#ifdef DEBUG
freopen("input.txt", "r", stdin);
#endif
ios_base::sync_with_stdio(false);
cin.tie(0);
double A, B, X;
cin >> A >> B >> X;
double s1 = X / (A * A) * A;
double h1 = (2 * s1) / B;
double ans1 = degrees(atan2(B, h1));
double s2 = A * B - s1;
double h2 = (2 * s2) / A;
double ans2 = degrees(atan2(h2, A));
if (X / (A * A) <= B / 2)
cout << fixed << setprecision(10) << ans1 << endl;
else
cout << fixed << setprecision(10) << ans2 << endl;
return 0;
}
| 0
| 62,111,641
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < n; i++)
#define per(i,n) for(int i = n-1; i >= 0; i--)
typedef long long ll;
typedef pair<int, int> P;
typedef pair<long long, long long> Pll;
typedef vector<int> vi;
typedef vector<ll> vll;
const long long mod = 1000000007LL;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
vi v;
int cnt0 = 0;
int cnt1 = 0;
rep(i,n) {
if(cnt1>0 && s[i]=='0') {
v.push_back(cnt1);
cnt1 = 0;
cnt0 = 1;
}
else if(cnt0>0 && s[i]=='1') {
v.push_back(cnt0);
cnt0 = 0;
cnt1 = 1;
}
else if(s[i]=='1') cnt1++;
else cnt0++;
}
if(cnt0>0) v.push_back(cnt0);
else v.push_back(cnt1);
if(s[0]=='1') {
int ans = 0;
int tmp = 0;
rep(i,2*k+1) {
if(i>=v.size()) break;
tmp += v[i];
}
ans = tmp;
rep(i,v.size()-2*k-1) {
if(i<0 || 2*k+1+i >= v.size()) break;
tmp -= v[i];
tmp -= v[i+1];
tmp += v[2*k+1+i];
if(2*k+2+i < v.size()) tmp += v[2*k+2+i];
ans = max(ans,tmp);
i++;
}
cout << ans << endl;
return 0;
}
else {
int ans = 0;
int tmp = 0;
rep(i,2*k) {
if(i>=v.size()) break;
tmp += v[i];
}
ans = tmp;
rep(i,v.size()-2*k) {
if(i==0) {
tmp -= v[i];
if(2*k+i < v.size()) tmp += v[2*k+i];
if(2*k+i+1 < v.size()) tmp += v[2*k+i+1];
ans = max(ans,tmp);
continue;
}
if(i<0 || 2*k+1+i >= v.size()) break;
if(i==0) {
tmp -= v[i];
tmp += v[2*k+i];
tmp += v[2*k+i+1];
ans = max(ans,tmp);
continue;
}
tmp -= v[i];
tmp -= v[i+1];
tmp += v[2*k+1+i];
if(2*k+2+i < v.size()) tmp += v[2*k+2+i];
ans = max(ans,tmp);
i++;
}
cout << ans << endl;
return 0;
}
}
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
const int INT_INF = 2147483647;
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; }
bool check(vector<char> c){
bool res = 1;
rep(i,c.size()/2){
if(c[i]!=c[c.size()-i-1])res=0;
}
return res;
}
int main(){
string s;
cin >> s;
vector<char> c;
rep(i,s.size())if(s[i]!='x')c.push_back(s[i]);
if(check(c)==0)cout << -1 << endl;
else{
int left = 0;
int right = s.size()-1;
int ans = 0;
while(left<right){
if(s[left]==s[right])left++,right--;
else if(s[left]=='x')ans++,left++;
else ans++,right--;
}
cout << ans << endl;
}
return 0;
}
| 0
| 66,604,948
|
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
#define repr(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) for(int i=0;i<n;i++)
#define invrepr(i,a,b) for(int i=b-1;i>=a;i--)
#define invrep(i,n) invrepr(i,0,n)
#define repitr(itr,a) for(auto itr=a.begin();itr!=a.end();++itr)
#define P pair<int,int>
const ll MOD=1e9+7;
const int MAX=1e5+10;
const ll INF=1e18;
const double PI=acos(-1);
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
cout << 180*(n-2) << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#include <string>
#include <numeric>
#include <tuple>
#include <algorithm>
#include <array>
#include <cmath>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define rep(i,n) for(decltype(n) i=0; i<n; ++i)
inline constexpr ll Inf = (1ULL << 62) -1;
template <class T>
void updatemax(T& a, T b) { if (b > a) a = b; }
int main() {
ull ans=1;
ll N;
cin >> N;
vector<ull> a(N);
rep(i,N) cin >> a[i];
if (find(begin(a), end(a), 0) != end(a)) {
ans = 0;
} else {
double log10 = log(10);
rep(i,N) {
ull p = ans;
ans *= a[i];
if ((log(p)+log(a[i]))/log10 > 18.000001 || ans > 1000000000000000000 || ans < p) {
cout << -1 << endl;
return 0;
}
}
}
cout << ans << endl;
return 0;
}
| 0
| 56,971,443
|
#include<bits/stdc++.h>
#define mod 1000000007
#define ll long long int
#define ar array
#define pb push_back
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
double r,g;
cin>>r>>g;
cout<<2*g-r<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<n;++i)
#define exrep(i, a, b) for(ll i = a; i < b; i++)
#define out(x) cout << x << endl
#define EPS (1e-7)
#define gearup ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
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<pair<int,int> > vpii;
typedef vector<vector<int> > vvi;
typedef vector<vector<char> > vvc;
typedef vector<vector<bool> > vvb;
typedef vector<vector<double> > vvd;
typedef vector<vector<string> > vvs;
typedef vector<ll> vl;
typedef vector<vector<ll> > vvl;
typedef vector<vector<vector<ll> > > vvvl;
ll MOD = 1000000007;
const long long L_INF = 1LL << 60;
const int INF = 2147483647;
const double PI = acos(-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<class T> void debug(T v){rep(i,v.size()) cout<<v[i]<<" ";cout<<endl;}
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
signed main()
{
gearup;
ll n,m;cin >> n >> m;
vvl p(n+1);
vpii pa;
rep(i,m){
int P,Y;cin>>P>>Y;
p[P].emplace_back(Y);
pa.emplace_back(make_pair(P,Y));
}
rep(i,n+1)sort(all(p[i]));
for(auto paa:pa){
int a = paa.first;
int b = lower_bound(all(p[a]),paa.second) - p[a].begin();
printf("%06d%06d\n",a,b+1);
}
}
| 0
| 69,841,978
|
#include <cstdio>
#include <vector>
#include <forward_list>
#include <queue>
using namespace std;
int cnt = 0;
int cntp = 0;
queue<int> source;
vector<int> pre;
vector<int> in;
class Edge{
public:
int v;
int w;
Edge(int vi,int wi):v(vi),w(wi){;}
};
class Graph{
public:
int V;
int E;
vector<forward_list<int>> adj_list;
Graph(int v,int e):V(v),E(e){
adj_list.resize(V);
pre.resize(V);
in.resize(V);
for(int i = 0; i < V;i++) {pre[i] = -1;in[i] = 0;}
}
void addEdge(int v,int w){
adj_list[v].push_front(w);
}
};
int main(){
int V,E,v,w;
scanf("%d %d",&V,&E);
Graph G(V,E);
for(int i = 0; i < E;i++){
scanf("%d %d",&v,&w);
G.addEdge(v,w);
in[w]++;
}
for(int i = 0; i < V;i++){
if(!in[i]) source.push(i);
}
while(!source.empty()){
int j = source.front();
pre[j] = 0;
printf("%d\n",j);
source.pop();
for(auto a = G.adj_list[j].begin();a!=G.adj_list[j].end();++a){
int v = *a;
if(pre[v] == -1){
if(--in[v] == 0)
source.push(v);
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<vector<int>> G(n+1);
for (int i=0; i<n; i++) {
int u,k;
cin >> u >> k;
for (int j=0; j<k; j++) {
int v;
cin >> v;
G[u].push_back(v);
}
}
vector<int> c(n+1,-1);
queue<int> q;
q.push(1);
c[1]=0;
while(!q.empty()) {
int a=q.front();
q.pop();
for (auto b:G[a]){
if (c[b]==-1) {
q.push(b);c[b]=true;c[b]=c[a]+1;
}
}
}
for (int i=0; i<n; i++) {
cout << i+1 << " " << c[i+1] << endl;
}
}
| 0
| 3,381,681
|
#include<iostream>
using namespace std;
int main(){
int siharai=1;
int oturi;
int a;
while(siharai!=0){
cin>>siharai;
oturi=0;
if(siharai==0)
break;
oturi=1000-siharai;
if(oturi>500){
a+=1;
oturi-=500;
}
while(oturi>=100){
a+=1;
oturi-=100;
}
while(oturi>=50){
a+=1;
oturi-=50;
}
while(oturi>=10){
a+=1;
oturi-=10;
}
while(oturi>=5){
a+=1;
oturi-=5;
}
while(oturi>=1){
a+=1;
oturi-=1;
}
cout<<a<<'\n';
a=0;
}
return 0;
}
|
#include <iostream>
#include <set>
#include <map>
#include <vector>
#include <algorithm>
#include <iomanip>
#include <climits>
#include <numeric>
#include <cmath>
#include <queue>
#include <sstream>
#include <string.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> v(n + 2, 0), t(n + 1, 0);
for (int i = 1; i <= n; i++) {
cin >> t[i];
t[i] += t[i - 1];
}
for (int i = 1; i <= n; i++) {
cin >> v[i];
}
vector<double> maxv(2*t[n]+1);
int ti = 1;
for (int i = 1; i <= n; i++) {
while(ti < 2*t[i]) {
maxv[ti] = v[i];
ti++;
}
maxv[ti] = min(v[i], v[i + 1]);
ti++;
}
for (int i = 1; i < 2*t[n]; i++) {
maxv[i] = min(maxv[i], maxv[i-1] + 0.5);
}
for(int i=2*t[n]-1; i>=0; i--){
maxv[i] = min(maxv[i], maxv[i+1]+0.5);
}
double ans = 0;
for (int i = 0; i < 2*t[n]; i++) {
ans += 0.5 / 2 *(maxv[i]+maxv[i+1]);
}
cout << fixed << ans << endl;
return 0;
}
| 0
| 32,651,043
|
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> ii;
typedef pair<int,ii> ti;
const int INF = 1e9;
const int MN = 110;
int g[MN][MN];
int dx[2] = {1,0};
int dy[2] = {0,1};
int dist[MN][MN];
int main() {
ios::sync_with_stdio(0);cin.tie(0);
int h,w;
cin >> h >> w;
for(int i=0;i<h;i++) {
string s;
cin >> s;
for(int j=0;j<w;j++) {
if(s[j] == '#') {
g[i][j] = 0;
} else {
g[i][j] = 1;
}
dist[i][j] = INF;
}
}
priority_queue<ti,vector<ti>,greater<ti> > lol;
int be = 1-g[0][0];
dist[0][0] = be;
for(int i=0;i<h;i++) {
for(int j=0;j<w;j++) {
int ad = ((g[i][j] && !g[i+1][j])?1:0);
dist[i+1][j] = min(dist[i][j]+ad,dist[i+1][j]);
int bd = ((g[i][j] && !g[i][j+1])?1:0);
dist[i][j+1] = min(dist[i][j]+bd,dist[i][j+1]);
}
}
cout << dist[h-1][w-1] << '\n';
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define pi 3.14159265359
#define all(i) i.begin(),i.end()
using namespace std;
const long long INF=1e9+7;
const string alp="abcdefghijklmnopqrstuvwxyz";
const string ALP="ABCDEFGHIJKLMNOPQRSTUVWXYZ";
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vector<ll>> vvl;
typedef pair<ll,ll> P;
typedef tuple<ll,ll,ll> T;
int main() {
ll s;
cin>>s;
vector<bool> judge(1000000,false);
ll a=s;
ll ans;
judge[s]=true;
for(int i=2;i<10000000;i++){
if(a%2==0){
a/=2;
if(judge[a]){
ans=i;
break;
}
else{
judge[a]=true;
}
}
else{
a=3*a+1;
if(judge[a]){
ans=i;
break;
}
else{
judge[a]=true;
}
}
}
cout<<ans<<endl;
}
| 0
| 73,230,316
|
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <stack>
#include <vector>
#include <set>
#include <tuple>
#include <utility>
#include <functional>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef tuple<int,int,int> T;
const int INF = 1000000000;
const int MOD = 1000000007;
int main(){
int n;
cin >> n;
map<int,int> mp1;
map<int,int> mp2;
for(int i = 0;i < n;i++){
int v;
cin >> v;
if(i % 2 == 0)mp1[v]++;
else mp2[v]++;
}
int mx11 = 0,mx11_value = 0;
for(auto p:mp1){
if(p.second > mx11){
mx11 = p.second;
mx11_value = p.first;
}
}
int mx12 = 0,mx12_value = 0;
for(auto p:mp1){
if(p.second > mx12 && p.first != mx11_value){
mx12 = p.second;
mx12_value = p.first;
}
}
int mx21 = 0,mx21_value = 0;
for(auto p:mp2){
if(p.second > mx21){
mx21 = p.second;
mx21_value = p.first;
}
}
int mx22 = 0,mx22_value = 0;
for(auto p:mp2){
if(p.second > mx22 && p.first != mx21_value){
mx22 = p.second;
mx22_value = p.first;
}
}
int ans = n;
if(mx11_value != mx21_value){
ans = min(ans,n-mx11-mx21);
}
if(mx11_value != mx22_value){
ans = min(ans,n-mx11-mx22);
}
if(mx12_value != mx21_value){
ans = min(ans,n-mx12-mx21);
}
if(mx12_value != mx22_value){
ans = min(ans,n-mx12-mx22);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int W, H, N;
cin >> W >> H >> N;
int x1 = 0, y1 = 0;
int x , y , a;
for (int i = 1; i <= N; i++) {
cin >> x >> y >> a;
if(a == 1 && x1 < x) {
x1 = x;
}
else if (a == 2 && W > x) {
W = x;
}
else if (a == 3 && y1 < y) {
y1 = y;
}
else if (a == 4 && H > y) {
H = y;
}
}
W -= x1;
H -= y1;
if(W <= 0 || H <= 0) {
cout << 0;
}
else {
cout << W*H;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 0
| 13,808,384
|
#include<iostream>
#include<algorithm>
using namespace std;
int SelectionSort(int A[], int N){
int cnt = 0;
for(int i = 0; i < N; i++){
int minj = i;
for(int j = i; j < N; j++){
if(A[j] < A[minj]){
minj = j;
}
}
swap(A[i],A[minj]);
if(i != minj) cnt++;
}
return cnt;
}
int main(){
int N,cnt;
cin >> N;
int A[N];
for(int i = 0; i < N; i++)
cin >> A[i];
cnt = SelectionSort(A,N);
for(int i = 0; i < N; i++){
cout << A[i];
if(i == N-1) cout << endl;
else cout << " ";
}
cout << cnt << endl;
}
|
#include<bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
using namespace std;
#define pb push_back
int dy[]={0, 0, 1, -1, 0};
int dx[]={1, -1, 0, 0, 0};
#define FOR(i,a,b) for (int i=(a);i<(b);i++)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define REP(i,n) for (int i=0;i<(n);i++)
#define RREP(i,n) for (int i=(n)-1;i>=0;i--)
int a[200],a2[200];
char mark[200],mark2[200],s[1000];
int main(void){
int n,mini;
char b;
scanf("%d",&n);
fgets(s,1000,stdin);
fgets(s,1000,stdin);
REP(i,n){
mark[i] = mark2[i] = s[i * 3];
a2[i] = a[i] = s[i * 3 + 1] - '0';
}
REP(i,n){
RFOR(j,i + 1,n)
if(a[j] < a[j - 1]){
swap<int>(a[j],a[j - 1]);
swap<char>(mark[j],mark[j - 1]);
}
}
REP(i,n){
mini = i;
FOR(j,i,n)
if(a2[j] < a2[mini])
mini = j;
if(i != mini){
swap<int>(a2[i],a2[mini]);
swap<char>(mark2[i],mark2[mini]);
}
}
REP(i,n){
if(i < n - 1)
printf("%c%d ",mark[i],a[i]);
else
printf("%c%d\n",mark[i],a[i]);
}
printf("Stable\n");
mini = 1;
REP(i,n)
if(mark[i] != mark2[i]){
mini = 0;break;
}
REP(i,n){
if(i < n - 1)
printf("%c%d ",mark2[i],a2[i]);
else
printf("%c%d\n",mark2[i],a2[i]);
}
if(mini == 1)
printf("Stable\n");
else
printf("Not stable\n");
return 0;
}
| 0
| 50,976,313
|
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <queue>
#include <bitset>
#include <iomanip>
#include <fstream>
#include <stack>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> PII;
typedef pair<ll , ll> PLL;
typedef long double ld;
#define pb push_back
#define all(c) c.begin(),c.end()
#define allr(c) c.rbegin(),c.rend()
int mod = 1000000007;
const int inf = 1034567891;
const ll LL_INF = 1234567890123456789ll;
#define PI 3.14159265
#define endl '\n'
#define F first
#define S second
#define debug(x) cout << #x << " = " << x << endl;
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cout << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');cout.write(names, comma - names) << " : " << arg1<<" | ";__f(comma+1, args...);
}
#else
#define trace(...)
#endif
#define out(container) for (auto it : container) cout << it << " "; cout << endl;
template < typename T > T GCD(T a, T b) { ll t; while(a) { t = a; a = b % a; b = t; } return b; }
template < typename T > string toString(T a) { return to_string(a); }
template < typename T > void toInt(string s, T &x) { stringstream str(s); str >> x;}
inline int add(int x, int y){ x += y; if(x >= mod) x -= mod; return x;}
inline int sub(int x, int y){ x -= y; if(x < 0) x += mod; return x;}
inline int mul(int x, int y){ return (x * 1ll * y) % mod;}
inline int powr(int a, ll b){
int x = 1 % mod;
while(b){
if(b & 1) x = mul(x, a);
a = mul(a, a);
b >>= 1;
}
return x;
}
inline int inv(int a){ return powr(a, mod - 2);}
long long get(long long n) {
return n * (n + 1) / 2;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int u, v;
long long ans = 0;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
if (u > v)
swap(u, v);
long long cur = u * 1ll * (n - v + 1);
ans -= cur;
}
for (int i = 0; i < n; i++) {
ans += get(n - i);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
int A, B, C, N, M ,K;
int sum = 0;
int t = 0;
char s, s1;
cin >> N;
vector<char> S(N);
for(int i = 0; i < N; i++){
cin >> S.at(i);
}
cin >> K;
s1 = S.at(K-1);
for(int i = 0; i < N; i++){
if(S.at(i) != s1) S.at(i) = '*';
}
for(int i = 0; i < N; i++){
cout << S.at(i);
}
cout << endl;
}
| 0
| 68,387,920
|
#include <iostream>
using namespace std;
int N, A[10010];
int min(int *a, int size) {
int min = a[0];
for(int i=0;i<size;i++){
if(a[i]<min){
min = a[i];
}
}
return min;
}
int max(int *a, int size) {
int max = a[0];
for(int i=0;i<size;i++){
if(a[i]>max){
max = a[i];
}
}
return max;
}
long long sum(int *a, int size) {
long long sum = 0;
for(int i=0;i<size;i++){
sum += a[i];
}
return sum;
}
int main() {
cin >> N;
for (int i=0; i<N; ++i)
cin >> A[i];
cout << min(A,N) << " " << max(A,N) << " " << sum(A,N) << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
const int MAX = 100;
const long long INF = 1e10;
long long M[MAX][MAX];
int main(){
int V, E;
cin >> V >> E;
rep(i,V){
rep(j,V){
if(i == j){
M[i][j] = 0;
}else{
M[i][j] = INF;
}
}
}
int s, t;
long long d;
rep(i,E){
cin >> s >> t >> d;
M[s][t] = d;
}
for(int k = 0; k < V; k++){
for(int i = 0; i < V; i++){
for(int j = 0; j < V; j++){
if(M[i][k] != INF && M[k][j] != INF){
M[i][j] = min(M[i][j], M[i][k] + M[k][j]);
}
}
}
}
for(int i = 0; i < V; i++){
if(M[i][i] < 0){
printf("NEGATIVE CYCLE\n");
return 0;
}
}
for(int i = 0; i < V; i++){
for(int j = 0; j < V; j++){
if(M[i][j] == INF){
printf("INF");
}else{
printf("%d", M[i][j]);
}
if(j < V - 1){
printf (" ");
}
}
printf("\n");
}
return 0;
}
| 0
| 1,120,003
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
int n,m;
int main(void){
cin>>n>>m;
cout<<max(n-m,0)<<endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
const int N = 110;
char s[N][N];
int n, m;
int dp[N][N];
int main() {
scanf("%d %d", &n, &m);
for(int i = 1; i <= n; ++i)
scanf("%s", s[i] + 1);
dp[1][1] = s[1][1] == '#';
for(int i = 1; i <= n; ++i) {
for(int j = 1; j <= m; ++j) {
if(i == 1 && j == 1) continue;
dp[i][j] = 1e9;
if(s[i][j] == '#') {
if(i > 1) dp[i][j] = min(dp[i][j], dp[i - 1][j] + (s[i - 1][j] != '#'));
if(j > 1) dp[i][j] = min(dp[i][j], dp[i][j - 1] + (s[i][j - 1] != '#'));
} else {
if(i > 1) dp[i][j] = min(dp[i][j], dp[i - 1][j]);
if(j > 1) dp[i][j] = min(dp[i][j], dp[i][j - 1]);
}
}
}
printf("%d\n", dp[n][m]);
return 0;
}
| 0
| 45,534,660
|
#include <bits/stdc++.h>
using namespace std;
using nagai = long long;
#define sz(x) int((x).size())
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin>>n;
cout<<(n-2)*180<<'\n';
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int,int> pii;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
typedef vector<pii> vii;
typedef vector<pll> vll;
typedef vector<pdd> vdd;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define mem(a,b) memset(a, b, sizeof(a) )
#define all(x) (x).begin(),(x).end()
#define INF 1000000000000
#define MOD 1000000007
#define PB push_back
#define MP make_pair
#define F first
#define S second
inline void normal(ll &a) { a %= MOD; (a < 0) && (a += MOD); }
inline ll modMul(ll a, ll b) { a %= MOD, b %= MOD; normal(a), normal(b); return (a*b)%MOD; }
inline ll modAdd(ll a, ll b) { a %= MOD, b %= MOD; normal(a), normal(b); return (a+b)%MOD; }
inline ll modSub(ll a, ll b) { a %= MOD, b %= MOD; normal(a), normal(b); a -= b; normal(a); return a; }
inline ll modPow(ll b, ll p) { ll r = 1; while(p) { if(p&1) r = modMul(r, b); b = modMul(b, b); p >>= 1; } return r; }
inline ll modInverse(ll a) { return modPow(a, MOD-2); }
inline ll modDiv(ll a, ll b) { return modMul(a, modInverse(b)); }
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
int main(){
int n,m;
cin>>n>>m;
vl x(n),y(n),z(n);
rep(i,n)cin>>x[i]>>y[i]>>z[i];
vvl a(8);
rep(i,n){
int cnt=0;
ll X,Y,Z;
rep(j,2){
rep(k,2){
rep(l,2){
if(j==0)X=x[i];
else X=-x[i];
if(k==0)Y=y[i];
else Y=-y[i];
if(l==0)Z=z[i];
else Z=-z[i];
a[cnt].PB(X+Y+Z);
cnt++;
}
}
}
}
rep(i,8){sort(all(a[i]));reverse(all(a[i]));}
ll ans=-1e18;
rep(i,8){
ll sum=0;
rep(j,m)sum+=a[i][j];
ans=max(ans,sum);
}
cout<<ans<<endl;
}
| 0
| 95,869,333
|
#include <iostream>
using namespace std;
int main(void)
{
ios_base::sync_with_stdio(false);
int A[10001]={};
int n,num;
cin >> n;
for(int i=0;i<n;i++){
cin >> num;
A[num]+=1;
}
for(int i=0;i<n;i++){
if(0<A[i]){
cout << i;
A[i]-=1;
break;
}
}
for(int i=0;i<10001;i++){
if(0<A[i]){
cout << " " << i;
A[i]-=1;
i--;
}
}
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
#define rep(i, a) for (int i = 0; (i) < (int) (a); (i)++)
#define reps(i, a, b) for (int i = (int) (a); (i) < (int) (b); (i)++)
#define rrep(i, a) for (int i = (int) a-1; (i) >= 0; (i)--)
#define rreps(i, a, b) for (int i = (int) (a)-1; (i) >= (int) (b); (i)--)
#define MP(a, b) make_pair((a), (b))
#define PB(a) push_back((a))
#define all(v) (v).begin(), (v).end()
#define PERM(v) next_permutation(all(v))
#define UNIQUE(v) sort(all(v));(v).erase(unique(all(v)), v.end())
#define CIN(type, x) type x;cin >> x
#define TRUE__ "Yes"
#define FALSE__ "No"
#define PRINT(f) if((f)){cout << (TRUE__) << endl;}else{cout << FALSE__ << endl;}
#define YES(f) if((f)){cout << "YES" << endl;}else{cout << "NO" << endl;}
#define Yes(f) if((f)){cout << "Yes" << endl;}else{cout << "No" << endl;}
#define MINV(v) min_element(all(v))
#define MAXV(v) max_element(all(v))
#define MIN3(a, b, c) min(min(a, b), c)
#define MIN4(a, b, c, d) min(MIN3(a, b, c), d)
#define MIN5(a, b, c, d, e) min(MIN4(a, b, c, d), e)
#define MIN6(a, b, c, d, e, f) min(MIN5(a, b, c, d, e), f)
#define MAX3(a, b, c) max(max(a, b), c)
#define MAX4(a, b, c, d) max(MAX3(a, b, c), d)
#define MAX5(a, b, c, d, e) max(MAX4(a, b, c, d), e)
#define MAX6(a, b, c, d, e, f) max(MAX5(a, b, c, d, e), f)
#define RANGE(a, b, c) ((a) <= (b) && (b) < (c))
#define RANGE2D(a, b, c, d, e, f) (RANGE((a), (c), (e)) && RANGE((b), (d), (f)))
#define chmin(a, b) a = min(a, (b))
#define chmin3(a, b, c) a = MIN3(a, (b), (c))
#define chmin4(a, b, c, d) a = MIN4(a, (b), (c), (d))
#define chmin5(a, b, c, d, e) a = MIN5(a, (b), (c), (d), (e))
#define chmin6(a, b, c, d, e, f) a = MIN6(a, (b), (c), (d), (e), (f))
#define chmax(a, b) a = max(a, (b))
#define chmax3(a, b, c) a = MAX3(a, (b), (c))
#define chmax4(a, b, c, d) a = MAX4(a, (b), (c), (d))
#define chmax5(a, b, c, d, e) a = MAX5(a, (b), (c), (d), (e))
#define chmax6(a, b, c, d, e, f) a = MAX6(a, (b), (c), (d), (e), (f))
#define RS resize
#define CINV(v, N) do {\
v.RS(N);\
rep(i, N) cin >> v[i];\
} while (0);
#define RCINV(v, N) do {\
v.RS(N);\
rrep(i, N) cin >> v[i];\
} while (0);
#define MOD 1000000007
template<class T>
inline T GET() {
T x;
cin >> x;
return x;
}
void init();
void solve();
signed main()
{
init();
solve();
}
#define INF 1123456789
int N;
vector<int> T, A;
void init()
{
cin >> N;
rep(i, N) {
T.PB(GET<int>());
}
rep(i, N) {
A.PB(GET<int>());
}
}
int calc()
{
vector<int> v(N);
v[0] = -T[0];
reps(i, 1, N) {
if (T[i] != T[i-1]) {
v[i] = -T[i];
} else {
v[i] = T[i];
}
}
if (v.back() < 0 && A.back() != -v.back() || v.back() > 0 && A.back() > v.back()) return 0;
v.back() = -A.back();
rrep(i, N-1) {
if (A[i] != A[i+1]) {
if (v[i] < 0 && A[i] != -v[i] || v[i] > 0 && A[i] > v[i]) {
return 0;
}
v[i] = -A[i];
}
else {
if (v[i] < 0 && A[i] < -v[i]) {
return 0;
}
chmin(v[i], A[i]);
}
}
int res = 1;
rep(i, N) {
if (v[i] > 0) res *= v[i];
res %= MOD;
}
return res;
}
void solve()
{
cout << calc() << endl;
}
| 0
| 37,664,237
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll MOD = 1000000007;
constexpr int NMAX = 2010;
ll _binom[NMAX][NMAX];
ll binom(ll n, ll r) {
if (n < 0 || r < 0 || r > n) return 0;
return _binom[n][r];
}
int main() {
for (int i = 0; i < NMAX; ++i) {
_binom[i][0] = _binom[i][i] = 1;
for (int j = 1; j < i; ++j) _binom[i][j] = (_binom[i-1][j] + _binom[i-1][j-1]) % MOD;
}
int s; scanf("%d", &s);
ll ans = 0;
for (int len = 1; len <= s; ++len) {
int as = s - 2 * len;
ans = (ans + binom(as - 1, len - 1)) % MOD;
}
printf("%lld\n", ans);
return 0;
}
|
#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 int64_t ll;
typedef long double ld;
const int INF = 1e9;
const ld EPS = 1e-8;
int main(){
int N;
cin >> N;
vector<int> t(N), v(N);
REP(i, N) cin >> t[i];
REP(i, N) cin >> v[i];
vector<int> tcum(N + 1, 0);
REP(i, N) tcum[i + 1] = tcum[i] + t[i];
int T = tcum[N];
vector<ld> vmax(2 * T + 1, INF);
REP(i, 2 * T + 1) {
ld time = 0.5 * i;
vmax[i] = min(vmax[i], min(time, T - time));
}
REP(i, N) {
REP(j, 2 * T + 1) {
ld time = 0.5 * j;
if(time > tcum[i + 1]) {
vmax[j] = min(vmax[j], v[i] + time - tcum[i + 1]);
}else if(time >= tcum[i]) {
vmax[j] = min(vmax[j], (ld)v[i]);
}else{
vmax[j] = min(vmax[j], v[i] + tcum[i] - time);
}
}
}
ld ret = 0;
REP(i, 2 * T) {
ret += 0.25 * (vmax[i] + vmax[i + 1]);
}
cout << fixed << setprecision(10) << ret << endl;
return 0;
}
| 0
| 40,982,986
|
#include<iostream>
using namespace std;
int main(){
int room[4][3][10]={0},b,f,v,r,n,k,j;
cin>>n;
for(int i=0;i<n;i++){
cin>>b>>f>>r>>v;
b=b-1;
f=f-1;
r=r-1;
room[b][f][r]=room[b][f][r]+v;
}
for(j=0;j<3;j++){
for(k=0;k<10;k++){
cout<<" "<<room[0][j][k];
if(k==9){
cout<<endl;
}
}
}
cout<<"####################"<<endl;
for(j=0;j<3;j++){
for(k=0;k<10;k++){
cout<<" "<<room[1][j][k];
if(k==9){
cout<<endl;
}
}
}
cout<<"####################"<<endl;
for(j=0;j<3;j++){
for(k=0;k<10;k++){
cout<<" "<<room[2][j][k];
if(k==9){
cout<<endl;
}
}
}
cout<<"####################"<<endl;
for(j=0;j<3;j++){
for(k=0;k<10;k++){
cout<<" "<<room[3][j][k];
if(k==9){
cout<<endl;
}
}
}
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define reps(i, f, n) for (ll i = (f); i < (n); i++)
#define repv(v) for (auto it = (v).begin(); it != (v).end(); it++)
ll const INF = 1LL << 60;
ll const MAX_N = 510000;
ll const MOD = 1000000007;
int main() {
ll A, B, K;
cin >> A >> B >> K;
for (ll i = 1; i <= K; i++) {
if (i % 2 == 1) {
if (A == 0) break;
if (A % 2 == 1) {
A -= 1;
}
B += A / 2;
A /= 2;
} else {
if (B == 0) break;
if (B % 2 == 1) {
B -= 1;
}
A += B / 2;
B /= 2;
}
}
cout << A << " " << B << endl;
return 0;
}
| 0
| 28,894,475
|
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
int n=s.size();
for(int i=0; i<n; i++){
if(i==3){
cout << s[i] << " ";
continue;
}
cout << s[i];
}
cout << endl;
}
|
#pragma GCC target ("avx2")
#pragma GCC optimize ("unroll-loops")
#pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include <unordered_set>
#include <unordered_map>
#include <random>
using namespace std;
typedef long long ll;
const ll MOD = 1'000'000'007LL;
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for(int (i)=0; (i)<(n); (i)++)
const int dx[4]={ 1,0,-1,0 };
const int dy[4]={ 0,1,0,-1 };
int N;
ll x[100000], L;
int p[100001];
int d[100001][20];
int Q;
signed main(){
cin >> N;
rep(i, N) cin >> x[i];
cin >> L;
int r = 0;
rep(i, N-1){
while(r < N && x[r]-x[i] <= L) r++;
p[i] = r-1;
}
p[N-1] = N;
rep(j, 20) d[N][j] = N;
for(int i=N-1; i>=0; i--){
d[i][0] = p[i];
rep(j, 19){
d[i][j+1] = d[d[i][j]][j];
}
}
cin >> Q;
rep(i, Q){
int a, b;
cin >> a >> b;
if(a > b) swap(a, b);
a--; b--;
int ans = 1;
int j = 19;
while(d[a][0] < b){
while(d[a][j] >= b){
j--;
}
ans += (1<<j);
a = d[a][j];
}
cout << ans << endl;
}
}
| 0
| 76,289,194
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
#define rep1(i, n) for (int i = 1; i < int(n); ++i)
#define repx(i, x, n) for (int i = int(x); i < int(n); ++i)
#define rrep(i, n) for (int i = int(n) - 1; i >= 0; --i)
#define ALL(n) begin(n), end(n)
#define IN(a, x, b) ((a) <= (x) && (x) < (b))
#define OUT(a, x, b) ((x) < (a) || (x) < (b))
typedef long long ll;
typedef long double ld;
const ll INF = 1e18;
const ll MOD = 1000000007;
int main()
{
int N, M;
cin >> N >> M;
int a[N], b[N], c[M], d[M];
rep(i, N)
{
cin >> a[i] >> b[i];
}
rep(i, M)
{
cin >> c[i] >> d[i];
}
rep(i, N)
{
ll now = 1e10, tmp, ans_idx;
rep(j, M)
{
tmp = abs(a[i] - c[j]) + abs(b[i] - d[j]);
if (now > tmp)
{
now = tmp;
ans_idx = j + 1;
}
}
cout << ans_idx << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using ll = long long;
using ld = long double;
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define rep3(i, n) for (int i = 1; i < (int)(n+1); i++)
#define rep4(i, s, n) for (int i = (s); i < (int)(n+1); i++)
#define repr(i,n) for (int i = (n-1); i>=0;i--)
#define repr3(i,n) for(int i = (n);i>0;i--)
#define stlen(s) ll s.size()-1
#define all(v) v.begin(), v.end()
#define cout(n) cout<<std::fixed<<std::setprecision(n)
using Graph = vector<vector<int>>;
#define INF const ll INF = 1001001001;
#define PI const ld PI = 3.14159265358979323846;
int main() {
ll N;
cin>>N;
vector<ll> ans;
for(ll i=1;i*i<=N;i++){
if(N%i==0){
if((N-i)/i>i){
ans.push_back(N/i-1);
}
}
}
ll sum=0;
rep(i,ans.size()){
sum+=ans[i];
}
cout<<sum<<endl;
}
| 0
| 40,192,377
|
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
const int inf=1e9+7;
const ll mod=1e9+7;
const ll big=1e18;
int DP[100000];
int main() {
int N;
vector<int> ansarr;
string s, t;
int sh, sm, ss, th, tm, ts;
int ans;
while(true){
for(int i=0;i<100000;++i){
DP[i] = 0;
}
cin>>N;
if(N==0) break;
for(int i=0;i<N;++i){
cin>>s>>t;
sh = stoi(s.substr(0, 2));
sm = stoi(s.substr(3, 2));
ss = stoi(s.substr(6, 2));
th = stoi(t.substr(0, 2));
tm = stoi(t.substr(3, 2));
ts = stoi(t.substr(6, 2));
DP[sh*60*60+sm*60+ss]++;
DP[th*60*60+tm*60+ts]--;
}
for(int i=1;i<100000;++i){
DP[i] += DP[i-1];
}
ans = 0;
for(int i=0;i<100000;++i){
if(ans<DP[i]) ans = DP[i];
}
ansarr.push_back(ans);
}
for(int i=0;i<ansarr.size();++i){
cout<<ansarr[i]<<endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{ int a,b;
cin>>a>>b;
a%=2;
b%=2;
if(a==1&&b==1)cout<<"Odd";
else if(a==2&&b==2)cout<<"Even";
else cout<<"Even";
return 0;
}
| 0
| 71,712,559
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
int N = S.size();
int count[26] = {0};
for (int i = 0; i < N; i++) {
count[S[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (count[i] == 0) {
printf("%c\n", 'a' + i);
return 0;
}
}
cout << "None" << endl;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <deque>
#include <fstream>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = long long;
#define fst first
#define snd second
template <class T, size_t D> struct _vec { using type = vector<typename _vec<T, D - 1>::type>; };
template <class T> struct _vec<T, 0> { using type = T; };
template <class T, size_t D> using vec = typename _vec<T, D>::type;
template <class T> vector<T> make_v(size_t size, const T& init) { return vector<T>(size, init); }
template <class... Ts> auto make_v(size_t size, Ts... rest) { return vector<decltype(make_v(rest...))>(size, make_v(rest...)); }
template <class T> inline void chmin(T &a, const T& b) { if (b < a) a = b; }
template <class T> inline void chmax(T &a, const T& b) { if (b > a) a = b; }
pair<ll, int> solve(int a, int b, ll c) {
ll res = 0;
vector<ll> mem_c(10, -1), mem_res(10, -1);
while (c > 0) {
if (mem_c[a] != -1) {
ll use_c = mem_c[a] - c;
ll cost = res - mem_res[a];
ll cnt = c / use_c;
res += cnt * cost;
c -= cnt * use_c;
auto v = solve(a, b, c);
res += v.fst;
a = v.snd;
break;
}
mem_c[a] = c;
mem_res[a] = res;
int s = a + b;
++res;
--c;
while (s > 9) {
int ns = (s / 10) + (s % 10);
++res;
s = ns;
}
a = s;
}
return {res, a};
}
int main() {
#ifdef DEBUG
ifstream ifs("in.txt");
cin.rdbuf(ifs.rdbuf());
#endif
int M;
while (cin >> M) {
ll res = 0;
int a = 0;
for (int i = 0; i < M; i++) {
int d;
ll c;
cin >> d >> c;
auto r = solve(a, d, c);
res += r.fst;
a = r.snd;
}
cout << res - 1 << endl;
}
return 0;
}
| 0
| 62,267,559
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <numeric>
#include <string>
#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>
#include <set>
#include <cmath>
typedef long long ll;
using namespace std;
#define FALSE printf("false\n");
#define TRUE printf("true\n");
#define all(x) (x).begin(),(x).end()
#define print(x) cout<<x<<endl
#define rep(i,n) for(int i = 0;i < ((int)(n));++i)
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define SUM(vec) accumulate(all(vec),0LL)
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );
#define test(a) cout<<(#a)<<':'<<(a)<<endl
const int INF = 1e9+7;
const ll INFL = 9*1e18;
ll inline digit(ll num){int tmp = 0;while(num){tmp++;num/=10;}return tmp;}
template<typename T>inline T digitSum(T num){T sum = 0;while(num){sum+=num%10;num/=10;}return sum;}
template<typename T>inline T gcd(T a,T b){if(b == 0)return a;return gcd(b,a%b);}
template<typename T>inline T lcm(T a, T b){T g = gcd(a,b);return a/g*b;}
template<typename T>inline T power(T a,T b){T tmp=1;rep(i,b){tmp*=a;}return tmp;}
bool isOk(ll key,ll value){
return key < value;
}
int binary_search(vector<ll> a,ll key){
ll ok = a.size();
ll ng = -1;
while(abs(ok - ng) > 1){
ll mid = (ok + ng) / 2;
if(isOk(key,a[mid]))ok = mid;
else ng = mid;
}
return ok;
}
int main() {
cin.tie(0); ios::sync_with_stdio(0);
int n;cin>>n;
vector<int> a(n),b(n);
rep(i,n)cin>>a[i];
rep(i,n)cin>>b[i];
ll plus = 0, minus = 0;
ll bad = 0;
vector<ll> points;
rep(i,n){
if(a[i] < b[i]){
bad += abs(a[i] - b[i]);
}else points.pb(a[i]-b[i]);
}
if(bad == 0){
print(0);
return 0;
}
int ans = -1;
sort(all(points));reverse(all(points));
ll tmp = 0;
rep(i,points.size()){
tmp += points[i];
if(bad <= tmp){
ans = i+1 + n - (points.size());
break;
}
}
print(ans);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cout<<fixed; cout<<setprecision(12);
#define randomINT mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#define newl cout<<"\n"
#define DISP(as) for(auto it : as) cout<<it<<" ";newl;
#define all(x) (x).begin(),(x).end()
#define mset(x,val) memset(x,val,sizeof(x))
#define newl cout<<"\n"
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define dline cerr<<"
#define deb1(x) cerr<<#x<<" = "<<x<<'\n';
#define deb2(x,y) cerr<<'['<<#x<<','<<#y<<"] = "<<'['<<x<<','<<y<<']'<<'\n';
#define deb3(x,y,z) cerr<<'['<<#x<<','<<#y<<','<<#z<<"] = "<<'['<<x<<','<<y<<','<<z<<']'<<'\n';
typedef long long ll;
typedef long double ld;
typedef vector<ll> vll;
typedef pair<ll , ll> pll;
typedef pair<ld, ld> pld;
typedef unordered_map<ll, ll> um;
typedef vector<pll> vpll;
const ll MAX5 = 1e+5 + 7;
const ll MAX7 = 1e+7 + 7;
const ll MAXN = MAX7;
const ll INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
const ll MOD = 1e+9 + 7;
int dx4[] = {0, 1, 0, -1}, dy4[] = {1, 0, -1, 0};
ll T = 1;
ll n, m, x, y, q, k;
string s, t, s0,s1,s2;
void MAIN() {
cin>>n>>y;
vll a(n);
k = y;
for(ll i=0;i<n;i++) {
cin>>a[i];
}
for(ll i=1;i<n;i++) k+=min(y,a[i]-a[i-1]);
cout<<k;
}
int main() {
fastio; randomINT;
while (T--) {
MAIN();
}
return 0;
}
| 0
| 63,029,530
|
#include <iostream>
using namespace std;
int main() {
int m, f, r;
for (int i = 1;; i++) {
cin >> m >> f >> r;
if (m == -1 && f == -1 && r == -1) break;
else if (m == -1 || f == -1) cout << "F\n";
else if ((m + f) >= 80) cout << "A\n";
else if ((m + f) >= 65 && (m + f) < 80) cout << "B\n";
else if ((m + f) >= 50 && (m + f) < 65) cout << "C\n";
else if ((m + f) >= 30 && (m + f) < 50) {
if (r < 50) cout << "D\n";
else cout << "C\n";
}
else cout << "F\n";
}
return 0;
}
|
#include <stdio.h>
bool x(int n, char str[]){
for(int i=0;i<n/2;i++){
if(str[i] != str[i+n/2]){
return false;
}
}
return true;
}
int main(){
int n;
char str[102];
scanf("%d %s", &n,str);
(n % 2 == 0 && x(n,str)) ? puts("Yes") : puts ("No");
return 0;
}
| 0
| 57,329,094
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll,ll> pint;
const int MAX = 510000;
const int MOD = 1000000007;
#define rep(i, n) for(ll i = 0; i < (n); i++)
#define Rep(i, n) for(ll i = 1; i < (n); i++)
#define ALL(a) (a).begin(),(a).end()
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
ll fac[MAX], finv[MAX], inv[MAX];
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;
}
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll Len(ll n) {
ll s=0;
while(n!=0) s++, n/=10;
return s;
}
ll Sint(ll n) {
ll m=0,s=0,a=n;
while(a!=0) s++, a/=10;
for(ll i=s-1;i>=0;i--) m+=n/((ll)pow(10,i))-(n/((ll)pow(10,i+1)))*10;
return m;
}
ll Svec(vector<ll> v){
ll n=0;
for(ll i=0;i<v.size();i++) n+=v[i];
return n;
}
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;
}
ll Factorial(ll n){
ll m=1;
while(n>=1) m*=n,n--;
return m;
}
void runlength(string s,vector<pair<char,ll>> &p){
ll x=1;
if(s.size()==1){
p.push_back(pair<char,ll>(s[0],1));
}
for(ll i=0;i<s.size()-1;i++){
if(s[i]==s[i+1]){
x++;
if(i==s.size()-2){
p.push_back(pair<char,ll>(s[i],x));
}
}else{
p.push_back(pair<char,ll>(s[i],x));
x=1;
if(i==s.size()-2){
p.push_back(pair<char,ll>(s[s.size()-1],x));
}
}
}
}
ll COM(ll n,ll k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
string Toupper(string s){
string ans="";
rep(i,s.size()){
if('a'<=s[i] && s[i]<='z') ans+=(char)s[i]-32;
else ans+=s[i];
}
return ans;
}
string Tolower(string s){
string ans="";
rep(i,s.size()){
if('A'<=s[i] && s[i]<='Z') ans+=(char)s[i]+32;
else ans+=s[i];
}
return ans;
}
const int MAX_N=100010;
vector<bool> sieve_of_eratosthenes(){
vector<bool> isPrime(MAX_N+1,true);
for(int i=2;i<=MAX_N;i++){
if(isPrime[i]){
for(int j=2*i;j<=MAX_N;j+=i){
isPrime[j]=false;
}
}
}
return isPrime;
}
vector<pint> prime_factorize(ll n){
vector<pint> ans;
for(ll p=2;p<=sqrt(n);p++){
if(n%p!=0) continue;
ll cnt=0;
while(n%p==0){
n/=p;
cnt++;
}
ans.push_back(make_pair(p,cnt));
}
if(n!=1) ans.push_back(make_pair(n,1));
return ans;
}
int main() {
IOS;
ll n;
cin>>n;
vector<ll> a(n),b(n);
rep(i,n) cin>>a[i];
rep(i,n) cin>>b[i];
if(Svec(a)<Svec(b)){
cout<<-1<<endl;
return 0;
}
ll cnt=0;
ll tmp=0;
vector<ll> v;
rep(i,n){
if(a[i]<b[i]){
cnt++;
tmp+=b[i]-a[i];
}else if(a[i]>b[i]){
v.push_back(a[i]-b[i]);
}
}
sort(ALL(v),greater<ll>());
vector<ll> sum;
if(v.size()>=1) sum.push_back(v[0]);
rep(i,v.size()-1){
sum.push_back(sum[i]+v[i+1]);
}
if(tmp>=1) cout<<cnt+((lower_bound(ALL(sum),tmp)-sum.begin()))+1<<endl;
else cout<<cnt<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
typedef pair<ll,ll> pll;
const ll mod=1e9+7;
const ll inf=1LL<<61;
int main() {
ll n,k;
cin >> n >> k;
vec a(n);
for(ll i=0;i<n;i++) cin >> a[i];
sort(a.begin(),a.end());
ll l=-1,r=n;
while(l+1<r) {
ll tmp=(l+r)>>1;
mat dp(n+1,vec(k,0));
dp[0][0]=1;
for(ll i=0;i<n;i++) {
for(ll j=0;j<k;j++) {
dp[i+1][j]|=dp[i][j];
if(i!=tmp&&j+a[i]<k) {
dp[i+1][j+a[i]]|=dp[i][j];
}
}
}
ll f=0;
for(ll i=max(k-a[tmp],0LL);i<k;i++) {
f|=dp[n][i];
}
if(f) {
r=tmp;
}
else {
l=tmp;
}
}
cout << l+1 << endl;
}
| 0
| 45,306,523
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define PI 3.14159265358979323846264338327950L
int n,m,x,cc,aa;
int a[12][12];
int c[12];
int tmp[12];
void solve(){
cin >> n >> m >> x;
for (int i = 0; i < n; i++)
{
cin >> cc;
c[i] = cc;
for (int j = 0; j < m; j++)
{
cin >> aa;
a[i][j] = aa;
}
}
ll ans = 0;
for (int i = 0; i < m; i++)
{
ans = 0;
for (int j = 0; j < n; j++)
{
ans += a[j][i];
}
if(ans < x){
cout << -1 << endl;
return;
}
}
ans = 1000000000000;
ll tans = 0;
for (ll i = 0; i < (1<<n); i++)
{
tans = 0;
bool flag = true;
for (int h = 0; h < m; h++) tmp[h] = 0;
for (int j = 0; j < n; j++)
{
if(i & (1<<j)){
tans +=c[j];
for (int h = 0; h < m; h++) tmp[h] += a[j][h];
}
}
for (int h = 0; h < m; h++){
if(tmp[h] < x){
flag = false;
}
}
if(flag) ans = min(ans, tans);
}
cout << ans << endl;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
#define ll long long
#define _GLIBCXX_DEBUG
const ll MOD = 1000000007;
const ll Mod = 998244353;
const int MAX = 510000;
const double PI = 3.14159265358979;
const vector<int> dx = {1, 0};
const vector<int> dy = {0, 1};
int main() {
int N;
cin >> N;
int res = N;
for (int i=0; i<=N; i++) {
int tmp = 0, t = i;
while (t>0) {
tmp += t%6;
t /= 6;
}
t = N-i;
while (t>0) {
tmp += t%9;
t /= 9;
}
res = min(res, tmp);
}
cout << res << endl;
return 0;
}
| 0
| 56,335,983
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, n) for (int i = 1; i <= (int)(n); i++)
int main(){
int N, K;
cin >> N >> K;
vector<int> vec(N);
for (int i = 0; i < N; i++){
cin >> vec.at(i);
}
int cnt = 0;
for (int i = 0; i < N; i++){
if (K <= vec.at(i)) cnt += 1;
}
cout << cnt << endl;
}
|
#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;
typedef tuple<ll,ll,ll> T;
const long long INF = 1LL<<60;
const int MOD = 1000000000+7;
#define rev(s) (string((s).rbegin(), (s).rend()))
template < typename T > inline string toString( const T &a ) { ostringstream oss; oss << a; return oss.str(); };
int main() {
string L;cin>>L;
int N = L.size();
vector<vector<ll>> dp(N+1,vector<ll>(2,0));
dp[0][1] = 1;
rep(i,N) {
if(L[i]=='1') {
dp[i+1][1] = 2 * dp[i][1] % MOD;
} else {
dp[i+1][1] = dp[i][1];
}
if(L[i]=='1') {
dp[i+1][0] = (dp[i+1][0] + dp[i][1]) % MOD;
}
dp[i+1][0] = (dp[i+1][0] + 3 * dp[i][0]) % MOD;
}
cout<<(dp[N][0] + dp[N][1])%MOD<<endl;
}
| 0
| 85,663,110
|
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <cmath>
#include <sstream>
#include <iomanip>
#include <set>
#include <queue>
#include <stack>
#include <utility>
using namespace std;
typedef long long int ll;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define drep(i, n) for(int i = n - 1; i >= 0; i--)
#define YES cout << "YES" << endl
#define Yes cout << "Yes" << endl
#define yes cout << "yes" << endl
#define NO cout << "NO" << endl
#define No cout << "No" << endl
#define no cout << "no" << endl
const int INF = 1001001001;
const ll LINF = 1001002003004005006ll;
const int mod = 1000000007;
#define PI 3.14159265359;
void P(int x) {cout << x << endl;}
void P(long x) {cout << x << endl;}
void P(double x) {cout << x << endl;}
void P(ll x) {cout << x << endl;}
void P(string x) {cout << x << endl;}
void P(char x) {cout << x << endl;}
ll gcd(ll a, ll b) { return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) { return a/gcd(a,b)*b;}
int main() {
int n, k;
cin >> n >> k;
int index = 0;
rep (i, n) {
int tmp;
cin >> tmp;
if (tmp == 1) index = i;
}
int ans = 0;
int hidari = index;
int migi = n - index - 1;
if (hidari + 1 < k) {
migi -= (k - hidari - 1);
ans++;
if (migi <= 0) {
P(ans);
return 0;
}
hidari = 0;
} else if (migi + 1 < k) {
hidari -= (k - migi - 1);
ans++;
if (hidari <= 0) {
P(ans);
return 0;
}
migi = 0;
}
ans += (hidari + migi) / (k - 1);
if ((hidari + migi) % (k - 1) != 0) ans++;
P(ans);
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
int main(){
string str;
getline(cin,str);
int ro,so,i,j,k,b[1000]={},p=0;
while(str.size()!=1||str[0]!='.'){
ro=0;so=0;k=0;p=0;
for(i=0;i<str.size();i++){
if(str[i]=='(') {
ro++;
p++;
b[p]=1;
}
if(str[i]=='[') {
so++;
p++;
b[p]=2;
}
if(str[i]==')') {
if(b[p]==1) {
ro--;
p--;
}
else k=1;
}
if(str[i]==']') {
if(b[p]==2) {
so--;
p--;
}
else k=1;
}
if(ro<0||so<0) k=1;
}
if(k==0&&ro==0&&so==0) cout << "yes" << endl;
else cout << "no" << endl;
getline(cin,str);
}
return 0;
}
| 0
| 84,652,884
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long N,M;
cin >> N >> M;
vector<long long>a(N);
long long cnt = 0;
for(int i = 0; i < N; i++) {
cin >> a[i];
a[i]/=2;
if(i == 0) {
cnt = a[i];
continue;
}
cnt = cnt/__gcd(cnt,a[i])*a[i];
if(cnt > M) {
cout << 0 << endl;
return 0;
}
}
for(int i = 0; i < N; i++) {
if(cnt/a[i]%2 == 0) {
cout << 0 << endl;
return 0;
}
}
cout << (M-cnt)/(cnt*2)+1LL << endl;
}
|
#include <iostream>
using namespace std;
int main()
{
double x1, y1, x2, y2, x3, y3, xp, yp;
double a, b, c;
while(cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> xp >> yp)
{
a = (x3 - x2)*(yp - y2) - (y3 - y2)*(xp - x2);
b = (x1 - x3)*(yp - y3) - (y1 - y3)*(xp - x3);
c = (x2 - x1)*(yp - y1) - (y2 - y1)*(xp - x1);
if((a >= 0 && b >= 0 && c >= 0) || (a <= 0 && b <= 0 && c <= 0))
{
cout << "YES" << endl;
}
else
{
cout << "NO" << endl;
}
}
}
| 0
| 88,556,884
|
#include <cstdio>
int main()
{
long long x, y;
scanf("%lld%lld", &x, &y);
if (x % y == 0)
{
puts("-1");
return 0;
}
printf("%lld\n", x * (y - 1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
main(){
int n;cin >> n;
int t[100010],x[100010],y[100010];
t[0]=x[0]=y[0]=0;
for(int i=0;i<n;i++) cin >> t[i+1] >> x[i+1] >> y[i+1];
string ans="Yes";
for(int i=0;i<n;i++){
int dt = t[i+1]-t[i];
int dist = abs(x[i+1]-x[i])+abs(y[i+1]-y[i]);
if(dt>=dist){
if(dt%2!=dist%2) ans="No";
} else {
ans = "No";
}
}
cout << ans <<endl;
return 0;
}
| 0
| 50,833,599
|
#include<bits/stdc++.h>
using namespace std;
int main(){
int N;
cin>>N;
cout<<111*((N-1)/111)+111<<endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
using vec_b = vector<bool>;
using vec_str = vector<string>;
#define INF (1LL << 60)
#define MOD 1000000007
#define REP(i,m,n) for(ll (i)=(m),i##_len=(n);(i)<(i##_len);++(i))
#define FORR(i,v) for(auto (i):v)
#define ALL(x) (x).begin(), (x).end()
#define _PR(x) cout << (x) << endl
#define _PS(x) cout << (x) << " "
#define SZ(x) ((ll)(x).size())
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
#define pb push_back
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);
}
int main()
{
ll N, M;
cin >> N >> M;
vec a(N);
REP(i,0,N) cin >> a[i];
vec_b F(N);
bool all_odd, all_even;
ll d = -1;
while(true) {
if(a[0] % 2 == 0) {
all_odd = false;
all_even = true;
}
else {
all_odd = true;
all_even = false;
}
REP(i,1,N) {
if(a[i] % 2 == 0 && all_odd) {
all_odd = false;
break;
}
else if(a[i] % 2 == 1 && all_even) {
all_even = false;
break;
}
}
if(!all_even) break;
REP(i,0,N) a[i] >>= 1;
++d;
}
if(!all_odd && !all_even) _PR(0);
else {
ll L = a[0];
REP(i,1,N) L = lcm(L, a[i]);
L *= (1 << d);
_PR(M/L-M/(L*2));
}
return 0;
}
| 0
| 5,738,214
|
#include <iostream>
int main()
{
int n, a; std::cin >> n >> a;
int mod = n % 500;
std::cout << (mod <= a ? "Yes" : "No") << std::endl;
}
|
#include <iostream>
using namespace std;
int main() {
int n, y;
cin >> n >> y;
int flag = 0;
int a_max = y / 10000;
for (int a = a_max; a >= 0; a--) {
int b_max = n - a;
for (int b = b_max; b >= 0; b--) {
int c = n - a - b;
if (y == 10000 * a + 5000 * b + 1000 * c) {
cout << a << " " << b << " " << c << endl;
flag = 1;
break;
}
}
if (flag == 1) {
break;
}
}
if (flag == 0) {
cout << "-1 -1 -1" << endl;
}
return 0;
}
| 0
| 46,870,173
|
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define FAST_IO ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int main(){
string str;
while(cin>>str){
cout<<str.substr(0,4)<<" "<<str.substr(4,str.length())<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template<typename T> istream &operator>>(istream &is, vector<T> &vec){ for (auto &v : vec) is >> v; return is; }
template<typename T> ostream &operator<<(ostream &os, const vector<T> &vec){ os << "["; for (auto v : vec) os << v << ", "; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const deque<T> &vec){ os << "deq["; for (auto v : vec) os << v << ", "; os << "]"; return os; }
template<typename T> ostream &operator<<(ostream &os, const set<T> &vec){ os << "{"; for (auto v : vec) os << v << ", "; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_set<T> &vec){ os << "{"; for (auto v : vec) os << v << ", "; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ", "; os << "}"; return os; }
template<typename T> ostream &operator<<(ostream &os, const unordered_multiset<T> &vec){ os << "{"; for (auto v : vec) os << v << ", "; os << "}"; return os; }
template<typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &pa){ os << "(" << pa.first << ", " << pa.second << ")"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << ": " << v.second << ", "; os << "}"; return os; }
template<typename TK, typename TV> ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp){ os << "{"; for (auto v : mp) os << v.first << ": " << v.second << ", "; os << "}"; return os; }
template<typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template<typename T, typename... Args> void ndarray(vector<T> &vec, int len, Args... args) { vec.resize(len); for (auto &v : vec) ndarray(v, args...); }
template<typename T> bool chmax(T &m, const T q) { if (m < q) {m = q; return true;} else return false; }
template<typename T> bool chmin(T &m, const T q) { if (q < m) {m = q; return true;} else return false; }
template<typename T1, typename T2> pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) { return make_pair(l.first + r.first, l.second + r.second); }
template<typename T1, typename T2> pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) { return make_pair(l.first - r.first, l.second - r.second); }
#define f first
#define s second
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long op, a, b;
cin >> op >> a >> b;
long long ans = op + 1;
long long c = 0;
if(b > 2) {
c = (((op - (a - 1)) / 2) - 1) * (b - a);
c += b;
if((op - (a - 1)) % 2 == 1)
c++;
}
cout << max(ans, c);
}
| 0
| 52,540,422
|
#include <iostream>
#include <queue>
#include <vector>
#include <math.h>
#include <algorithm>
using namespace std;
int main(){
int num;
cin >> num;
priority_queue<int> pq;
for (int i = 0; i < num; ++i) {
for (int j = 0; j < 3; ++j) {
int a;
cin >> a;
pq.push(a);
}
int a, b, c;
a = pq.top();
pq.pop();
b = pq.top();
pq.pop();
c = pq.top();
pq.pop();
if (a * a == b * b + c * c) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
int s[3],a[3][3],ans=0;
for(int i=0;i<3;i++) cin>>s[i];
sort(s,s+3);
for(int i=0;i<3;i++)
{
for(int j=i+1;j<3;j++)
{
a[i][j]=(max(s[i],s[j])-min(s[i],s[j]))%2;
a[j][i]=a[i][j];
}
}
for(int i=0;i<3;i++)
{
bool w=true;
for(int j=0;j<3;j++)
{
if(i==j) continue;
if(a[i][j]==0) w=false;
}
if(w==true)
{
ans++;
for(int j=0;j<3;j++)
{
if(i==j) continue;
s[j]++;
}
}
}
ans+=(s[2]-s[0])/2;
ans+=(s[2]-s[1])/2;
cout<<ans<<endl;
}
| 0
| 30,788,973
|
#include "bits/stdc++.h"
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
else return gcd(b, a%b);
}
long long lcm(long long x, long long y) {
return x * y / gcd(x, y);
}
int main() {
long long A,B;
cin >> A >>B;
cout << lcm(A,B)<< endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <cctype>
#include <map>
using namespace std;
int to_num_from_mcxi(string inp);
string to_mcxi_from_num(int num);
int main()
{
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string x1, x2;
int num1, num2;
num1 = num2 = 0;
cin >> x1 >> x2;
num1 = to_num_from_mcxi(x1);
num2 = to_num_from_mcxi(x2);
num1 += num2;
cout << to_mcxi_from_num(num1) << endl;
}
return 0;
}
int to_num_from_mcxi(string inp)
{
int num = 0;
map<char, int> mcxi;
mcxi['m'] = 1000;
mcxi['c'] = 100;
mcxi['x'] = 10;
mcxi['i'] = 1;
for (int i = 0; i < inp.size(); i++) {
if (isdigit(inp[i]))
num += (inp[i] - '0') * mcxi[inp[++i]];
else
num += mcxi[inp[i]];
}
return num;
}
string to_mcxi_from_num(int num)
{
string output;
int dig[] = {1000, 100, 10, 1};
char mcxi[] = {'m', 'c', 'x', 'i'};
for (int i = 0; i < 4; i++) {
if (num / dig[i] == 0)
continue;
else if (num / dig[i] == 1)
output += mcxi[i];
else {
output += (num / dig[i]) + '0';
output += mcxi[i];
}
num %= dig[i];
}
return output;
}
| 0
| 72,588,204
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll inf = 3e18;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll a,b,c,d;
cin>>a>>b>>c>>d;
ll ans = -inf;
ans=max(ans,a*c);
ans=max(ans,a*d);
ans=max(ans,b*c);
ans=max(ans,b*d);
cout<<ans<<'\n';
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
#include <cmath>
#include <deque>
#include <queue>
#include <fstream>
#include <iomanip>
#include <stack>
#include <algorithm>
#include <set>
#include <map>
#include <list>
#define endl "\n"
typedef long long ll;
using namespace std;
void Lancer() { ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); }
bool isPrime(ll n){
if (n == 2 || n == 3 || n == 5)
return true;
else if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n == 1)
return false;
else {
for (int i = 5; i <= sqrt(n); i += 2){
if (n%i == 0)
return false;
}
return true;
}
}
int main(){
Lancer();
ll n, a, b, sum ,res=0, dgt;
cin >> n >> a >> b;
for (int i = 1; i <= n; i++){
dgt = i; sum = 0;
while (dgt)
{
sum += (dgt % 10);
dgt /= 10;
}
if (sum >= a && sum <= b)
res += i;
}
cout << res;
cout << endl;
return 0;
}
| 0
| 10,136,782
|
#include<iostream>
#include<algorithm>
using namespace std;
int N_MAX = 100000;
int main()
{
int n,t=1,i,res=0;
int a[N_MAX];
cin >> n;
for(i=0;i<n;i++)
cin >> a[i];
sort(a,a+n);
for(i=1;i<n;i++)
if(a[i]==a[i-1]){
t++;
}else{
if(t>=a[i-1])
res+=t-a[i-1];
else
res+=t;
t=1;
}
if(t>=a[i-1])
res+=t-a[i-1];
else
res+=t;
cout << res << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long int
using namespace std;
ll a[200010], ans;
bool visited[200010];
int main()
{
int i, v, u, edges, nodes;
cin >> nodes >> edges;
for(i=1;i<=nodes;i++)
{
cin >> a[i];
visited[i] = true;
}
for(i=1;i<=edges;i++)
{
cin >> u >> v;
if(a[u]==a[v])
{
visited[u] = false;
visited[v] = false;
}
else if(a[u]>a[v])
{
visited[v] = false;
}
else{
visited[u] = false;
}
}
for(i=1;i<=nodes;i++)
ans += visited[i];
cout << ans << endl;
return 0;
}
| 0
| 13,082,861
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<ll, ll>;
#define mp make_pair
#define pb push_back
#define fi first
#define se second
const ll MOD = 1e9 + 7;
const ll N = 1e2 + 5;
ll n, m;
ll dx[] = {1, 0};
ll dy[] = {0, 1};
ll dp[N][N];
char grid[N][N];
bool outside(ll r, ll c) {
return r < 0 || r > n || c < 0 || c > m;
}
ll f(ll r, ll c) {
if(r == n && c == m) return grid[r][c] == '#';
if(dp[r][c] != -1) return dp[r][c];
ll res = INT_MAX;
for(ll i = 0; i < 2; i++) {
ll nr = r + dx[i], nc = c + dy[i];
if(outside(nr, nc)) continue;
if(grid[r][c] == '.') res = min(res, f(nr, nc));
else if(grid[r][c] == '#' && grid[nr][nc] == '#') res = min(res, f(nr, nc));
else if(grid[r][c] == '#' && grid[nr][nc] == '.') res = min(res, f(nr, nc) + 1);
}
return dp[r][c] = res;
}
void solve() {
cin >> n >> m;
for(ll i = 1; i <= n; i++) {
for(ll j = 1; j <= m; j++) {
cin >> grid[i][j];
}
}
memset(dp, -1, sizeof(dp));
cout << f(1, 1) << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
solve();
}
|
#include<bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
int N,M;
cin>>N>>M;
vector<vector<int>> A(N);
while(M--){
int a,b;
cin>>a>>b;
A[a-1].push_back(b-1);
A[b-1].push_back(a-1);
}
vector<int> B(N,-1);
queue<int> Q;
B[0]=0;
Q.push(0);
while(!Q.empty()){
int I=Q.front();
Q.pop();
for(int i:A[I])
if(B[i]==-1){
B[i]=I;
Q.push(i);
}
}
puts("Yes");
for(int i=1;i<N;i++)cout<<B[i]+1<<endl;
}
| 0
| 83,641,681
|
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i=0;i<(n);++i)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define all(x) (x).begin(), (x).end()
#define PI 3.14159265358979323846264338327950L
using namespace std;
typedef long long ll;
typedef long double ld;
int main() {
int n;
string s,t;
cin>>n>>s>>t;
int cnt=0,a=0;
if(n==1){
if(s==t) cout<<1;
else cout<<2;
return 0;
}
rep(a,n){
int match=0;
rep(i,n-a){
if(s[i+a]==t[i]) match++;
}
if(match==n-a){
cout<<n+a;
return 0;
}
}
cout<<2*n;
}
|
#include<stdio.h>
#include<vector>
#include<queue>
#include<string.h>
#include<iostream>
#include<algorithm>
#define INF 1000000000
#define MAXN 100005
using namespace std;
int mmin=11;
int step[4][2]={0,1,0,-1,-1,0,1,0};
int a[1005][1005];int m,n,k,sx,sy;
struct node{
int x,y,cost;
};
int bfs(int x,int y,int s)
{
queue<node>q;
bool vis[1005][1005]={0};
node now={x,y,0};
q.push(now);
while(!q.empty())
{
now=q.front();q.pop();
if(a[now.x][now.y]==s)break;
for(int i=0;i<4;i++)
{
int xx=now.x+step[i][0],yy=now.y+step[i][1];
if(!vis[xx][yy]&&a[xx][yy]!=-1){
vis[xx][yy]=1;
node temp={xx,yy,now.cost+1};
q.push(temp);
}
}
}
sx=now.x;sy=now.y;
return now.cost;
}
int main()
{
scanf("%d%d%d",&n,&m,&k);
memset(a,-1,sizeof(a));
for(int i=1;i<=n;i++){
string x;cin>>x;
for(int j=1;j<=m;j++)
{
char c=x[j-1];
if(c=='S'){a[i][j]=0;sx=i;sy=j;}
else if(c=='X')a[i][j]=-1;
else if(c=='.')a[i][j]=0;
else a[i][j]=c-'0';
}
}
int sum=0;
for(int i=1;i<=k;i++)
{
sum+=bfs(sx,sy,i);
}
printf("%d\n",sum);
}
| 0
| 33,406,641
|
#include <queue>
#include <iostream>
#define ll long long
using namespace std;
int main(){
string s;
priority_queue<ll> pq;
while(cin >> s){
if(s == "insert"){
ll input;
cin >> input;
pq.push(input);
}else if(s == "extract"){
cout << pq.top() << '\n';
pq.pop();
}else{
return 0;
}
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define SORT(c) sort((c).begin(),(c).end());
#define pb push_back
#define MP make_pair
#define pii pair<int,int>
#define pcc pair<char,char>
#define pic pair<int,char>
#define pci pair<char,int>
#define VS vector<string>
#define VI vector<int>
#define pi 3.141592653589793
#define ll long long
#define ull unsigned long long
#define w(x) int x;cin>>x;while(x--)
#define fast ios_base::sync_with_stdio(0)
#define sz size()
typedef unsigned long long UL;
template<typename T>inline T S(T a)
{
return a*a;
}
template<class T>inline string tostring(T a)
{
ostringstream os("");
os << a;
return os.str();
}
template<typename T>inline ll tolong(T a)
{
ll res;
istringstream os(a);
os>>res;
return res;
}
template<typename T>inline T gcd(T a, T b)
{
if (b == 0)return a;
else return gcd(b, a % b);
}
template<typename T>inline T bigmod(T a, T b, T m)
{
if (b == 0)return 1;
else if (b % 2 == 0)return S(bigmod(a, b / 2, m)) % m;
else return (a % m*bigmod(a, b - 1, m)) % m;
}
const int inf = (int)1e9 + 5;
const ll linf = (ll)1e16 + 5;
const ll modd = (ll)1e9 + 7;
const int mod = 10000007;
void pr (int f)
{
if(f==1)
cout<<"YES\n";
else
cout<<"NO\n";
}
map<string,string>ma;
set<int > s;
multiset<string> :: iterator it;
deque <char> q ;
ll ar [55100];
int main()
{
fast;
int n,k,x,y;
cin>>n>>k>>x;
set < int > s;
s.insert(n);
s.insert(k);
s.insert(x);
cout << s.sz<<endl;
}
| 0
| 81,932,046
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
typedef pair<int, int> P;
#define INF 1000000000000
#define MOD 1000000007
#define MAXR 100000
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define Z class
template <typename T>
T square(T x) { return x * x; }
template <class T>
T GCD(T a, T b)
{
T r;
while (a)
r = b, b = a, a = r % a;
return b;
}
template <class T>
T LCM(T a, T b) { return a / GCD(a, b) * b; }
#define chmax(x, y) (x = max(x, y))
#define chmin(x, y) (x = min(x, y))
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repd(i, n) for (ll i = n; i >= 0; i--)
#define FOR(i, a, b) for (ll i = a; i <= (b); i++)
#define FORD(i, a, b) for (ll i = a; i >= (b); i--)
#define FORA(i, I) for (const auto &i : I)
#define ALL(x) x.begin(), x.end()
typedef vector<int> vi;
typedef vector<string> vs;
typedef vector<vi> vvi;
typedef vector<ll> vl;
#define ERASE(x) x.erase(unique(ALL(x)), x.end());
#define VEC(type, c, n) \
std::vector<type> c(n); \
for (auto &i : c) \
std::cin >> i;
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0);
#define VAR(type, ...) \
type __VA_ARGS__; \
MACRO_VAR_Scan(__VA_ARGS__);
template <typename T>
void MACRO_OUT(const T t) { std::cout << t; }
#define OUT(...) MACRO_OUT(__VA_ARGS__);
#define SP std::cout << " ";
#define TAB std::cout << "\t";
#define BR std::cout << "\n";
#define ENDL std::cout << std::endl;
#define YES() printf("YES\n")
#define NO() printf("NO\n")
#define isYES(x) printf("%s\n", (x) ? "YES" : "NO")
#define Yes() printf("Yes\n")
#define No() printf("No\n")
#define yes() printf("yes\n")
#define no() printf("no\n")
#define ln cout << '\n'
template <Z A>
void pr(A a)
{
cout << a;
ln;
}
template <Z A, Z B>
void pr(A a, B b)
{
cout << a << ' ';
}
ll ans = 0;
bool check = 0;
string s, t;
int N = 3;
vector<int> v(N);
int a, b, c, d, n;
int x, y;
int sum;
char ch;
int main()
{
INIT;
cin >> s;
a = s.length();
sort(ALL(s));
ERASE(s);
if (a == s.length())
yes();
else
no();
return 0;
}
|
#include<iostream>
#include<map>
using namespace std;
int main() {
map<int,int> data;
int n,max;
while (cin >> n) {
data[n]++;
}
max = 0;
for (int i = 0; i < data.size();i++)
if( data[i] > max )
max = data[i];
map<int,int>::iterator it = data.begin();
while (it != data.end()) {
if ( (*it).second == max )
cout << (*it).first << endl;
it++;
}
return 0;
}
| 0
| 66,354,621
|
#include <stdio.h>
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
#ifdef LOCAL
#define debug(x...) \
cerr << "[" << #x << "] = ["; \
_print(x)
#else
#define debug(x...)
#endif
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
typedef long long ll;
const string DIGITS = "0123456789";
const string ALPH = "abcdefghijklmnopqrstuvwxyz";
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll A, B;
cin >> A >> B;
cout << A * B - A - B + 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
vector<vector<ll>> d;
ll ans = LINF;
void rec(ll start, map<ll, ll> done, ll sum) {
bool last = true;
for (auto town : done) {
if (town.second == 0) last = false;
}
if (last) {
ans = min(ans, sum);
return;
}
for (auto town : done) {
if (town.second == 1) continue;
done[town.first] = 1;
rec(town.first, done, sum + d[start][town.first]);
done[town.first] = 0;
}
};
int main() {
ll n, m, r; cin >> n >> m >> r;
vector<ll> t(r);
for (ll i = 0; i < r; ++i) {
cin >> t[i];
t[i]--;
}
d.resize(n, vector<ll>(n, LINF));
for (int i = 0; i < n; ++i) {
d[i][i] = 0;
}
for (ll i = 0; i < m; ++i) {
ll a, b, c; cin >> a >> b >> c;
--a; --b;
d[a][b] = c;
d[b][a] = c;
}
for (ll k = 0; k < n; ++k) {
for (ll i = 0; i < n; ++i) {
for (ll j = 0; j < n; ++j) {
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
map<ll, ll> done;
for (ll i = 0; i < r; ++i) {
done[t[i]] = 0;
}
for (ll i = 0; i < r; ++i) {
done[t[i]] = 1;
rec(t[i], done, 0);
done[t[i]] = 0;
}
cout << ans << endl;
}
| 0
| 83,400,961
|
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <string>
#include <cmath>
#include <iostream>
#include <stack>
#include <queue>
#include <climits>
#include <iomanip>
#define all(x) x.begin(), x.end()
#define MOD 1000000007
#define debug(x) cout << #x << " = " << x << "\n"
const long double PI = 3.141592653589793236L;
typedef long long int ll;
typedef long double ld;
using namespace std;
void solve()
{
string s;
cin >> s;
ll count = 0;
ll n = s.size();
for (ll i=0; i<n; i++)
{
count += s[i]-'0';
}
if (count % 9 == 0)
{
cout << "Yes";
return;
}
cout << "No";
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll T = 1;
while (T--)
{
solve();
}
return 0;
}
|
#define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
using namespace std;
typedef long long int lli;
typedef unsigned long long int ulli;
typedef long double ld;
#define vec(s) vector<s>
#define vvec(s) vector<vector<s>>
typedef vector<lli> vi;
typedef vector<vi> vvi;
typedef pair<lli,lli> pii;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define Yes(x) cout<<(x?"Yes":"No")<<endl;
#define YES(x) cout<<(x?"YES":"NO")<<endl;
#define out(s) cout<<s<<endl;
#define Reverse(x) reverse(all(x));
#define Sort(x) sort(all(x));
#define pb(s) push_back(s);
#define sp " "
#define INF 10000000000
#define LINF 9000000000000000000
#define all(s) s.begin(),s.end()
void vout(vi v){
for(lli i=0;i<v.size();i++)
cout<<v.at(i)<<endl;
}
int main(){
cout << std::fixed << std::setprecision(10);
lli s;
cin>>s;
set<lli> rec;
while (!rec.count(s)){
rec.insert(s);
(s%2==0?s/=2:s=3*s+1);
}
out(rec.size()+1);
}
| 0
| 6,740,136
|
#include "bits/stdc++.h"
#include <chrono>
using namespace std;
using namespace std::chrono;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define forn(ii,nn) for (int ii = 0; ii < nn; ++ii)
#define gcd(ade,bde) __gcd(ade,bde)
#define vi vector<int>
#define vll vector<ll>
#define vs vector<string>
#define vc vector<char>
#define pb(ade) push_back(ade)
#define pp pop_back()
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define type(ade) typeid(ade).name();
#define starting() auto start = high_resolution_clock::now()
#define ending() auto stop = high_resolution_clock::now();\
auto duration = duration_cast<microseconds>(stop - start);\
cerr << "\n" << "\n" << "Execution Time : "<< duration.count()/1000 << " ms" << "\n"
template <typename T1>
void print(vector<T1> arr) {
int l = (int)arr.size();
cerr << "[" ;
for(int i = 0; i < l; i++) {
(i == l - 1) ? cerr << arr[i] : cerr << arr[i] << "," ;
}
cerr << "]" << "\n";
}
template <typename T1>
void printArr(int arr[], int l) {
cerr << "[" ;
for (int i = 0; i < (int)l; i++) {
(i == l-1) ? cerr << arr[i] : cerr << arr[i] << "," ;
}
cerr << "]" << "\n";
}
template <typename T1>
void console(vector<vector<T1>> arr) {
for (int i = 0; i < (int)arr.size(); ++i) {
cerr << "\n" << " [" ;
for(int j = 0; j < (int)arr[i].size(); ++j) {
(j == (int)arr[i].size() - 1) ? cerr << arr[i][j] : cerr << arr[i][j] << "," ;
}
cerr << "]";
}
cerr << "\n";
}
template <typename T1,typename T2>
void mapped(map<T1,T2> m) {
for(auto ite = m.begin(); ite != m.end(); ++ite){
cerr << "'" << ite->first << "'"<< " : " << ite->second << "\n";
}
}
template <typename T1 , typename T2>
void mappedArr(map<T1,vector<T2>> m) {
for (auto ity = m.begin(); ity != m.end(); ++ity) {
cerr << "'" << ity->first << "'" << " : " << "[";
for (int i = 0; i < (int)ity->second.size(); ++i) {
(i == (int)ity->second.size() - 1) ? cerr << ity->second[i] : cerr << ity->second[i] << ",";
}
cerr << "]"<< "\n";
}
}
string int_to_string(int x) {
stringstream ss;
ss << x;
string ni = ss.str();
return ni;
}
int char_to_int(char c) {
int n = (int)c - 48;
return n;
}
int string_to_int(string x) {
int n;
stringstream s(x);
s >> n;
return n;
}
template <typename T1, typename T2>
void vectPair(vector<pair<T1,T2>> vp) {
for (int arrp = 0; arrp< (int)vp.size(); ++arrp){
cerr << "(" << vp[arrp].first << "," << vp[arrp].second << ")" << "\n" ;
}
}
typedef long long ll;
ll power (ll a, ll n) {
ll ans = 1;
for (ll i = 0; pow(2,i) <= n; ++i) {
if ((n >> i) & 1) {
ans *= a;
}
a = a * a;
}
return ans;
}
void inverse(vector<ll>& v, ll w, ll p) {
v[1] = 1;
for (ll i = 2; i < w; ++i) {
v[i] = (p - (p/i) * v[p % i] % p) % p;
}
}
ll gcd(ll a, ll b) {
if (b == 0) {
return a;
}
return gcd(b,a % b);
}
ll lcm(ll a, ll b) {
ll ans = a * b / gcd(a,b);
return ans;
}
const ll INF = 1e18L + 5;
const int MOD = 1e9 + 7;
int main() {
IOS;
string s;
cin >> s;
bool df = 1;
int i = 0;
string a = "maerd";
string b = "remaerd";
string c = "esare";
string d = "resare";
reverse(s.begin(),s.end());
int n = (int)s.size();
while (i < n) {
int e = 0;
for (int j = i; j < min((int)b.size() + i,n); ++j) {
if (b[e] != s[j]) {
break;
}
e++;
}
if (e == (int)b.size()) {
i = i + e;
continue;
}
e = 0;
for (int j = i; j < min((int)a.size() + i,n); ++j) {
if (a[e] != s[j]) {
break;
}
e++;
}
if (e == (int)a.size()) {
i = i + e;
continue;
}
e = 0;
for (int j = i; j < min((int)d.size() + i, n); ++j) {
if (d[e] != s[j]) {
break;
}
e++;
}
if (e == (int)d.size()) {
i = i + e;
continue;
}
e = 0;
for (int j = i; j < min((int)c.size() + i,n); ++j) {
if (c[e] != s[j]) {
break;
}
e++;
}
if (e == (int)c.size()) {
i = i + e;
continue;
}
df = 0;
break;
}
if (df) {
cout << "YES";
}else {
cout << "NO";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void){
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector< vector<int> > v(n, vector<int>(n, 0));
for(int i = 0; i < n; i++){
int u, k; cin >> u >> k;
u--;
for(int j = 0; j < k; j++){
int a; cin >> a;
a--;
v[u][a] = 1;
}
}
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
if(j == n-1) cout << v[i][j];
else cout << v[i][j] << " ";
}
cout << endl;
}
return 0;
}
| 0
| 9,885,268
|
#include <iostream>
using namespace std;
int main()
{
int a,b,c;
cin>>a>>b>>c;
if (a+b>=c) cout<<"Yes";
if (a+b<c) cout<<"No";
}
|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
const vector<vector<int>> dir4 = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}};
const vector<vector<int>> dir8 = {{0, 1}, {1, 0}, {-1, 0}, {0, -1}, {1, 1}, {-1, 1}, {1, -1}, {-1, -1}};
int main()
{
int h, w;
cin >> h >> w;
vector<vector<bool>> grid(h + 2, vector<bool>(w + 2, true));
vector<vector<int>> dist(h + 2, vector<int>(w + 2, 0));
queue<pair<int,int>> que;
for(int i = 1; i <= h; i++) {
for(int j = 1; j <= w; j++) {
char c; cin >> c;
grid[i][j] = (c == '#');
if(c == '#') {
que.emplace(i, j);
}else {
dist[i][j] = -1;
}
}
}
while(que.size()) {
auto cur = que.front(); que.pop();
for(auto d : dir4) {
if(dist[cur.first + d[0]][cur.second + d[1]] != -1)continue;
dist[cur.first + d[0]][cur.second + d[1]] = dist[cur.first][cur.second] + 1;
que.emplace(cur.first + d[0], cur.second + d[1]);
}
}
int nax = 0;
for(int i = 0; i <= h; i++) {
nax = max(nax, *max_element(dist[i].begin(), dist[i].end()));
}
cout << nax << endl;
}
| 0
| 100,199,085
|
#include<bits/stdc++.h>
#define ll long long
#define db double
#define mp make_pair
#define pb push_back
#define pii pair<int,int>
#define A first
#define B second
#define lowbit(p) (p&(-p))
using namespace std;
void read(int &x){
x=0; char c=getchar(); int p=1;
for (;c<48;c=getchar())if (c=='-')p=-1;
for (;c>47;c=getchar())x=(x<<1)+(x<<3)+(c^48);
x*=p;
}
void read(ll &x){
x=0; char c=getchar(); int p=1;
for (;c<48;c=getchar())if (c=='-')p=-1;
for (;c>47;c=getchar())x=(x<<1)+(x<<3)+(c^48);
x*=p;
}
void Min(int &x,int y){
if (x>y)x=y;
}
void Min(ll &x,ll y){
if (x>y)x=y;
}
void Max(int &x,int y){
if (x<y)x=y;
}
void Max(ll &x,ll y){
if (x<y)x=y;
}
map<int,int>f;
struct node{
priority_queue<int>q;
void clear(){
for (;!q.empty();)q.pop();
}
void push(int x){
q.push(x);
}
void upd(int x){
for (;!q.empty();){
int t=q.top();
if (t>x){
f[t]=0;
q.pop();
}
else return ;
}
}
}q;
#define M 200005
int a[M],n;
bool chk(int l){
q.clear();
f.clear();
q.push(1);
if (a[1]!=1){
q.push(a[1]);
}
int i,x;
for (i=2;i<=n;i++){
if (a[i]>a[i-1]){
q.push(a[i]);
}
else if (a[i]==a[i-1]){
x=a[i];
f[x]++;
for (;f[x]==l;){
if (x==1)return 0;
f[x]=0;
f[x-1]++;
x--;
q.push(x);
}
}
else{
x=a[i];
q.upd(x);
q.push(x);
f[x]++;
for (;f[x]==l;){
if (x==1)return 0;
f[x]=0;
f[x-1]++;
x--;
q.push(x);
}
}
}
return 1;
}
int main(){
read(n);
int i,l,r,mid,res=0;
for (i=1;i<=n;i++){
read(a[i]);
}
int fl=1;
for (i=2;i<=n;i++)if (a[i-1]>=a[i])fl=0;
if (fl){
printf("1\n");
return 0;
}
l=2; r=n;
for (;l<=r;){
mid=(l+r)>>1;
if (chk(mid)){
r=mid-1;
res=mid;
}
else{
l=mid+1;
}
}
printf("%d\n",res);
return 0;
}
|
#include <iostream>
#include <vector>
#include <array>
#include <queue>
#include <stack>
#include <map>
#include <string>
#include <climits>
#include <tuple>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <cmath>
#include <algorithm>
#include <memory>
#include <iomanip>
#define rep(i, n) for(Int (i) = 0; (i) < (n); ++(i))
#define debug(var) std::cout << #var << ": " << var << "\n"
using Int = int64_t;
constexpr Int INF = INT_MAX;
constexpr Int mod = 1e9 + 7;
void calc() {
Int N; std::cin >> N;
std::vector<Int> A(N);
rep(i, N)std::cin >> A[i];
std::vector<Int> S(N + 1);
S[0] = 0;
for (Int i = 1; i <= N; ++i) {
S[i] = S[i - 1] + A[i - 1];
}
std::unordered_map<Int, Int> m;
rep(i, N + 1)m[S[i]]++;
Int ans = 0;
for (const auto& elem : m) {
if (elem.second >= 2)
ans += (elem.second * (elem.second - 1) / 2);
}
std::cout << ans;
}
int main() {
calc();
return 0;
}
| 0
| 17,420,562
|
#include<bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int H,W,M;
cin>>H>>W>>M;
vector<pair<int,int>>items(M);
vector<int>Hcount(H),Wcount(W);
int Hmax=-1,Wmax=-1;
for(int i=0;i<M;i++)
{
cin>>items[i].first>>items[i].second;
}
for(int i=0;i<M;i++)
{
items[i].first--;
items[i].second--;
Hcount[items[i].first]++;
Wcount[items[i].second]++;
Hmax= max(Hmax,Hcount[items[i].first]);
Wmax= max(Wmax,Wcount[items[i].second]);
}
int ans = Hmax + Wmax;
int Hmaxcount=0,Wmaxcount=0;
for(int i=0;i<H;i++)
{
if(Hcount[i] == Hmax)
Hmaxcount++;
}
for(int i=0;i<W;i++)
{
if(Wcount[i] == Wmax)
Wmaxcount++;
}
long long total_common_space = (long long)Hmaxcount*Wmaxcount;
long long total_common_item = 0;
for(int i=0;i<M;i++)
{
if((Hcount[items[i].first]==Hmax) && (Wcount[items[i].second]== Wmax))
{
total_common_item++;
}
}
if(total_common_item >= total_common_space)
{ ans--;}
cout<<ans<<endl;
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
int n,x;
int ans;
while(true){
ans = 0;
cin >> n >> x;
if(n == 0 && x == 0) break;
for(int i = 1; i <= n-2; ++i){
for(int j = i+1; j <= n-1; ++j){
if(i == j) continue;
for(int k = j+1; k <= n; ++k){
if(i == k || j == k) continue;
if(i+j+k == x){
++ans;
}
}
}
}
cout << ans << endl;
}
return 0;
}
| 0
| 52,106,480
|
#include<bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define all(v) (v).begin(),(v).end()
using namespace std;
using ll=long long;
using pii=pair<int, int>;
using vi=vector<int>;
const ll INF=1LL<<60;
const int MOD=998244353;
const int N=2e5+5;
int main(){
int N, K; cin >> N >> K;
ll R, S, P; cin >> R >> S >> P;
string T; cin >> T;
vi cnt(3, 0);
vector<vi> db_cnt(K, vi(3, 0));
vi prev_val(K, -1);
vi f(K, 0);
for(int i=0; i<N; i++){
int val;
switch (T[i]){
case 'r' :
val=0;
break;
case 's' :
val=1;
break;
case 'p' :
val=2;
break;
}
cnt[val]++;
if(i < K) continue;
if(T[i] == T[i-K]){
prev_val[i%K]=val;
if(f[i%K] == 0){
f[i%K]++;
db_cnt[i%K][val]+=2;
}
else db_cnt[i%K][val]++;
}
else{
if(f[i%K]){
cnt[prev_val[i%K]]-=db_cnt[i%K][prev_val[i%K]]/2;
db_cnt[i%K][prev_val[i%K]]=0;
f[i%K]=0;
}
}
}
for(int i=0; i<K; i++){
if(f[i%K]) cnt[prev_val[i%K]]-=db_cnt[i%K][prev_val[i%K]]/2;
}
ll res;
res=cnt[0]*P+cnt[1]*R+cnt[2]*S;
printf("%lld\n", res);
return 0;
}
|
#include<bits/stdc++.h>
#include<cmath>
#define pb push_back
#define ld long double
#define mp make_pair
#define vl vector<ll>
#define vd vector<double>
#define vld vector<long double>
#define ll long long int
#define pl pair<ll, ll>
#define all(a) a.begin(), a.end()
#define forr(i, n) for(ll i=0; i<n; i++)
#define forr1(i, n) for(ll i=1; i<=n; i++)
using namespace std;
const ld PI =3.1415926535897923846;
const ll MOD = 1000000007;
const ll N=998244353;
ll power(ll x,ll n){ll res=1;while(n>0){if(n&1) res=res*x%MOD;x=x*x%MOD;n>>=1;}return res;}
ll modinverse(ll a){return power(a, MOD-2);}
void solve()
{
set<ll> s;
s.insert(1), s.insert(2), s.insert(3);
ll a, b;
cin>>a>>b;
s.erase(a), s.erase(b), cout<<*s.begin();
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll test=1;
while(test--)
{
solve();
}
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC << "ms\n";
}
| 0
| 1,114,939
|
#include <iostream>
using namespace std;
int Y, M, D;
int cal(int ey, int em, int ed){
int cnt = 0;
for(int y=1; y<=ey; y++){
for(int m=1 ; m<=10; m++){
int mc;
if(y%3 == 0)
mc = 20;
else{
if(m%2 == 1)
mc = 20;
else
mc = 19;
}
for(int d=1; d<=mc; d++){
cnt++;
if(ey == y && em == m && ed == d)
return cnt;
}
}
}
return 0;
}
void solve(){
cout << cal(1000, 1, 1) - cal(Y, M, D) << endl;
}
int main(int argc, const char * argv[])
{
int N;
cin >> N;
for(int i=0; i<N; i++){
cin>>Y>>M>>D;
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
const int INF = 1LL<<30;
int G[10][10];
int main() {
int n,m;
cin>>n>>m;
rep(i,m){
int a,b;
cin>>a>>b;
a--,b--;
G[a][b]=1;
G[b][a]=1;
}
vector<int> ord(n);
rep(i,n) ord[i]=i;
int ans=0;
do{
if(ord[0]!=0) continue;
bool ok=true;
rep(i,n-1){
if(G[ord[i]][ord[i+1]]==0) ok=false;
}
if(ok) ans++;
}while(next_permutation(all(ord)));
cout<<ans<<endl;
}
| 0
| 61,080,192
|
#include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <vector>
const int MOD = 1e9 + 7;
const int iINF = 2147483647 / 2;
const long long int llINF = 9223372036854775807 / 2;
using namespace std;
using ll = long long int;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using vvvl = vector<vector<vector<ll>>>;
typedef pair<ll, ll> pll;
bool paircomp(const pll &a, const pll &b) {
if (a.first == b.first)
return a.second < b.second;
return a.first < b.first;
}
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define RREP(i, n) for (ll i = (n)-1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define AUTO(i, m) for (auto &i : m)
#define ALL(a) (a).begin(), (a).end()
#define MAX(vec) *std::max_element(vec.begin(), vec.end())
#define MIN(vec) *std::min_element(vec.begin(), vec.end())
#define ARGMAX(vec) \
std::distance(vec.begin(), std::max_element(vec.begin(), vec.end()))
#define ARGMIN(vec) \
std::distance(vec.begin(), std::min_element(vec.begin(), vec.end()))
#define REV(T) greater<T>()
#define PQ(T) priority_queue<T, vector<T>, greater<T>>
#define VVL(a, b, c) vector<vector<ll>>(a, vector<ll>(b, c))
#define VV(T, a, b, c) vector<vector<T>>(a, vector<T>(b, c))
#define VVVL(a, b, c, d) \
vector<vector<vector<ll>>>(a, vector<vector<ll>>(b, vector<ll>(c, d)))
#define VVV(T, a, b, c, d) \
vector<vector<vector<T>>>(a, vector<vector<T>>(b, vector<T>(c, d)))
#define SP(a) setprecision(a)
#define SQRT(a) sqrt((long double)(a))
#define DPOW(a, b) pow((long double)(a), (long double)(b))
#define UNIQUE(vec) \
do { \
sort(ALL((vec))); \
(vec).erase(std::unique(ALL((vec))), (vec).end()); \
} while (0)
ll POW(ll n, ll m) {
if (m == 0) {
return 1;
} else if (m % 2 == 0) {
ll tmp = POW(n, m / 2);
return (tmp * tmp);
} else {
return (n * POW(n, m - 1));
}
}
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll N;
cin >> N;
vl A(N);
REP(i, N) cin >> A[i];
ll now = 0;
ll ans = 0;
REP(i, N) {
ll po = (A[i] - 1) / (now + 1);
ans += po;
if (i == 0)
now = 1;
else if (po == 0) {
now = max(now, A[i]);
}
}
cout << ans << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int N;
void solve() {
int counter = 0;
if (!N)
return;
while (true) {
++counter;
int kagen = counter * (counter - 1) / 2;
int jyogen = counter * (counter + 1) / 2;
if (kagen < N && N <= jyogen) {
cout << counter << endl;
N -= counter;
break;
}
}
solve();
}
int main() {
cin >> N;
solve();
}
| 0
| 50,057,858
|
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iomanip>
#include <numeric>
#include <queue>
#include <cmath>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n, 0);
int p = 0;
for (int i = 0; i < n; i++) {
cin >> v[i];
p += v[i];
}
p /= n;
int res1 = 0;
for (int i = 0; i < n; i++) {
res1 += (p - v[i]) * (p - v[i]);
}
p++;
int res2 = 0;
for (int i = 0; i < n; i++) {
res2 += (p - v[i]) * (p - v[i]);
}
cout << min(res1, res2) << endl;
}
|
#include <bits/stdc++.h>
#include <iomanip>
#include <math.h>
#define rep(i,x) for(ll i = 0;i<x;i++)
#define all(a) (a).begin(),(a).end()
using ll = long long;
using ld = long double;
using namespace std;
using dou = double;
const ll INF = 1LL << 60;
const ll mod = 1000000007;
typedef pair<ll,ll> P;
using graph = vector<vector<ll>>;
template<class T> inline bool chmax(T& a, T b){if(a < b){a = b; return true;}return false;}
template<class T> inline bool chmin(T& a, T b){if(a > b){a = b; return true;}return false;}
ll gcd(ll a,ll b){
if(a < b)swap(a,b);
if(a % b == 0)return b;
else return gcd(b,a%b);
}
bool isp(ll n){
bool res = true;
if(n == 1)return false;
else{
for(ll i = 2;i * i <= n;i++){
if(n % i == 0){
res = false;
break;
}
}
return res;
}
}
int main(){
ll N,M;
cin >> N >> M;
vector<vector<char>> field(N,vector<char>(M));
rep(i,N)
rep(j,M)cin >> field[i][j];
rep(i,N){
rep(a,2){
rep(j,M){
cout << field[i][j];
}
cout << endl;
}
}
}
| 0
| 10,184,038
|
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#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;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m; cin >> n >> m;
vector<ll> A(n), B(n), id(n);
rep(i, n) {
cin >> A[i] >> B[i];
id[i] = i;
}
sort(all(id), [&](int i, int j) {
return A[i] < A[j];
});
int cnt = m;
ll ans = 0;
int i = 0;
while(cnt) {
if(cnt < B[id[i]]) {
ans += A[id[i]] * cnt;
break;
} else {
ans += A[id[i]] * B[id[i]];
cnt -= B[id[i]];
}
i++;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define en '\n'
const int MAXN = 1e6+69;
const int INF = 1e18;
const int mod = 1e9+7;
struct vl{
int x,y;
bool operator<(vl t)const{
if(x==t.x)return (y<t.y);
return x<t.x;
}
};
map<int,int>mp;
int q;
int m,p,n,k;
int x,y,z;
int a[MAXN],b[MAXN];
int cnt;
set<int> s;
int luythua(int x, int y){
if(y==0)return 1;
if(y==1)return x%mod;
int k = luythua(x,y/2);
if(y%2==0)return k*k%mod;
return k*k%mod*x%mod;
}
int fact[MAXN];
int comb(int k, int n){
return fact[n]*luythua(fact[k],mod-2)%mod*luythua(fact[n-k],mod-2)%mod;
}
signed main(){ ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
cin>>x>>y;
if((x+y)%3!=0){
cout<<0;
return 0;
}
int k = (x+y)/3;
fact[0]=1;
for(int i=1;i<=1000000;i++){
fact[i]=fact[i-1]*i%mod;
}
if(min(x,y)<k){
cout<<0;
return 0;
}
cout<<comb(min(x,y)-k,k)%mod;
}
| 0
| 68,270,040
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int i = 0; i < (n); i++)
#define all(v) v.begin(), v.end()
const int INF = 1LL<<30;
ll dp[110][2][5];
int main() {
string N;
int K;
cin>>N>>K;
int n=N.size();
dp[0][0][0]=1;
rep(dgt,n){
rep(isless,2){
rep(k,K+1){
int c=N[dgt]-'0';
rep(nxt,10){
if(c<nxt && isless==0) continue;
int dgt2=dgt+1;
int isless2=isless;
if(nxt<c) isless2=1;
int k2=k;
if(nxt!=0) k2++;
dp[dgt+1][isless2][k2]+=dp[dgt][isless][k];
}
}
}
}
ll ans=dp[n][0][K]+dp[n][1][K];
cout<<ans<<endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define INF 1000000007
#define LINF (1LL << 60)
#define PI 3.14159265358979
typedef long long i64;
typedef pair<i64,i64> P;
inline i64 mod(i64 a, i64 m) { return (a % m + m) % m; }
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int n, a[101010];
void solve(){
cin >> n;
for(int i = 0; i < n; i++){
cin >> a[i];
a[i]--;
}
int cnt = 0;
for(int i = 0; i < n; i++){
if(i == a[a[i]]) cnt++;
}
cout << cnt/2 << endl;
}
int main(){
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int t = 1;
while(t--){
solve();
}
return 0;
}
| 0
| 87,871,036
|
#include<bits/stdc++.h>
#define ll long long
#define MAX 1000005
#define evn(x) (!((x)&1))
#define MOD (ll)(1e9+7)
#define INF INT32_MAX
#define INFL INT64_MAX
using namespace std;
int n;
bool vis[MAX];
vector<int> gp[MAX];
int dist[MAX];
void connect(int a, int b) {
gp[a].push_back(b);
}
void bfs(int a) {
vis[a]=1;
queue<int> q;
q.push(a);
while(!q.empty()) {
q.pop();
for(auto p:gp[a]) {
if(vis[p]) continue;
q.push(p);
vis[p]=1;
dist[p]=1+dist[a];
}
a=q.front();
}
}
void solve() {
cin >> n;
memset(dist,0,sizeof(dist));
int x;
for(int i=0; i<n; i++) {
cin >> x;
connect(i+1,x);
}
bfs(1);
if(vis[2]) cout << dist[2] << endl;
else cout << -1 << endl;
}
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t=1;
for(int i=1; i<=t; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
const ll INF = 1LL<<60;
int main()
{
int H,W; cin>>H>>W;
string board[H];
rep(i,H) cin>>board[i];
string ans = "Yes";
rep(i, H) {
rep(j, W) {
if (board[i][j] == '#') {
bool can = false;
for (int dy = -1; dy < 2; dy++) {
int ny = i + dy;
if (ny >= 0 && ny < H) {
if (i != ny && board[ny][j] == '#') can = true;
}
}
for (int dx = -1; dx < 2; dx++) {
int nx = j + dx;
if (nx >= 0 && nx < W) {
if (j != nx && board[i][nx] == '#') can = true;
}
}
if (can == false) {
ans = "No";
}
}
}
}
cout << ans << endl;
return 0;
}
| 0
| 74,501,057
|
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<stack>
#include<queue>
#include<map>
#include<functional>
#include<math.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<(n);i++)
#define pf(n) printf("%d\n",n)
#define pff(a,b) printf("%d %d\n",a,b);
typedef long long ll;
typedef pair<ll, ll> p;
const int INF = 1001001001;
const double PI = acos(-1);
int main() {
string s;
cin >> s;
int sum = 0;
rep(i, s.size()) {
sum += s[i] - '0';
}
if (sum % 9==0)puts("Yes");
else puts("No");
return 0;
}
|
#include <iostream>
using namespace std;
int main(){
int m, f, r;
for(;;){
cin >> m >> f >> r;
if(m==-1 && f == -1 && r == -1){
break;
}
if(m == -1 || f == -1){
cout << 'F' << endl;
}else if(m+f >= 80){
cout << 'A' << endl;
}else if (65 <= m+f && m+f <80){
cout << 'B' << endl;
}else if (50 <= m+f && m+f < 65){
cout << 'C' << endl;
}else if (30 <= m+f && m+f < 50 && 50 <= r){
cout << 'C' << endl;
}else if (30 <= m+f && m+f < 50 && r < 50){
cout << 'D' << endl;
}else if (m+f < 30){
cout << 'F' << endl;
}
}
}
| 0
| 31,126,480
|
#include<iostream>
#include<string>
using namespace std;
int main(){
string S;
cin>>S;
string check;
int num=0;
int A=0;
int B=0;
int ans=0;
for(int i=0;i<=(int)(S.length()-3);i++){
check=S.substr(i,3);
num=stoi(check);
A=num-753;
if(A<0)A*=-1;
B=ans-753;
if(B<0)B*=-1;
if(A<B)ans=num;
}
int trueans=ans-753;
if(trueans<0)trueans*=-1;
cout<<trueans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) FOR(i,0,n)
#define req(i,n) for(int i = 1;i <=n;i++)
#define pai 3.14159265358979323846
const int INF = 1001001001;
typedef long long ll;
int A[3][3], N;
bool punched[3][3];
bool ok[3][3];
using Graph = vector<vector<int>>;
vector<vector<int>> field;
vector<bool> seen;
const int MOD = 1000000007;
typedef pair<int,int> P;
int gcd(int a,int b){
if (a%b == 0){
return b;
}
else{
return gcd(b,a%b);
}
}
int lcm(int a,int b){
return a /gcd(a,b) * b;
}
bool is_prime(long long N) {
if (N == 1) return false;
for (long long i = 2; i * i <= N; ++i) {
if (N % i == 0) return false;
}
return true;
}
vector<pair<long long, long long> > prime_factorize(long long n) {
vector<pair<long long, long long> > res;
for (long long p = 2; p * p <= n; ++p) {
if (n % p != 0) continue;
int num = 0;
while (n % p == 0) { ++num; n /= p; }
res.push_back(make_pair(p, num));
}
if (n != 1) res.push_back(make_pair(n, 1));
return res;
}
int binary(int bina){
int ans = 0;
for (int i = 0; bina>0 ; i++)
{
ans = ans+(bina%2)*pow(10,i);
bina = bina/2;
}
return ans;
}
int main() {
ll x,y;
cin >> x >> y;
long long res = 1LL<<60;
if (x <= y) res = min(res, y-x);
if (-x <= y) res = min(res, y+x+1);
if (x <= -y) res = min(res, -y-x+1);
if (-x <= -y) res = min(res, -y+x+2);
cout << res << endl;
}
| 0
| 85,624,450
|
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
using std::max;
typedef long long ll;
const int N = 100010;
int _w;
int n, a[N], d[N];
namespace Tree {
int head[N], nxt[N*2], to[N*2], eid;
void init() {
eid = 0;
memset(head, -1, sizeof head);
}
void link( int u, int v ) {
to[eid] = v, nxt[eid] = head[u], head[u] = eid++;
to[eid] = u, nxt[eid] = head[v], head[v] = eid++;
}
}
ll f[N];
void dfs( int u, int fa ) {
using namespace Tree;
if( d[u] == 1 ) {
f[u] = a[u];
} else {
ll s = 0, mx = 0;
for( int i = head[u]; ~i; i = nxt[i] ) {
int v = to[i];
if( v == fa ) continue;
dfs(v, u);
s += f[v];
mx = max( mx, f[v] );
}
if( s < a[u] || s > a[u] + a[u] )
puts("NO"), exit(0);
ll t = s - a[u];
f[u] = a[u] - t;
t += t;
if( mx > s-mx ) {
ll t2 = s-mx;
t2 += t2;
if( t2 < t ) puts("NO"), exit(0);
} else {
ll t2 = s % 2 ? s-1 : s;
if( t2 < t ) puts("NO"), exit(0);
}
}
}
int main() {
_w = scanf( "%d", &n );
for( int i = 1; i <= n; ++i )
_w = scanf( "%d", a+i );
Tree::init();
for( int i = 0; i < n-1; ++i ) {
int u, v;
_w = scanf( "%d%d", &u, &v );
Tree::link(u, v);
++d[u], ++d[v];
}
if( n == 2 ) {
puts( a[1] == a[2] ? "YES" : "NO" );
return 0;
}
for( int i = 1; i <= n; ++i )
if( d[i] > 1 ) {
dfs(i, 0);
puts( f[i] ? "NO" : "YES" );
break;
}
return 0;
}
|
#include "bits/stdc++.h"
#define rep(i,n) for(int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
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; }
class union_find {
private:
vector<int> par;
vector<int> ran;
vector<ll> size;
public:
union_find(int n);
int find(int x);
void unite(int x, int y);
bool same(int x, int y);
ll show_size(int x);
};
union_find::union_find(int n){
par.resize(n);
ran.resize(n);
size.resize(n);
rep(i,n) par[i] = i;
rep(i,n) ran[i] = 0;
rep(i,n) size[i] = 1;
};
int union_find::find(int x) {
if(par[x] == x) return x;
else return par[x] = find(par[x]);
};
void union_find::unite(int x, int y) {
x = find(x);
y = find(y);
if(x == y) return;
ll t = show_size(x)+show_size(y);
size[x] = size[y] = t;
if(ran[x] < ran[y]){
par[x] = y;
}
else{
par[y] = x;
if(ran[x] == ran[y]) ran[x]++;
}
};
ll union_find::show_size(int x) {
if(par[x] == x) return size[x];
return show_size(par[x] = find(par[x]));
}
bool union_find::same(int x, int y) {
return (find(x) == find(y));
};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
union_find uf(n);
rep(i,m){
int a, b;
cin >> a >> b;
--a; --b;
uf.unite(a, b);
}
int ans = 0;
rep(i,n){
chmax(ans, (int)uf.show_size(i));
}
cout << ans << endl;
return 0;
}
| 0
| 80,530,078
|
#include <iostream>
#include <vector>
using namespace std;
int main() {
uint N; cin >> N;
vector<int> d(N, 0);
int recover = 0;
for (auto &x: d) cin >> x;
for (uint i=0; i<N; i++) {
for (uint j=(i+1); j<N; j++) {
recover += d[i] * d[j];
}
}
cout << recover << endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#define rep(i,n)for(int i=0;i<(int)(n);i++)
#define PI 3.141592653589793
int main()
{
int h, n;
cin >> h >> n;
int i;
vector<int>a(n);
for (i = 0; i < n; i++)
{
cin >> a.at(i);
h -= a.at(i);
if (h <= 0)
{
break;
}
}
if (h <= 0)
cout << "Yes" << endl;
else
cout << "No"<<endl;
}
| 0
| 85,326,501
|
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <cassert>
#include <algorithm>
#include <functional>
#include <iostream>
#include <iomanip>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <unordered_map>
#include <utility>
#include <limits.h>
#include <bitset>
#include <set>
using namespace std;
#define LL long long int
const LL INF = (1LL<<60);
const int INF_INT = 2147483647-1e6-1;
const LL mod = 1000000007ll;
const int mod_int = 1000000007;
LL M;
LL D[200000],C[200000];
LL ans = 0;
void solve(){
LL digit = 0;
LL sum_per_digit = 0;
for(int i=0;i<M;i++){
sum_per_digit += (D[i]*C[i]);
digit += C[i];
}
ans = (sum_per_digit)/9LL - (sum_per_digit%9LL==0) + digit - 1LL;
}
int main(){
cin >> M;
for(int i=0;i<M;i++){
cin >> D[i] >> C[i];
}
solve();
cout << ans << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define forn(i, n) for (int i = 0; i < (int)(n); ++i)
#define for1(i, n) for (int i = 1; i <= (int)(n); ++i)
#define ford(i, n) for (int i = (int)(n) - 1; i >= 0; --i)
#define fore(i, a, b) for (int i = (int)(a); i <= (int)(b); ++i)
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vpi;
typedef vector<vi> vvi;
typedef long long i64;
typedef vector<i64> vi64;
typedef vector<vi64> vvi64;
typedef pair<i64, i64> pi64;
typedef double ld;
int main(){
ios_base::sync_with_stdio(0);
i64 n,c,k;
cin>>n>>c>>k;
vi64 a(n), d(n);
i64 cnt=1, bus=1;
forn(i,n)
{
cin>>a[i];
d[i] = a[i] + k;
}
sort(all(d));
i64 i=0,j=1;
while(i<n && j<n){
if((d[j]-d[i]<=k) && cnt<c)
{
j++;
cnt++;
}
else
{
bus++;
i=j;
j++;
cnt=1;
}
}
cout<<bus<<endl;
return 0;
}
| 0
| 94,060,990
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <ctime>
#include <cstring>
#include <functional>
#include <iostream>
#include <iomanip>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <regex>
#include <vector>
#define fix(n) cout<<fixed<<setprecision(n)
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define sort(a) sort((a).begin(), (a).end())
#define uniq(a) sort(a);(a).erase(unique((a).begin(), (a).end()), (a).end())
#define reverse(a) reverse((a).begin(), (a).end())
#define ctos(c) string(1, (c))
#define out(d) cout << (d)
#define outl(d) std::cout<<(d)<<"\n"
#define YES() cout << "YES" << endl
#define NO() cout << "NO" << endl
#define Yes() cout << "Yes" << endl
#define No() cout << "No" << endl
#define ceil(x, y) ((x + y - 1) / (y))
#define debug(x) cerr << #x << ": " << (x) << '\n'
#define debug2(x, y) cerr << #x << ": " << (x) << ", " << #y << ": " << (y) << '\n'
#define debug3(x, y, z) cerr << #x << ": " << (x) << ", " << #y << ": " << (y) << ", " << #z << ": " << (z) << '\n'
#define dbg(v) for (size_t _ = 0; _ < v.size(); ++_){ cerr << #v << "[" << _ << "] : " << v[_] << '\n'; }
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll,ll>;
const ll MOD = 1000000007;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
void solve() {
ll ans = 1;
int num[30] = {};
int n; cin>>n;
string s; cin >> s;
for (char c : s) num[c-'a']++;
rep(i, 26) {
ans*=num[i]+1;
ans%=MOD;
}
outl((ans+MOD-1)%MOD);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
srand((unsigned)time(NULL));
fix(12);
solve();
}
|
#include <bits/stdc++.h>
using namespace::std;
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef array<int, 3> tri;
typedef long double ld;
template <class T> istream& operator>>(istream& I, vector<T>& v) {for (T &e: v) I >> e; return I;}
template <class T> ostream& operator<<(ostream &O, const vector<T>& v) {for (const T &e: v) O << e << ' '; return O;}
void _main() {
int n; cin >> n;
vector<double> a(n); cin >> a;
sort(all(a), greater<>());
while (a.size() > 1) {
double x = a.back(); a.pop_back();
double y = a.back(); a.pop_back();
a.emplace_back((x + y) / 2);
}
cout << a.back();
}
signed main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int _t = 1;
while (_t--) _main();
return 0;
}
| 0
| 229,056
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MM = 1000000000;
const int MOD = MM + 7;
const int MAX = 510000;
#define rep(i, n) for(ll i=0; i<n; i++)
#define Rep(i, j, n) for(ll i=j; i<n; i++)
#define all(vec) vec.begin(), vec.end()
template<class T> inline bool chmin(T& a, T b) {if(a > b) {a = b; return true;} return false;}
template<class T> inline bool chmax(T& a, T b) {if(a < b) {a = b; return true;} return false;}
const ll INF = 1LL << 60;
int main() {
int k; string s; cin >> k >> s;
if(s.size() <= k) cout << s << endl;
else cout << s.substr(0, k) << "..." << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(void){
string S;
cin >> S;
bool kaibun1=true;
bool kaibun2=true;
bool kaibun3=true;
int N=S.size();
for (int i=0;i<N;i++) {
if (S[i] != S[N-1-i]) {
kaibun1 = false;
break;
}
}
for (int i=0;i<(N-1)/2;i++) {
if (S[i] != S[(N-1)/2-1-i]) {
kaibun2 = false;
break;
}
}
for (int i=0;i<(N-1)/2;i++) {
if (S[(N+3)/2-1+i] != S[N-1-i]) {
kaibun3 = false;
break;
}
}
if (kaibun1==true&&kaibun2==true&&kaibun3==true) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
}
| 0
| 78,212,685
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
const double EPS = 1e-9;
const ll MOD = 1000000007;
const int inf = 1 << 30;
const ll linf = 1LL << 60;
const double PI = 3.14159265358979323846;
int n, k;
int main() {
cin >> n >> k;
cout << n-k+1 << endl;
}
|
#include<bits/stdc++.h>
using namespace std;
#define REPP(i,a,b,c) for(int i=a; i<=b; i+=c)
#define REP(i,a,b) REPP(i,a,b,1)
#define REVV(i,a,b,c) for(int i=a; i>=b; i-=c)
#define REV(i,a,b) REVV(i,a,b,1)
#define FOR(i,a) REP(i,0,(int)a-1)
#define FORD(i,a) REV(i,(int)a-1,0)
#define PB push_back
#define POB pop_back
#define MP make_pair
#define FI first
#define SE second
typedef long long ll;
typedef unsigned long long ull;
typedef pair < int , int > pii;
typedef vector < int > vi;
typedef vector < pii > vii;
typedef vector < ll > vl;
const double EPS = 1e-9;
const double PI = acos(-1);
const int INF = 1e9;
const ll MOD = 1e9 + 7;
ll addMod(ll a, ll b){
return (a+b) % MOD;
}
ll mulMod(ll a, ll b){
return (a*b) % MOD;
}
ll cnt[15];
ll h,w,n;
map < pii , bool > flag;
int dy[] = {-2,-2,-2,-1,-1,-1,0,0,0};
int dx[] = {-2,-1,0,-2,-1,0,-2,-1,0};
bool inRange(int y, int x){
return y > 0 && y <= h && x > 0 && x <= w;
}
int getCnt(int ty, int tx, int ny, int nx){
int ret = 0;
REP(i,ty,ny){
REP(j,tx,nx){
if(flag[MP(i,j)]) ret++;
}
}
return ret;
}
void update(int y, int x){
FOR(i,9){
int ty = y + dy[i];
int tx = x + dx[i];
int ny = ty + 2;
int nx = tx + 2;
if(inRange(ty,tx) && inRange(ny,nx)){
int bef = getCnt(ty,tx,ny,nx);
cnt[bef]--;
cnt[bef+1]++;
}
}
flag[MP(y,x)] = true;
}
int main(){
ios_base :: sync_with_stdio(0); cin.tie(0); cout.tie(0);
cin >> h >> w >> n;
cnt[0] = (h-2) * (w - 2);
int y,x;
FOR(i,n){
cin >> y >> x;
update(y,x);
}
FOR(i,10) cout << cnt[i] << endl;
return 0;
}
| 0
| 6,101,093
|
#include <bits/stdc++.h>
#define rep2(x,fr,to) for(int x=(fr);x<(to);x++)
#define rep(x,to) for(int x=0;x<(to);x++)
#define repr(x,fr,to) for(int x=(fr);x>=(to);x--)
#define all(c) c.begin(),c.end()
#define sz(v) (int)v.size()
using namespace std;
using ll = long long; using VI=vector<int>; using pii=pair<int, int>; using VL=vector<ll>; const int MD=1e9+7;
void dbg(){cerr<<"\n";} template <class F,class ...S> void dbg(const F& f, const S&...s){cerr <<f <<": "; dbg(s...);}
int main()
{
cin.tie(0); ios_base::sync_with_stdio(false);
int n, k;
cin >>n >>k;
VL a(n), dp(k+2);
rep(i, n) cin >>a[i];
dp[0] = 1;
rep(i, n){
for(int j=k; j>=(a[i]+1); j--) (dp[j] += MD - dp[j-(a[i]+1)]) %=MD;
for(int j=0; j+1 <= k; j++) (dp[j + 1] += dp[j]) %=MD;
}
cout <<dp[k] <<"\n";
return 0;
}
|
#include <iostream>
#include <fstream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <cstring>
#include <cassert>
#include <utility>
#include <iomanip>
#include <chrono>
#include <random>
#include <bitset>
using namespace std;
#define sz(x) (int) x.size()
#define unique(x) x.erase(unique(x.begin(), x.end()), x.end())
#define all(a) a.begin(), a.end()
#define sqr(x) ((x) * (x))
#define y1 aksjdaskdjksjfksdjf
#define left kdnvldvoiwejifejg
#define right lkdsjflksdjfdjfk
#define prev asdasfsadjkjsdfjs
#define tm aklsjdasjdasjdkdjjf
#define lcm hddalkwjeidjjhasda
#define random_shuffle asdasdd
const int MAXN = 105000;
int n;
int a[MAXN];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
long long l = 2, r = 2;
for (int i = n - 1; i >= 0; i--) {
long long mn = 1ll * a[i] * ((l + a[i] - 1) / a[i]);
long long mx = 1ll * a[i] * (r / a[i]);
if (mn > r) {
puts("-1");
return 0;
}
l = mn; r = mx + a[i] - 1;
}
cout << l << " " << r << endl;
return 0;
}
| 0
| 36,346,280
|
#include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
using ll = long long;
using P = pair<int, int>;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define all(v) v.begin(), v.end()
#define sz(x) ((int) x.size())
#define pb push_back
#define mp make_pair
#define F first
#define S second
typedef vector<ll> vi;
const int MOD = 1000000007;
template<class T> void print(const T& t){ cout << t << endl; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main(){
ll a, b, c, d;
cin >> a >> b >> c >> d;
chmin(a, b);
chmin(c, d);
print(a + c);
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
cin.tie( 0 );
ios::sync_with_stdio( false );
while(true){
int n;
cin >> n;
if(n == 0){ break; }
vector<int> vc(n);
for(int i=0; i<n; i++){
cin >> vc[i];
}
sort(vc.begin(), vc.end());
auto res = (accumulate(vc.begin() + 1, vc.end() -1, 0));
cout << res / (n-2) << endl;
}
return 0;
}
| 0
| 57,901,871
|
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i < n; i++)
#define REP(i, n, m) for(int i=n; i < m; i++)
#define reps(i, n) for(int i=1; i <= n; i++)
#define ALL(v) v.begin(), v.end()
#define rALL(v) v.rbegin(), v.rend()
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
using namespace std;
using ll=long long;
ll mod=2019;
const ll INF = 1LL << 60;
template<class T> inline bool chmin(T& a, T b) {if (a > b) {a = b;return true;}return false;}
template<class T> inline bool chmax(T& a, T b) {if (a < b) {a = b;return true;}return false;}
ll modpow(ll a,ll n,ll &mod){
if(!n) return 1;
ll x = modpow(a,n/2,mod)%mod;
x *=x;
if(n%2==1)x*=a;
return x%mod;
}
int main(){
int a,b,c,d;cin>>a>>b>>c>>d;
int x=abs(a-b);
int y=abs(b-c);
int z=abs(c-a);
if(z<=d)cout<<"Yes";
else if(x<=d && y<=d)cout<<"Yes";
else cout <<"No";
}
|
#include<bits/stdc++.h>
#define rep(i,n) for (long long i = 0; i < (n); ++i)
#define DIV 1000000007
using namespace std;
long long N;
long long A[300005];
long long modpow(long long ori, long long po){
long long res = 1;
while(po > 0){
if(po&1){
res *= ori;
res %= DIV;
}
ori *= ori;
ori %= DIV;
po >>= 1;
}
return res;
}
int main(){
cin >> N;
rep(i, N) cin >> A[i];
reverse(A, A + N);
long long ans = 0;
rep(i, 61) {
long long zerocount = 0;
long long onecount = 0;
rep(j, N) {
long long num = A[j];
if((num>>i)&1) {
ans += zerocount * modpow(2, i);
ans %= DIV;
} else {
ans += onecount * modpow(2, i);
ans %= DIV;
}
if((num>>i)&1) {
onecount++;
} else {
zerocount++;
}
}
}
cout << ans << endl;
}
| 0
| 86,769,613
|
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
#define all(x) (x).begin(),(x).end()
#define SZ(x) ((int)(x).size())
#define bit(n) (1<<(n))
using namespace std;
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<bool> vb;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1;} return 0;}
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1;} return 0;}
int const INF = 1001001001;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int N,K; cin >> N >> K;
int R = (N-1) * (N-2) / 2 - K;
if(R < 0) {
cout << -1 << endl;
return 0;
}
int M = N - 1 + R;
cout << M << endl;
for(int i = 2; i <= N; ++i) {
cout << 1 << ' ' << i << endl;
}
for(int i = 2; i <= N; ++i) {
for(int j = i+1; j <= N; ++j) {
if(R == 0) return 0;
cout << i << ' ' << j << endl;
R--;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
using P = pair<i64, i64>;
#define overload3(_1, _2, _3, name, ...) name
#define rep1(i, n) for(i64 i = 0LL; i < (n); ++i)
#define rep2(i, a, b) for(i64 i = (a); i < (b); ++i)
#define rep(...) overload3(__VA_ARGS__, rep2, rep1)(__VA_ARGS__)
#define all(v) v.begin(), v.end()
void solve(long long N, long long K, std::vector<long long> a){
vector<i64> b;
rep(i, N){
i64 sum = 0;
rep(j, i, N){
sum += a[j];
b.emplace_back(sum);
}
}
vector<bool> f(b.size(), true);
i64 ans = 0;
for(i64 i = 60; i >= 0; --i){
i64 cnt = 0;
rep(j, b.size()) if(((1LL<<i) & b[j]) && f[j]) ++cnt;
if(cnt >= K){
rep(j, b.size()) if(((1LL<<i) & b[j]) == 0) f[j] = false;
ans += 1LL << i;
}
}
cout << ans << endl;
}
struct IoSetup {
IoSetup() {
cout << fixed << setprecision(10);
cerr << fixed << setprecision(10);
}
} iosetup;
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
| 33,821,088
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast,03")
#pragma comment(linker, "/stack:200000000")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("unroll-loops")
#define boost ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define nl "\n"
#define ll long long
#define pb push_back
#define mpr make_pair
#define fr(i,a,n) for(ll i=a;i<n;++i)
#define fr0(i,n) for(ll i=0;i<n;++i)
#define pii pair<int, int>
#define FO find_by_order
#define OK order_of_key
#define mem(a) memset(a,0,sizeof(a))
#define F first
#define S second
#define sp " "
#define vi vector<int>
#define vii vector<pair<int, int>>
#define all(a) a.begin(), a.end()
void fio()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
template<typename T> void TIME(T start, T end)
{
#ifndef ONLINE_JUDGE
double time_taken = chrono::duration_cast<chrono::nanoseconds>(end - start).count();
time_taken *= 1e-9;
cout << "\nExecuted in: " << fixed
<< time_taken << setprecision(9);
cout << " sec";
#endif
}
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\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
#define int long long
const int mod = 1e9 + 7;
void solve()
{
int a, b, c;
cin >> a >> b >> c;
if (a == b && b == c) cout << "Yes";
else cout << "No";
}
int32_t main()
{
auto start = chrono::high_resolution_clock::now();
boost;
fio();
int t;
t = 1;
while (t--) solve();
auto end = chrono::high_resolution_clock::now();
TIME(start, end);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=5e3+5;
int n;
ll k,a[N],p[N],cnt[N]={0},sum[N][N]={0};
ll dfs(ll i){
ll u=i,num=1,pos=1;
while(p[i]!=u){
num++;
i=p[i];
sum[u][pos]=sum[u][pos-1]+a[i];
pos++;
}
sum[u][pos]=sum[u][pos-1]+a[u];
return num;
}
int main()
{
cin>>n>>k;
for(int i=1;i<=n;i++) cin>>p[i];
for(int i=1;i<=n;i++) cin>>a[i];
ll ans=-1e18;
for(int i=1;i<=n;i++){
cnt[i]=dfs(i);
ll mx1=-1e18,mx2=-1e18;
for(int j=1;j<=cnt[i];j++){
mx1=max(mx1,sum[i][j]);
}
for(int j=1;j<=(k%cnt[i]?k%cnt[i]:cnt[i]);j++){
mx2=max(mx2,sum[i][j]);
}
if(k>cnt[i]){
ll num=(k%cnt[i])?k/cnt[i]:k/cnt[i]-1;
ans=max(ans,max(mx1,num*sum[i][cnt[i]]+mx2));
}
else ans=max(ans,mx2);
}
cout<<ans;
}
| 0
| 6,692,608
|
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <unordered_set>
#include <unordered_map>
#define ll long long
#define fi first
#define se second
#define pb push_back
#define me memset
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
using namespace std;
typedef pair<int,int> PII;
typedef pair<ll,ll> PLL;
inline int read()
{
int X=0; bool flag=1; char ch=getchar();
while(ch<'0'||ch>'9') {if(ch=='-') flag=0; ch=getchar();}
while(ch>='0'&&ch<='9') {X=(X<<1)+(X<<3)+ch-'0'; ch=getchar();}
if(flag) return X;
return ~(X-1);
}
int s;
int dp[N];
int main() {
s=read();
dp[0]=1;
for(int i=1;i<=s;++i){
for(int j=0;j<=i-3;++j){
dp[i]+=dp[j];
dp[i]%=mod;
}
}
printf("%d\n",dp[s]);
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"
const int mod = 1e9 + 7;
#define int long long int
int32_t main() {
IOS ;
int n, k ; cin >> n >> k ;
int arr[n+1], dp[n+1][k+1] ;
for(int i=1; i<=n; i++) cin >> arr[i] ;
dp[0][0] = 1 ;
for(int i=1; i<=k; i++) dp[0][i] = 0 ;
for(int i=1; i<=n; i++) dp[i][0] = 1 ;
for(int i=1; i<=n; i++) {
int sum[k+1] ; sum[0] = dp[i-1][0] ;
for(int j=1; j<=k; j++)
sum[j] = (sum[j-1] + dp[i-1][j]) % mod ;
for(int j=1; j<=k; j++)
if(j - arr[i] - 1 >= 0)
dp[i][j] = (sum[j] - sum[j-arr[i]-1]+ mod) % mod ;
else dp[i][j] = sum[j] ;
}
cout << dp[n][k] ;
return 0 ;
}
| 0
| 51,015,380
|
#include <iostream>
#include <string>
struct TNode
{
int Value;
TNode* Next;
TNode* Prev;
TNode(int AValue);
};
TNode::TNode(int AValue)
{
Value = AValue;
Next = NULL;
Prev = NULL;
}
class TList
{
TNode* FFirst;
TNode* FEnd;
public:
TList();
~TList();
void PushFront(int Value);
void PopFront();
void PopBack();
TNode* Search(int Value)const;
void Delete(int Value);
void Show()const;
};
TList::TList()
{
FFirst = NULL;
FEnd = NULL;
}
TList::~TList()
{
while(FFirst != NULL)
{
PopFront();
}
}
void TList::PushFront(int Value)
{
TNode* Node = new TNode(Value);
Node->Next = FFirst;
if(FFirst != NULL)
{
FFirst->Prev = Node;
}else{
FEnd = Node;
}
FFirst = Node;
}
void TList::PopFront()
{
TNode* NewFirst = FFirst->Next;
if(NewFirst != NULL)
{
NewFirst->Prev = NULL;
}else{
FEnd = NULL;
}
delete FFirst;
FFirst = NewFirst;
}
void TList::PopBack()
{
TNode* NewEnd = FEnd->Prev;
if(NewEnd != NULL)
{
NewEnd->Next = NULL;
}else{
FFirst = NULL;
}
delete FEnd;
FEnd = NewEnd;
}
TNode* TList::Search(int Value)const
{
for(TNode* Node = FFirst;Node != NULL;Node = Node->Next)
{
if(Node->Value == Value) return Node;
}
return NULL;
}
void TList::Delete(int Value)
{
TNode* Node = Search(Value);
if(Node == NULL) return;
if(Node->Next != NULL)
{
Node->Next->Prev = Node->Prev;
}else{
FEnd = FEnd->Prev;
}
if(Node->Prev != NULL)
{
Node->Prev->Next = Node->Next;
}else{
FFirst = FFirst->Next;
}
delete Node;
}
void TList::Show()const
{
TNode* Node = FFirst;
while(Node->Next != NULL)
{
std::cout << Node->Value << " ";
Node = Node->Next;
}
std::cout << Node->Value << std::endl;
}
class TDoublyLinkedList
{
TList Data;
void InsertInput();
void DeleteInput();
void DeleteFirst();
void DeleteEnd();
public:
void Manupulate(int Command);
void Output() const;
};
void TDoublyLinkedList::InsertInput()
{
int Number = 0;
std::cin >> Number;
Data.PushFront(Number);
}
void TDoublyLinkedList::DeleteInput()
{
int Number = 0;
std::cin >> Number;
Data.Delete(Number);
}
void TDoublyLinkedList::DeleteFirst()
{
Data.PopFront();
}
void TDoublyLinkedList::DeleteEnd()
{
Data.PopBack();
}
void TDoublyLinkedList::Output()const
{
Data.Show();
}
void TDoublyLinkedList::Manupulate(int Command)
{
switch(Command)
{
case 0 : InsertInput();break;
case 1 : DeleteInput();break;
case 2 : DeleteFirst();break;
case 3 : DeleteEnd();break;
}
}
int CommandToIndex(std::string Command)
{
if(Command == "insert") return 0;
if(Command == "delete") return 1;
if(Command == "deleteFirst") return 2;
if(Command == "deleteLast") return 3;
return -1;
}
int main()
{
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int Count = 0;
std::cin >> Count;
TDoublyLinkedList List;
for(int i=0;i<Count;i++)
{
std::string Command;
std::cin >> Command;
List.Manupulate(CommandToIndex(Command));
}
List.Output();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define INF 1e9
#define PI 3.14159265359
#define MOD 1000000007
#define ALL(v) v.begin(),v.end()
#define ALLR(v) v.rbegin(),v.rend()
typedef long long ll;
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;
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
long long modinv(long long a,long long mod){
return modpow(a,mod-2,mod);
}
long long int modfact(long long int n,long long int mod){
if(n){
return n*modfact(n-1,mod)%mod;
}else{
return 1;
}
}
int main() {
cout << fixed << setprecision(10);
ll n;
cin >> n;
vector<ll> a(n);
rep(i,n) cin >> a[i];
ll ans = 0;
rep(i,60){
ll p = 0;
rep(j,n){
if(a[j]&(1LL<<i)){
p++;
}
}
ans+=p*(n-p)%MOD*modpow(2,i,MOD)%MOD;
ans%=MOD;
}
cout << ans << endl;
}
| 0
| 62,011,041
|
#include <bits/stdc++.h>
#include <cmath>
using namespace std;
int main(){
int N;
cin >> N;
vector<vector<int>> seat(N, vector<int>(2));
for (int i = 0; i < N; i++){
for (int j = 0; j < 2; j++){
cin >> seat.at(i).at(j);
}
}
int people = 0;
for (int i = 0; i < N; i++){
people += seat.at(i).at(1) - seat.at(i).at(0) + 1;
}
cout << people << endl;
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
using ll = long long int;
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto &i:a)
#define all(x) (x).begin(),(x).end()
#define pi 3.14159265358979323846
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 cnt_rep = 0;
ll powmod(ll N, ll P, ll M){
cnt_rep++;
if(P == 0) return 1;
if(P%2 == 0){
ll t = powmod(N, P/2, M);
return t*t % M;
}
return (N * powmod(N, P-1, M)) % M;
}
ll gcd(ll a, ll b){
ll resi, g, l;
if(a > b){
g = a; l = b;
}else if(b > a){
g = b; l = a;
}else{
return a;
}
resi = g % l;
if(resi != 0){
return gcd(l, resi);
}else{
return l;
}
}
template<typename T>
void remove(std::vector<T>& vector, unsigned int index)
{
vector.erase(vector.begin() + index);
}
int ans = 0;
int N, M, Q;
template<typename T>
void showall(vector<T> v){
rep(i, 0, v.size()){
cout << v[i] << " ";
}
cout << endl;
}
template<typename T>
ll com(T n, T m, T mod){
ll a = 1, b = 1, ans;
if(n == m || m == 0){
ans = 1;
}else{
for(ll i = 0;i < m; i++){
a *= n-i;
a %= mod;
b *= i+1;
b %= mod;
}
ans = (a * powmod(b, mod-2, mod)) % mod;
}
return ans;
}
int main() {
ll N;
cin >> N;
if(N % 2 != 0){
cout << 0 << endl;
return 0;
}
ll five = 0, div = 10;
while(N >= div){
five += N / div;
div *= 5;
}
cout << five << endl;
}
| 0
| 27,315,653
|
#include<bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define ALL(A) A.begin(),A.end()
#define RALL(A) A.rbegin(),A.rend()
typedef long LL;
typedef pair<LL,LL> P;
const LL mod=1e9+7;
const LL LINF=1LL<<62;
const int INF=1000000000;
int main(){
int N;cin >> N;
vector<int> t(N),v(N);
LL T=0;
for (int i = 0; i < N; i++) {
cin >> t[i];
T+=t[i];
t[i]*=2;
}
for (int i = 0; i < N; i++) {
cin >> v[i];
v[i]*=2;
}
v.pb(0);
t.pb(2);
vector<vector<double>> dp(2*T+1,vector<double> (201,0.0));
int c=0;
for (int i = 0; i < 2*T; i++) {
int lim=v[c];
if(--t[c]==0){
c++;
lim=min(v[c],lim);
}
for (int j = 0; j < 201; j++) {
if(dp[i][j]==0.0&&j!=0) continue;
dp[i+1][j]=max(dp[i+1][j],dp[i][j]+j/4.);
if(j<200) dp[i+1][j+1]=max(dp[i+1][j+1],dp[i][j]+j/4.+0.025);
if(j>0) dp[i+1][j-1]=max(dp[i+1][j-1],dp[i][j]+j/4.-0.025);
}
for (int j = lim+1; j < 201; j++) {
dp[i+1][j]=0.0;
}
}
cout << setprecision(10) << fixed << dp[2*T][0] << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define fi first
#define se second
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define rrep(i,n) for(int i = 1; i <= (n); ++i)
#define drep(i,n) for(int i = (n)-1; i >= 0; --i)
#define srep(i,s,t) for (int i = s; i < t; ++i)
#define rng(a) a.begin(),a.end()
#define rrng(a) a.rbegin(),a.rend()
#define maxs(x,y) (x = max(x,y))
#define mins(x,y) (x = min(x,y))
#define limit(x,l,r) max(l,min(x,r))
#define lims(x,l,r) (x = max(l,min(x,r)))
#define isin(x,l,r) ((l) <= (x) && (x) < (r))
#define pb push_back
#define eb emplace_back
#define sz(x) (int)(x).size()
#define pcnt __builtin_popcountll
#define uni(x) x.erase(unique(rng(x)),x.end())
#define show(x) cout<<#x<<" = "<<x<<endl;
#define print(x)cout<<x<<endl;
#define PQ(T) priority_queue<T,v(T),greater<T> >
#define bn(x) ((1<<x)-1)
#define dup(x,y) (((x)+(y)-1)/(y))
#define newline puts("")
#define v(T) vector<T>
#define vv(T) v(v(T))
using namespace std;
typedef long long int ll;
typedef unsigned uint;
typedef unsigned long long ull;
typedef pair<int,int> P;
typedef tuple<int,int,int> T;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
typedef vector<T> vt;
int main() {
int n;
cin >> n;
vl a(n);
rep(i,n)cin >> a[i];
sort(rng(a));
ll l = a[n/2-1], r = a[n/2];
cout<<r-l<<endl;
return 0;
}
| 0
| 24,200,789
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) REP(i, 0, n)
#define rrep(i, n) for (int i = (int)(n-1); i >= 0; i--)
#define sz(x) int(x.size())
#define bitsz(x) int(__builtin_popcount(x))
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define pb(x) push_back(x)
#define INF 2e9
#define LINF 1e18
#define mod 1000000007
template<class T> inline bool chmax(T &a, const T &b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T &a, const T &b) { if (a > b) { a = b; return 1; } return 0; }
template < typename T > inline string toString( const T &a ) { ostringstream oss; oss << a; return oss.str(); };
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, ll> LP;
const int di[4] = {1,0,-1,0};
const int dj[4] = {0,1,0,-1};
int main() {
int n; cin >> n;
vector<int> a(n);
rep(i,n) cin >> a[i];
ll ans = 0;
for (int i=1; i<n; i++) {
if (a[i-1]<=a[i]) continue;
ans += a[i-1]-a[i];
a[i] += a[i-1]-a[i];
}
cout << ans << endl;
}
|
#include <iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cmath>
#include<cstdlib>
#include<utility>
#include<cstdio>
#define vii vector< pair<int,int> >
#define vi vector<int>
#define INF 1000000007
#define ff first
#define ss second
#define lli long long int
#define ulli unsigned long long int
using namespace std;
char a[7][7],b[7][7];
int n,m,k;
void copy_max(){
for(int i=0; i<n; i++){
for(int j=0; j<m; j++){
b[i][j]=a[i][j];
}
}
}
void fill_max(int a1, int b1){
for(int i=0; i<n; i++){
if(a1&(1<<i)){
for(int j=0; j<m; j++)
b[i][j]='R';
}
}
for(int i=0; i<m; i++){
if(b1&(1<<i)){
for(int j=0; j<n; j++)
b[j][i]='R';
}
}
}
bool check(){
int cnt=0;
for(int i=0; i<n; i++){
for(int j=0; j<m; j++){
if(b[i][j]=='#')
cnt++;
}
}
if(cnt==k)
return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin>>n>>m>>k;
for(int i=0; i<n; i++){
for(int j=0; j<m; j++){
cin>>a[i][j];
}
}
int cnt=0;
int subn=1<<n, subm=1<<m;
for(int i=0; i<subn; i++)
for(int j=0; j<subm; j++){
copy_max();
fill_max(i,j);
if(check())
cnt++;
}
cout<<cnt<<endl;
}
| 0
| 39,350,247
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.