code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <cstdio>
#include <iostream>
using namespace std ;
typedef long long ll ;
const int N = 300010 ;
int n ;
ll ans ;
ll S[4] ;
ll minx ;
ll maxx ;
ll sum[N] ;
ll base[N] ;
ll gt(ll x){
return x < 0 ? -x : x ;
}
void chkmin(ll x){
minx = x >= minx ? minx : x ;
}
void chkmax(ll x){
maxx = x >= maxx ? x : maxx ;
}
int main(){
cin >> n ;
ans = (1ll << 62) ;
for (int i = 1 ; i <= n ; ++ i){
scanf("%lld", &base[i]) ;
sum[i] = sum[i - 1] + base[i] ;
}
int l = 2, r = 4 ;
S[0] = base[1] ; S[2] = base[3] ;
S[1] = base[2] ; S[3] = sum[n] - sum[3] ;
for (int i = 3 ; i <= n ; ++ i){
while (l < i && gt(S[0] - S[1]) > gt(S[0] + base[l] - S[1] + base[l])){
S[0] += base[l], S[1] -= base[l], ++ l ;
}
while (r <= n && gt(S[3] - S[2]) > gt(S[2] + base[r] - S[3] + base[r])){
S[2] += base[r], S[3] -= base[r], ++ r ;
}
minx = (1ll << 61) ; maxx = -(1ll << 61) ;
for (int j = 0 ; j <= 3 ; ++ j) chkmin(S[j]), chkmax(S[j]) ;
ans = min(ans, maxx - minx) ; S[1] += base[i] ; S[2] -= base[i] ;
//for (int j = 0 ; j <= 3 ; ++ j) cout << S[j] << " " ; puts("") ;
}
cout << ans << endl ; return 0 ;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
template <class T>
using V = vector<T>;
template <class T>
using VV = V<V<T>>;
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define fi first
#define se second
#define rep(i, n) rep2(i, 0, n)
#define rep2(i, m, n) for (int i = m; i < (n); i++)
#define ALL(c) (c).begin(), (c).end()
constexpr ll TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
template <class T, class U>
void chmin(T& t, const U& u) {
if (t > u) t = u;
}
template <class T, class U>
void chmax(T& t, const U& u) {
if (t < u) t = u;
}
template <class T, class U>
ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
rep(i, v.size()) {
if (i) os << ",";
os << v[i];
}
os << "}";
return os;
}
#ifdef LOCAL
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << H;
debug_out(T...);
}
#define debug(...) \
cerr << __LINE__ << " [" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#define dump(x) cerr << __LINE__ << " " << #x << " = " << (x) << endl
#else
#define debug(...) (void(0))
#define dump(x) (void(0))
#endif
const ll INF = TEN(18);
int main() {
int n;
cin >> n;
V<int> A(n);
rep(i, n) cin >> A[i];
using pll = pair<ll, ll>;
V<pll> vl(n, mp(-INF, INF)), vr(n, mp(-INF, INF));
auto ch = [&](pll& a, pll b) {
if (abs(a.se - a.fi) > abs(b.fi - b.se)) {
a = b;
}
return;
};
rep(t, 2) {
ll s = 0;
V<ll> acm;
V<pll>& vec = (t == 0 ? vl : vr);
rep(i, n) {
s += A[i];
acm.pb(s);
if (i) {
int p = lower_bound(ALL(acm), s / 2) - acm.begin();
if (p == i) --p;
auto x = mp(acm[p], s - acm[p]);
ch(vec[i], x);
--p;
if (p >= 0) {
auto x = mp(acm[p], s - acm[p]);
ch(vec[i], x);
}
}
}
reverse(ALL(A));
}
ll ans = INF;
for (int i = 1; i < n - 2; ++i) {
auto p = vl[i], q = vr[n - i - 2];
V<ll> v = {p.fi, p.se, q.fi, q.se};
sort(ALL(v));
chmin(ans, v.back() - v[0]);
}
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
ll N, M;
cin >> N >> M;
vector<ll> A(N);
for (ll i=0; i<N; i++){
cin >> A[i];
}
ll temp=0;
map<ll,ll> count;
vector<ll> elem;
count[0]=1;
elem.push_back(0);
for (ll i: A){
temp=(temp+i)%M;
//cout<<temp<<endl;
if (count.find(temp)!=count.end()){
count[temp]++;
} else{
count[temp]=1;
elem.push_back(temp);
}
}
ll ans=0;
for (ll i=0; i<elem.size(); i++){
ll curr=count[elem[i]];
ans+=(long long) curr*(curr-1)/2;
}
cout<<ans<<endl;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (ll)(n); ++i)
#define rep2(i, s, n) for (ll i = s; i < (ll)(n); i++)
#define repr(i, n) for (ll i = n; i >= 0; i--)
#define pb push_back
#define COUT(x) cout << (x) << "\n"
#define COUTF(x) cout << setprecision(15) << (x) << "\n"
#define ENDL cout << "\n"
#define DF(x) x.erase(x.begin()) // 先頭文字削除
#define ALL(x) x.begin(), x.end()
#define SZ(x) (ll) x.size()
#define SORT(x) sort(ALL(x))
#define REVERSE(x) reverse(ALL(x))
#define ANS cout << ans << "\n"
#define RETURN(x) \
cout << x << "\n"; \
return 0
clock_t CLOCK;
#define START_TIMER CLOCK = clock()
#define SHOW_TIMER cerr << "time: " << (ld)(clock() - CLOCK) / 1000000 << "\n"
#define init() \
cin.tie(0); \
ios::sync_with_stdio(false)
#define LINE cerr << "[debug] line: " << __LINE__ << "\n";
#define debug(x) cerr << "[debug] " << #x << ": " << x << "\n";
#define debugV(v) \
cerr << "[debugV] " << #v << ":"; \
rep(i, v.size()) cerr << " " << v[i]; \
cerr << "\n";
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using mll = map<ll, ll>;
using qll = queue<ll>;
using P = pair<ll, ll>;
constexpr ll INF = 0x3f3f3f3f3f3f3f3f;
constexpr ld PI = 3.141592653589793238462643383279;
ll get_digit(ll x) {
return to_string(x).size();
}
ll gcd(ll x, ll y) {
return y ? gcd(y, x % y) : x;
}
ll lcm(ll a, ll b) {
return a / gcd(a, b) * b;
}
vector<P> factorize(ll n) {
vector<P> result;
for (ll i = 2; i * i <= n; ++i) {
if (n % i == 0) {
result.pb({i, 0});
while (n % i == 0) {
n /= i;
result.back().second++;
}
}
}
if (n != 1) {
result.pb({n, 1});
}
return result;
}
vll divisor(ll n) {
vll ret;
for (ll i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
SORT(ret);
return (ret);
}
signed main() {
init();
ll N, M;
cin >> N >> M;
vll A(N + 1);
mll m;
rep(i, N + 1) {
if (i == 0) {
A[i] = 0;
m[0]++;
continue;
}
ll a;
cin >> a;
A[i] = A[i - 1] + a;
m[A[i] % M]++;
}
ll ans = 0;
rep(i, N + 1) {
ans += m[A[i] % M] - 1;
}
ans /= 2;
ANS;
return 0;
} | 1 |
#include <bits/stdc++.h>
#define loop(v, f, l) for(int v = (f), v##_ = (l); v < v##_; ++v)
using namespace std;
typedef long long int lint;
static inline int in(){ int x; scanf("%d", &x); return (x); }
static inline lint inl(){ lint x; scanf("%lld", &x); return (x); }
int matrix[11][11];
int main()
{
int n;
while( (n = in()) != 0 )
{
loop(i, 0, 11)
{
loop(j, 0, 11)
{
matrix[i][j] = 0;
}
}
loop(i, 0, n)
{
loop(j, 0, n)
{
matrix[i][j] = in();
}
}
loop(i, 0, n)
{
loop(j, 0, n)
{
matrix[i][n] += matrix[i][j];
matrix[n][i] += matrix[j][i];
}
matrix[n][n] += matrix[i][n];
}
loop(i, 0, n + 1)
{
loop(j, 0, n + 1)
{
printf("%5d", matrix[i][j]);
}
printf("\n");
}
}
return (0);
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF 1e9
typedef long long ll;
int main() {
int A,B; cin >> A >> B; // Aが白
bool changed = false;
if (A>B){
swap(A,B);
changed = true;
}
vector<vector<int>> T(100,vector<int>(100,0));
int b = 1;
while(b<=B){
int yoko = (b-1)%25;
yoko *= 4;
int tate = (b-1)/25;
tate *= 4;
T[tate][yoko] = 1;
T[tate][yoko+1] = 1;
T[tate][yoko+2] = 1;
T[tate+1][yoko] = 1;
T[tate+1][yoko+1] = 1;
T[tate+1][yoko+2] = 1;
T[tate+2][yoko] = 1;
T[tate+2][yoko+1] = 1;
T[tate+2][yoko+2] = 1;
b++;
}
int a = 1;
while(a<=A-1){
int yoko = (a-1)%25;
yoko *= 4;
int tate = (a-1)/25;
tate *= 4;
T[tate+1][yoko+1] = 0;
a++;
}
cout << 100 << " " << 100 << endl;
REP(i,100){
REP(j,100){
if(!changed){
if(T[i][j]==0)cout << ".";
else cout << "#";
}else{
if(T[i][j]==0)cout << "#";
else cout << ".";
}
}
cout << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i=0; i<(n); ++i)
#define repr(i, a, b) for (int i=a; i<(b); ++i)
#define reprev(i, n) for (int i=n-1; i>=0; --i)
#define reprrev(i, a, b) for (int i=b-1; i>=(a); --i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
cout << fixed << setprecision(10);
// cout << 1.0 / 2 << endl;
int n, m, d; cin >> n >> m >> d;
// 隣り合う二項はm-1個ある
// (a, b)並んでいた場合の期待値を求めて、それをm-1倍する
double ans = 0.0;
double e = 0.0;
if (d == 0) {
e = double(1.0) / n;
} else {
e = double(2.0);
ll n2 = ll(n) * n;
e *= (n-d);
e /= n2;
}
cout << e * (m-1) << endl;
return 0;
} | #include <bits/stdc++.h>
#include <chrono>
using namespace std;
using namespace std::chrono;
// #pragma GCC target ("avx2")
// #pragma GCC optimization ("O3")
// #pragma GCC optimization ("unroll-loops")
// #pragma optimization_level 3
// #pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define f0r(a, b) for (long long a = 0; a < (b); ++a)
#define f1r(a, b, c) for (long long a = (b); a < (c); ++a)
#define f0rd(a, b) for (long long a = (b); a >= 0; --a)
#define f1rd(a, b, c) for (long long a = (b); a >= (c); --a)
#define ms(arr, v) memset(arr, v, sizeof(arr))
#define pb push_back
#define send {ios_base::sync_with_stdio(false);}
#define help {cin.tie(NULL); cout.tie(NULL);}
#define fix(prec) {cout << setprecision(prec) << fixed;}
#define mp make_pair
#define f first
#define s second
#define presum(p, a, n) {p[0] = a[0]; for (int i = 1; i < (n); i++) p[i] = a[i] + p[i-1];}
#define all(v) v.begin(), v.end()
#define getunique(v) {sort(all(v)); v.erase(unique(all(v)), v.end());}
#define readgraph(list, edges) for (int i = 0; i < edges; i++) {int a, b; cin >> a >> b; a--; b--; list[a].pb(b); list[b].pb(a);}
#define ai(a, n) for (int ele = 0; ele < n; ele++) cin >> a[ele];
#define ain(a, lb, rb) for (int ele = lb; ele <= rb; ele++) cin >> a[ele];
#define ao(a, n) {for (int ele = 0; ele < (n); ele++) { if (ele) cout << " "; cout << a[ele]; } cout << '\n';}
#define aout(a, lb, rb) {for (int ele = (lb); ele <= (rb); ele++) { if (ele > (lb)) cout << " "; cout << a[ele]; } cout << '\n';}
typedef long long ll;
typedef double ld;
typedef long double lld;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pii> vpi;
typedef vector<pll> vpl;
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v);
template<typename A, typename B> ostream& operator<<(ostream &cout, pair<A, B> const &p) { return cout << "(" << p.f << ", " << p.s << ")"; }
template<typename A> ostream& operator<<(ostream &cout, vector<A> const &v) {
cout << "["; for(int i = 0; i < v.size(); i++) {if (i) cout << ", "; cout << v[i];} return cout << "]";
}
template<typename A, typename B> istream& operator>>(istream& cin, pair<A, B> &p) {
cin >> p.first;
return cin >> p.second;
}
// mt19937 rng(steady_clock::now().time_since_epoch().count());
mt19937 rng(61378913);
/* usage - just do rng() */
void usaco(string filename) {
// #pragma message("be careful, freopen may be wrong")
freopen((filename + ".in").c_str(), "r", stdin);
freopen((filename + ".out").c_str(), "w", stdout);
}
const lld pi = 3.14159265358979323846;
const ll mod = 1000000007;
// const ll mod = 998244353;
// ll mod;
ll n, m, k, q, l, r, x, y, z;
ll a[1000005];
ll b[1000005];
ll c[1000005];
string s, t;
ll ans = 0;
void solve(int tc) {
lld n, m, d; cin >> n >> m >> d;
lld v = 0;
if (d == 0) v = 1 / n;
else {
v = 2 * (n - d) / (n * n);
}
cout << setprecision(15) << fixed << v * (m - 1) << '\n';
}
int main() {
send help
// usaco("file");
int tc = 1;
// cin >> tc;
for (int t = 0; t < tc; t++) solve(t);
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
ll k, a[55] = {};
cin >> k;
for (int i = 0; i < 50; i++) a[i] = k / 50 + 50 - 1;
for (int i = 0; i < k % 50; i++) {
for (int j = 0; j < 50; j++) a[j]--;
a[i] += 51;
}
cout << 50 << '\n';
for (int i = 0; i < 50; i++) cout << a[i] << ' ';
}
| #include <algorithm>
#include <iostream>
#include <iomanip>
#include <numeric>
#include <vector>
#include <string>
#include <bitset>
#include <stack>
#include <queue>
#include <tuple>
#include <regex>
#include <cmath>
#include <map>
#include <set>
#include <functional>
#include <cstring>
using namespace std;
template<typename T> bool chmax( T &a, const T b ) { if ( a <= b ) { a = b; return ( true ); } else { return ( false ); } }
template<typename T> bool chmin( T &a, const T b ) { if ( a >= b ) { a = b; return ( true ); } else { return ( false ); } }
using ll = long long;
using Pint = pair<int, int>;
using Pll = pair<ll, ll>;
#define eb emplace_back
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define popcnt __builtin_popcountll
#define rep( i, n ) for ( ll i = 0; i < (ll)( n ); ++i )
#define reps( i, n ) for ( ll i = 1; i <= (ll)( n ); ++i )
#define rrep( i, n ) for ( ll i = (ll)( ( n ) - 1 ); i >= 0; --i )
#define rreps( i, n ) for ( ll i = (ll)( ( n ) ); i > 0; --i )
#define arep( i, v ) for ( auto &&i : ( v ) )
#define ALL( c ) ( c ).begin(), ( c ).end()
#define RALL( c ) ( c ).rbegin(), ( c ).rend()
#define UNIQUE( c ) ( c ).erase( unique( ( c ).begin(), ( c ).end() ), ( c ).end() )
template<typename T = ll> constexpr T MAX = numeric_limits<T>::max();
template<typename T> T gcd( const T a, const T b ) { return ( b ? gcd( b, a % b ) : a ); }
template<typename T> T lcm( const T a, const T b ) { return ( a / gcd( a, b ) * b ); }
int main()
{
ll n; cin >> n;
vector<vector<ll>> cnt( 20, vector<ll>( 20 ) );
vector<ll> v;
rep( i, n )
{
string s; cin >> s;
string t = "", u = "";
auto idx = string::npos;
if ( ( idx = s.find( "." ) ) != string::npos )
{
t = s.substr( 0, idx );
u = s.substr( idx + 1 );
while ( u.length() < 9 ) u += "0";
}
else
{
t = s;
u = "0";
}
v.eb( atoll( t.c_str() ) * 1e9 + atoll( u.c_str() ) );
}
arep( it, v )
{
ll tcnt = 0, fcnt = 0;
while ( it % 2 == 0 && tcnt < 18 )
{
it /= 2;
++tcnt;
}
while ( it % 5 == 0 && fcnt < 18 )
{
it /= 5;
++fcnt;
}
++cnt[tcnt][fcnt];
}
ll ans = 0;
rep( i, 19 )
{
rep( j, 19 )
{
rep( k, 19 )
{
rep( l, 19 )
{
if ( i + k < 18 || j + l < 18 )
continue;
if ( i == k && j == l )
ans += cnt[i][j] * ( cnt[k][l] - 1 );
else
ans += cnt[i][j] * cnt[k][l];
}
}
}
}
cout << ans / 2 << endl;
return ( 0 );
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF 1e9
#define LINF 1e18
typedef long long ll;
int main() {
ll N; cin >> N;
ll a = N/15;
ll b = N/3;
ll c = N/5;
cout << N*(N+1)/2 + 15*a*(a+1)/2 - 3*b*(b+1)/2 - 5*c*(c+1)/2 << endl;
return 0;
} | #include <algorithm>
#include<iostream>
#include<vector>
#include<deque>
#include<queue>
#include<stack>
#include<list>
#include<map>
#include<set>
#include<string>
#include <sstream>
#include<bitset>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<limits.h>
const int INF = 0x7fffffff;
using lll = long long;
using ull = unsigned long long;
using namespace std;
int main(){
lll ii,jj,kk;
vector<int> ret;
int n;
cin >> n;
lll sum = 0;
for(ii=1;ii<=n;ii++){
if((ii % 3 == 0) &&
(ii % 5 == 0)){
}
else if(ii % 3 == 0){
}
else if(ii % 5 == 0){
}
else{
sum += ii;
}
}
cout << sum << endl;
return 0;
}
| 1 |
#include<iostream>
#include<algorithm>
using namespace std;
static const int N = 100;
struct Matrix{int row, col;};
Matrix M[N];
int cost[N][N] = {0};
int prod(int begin, int end){
int mincost = 100000000, l = end - begin;
if(cost[begin][end] > 0){
return cost[begin][end];
} else {
if(l == 0){
mincost = 0;
} else if(l == 1){
cost[begin][end] = M[begin].row * M[begin].col * M[end].col;
mincost = cost[begin][end];
} else {
int temp;
for(int i = 0; i < l; i++){
temp = prod(begin, begin + i) + prod(begin + i + 1, end);
temp += M[begin].row * M[begin + i].col * M[end].col;
mincost = min(mincost, temp);
}
cost[begin][end] = mincost;
}
return mincost;
}
}
int main(){
int n;
cin >> n;
for(int i = 0; i < n; i++){
cin >> M[i].row >> M[i].col;
}
cout << prod(0, n - 1) << endl;
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<int> p(n+1);
cin >> p[0] >> p[1];
for(int i = 0; i < n-2; i++){
int a, b; cin >> a >> b;
p[i+2] = b;
}
{
int a, b; cin >> a >> b;
p[n] = b;
}
int dp[101][101];
memset(dp, 0, sizeof(dp));
n = p.size() - 1;
for(int l = 2; l <= n; l++){
for(int i = 1; i <= n-l+1; i++){
int j = i+l-1;
dp[i][j] = INT_MAX/10;
for(int k = i; k < j; k++){
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j] + p[i-1]*p[k]*p[j]);
}
}
}
cout << dp[1][n] << endl;
return 0;
} | 1 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(a) (a).begin(),(a).end()
#define pb push_back
int solve(int a,int b,int c){
if(c==0)return 0;
if(b<=c&&b<=a)return b;
return 0;
}
int main(){
string s;
cin>>s;
int ans=0;
static int J[2000000]={},O[2000000]={},I[2000000]={};
if(s[0]=='J')J[0]=1;
for(int i=1;i<s.size();i++){
// cout<<s[i-1]<<" "<<J[i-1]<<" "<<O[i-1]<<" "<<I[i-1]<<endl;
if(s[i]=='J'){
if(O[i-1]!=0){
ans=max(ans,solve(J[i-1],O[i-1],I[i-1]));
J[i]=1;
}
else{
J[i]=J[i-1]+1;
O[i]=O[i-1];
I[i]=I[i-1];
}
}else if(s[i]=='O'){
if(J[i-1]!=0&&I[i-1]==0){
J[i]=J[i-1];
O[i]=O[i-1]+1;
I[i]=I[i-1];
}else{
ans=max(ans,solve(J[i-1],O[i-1],I[i-1]));
}
}else if(s[i]=='I'){
if(O[i-1]!=0){
J[i]=J[i-1];
O[i]=O[i-1];
I[i]=I[i-1]+1;
}
else{
ans=max(ans,solve(J[i-1],O[i-1],I[i-1]));
}
}
}
ans=max(ans,solve(J[s.size()-1],O[s.size()-1],I[s.size()-1]));
cout<<ans<<endl;
} | #include<stdio.h>
int max(int a,int b){return a>b?a:b;}
int main(){
int i,j;
int n;
char c;
int jc=0;
int oc=0;
int ic=0;
int lev=0;
int ans=0;
scanf("%d",&n);
while(scanf("%c",&c)!=EOF){
switch(c){
case 'J':
if(jc==0){
oc=0;
ic=0;
lev=0;
}
jc++;
break;
case 'O':
if(oc==0){
if(jc>0)lev=jc;
if(ic>0)lev=0;
jc=0;
ic=0;
}
oc++;
if(lev<oc){
oc=0;
lev=0;
}
break;
case 'I':
if(ic==0){
if(lev>0)lev=oc;
jc=0;
oc=0;
}
ic++;
if(ic>=lev)ans=max(ans,lev);
break;
}
}
printf("%d\n",ans);
}
| 1 |
#include <iostream>
#include <map>
#include <set>
using namespace std;
int main() {
int H, W;
cin >> H >> W;
map<int, int> m;
multiset<int> s;
for (int w = 1; w <= W; ++w) {
m[w] = w;
s.insert(0);
}
int a, b;
for (int h = 1; h <= H; ++h) {
cin >> a >> b;
auto it = m.lower_bound(a);
int mx = -1;
while (it != m.end() && it->first <= b + 1) {
mx = max(mx, it->second);
int d = it->first - it->second;
s.erase(s.find(d));
m.erase(it++);
}
if (mx != -1 && b + 1 <= W) {
s.insert(b+1 - mx);
m[b+1] = mx;
}
if (s.empty()) {
cout << -1 << '\n';
} else {
cout << *s.begin() + h << '\n';
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("unroll-loops")
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define int long long
#define fr(i,a,b) for(int i = a ; i <= b ; ++i)
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) (int)(x).size()
#define pb push_back
#define fst first
#define snd second
using namespace __gnu_pbds;
using ordered_set =
tree<int, null_type,less<int>,
rb_tree_tag,tree_order_statistics_node_update>;
//find_by_order(k):returns iterator to kth element starting from 0
//order_of_key(k):returns count of elements strictly smaller than k
typedef long long ll;typedef pair<int, int> pii;
typedef vector<int> vi;typedef long double ld;
template<class T>
using min_heap = priority_queue<T,vector<T>,greater<T>>;
template<typename T> T gcd(T a, T b){return(b?__gcd(a,b):a);}
template<typename T> T lcm(T a, T b){return(a*(b/gcd(a,b)));}
template<typename T>
void remdup(vector<T>& v) {
sort(all(v)); v.erase(unique(all(v)), v.end());
}
template<typename T> void re(vector<T> &v) {trav(i,v) cin >> i;}
void unsyncIO() { ios_base::sync_with_stdio(0); cin.tie(0); }
#ifdef np
#include "C:\Users\navodit\Desktop\mycodes\pr.h"
#else
#define trace(...)
#endif
#define MOD 1000000007
void solve(){
int n , m;
cin >> n >> m;
int cnt = 0;
vi v(n+1);
rep(i,0,m){
int l ,r ;
cin >> l >> r;
l--;
v[l]++;
v[r]--;
}
rep(i,0,n) v[i+1] += v[i];
rep(i,0,n) cnt+=(v[i]==m);
cout << cnt << endl;
}
signed main() {
unsyncIO();
int tt =1 ;
// cin >> tt;
rep(i,0,tt) solve();
#ifdef np
cout <<endl<<endl<< "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
}
| 0 |
/// In The Name Of God
#include <bits/stdc++.h>
#define f first
#define s second
#define pb push_back
#define pp pop_back
#define mp make_pair
#define sz(x) (int)x.size()
#define sqr(x) ((x) * 1ll * (x))
#define all(x) x.begin(), x.end()
#define rep(i, l, r) for (int i = (l); i <= (r); i++)
#define per(i, l, r) for (int i = (l); i >= (r); i--)
#define Kazakhstan ios_base :: sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define nl '\n'
#define ioi exit(0);
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
const int N = (int)5e5 + 7;
const int inf = (int)1e9 + 7;
const int mod = (int)1e9 + 7;
const ll linf = (ll)1e18 + 7;
const int dx[] = {-1, 0, 1, 0, 1, -1, -1, 1};
const int dy[] = {0, 1, 0, -1, 1, -1, 1, -1};
using namespace std;
int n, m;
unordered_map <int, vector <int > > g[N];
unordered_map <int, int> d[N];
int c[N];
int main() {
#ifdef IOI2018
freopen ("in.txt", "r", stdin);
freopen ("E.out", "w", stdout);
#endif
Kazakhstan
cin >> n >> m;
rep(i, 1, m) {
int a, b, c;
cin >> a >> b >> c;
g[a][c].pb(b);
g[b][c].pb(a);
}
d[1][0] = 0;
deque < pair <int, pair <int, int> > > st;
st.pb({0, {1, 0}});
vector <bool> was(n + 1, 0);
while (sz(st)) {
int dist = st.front().f;
int v = st.front().s.f, last = st.front().s.s;
st.pop_front();
if (!was[v]) {
for (auto it : g[v]) {
int C = it.f;
for (auto to : it.s) {
if (!d[to].count(C) || d[to][C] > dist + 1) {
d[to][C] = dist + 1;
st.pb({d[to][C], {to, C}});
}
}
}
was[v] = 1;
}
if (sz(g[v][last])) {
int C = last;
for (auto to : g[v][last]) {
if (!d[to].count(last) || d[to][last] > dist) {
d[to][C] = dist;
st.push_front({d[to][C], {to, C}});
}
}
g[v][last].clear();
g[v].erase(last);
}
}
int ans = inf;
for (auto it : d[n]) ans = min(ans, it.s);
cout << (ans == inf ? -1 : ans);
ioi
}
| #include <iostream>
#include<map>
using namespace std;
const int maxn = 2e6 + 10;
typedef pair<int, int> P;
int fa[maxn], ma[maxn];
void init(int n)
{
for (int i = 0; i <= n; ++i)
{
fa[i] = i;
ma[i] = i;
}
}
int find(int* fa, int x)//找到根节点
{
if (fa[x] == x)
{
return fa[x];
}
return fa[x] = find(fa, fa[x]);
}
void unin(int a, int b, int* fa)
{
a = find(fa, a);//找到a根节点
b = find(fa, b);//找到b跟节点
fa[a] = b;//a为b的父节点
}
map<P, int>ans;
int main()
{
int n, k, l;
while (scanf("%d%d%d", &n, &k, &l) != EOF)
{
init(n);
ans.clear();
for (int i = 0; i < k; ++i)
{
int a, b;
scanf("%d%d", &a, &b);
unin(a, b, ma);
}
for (int i = 0; i < l; ++i)
{
int a, b;
scanf("%d%d", &a, &b);
{
unin(a, b, fa);
}
}
for (int i = 1; i <= n; ++i)
{
ans[make_pair(find(ma, i), find(fa, i))]++;
}
for (int i = 1; i <= n; ++i)
{
i == n ? printf("%d\n", ans[make_pair(find(ma, i), find(fa, i))]) : printf("%d ", ans[make_pair(find(ma, i), find(fa, i))]);
}
}
return 0;
} | 0 |
#include<bits/stdc++.h>
#include<tr1/unordered_map>
#define ri register int
using namespace std;
#define fi first
#define se second
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> poly;
#define pb push_back
const int rlen=1<<18|1,inf=0x3f3f3f3f;
const ll Inf=1e18;
char buf[rlen],*ib=buf,*ob=buf;
#define gc() (((ib==ob)&&(ob=(ib=buf)+fread(buf,1,rlen,stdin)),ib==ob)?-1:*ib++)
inline int read() {
int ans=0;
bool f=1;
char ch=gc();
while(!isdigit(ch)) f^=ch=='-',ch=gc();
while(isdigit(ch)) ans=((ans<<2)+ans<<1)+(ch^48),ch=gc();
return f?ans:-ans;
}
inline ll readl() {
ll ans=0;
bool f=1;
char ch=gc();
while(!isdigit(ch)) f^=ch=='-',ch=gc();
while(isdigit(ch)) ans=((ans<<2)+ans<<1)+(ch^48),ch=gc();
return f?ans:-ans;
}
inline int Read(char*s) {
int tp=0;
char ch=gc();
while(!isdigit(ch)&&!isalpha(ch)) ch=gc();
while(isdigit(ch)||isalpha(ch)) s[++tp]=ch,ch=gc();
return tp;
}
namespace modular {
const int mod=1e9+7;
inline int add(int a,int b) { return a+b<mod?a+b:a+b-mod; }
inline int dec(int a,int b) { return a<b?a-b+mod:a-b; }
inline int mul(int a,int b) { return (ll)a*b%mod; }
inline void Add(int&a,int b) { a=a+b<mod?a+b:a+b-mod; }
inline void Dec(int&a,int b) { a=a<b?a-b+mod:a-b; }
inline void Mul(int&a,int b) { a=(ll)a*b%mod; }
inline int ksm(int a,int p) { int ret=1;for(;p;p>>=1,Mul(a,a)) (p&1)&&(Mul(ret,a),1);return ret; }
inline int Inv(int a) { return ksm(a,mod-2); }
inline int sqr(int a) { return mul(a,a); }
inline int cub(int a) { return (ll)a*a%mod*a%mod; }
}
using namespace modular;
template<typename T> inline void ckmax(T&a,T b) { a<b?a=b:0; }
template<typename T> inline void ckmin(T&a,T b) { a>b?a=b:0; }
template<typename T> inline T gcd(T a,T b) { T t;while(b)t=a,a=b,b=t-t/a*a;return a; }
template<typename T> inline T Abs(T x) { return x<0?-x:x; }
inline int rd() { return rand()|(rand()<<15); }
const int N=5e5+5;
int n,pre[N],suf[N];
pii a[N];
int main() {
#ifdef ldxcaicai
freopen("lx.in","r",stdin);
#endif
n=read();
for(ri i=1;i<=n;++i) a[i].fi=read(),a[i].se=read();
sort(a+1,a+n+1);
pre[0]=0x3f3f3f3f,suf[n]=0x3f3f3f3f;
for(ri i=1;i<n;++i) pre[i]=min(pre[i-1],a[i].se);
for(ri i=n-1;i;--i) suf[i]=min(suf[i+1],a[i].se);
int res=0;
for(ri mn,r1,r2,t,i=1;i<n;++i) {
r1=a[i].se,r2=min(max(suf[i+1],a[n].fi-1),a[n].se);
t=(r1-a[i].fi+1)+(r2-a[n].fi+1);
mn=pre[i-1];
ckmax(res,t-max(0,min(r1-max(a[i].fi-1,mn),r2-max(a[n].fi-1,mn))));
}
cout<<res;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> ii;
typedef tuple<ll, ll, ll> iii;
typedef vector<ll> vi;
typedef vector<ii> vii;
typedef vector<iii> viii;
typedef vector<vi> vvi;
typedef vector<vii> vvii;
#define REP(i,n) for (ll i = 0; i < n; ++i)
#define REPR(i,n) for (ll i = n-1; i >= 0; --i)
#define FOR(i,m,n) for (ll i = m; i < n; ++i)
#define FORR(i,m,n) for (ll i = n-1; i >= m; --i)
#define FORE(x,xs) for (const auto& x : xs)
#define ALL(v) v.begin(), v.end()
#define CHMIN(x,y) x = min(x, y)
#define CHMAX(x,y) x = max(x, y)
const int MAX = 2e5+10;
int N;
vii lr;
ll solve() {
ll mx = 0, mn = 1e10;
ll ans = 0;
FORE (x, lr) {
CHMAX(mx, x.first); // 最も右にある左端, X
CHMIN(mn, x.second); // 最も左にある右端, Y
CHMAX(ans, x.second - x.first); // 最長の区間
}
ans += max(0ll, mn - mx); // 最長以外を反対にした場合
vii t;
FORE (x, lr) {
ll a = max(0ll, x.second - mx); // Xと同じグループにした時の範囲
ll b = max(0ll, mn - x.first); // Yと同じグループにした時の範囲
t.push_back(make_pair(a, -b));
}
sort(ALL(t));
REP (i, N) t[i].second *= -1;
ll w = t[0].second;
FOR (i, 1, N) {
CHMAX(ans, w + t[i].first);
CHMIN(w, t[i].second);
}
return ans;
}
int main() {
cin >> N;
REP (i, N) {
int l, r;
cin >> l >> r;
lr.push_back(make_pair(l, r+1));
}
cout << solve() << endl;
} | 1 |
#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
#include <cmath>
using namespace std;
int main(int argc, const char *argv[]) {
vector<int> abc(3);
int k;
cin >> abc[0] >> abc[1] >> abc[2];
cin >> k;
vector<int>::iterator iter = max_element(abc.begin(), abc.end());
size_t index = distance(abc.begin(), iter);
abc[index] *= (int)pow(2.0, (double)k);
cout << accumulate(abc.begin(), abc.end(), 0) << endl;
return 0;
}
| #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vl = vector<ll>;
using vvl = vector<vl>;
#define rep(i, s, n) for(int i = (int)(s); i < (int)(n); i++)
const int MAX_k = 200010;
const int mod = 998244353;
ll com[MAX_k];
ll fac[MAX_k], inv[MAX_k], finv[MAX_k];
void cominit(int n){
com[0] = 1;
com[1] = n;
fac[0] = 1;
fac[1] = n;
inv[1] = 1;
finv[0] = finv[1] = 1;
rep(i, 2, MAX_k){
fac[i] = fac[i-1]*(n-i+1) %mod;
inv[i] = mod - inv[mod%i]*(mod/i) %mod;
finv[i] = finv[i-1]*inv[i] %mod;
com[i] = fac[i]*finv[i] %mod;
}
}
ll modPow(int a, int n, int mod){
if(n == 0)
return 1;
if(n%2 == 0){
ll t = modPow(a, n/2, mod);
return t*t%mod;
}
ll t = modPow(a, n-1, mod);
return a*t%mod;
}
int main(){
int n, m, k;
cin >> n >> m >> k;
ll ans = 0;
cominit(n-1);
rep(i, 0, k+1){
ll t = m;
t = t*com[i]%mod;
t = t*modPow(m-1, n-i-1, mod)%mod;
ans = (ans + t)%mod;
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
// --------------------------------------------------------
template<class T> bool chmax(T& a, const T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> bool chmin(T& a, const T b) { if (b < a) { a = b; return 1; } return 0; }
#define FOR(i,l,r) for (int i = (l); i < (r); ++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define MIN(c) *min_element(ALL(c))
#define MAX(c) *max_element(ALL(c))
#define SUM(c) accumulate(ALL(c), 0)
#define SUMLL(c) accumulate(ALL(c), 0LL)
#define SZ(c) ((int)(c).size())
#define debug(x) cerr << #x << " = " << (x) << '\n';
using P = pair<int,int>;
using VP = vector<P>;
using VVP = vector<VP>;
using VS = vector<string>;
using VI = vector<int>;
using VVI = vector<VI>;
using VLL = vector<ll>;
using VVLL = vector<VLL>;
using VB = vector<bool>;
using VVB = vector<VB>;
using VD = vector<double>;
using VVD = vector<VD>;
static const double EPS = 1e-10;
static const double PI = acos(-1.0);
static const ll MOD = 1000000007;
// static const ll MOD = 998244353;
static const int INF = 1 << 30;
// static const ll INF = 1LL << 62;
// --------------------------------------------------------
vector<bool> is_prime_numbers(ll n) {
vector<bool> is_prime(n + 1, true);
is_prime[0] = false;
is_prime[1] = false;
ll root_n = (ll)(sqrt(n) + 0.5);
for (int i = 2; i <= root_n; i++) {
for (int j = 2 * i; j <= n; j += i) {
is_prime[j] = false;
}
}
return is_prime;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(10);
ll N; cin >> N;
static const int MAX_A = 55555;
auto is_prime = is_prime_numbers(MAX_A);
VI B;
FOR(i,11,MAX_A+1) {
if (is_prime[i]) {
if (i % 5 == 1) {
B.push_back(i);
if (SZ(B) == N) break;
}
}
}
REP(i,N) {
if (i) cout << " ";
cout << B[i];
}
cout << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int>ans = { 2,7,17,37,47,67,97,107,127,137,157,167,197,227,257,277,307,317,337,347,367,397,457,467,487,547,557,577,587,607,617,647,677,727,757,787,797,827,857,877,887,907,937,947,967,977,997,1087,1097,1117,1187,1217,1237,1277,1297,1307 };
for (int i = 0; i < n; i++) {
if (i == 0)cout << ans.at(i);
else cout << " " << ans.at(i);
}
} | 1 |
#include<iostream>
#include<cstdio>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<cstring>
#include<string>
#include<cmath>
#include<list>
#include<algorithm>
using namespace std;
#define inf 0x3f3f3f3f
typedef long long ll;
const int maxn = 100000 + 8;
int n,a[maxn];
int Partition(int a[],int p,int r)
{
int last_element = a[r];
int i = p-1;
for(int j = p; j < r; ++j)
{
if(a[j] <= last_element)
{
i++;
swap(a[i],a[j]);
}
}
swap(a[i+1],a[r]);
return i+1;
}
int main()
{
scanf("%d",&n);
fill(a,a+n,0);
for(int i = 0; i < n; ++i)
{
scanf("%d",&a[i]);
}
int pos = Partition(a,0,n-1);
for(int i = 0;i < n; ++i){
if(i == pos) printf("");
printf("%s%s%d%s", i==0?"":" ",i == pos?"[":"",a[i],i == pos?"]":"");
}
printf("\n");
return 0;
}
///*
//const int maxn = 1e5 + 8;
//
//int n,k,w[maxn];
//
//int check(ll P)
//{
// for(int i = 0; i < n; ++i){
//
// }
//}
//ll BinarySearch()
//{
// ll left = 0;
// ll right = maxn * maxn;
// while(left <= right)
// {
// ll mid = (left + right) / 2;
// int r = check(mid);
// if(r >= n) ;
// else ;
// }
// return right;
//}
//int main()
//{
// scanf("%d%d",&n,&k);
// fill(w,w+n,0);
// for(int i = 0; i < n; ++i) scanf("%d",&w[i]);
// ll ans = BinarySearch();
//}
//
/*
#include <iostream>
#include <deque>
#include <string>
#include <vector>
#include <queue>
#include <cstdio>
#include <stack>
#include <algorithm>
#include <cstring>
#include <cctype>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <iomanip>
using namespace std;
int tile = 0;
int Board[8][8];
void ChessBoard(int tr,int tc,int dr,int dc,int size){
if(size == 1)return ;
int t = tile++;
int s = size / 2;
if(dr < tr + s && dc < tc + s){
ChessBoard(tr,tc,dr,dc,s);
}
else{
Board[tr + s - 1][tc + s - 1] = t;
ChessBoard(tr,tc,tr + s - 1, tc + s - 1,s);
}
if(dr < tr + s && dc >= tc + s){
ChessBoard(tr,tc + s,dr,dc,s);
}
else{
Board[tr + s - 1][tc + s] = t;
ChessBoard(tr,tc+s,tr + s - 1, tc + s,s);
}
if(dr >= tr + s && dc < tc + s){
ChessBoard(tr+s,tc,dr,dc,s);
}
else{
Board[tr + s][tc + s - 1] = t;
ChessBoard(tr+s,tc,tr + s, tc + s - 1,s);
}
if(dr >= tr + s && dc >= tc + s){
ChessBoard(tr+s,tc+s,dr,dc,s);
}
else{
Board[tr + s][tc + s] = t;
ChessBoard(tr+s,tc+s,tr + s, tc + s,s);
}
}
void Print(){
for (int i = 0; i < 8; ++i) {
for (int j = 0; j < 8; ++j) {
cout << setw(3) << Board[i][j];
}
cout << endl;
}
cout << endl;
}
int main(){
memset(Board,0,sizeof Board);
ChessBoard(0,0,0,1,8);
Print();
}
*/ | #include <iostream>
#include <string>
#include <sstream>
int partition(int* arr, int n)
{
const int x = arr[n - 1]; //pivot value
int i = 0; //increment if swaped
int j = 0; //increment every loop
for (; j < n; ++j) { //scan start to end
if (arr[j] <= x) {
std::swap(arr[i], arr[j]);
++i;
}
}
return i - 1;
}
void print(int const* arr, const int n, int q, int i)
{
if (i == n - 1 ) {
std::cout << arr[i] << std::endl;
return;
}
if (i == q) {
std::cout << "[" << arr[i] << "] ";
}
else {
std::cout << arr[i] << " ";
}
return print(arr, n, q, i + 1);
}
void print(int const* arr, const int n, int q)
{
print(arr, n, q, 0);
return;
}
int main()
{
int n;
{
std::string buf;
std::getline(std::cin, buf);
n = std::stoi(buf);
}
int arr[100000];
{
std::string buf;
std::getline(std::cin, buf);
std::stringstream stream;
stream << buf;
for (int i = 0; std::getline(stream, buf, ' '); ++i) {
arr[i] = std::stoi(buf);
}
}
int q = partition(arr, n);
print(arr, n, q);
return 0;
} | 1 |
#include <iostream>
using namespace std;
int main()
{
int n;
int a,b,c,d;
int team[100];
int p[100];
int sum=0;
cin >> n;
for(int i=1 ;i<n+1 ;i++){
team[i] = 0;
p[i] = 1;
}
for(int i=0 ;i<(n*(n-1))/2 ;i++){
cin >> a >> b >> c >> d;
if(c > d)
team[a] += 3;
else if(c < d)
team[b] += 3;
else if(c == d){
team[a]++;
team[b]++;
}
}
for(int i=1 ;i<n+1 ;i++){
for(int j=1 ;j<n+1 ;j++){
if(team[i] < team[j]){
p[i]++;
}
}
}
for(int i=1 ;i<n+1 ;i++){
cout << p[i] << endl;
}
return 0;
} | #include <cstdio>
#include <cstring>
#define repeat(i, n) for (int i = 0; i < (n); i++)
using namespace std;
int table[11][11];
int main() {
for (;;) {
int n;
scanf("%i", &n);
if (!n) return 0;
memset(table, 0, sizeof table);
repeat(i, n) {
repeat(j, n) {
scanf("%i", &table[i][j]);
table[i][n] += table[i][j];
table[n][j] += table[i][j];
printf("%5i", table[i][j]);
}
printf("%5i\n", table[i][n]);
}
repeat(i, n)
table[n][n] += table[n][i];
repeat (i, n+1)
printf("%5i", table[n][i]);
puts("");
}
} | 0 |
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
int main(){
ll N,D;
ll A[200005];
cin>>N>>D;
ll ret = D*(N-1);
for(int i = 0;i < N;i++){
cin>>A[i];
ret += A[i];
}
for(int i = 1;i < N;i++){
A[i]=min(A[i-1]+D,A[i]);
}
for(int i = N-2;i >=0;i--){
A[i]=min(A[i+1]+D,A[i]);
}
for(int i = 1;i < N-1;i++){
ret += A[i];
}
cout<<ret<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int>> vvi;
typedef vector<vector<ll>> vvl;
class U {
public:
int n;
vector<int> p, s;
U(int _) {
n = _;
p.resize(n);
s.resize(n);
for (int i = 0; i < n; i++) {
p[i] = i;
s[i] = 1;
}
}
bool connect(int a, int b) {
int ap, bp;
for (ap = p[a]; ap != p[ap]; ap = p[ap])
;
for (bp = p[b]; bp != p[bp]; bp = p[bp])
;
if (ap == bp)
return true;
int mi = min(ap, bp), ma = max(ap, bp);
p[ma] = mi;
s[mi] += s[ma];
s[ma] = 0;
for (int pp = a; pp != mi;) {
int next = p[pp];
p[pp] = mi;
pp = next;
}
for (int pp = b; pp != mi;) {
int next = p[pp];
p[pp] = mi;
pp = next;
}
return false;
}
int q(int a) {
int ap;
for (ap = a; ap != p[ap]; ap = p[ap])
;
return s[ap];
}
int parent(int a) {
int ap;
for (ap = a; ap != p[ap]; ap = p[ap])
;
return p[ap];
}
bool query(int a, int b) { return parent(a) == parent(b); }
};
template <typename T> class RMQ {
vector<T> data;
T unit;
public:
static const long long INF = 100000000000;
int n;
function<T(const T &, const T &)> f;
RMQ(int _, T u, function<T(T, T)> bi) {
unit = u;
f = bi;
n = 1;
while (n < _) {
n <<= 1;
}
data.resize(n * 4);
for (int i = 0; i < n * 4; i++)
data[i] = unit;
}
void update(int index, T val) {
int i = index + n - 1;
data[i] = val;
while (i > 0) {
i = (i - 1) / 2;
data[i] = f(data[i * 2 + 1], data[i * 2 + 2]);
}
}
// [a, b)
T query(int a, int b, int k, int l, int r) {
if (a < 0 || r <= a || b <= l)
return unit;
if (a <= l && r <= b)
return data[k];
else
return f(query(a, b, k * 2 + 1, l, (l + r) / 2),
query(a, b, k * 2 + 2, (r + l) / 2, r));
}
T query(int a, int b) { return query(a, b, 0, 0, n); }
};
struct N {
int i, j;
long long c;
};
bool operator<(const N &l, const N &r) { return l.c < r.c; }
ll INF = 1000000000000000000LL;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
ll d;
cin >> n >> d;
vll a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
map<ll, vi> mp;
for (int i = 0; i < n; i++)
mp[a[i]].push_back(i);
auto f = [](const pair<ll, int> &l, const pair<ll, int> &r) {
if (l.first < r.first)
return l;
else
return r;
};
pair<ll, int> unit = make_pair(INF, -1);
RMQ<pair<ll, int>> l(n + 2, unit, f), r(n + 2, unit, f);
U u(n);
vector<N> paths;
for (auto &v : mp) {
for (auto &i : v.second) {
auto lp = l.query(0, i);
auto rp = r.query(i, n);
if (lp.second >= 0) {
paths.push_back(
N{i, lp.second, abs(i - lp.second) * d + a[i] + a[lp.second]});
}
if (rp.second >= 0) {
paths.push_back(
N{i, rp.second, abs(i - rp.second) * d + a[i] + a[rp.second]});
}
l.update(i, make_pair(a[i] + (n - i) * d, i));
r.update(i, make_pair(a[i] + i * d, i));
}
}
sort(paths.begin(), paths.end());
ll ans = 0;
for (auto &p : paths) {
if (!u.connect(p.i, p.j)) {
ans += p.c;
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define rrep(i,n) for(int (i)=((n)-1);(i)>=0;(i)--)
#define itn int
#define all(x) (x).begin(),(x).end()
#define F first
#define S second
const long long INF = 1LL << 60;
const int MOD = 1000000007;
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; }
//https://www.creativ.xyz/dump-cpp-652/
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
// vector
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec) is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, map<T, U> &map_var) {
os << "{";
repi(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end()) os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T>
ostream &operator<<(ostream &os, set<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end()) os << ", ";
itr--;
}
os << "}";
return os;
}
#define DUMPOUT cerr
void dump_func() {
DUMPOUT << endl;
}
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&... tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" \
<< endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
signed main(void) { cin.tie(0); ios::sync_with_stdio(false);
int n; cin>>n;
string s; cin>>s;
int q; cin>>q;
rep(timpo, q){
int k; cin>>k;
int d=0,m=0,dm=0,ans=0;
rep(i,n){
if(i-k>=0){
if(s[i-k]=='D') dm -= m, d--;
if(s[i-k]=='M') m--;
}
if(s[i]=='D') d++;
if(s[i] == 'M'){
m++;
dm += d;
}
if(s[i] == 'C') ans += dm;
}
cout<<ans<<endl;
}
} | #include <bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,b,a) for(int i=b;i>=a;i--)
#define fori(a) for(auto i : a )
#define all(a) begin(a), end(a)
#define set(a,b) memset(a,b,sizeof(a))
#define sz(a) a.size()
#define pi 3.14159
#define ll long long
#define ull unsigned long long
#define pb push_back
#define PF push_front //deque
#define mp make_pair
#define pq priority_queue
#define mod 1000000007
#define f first
#define s second
#define pii pair< int, int >
#define vi vector<int>
#define vpii vector<pii>
#define debug(v) for(auto i:v) cout<<i<<" ";
#define tc int t; cin >> t; while(t--)
using namespace std;
void optimizeIO(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int dp[509][509];
int C[509][509];
int recurr(int i,int j){
if(dp[i][j]!=-1) return dp[i][j];
if(i==j) {dp[i][j]=C[i][j]; return dp[i][j];}
// number of line segements b/w i & j = line segement from i to j and line segments b/w i to j-1
// and line segments b/w i+1 to j - line segments included in both(i to j-1, i+1 to j) range i.e i+1 to j-1
dp[i][j]=C[i][j]+recurr(i,j-1)+recurr(i+1,j)-recurr(i+1,j-1);
return dp[i][j];
}
void solve(){
int n,m,Q,l,r;
cin>>n>>m>>Q;
rep(i,0,m){
cin>>l>>r;
C[l][r]++;
}
rep(i,1,n+1) rep(j,1,n+1) dp[i][j]=-1;
recurr(1,n);
rep(i,0,Q){
cin>>l>>r;
cout<<dp[l][r]<<endl;
}
}
int main(){
optimizeIO();
solve();
}
| 0 |
#include <iostream>
#include <ccomplex>
#include <vector>
#include <cassert>
#include <utility>
#include <algorithm>
#include <string>
#include <deque>
#include <queue>
#include <functional>
#include <cmath>
#include <iomanip>
#include <map>
#include <numeric>
#include <list>
#include <assert.h>
#include <math.h>
#include <valarray>
#include <stdio.h>
#include <algorithm>
#include <set>
#include <complex>
#include <list>
#include <time.h>
#include <stack>
#include <locale>
#include <clocale>
#include <ctype.h>
#include <wchar.h>
using namespace std;
typedef long long int LL;
typedef pair<long long int, long long int> pii;
typedef pair<double, double> pdd;
#define SORT(c) sort((c).begin(),(c).end())
#define BACKSORT(c) sort((c).begin(),(c).end(),std::greater<LL>())
#define FOR(i,a,b) for(LL i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
int xcomp(vector<LL>& a, vector<LL>& b) {
return a[0] < b[0];
}
#define XSORT(c) sort((c).begin(),(c).end(),xcomp)
#define ALL(x) (x).begin(),(x).end()
LL mod = 1000000007;
int main() {
int N;
cin >> N;
REP(i, N) {
int a1 = 0;
int a2 = 0;
int a3 = 0;
int out = 0;
int pt = 0;
while (true) {
string s;
cin >> s;
if (s[1] == 'I') {
if (a3 == 1) {
a3 = 0;
pt++;
}
if (a2 == 1) {
a2 = 0;
a3 = 1;
}
if (a1 == 1) {
a1 = 0;
a2 = 1;
}
a1 = 1;
}
else
if (s[1] == 'U') {
out++;
if (out == 3) {
break;
}
}
else {
if (a1 == 1) {
a1 = 0;
pt++;
}
if (a2 == 1) {
a2 = 0;
pt++;
}
if (a3 == 1) {
a3 = 0;
pt++;
}
pt++;
}
}
cout << pt << endl;
}
} | #include<iostream>
#include<iomanip>
#include<vector>
using namespace std;
int main(){
int n;
cin>>n;
while(n--){
string s;
int out=0,score=0,base=0;
while(out<3){
cin>>s;
if(s=="HIT"){
base++;
if(base>3){
score+=base%3;
base-=base%3;
}
}
if(s=="HOMERUN"){
score+=base+1;
base=0;
}
if(s=="OUT"){
out++;
}
}
cout<<score<<endl;;
}
} | 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mx = 2e5+10;
ll dp[mx],arr[mx];
int main()
{
ll n ;
cin>>n;
ll sum=0;
for(int i=1; i<=n; i++)
{
cin>>arr[i];
if(i%2!=0)
sum+=arr[i];
if(i!=1)
{
if(i%2!=0)
dp[i]=max(dp[i-2]+arr[i],dp[i-1]);
else
dp[i]=max(dp[i-2]+arr[i],sum);
}
}
cout<<dp[n]<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
using ll = long long;
using ld = long double;
ll INF = LLONG_MAX;
using vi = vector<int>;
using vll = vector<ll>;
using pii = pair<int, int>;
namespace output {
void pr(int x) { cout << x; }
void pr(long x) { cout << x; }
void pr(ll x) { cout << x; }
void pr(unsigned x) { cout << x; }
void pr(unsigned long x) { cout << x; }
void pr(unsigned long long x) { cout << x; }
void pr(float x) { cout << x; }
void pr(double x) { cout << x; }
void pr(ld x) { cout << x; }
void pr(char x) { cout << x; }
void pr(const char* x) { cout << x; }
void pr(const string& x) { cout << x; }
void pr(bool x) { pr(x ? "true" : "false"); }
template<class T> void pr(const complex<T>& x) { cout << x; }
template<class T1, class T2> void pr(const pair<T1,T2>& x);
template<class T> void pr(const T& x);
template<class T, class... Ts> void pr(const T& t, const Ts&... ts) {
pr(t); pr(ts...);
}
template<class T1, class T2> void pr(const pair<T1,T2>& x) {
pr("{",x.f,", ",x.s,"}");
}
template<class T> void pr(const T& x) {
pr("{"); // const iterator needed for vector<bool>
bool fst = 1; for (const auto& a: x) pr(!fst?", ":"",a), fst = 0;
pr("}");
}
void print() { pr("\n"); } // print w/ spaces
template<class T, class... Ts> void print(const T& t, const Ts&... ts) {
pr(t); if (sizeof...(ts)) pr(" "); print(ts...);
}
}
using namespace output;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int N; cin >> N; N *= 2;
vi arr (N);
F0R(i, N) cin >> arr[i];
sort(arr.begin(), arr.end());
int ans = 0;
for (int i = 0; i < N; i += 2) {
ans += arr[i];
}
print(ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
float r,g,ans;
cin>>r>>g;
ans=2*g-r;
cout << ans << endl;
} | #include <iostream>
#include <cmath>
#include <cstdio>
using namespace std;
int main(){
double x1,y1,x2,y2;
cin>>x1>>y1>>x2>>y2;
double a=sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
printf("%lf\n",a);
} | 0 |
#include <algorithm>
#include <array>
#include <iostream>
#include <numeric>
#include <sstream>
#include <string>
using std::accumulate;
using std::array;
using std::cin;
using std::cout;
using std::endl;
using std::for_each;
using std::getline;
using std::replace;
using std::string;
using std::stringstream;
int main() {
string input;
while (getline(cin,input)) {
replace(input.begin(),input.end(),',',' ');
array<int,10> len; // length of each section
stringstream str_in(input);
for_each(len.begin(),len.end(),[&str_in](int& l){str_in >> l;});
int v1,v2; // velocity of each train
str_in >> v1 >> v2;
double total_time = accumulate(len.begin(),len.end(),0)/static_cast<double>(v1+v2);
double total_len = total_time*v1; // total length the train passes
int pass_len = 0; // the length the train passes
int section = 0; // the number of section where the train passes
while (pass_len < total_len) {
pass_len += static_cast<double>(len[section++]);
}
cout << section << endl;
}
} | #include <bits/stdc++.h>
#define rep(i,l,n) for(int i=l;i<n;i++)
using namespace std;
int main(){
int l[11],v1,v2,ans;
double x;
while(1){
int sum=0,y=0;
rep(i,0,10){
scanf("%d,",&l[i]);
sum+=l[i];
}
if(scanf("%d,%d",&v1,&v2)==EOF) break;
x=(double)sum*v1/(v1+v2);
rep(j,0,10){
y+=l[j];
if(y>=x){
ans=j+1;
break;
}
}
cout<<ans<<endl;
}
} | 1 |
/**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author Kein Yukiyoshi
*/
#include "bits/stdc++.h"
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define FOR(i, a) for (auto &i : a)
#define ALL(obj) begin(obj), end(obj)
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define SUM(x) accumulate(ALL(x), 0LL)
#define LOWER_BOUND(A, key) distance(A.begin(), lower_bound(ALL(A), key))
#define UPPER_BOUND(A, key) distance(A.begin(), upper_bound(ALL(A), key))
using namespace std;
const int MOD = (int)(1e9 + 7);
const int INF = (int)(1e13 + 7);
const double EPS = 1e-14;
const double PI = acos(-1);
int CEIL(int a, int b) { return (a >= 0 ? (a + (b - 1)) / b : (a - (b - 1)) / b); } //ceil() for int
int mod(int a, int b) { return a >= 0 ? a % b : a - (b * CEIL(a, b)); } //always return positive num
int bpm(int a, int b) { //return x^y in order(log(y))
int res = 1;
for (a %= MOD; b; a = a * a % MOD, b >>= 1)
if (b & 1) res = res * a % MOD;
return res;
}
class CDigitsInMultiplication {
public:
static void solve(istream &cin, ostream &cout) {
int N;
cin >> N;
int ans = INF;
REP(i, 1, bpm(10, 5) + 1) {
if (N % i == 0) {
ans = min(ans, (int)max(log10(i) / 1 + 1, log10(N / i) / 1 + 1));
}
}
cout << ans << endl;
}
};
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cout<<fixed<<setprecision(15);
CDigitsInMultiplication solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long LL;
int main() {
string S; cin >> S;
if (S[0] != 'A') {
cout << "WA" << endl;
return 0;
}
for (char c : S) {
if (c == 'A' || c == 'C') continue;
if (isupper(c)) {
cout << "WA" << endl;
return 0;
}
}
int cnt = 0;
for (int i = 2; i < S.size() - 1; ++i) {
if (S[i] == 'C') ++cnt;
}
if (cnt == 1) cout << "AC" << endl;
else cout << "WA" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int D ;
int T ;
int S ;
cin >> D;
cin >> T;
cin >> S;
if (T*S < D ) {
cout << "No" << endl;
}
else if (T*S >= D) {
cout << "Yes" << endl;
}
}
|
#include <bits/stdc++.h>
#define watch(x) cout << (#x) << " is " << (x) << endl
#define eps 1e-9
typedef long long ll;
using namespace std;
const ll inf = 1e18;
const ll mod = 1e9+7;
const int N = 2e5+5;
//int a[N];
int main()
{
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
int d, t, s;
cin >> d >> t >> s;
if (((d+s-1)/s) > t) cout << "No";
else cout << "Yes";
return 0;
} | 1 |
// ABC178F.cpp
#include <iostream>
#include <vector>
#include <algorithm> // sort
#include <string>
#define rep(i,n) for(int i=0;i<(n);++i)
using namespace std;
using ll = long long;
using P = pair<int, char>;
using Pi = pair<int, int>;
int main()
{
int n;
cin >> n;
vector<P>a(n), b(n);
vector<P>c(n * 2);
vector<int>count(200005);
int num;
int num_mx = 0;
rep(i, n) {
cin >> num;
a[i].first = num;
a[i].second = 'A';
c[i] = a[i];
count[num]++;
if (i == n - 1) num_mx = num;
}
rep(i, n) {
cin >> num;
b[i].first = num;
b[i].second = 'B';
c[n + i] = b[i];
count[num]++;
if (i == n - 1) num_mx = max(num, num_mx);
}
int mx = 0;
for (int i = 1; i <= num_mx; i++) {
mx = max(mx, count[i]);
}
// 同じ数が半分以上あるとき、作れない
if (mx > n) {
cout << "No" << endl;
return 0;
}
sort(c.begin(), c.end());
vector<P> d(n), e(n);
rep(i, n) {
d[i] = c[i];
e[i] = c[i + n];
}
vector<int>aal,bbl,abl,bal;
rep(i, n) {
if (d[i].second == 'A' && e[i].second == 'A') aal.push_back(i);
if (d[i].second == 'B' && e[i].second == 'B') bbl.push_back(i);
}
// AAの組み合わせの時は、bbの組とeを入れ替えるか、eとdを入れ替える
rep(i, aal.size()) {
if (d[aal[i]].first != e[bbl[i]].first) {
swap(e[aal[i]], e[bbl[i]]);
continue;
}
if (d[aal[i]].first == e[bbl[i]].first) {
swap(e[aal[i]], d[bbl[i]]);
continue;
}
if (d[bbl[i]].first != e[aal[i]].first) {
swap(e[aal[i]], e[bbl[i]]);
continue;
}
if (d[bbl[i]].first == e[aal[i]].first) {
swap(d[aal[i]], e[bbl[i]]);
continue;
}
}
cout << "Yes" << endl;
vector<Pi>f;
rep(i, n) {
if (d[i].second == 'A') f.emplace_back(d[i].first, e[i].first);
if(e[i].second=='A') f.emplace_back(e[i].first, d[i].first);
}
sort(f.begin(), f.end());
rep(i, n) {
cout << f[i].second << " ";
}
cout << endl;
}
/*
6
1 1 2 2 2 3
1 2 2 2 3 3
*/
| #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#define MAXN 100010
int n, k, a[MAXN];
inline int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int g;; k ^= 1) {
int count = 0;
for (int i = 1; i <= n; i++) count += a[i] & 1;
if ((n - count) & 1) {
return puts(k ? "Second" : "First"), 0;
}
if (count >= 2) {
return puts(k ? "First" : "Second"), 0;
}
g = 0;
for (int i = 1; i <= n; i++) {
if (a[i] & 1) {
if (a[i] == 1) return puts(k ? "First" : "Second"), 0;
--a[i];
}
g = gcd(a[i], g);
}
for (int i = 1; i <= n; i++) a[i] /= g;
}
return 0;
} | 0 |
#include <iostream>
using namespace std;
int main() {
int n;
while(1){
cin >> n;
if(n == 0) break;
int num[10000][2] = {};
int score[2] = {};
for (int i = 0; i < n; ++i)
{
for (int j = 0; j < 2; ++j){
cin >> num[i][j];
}
if (num[i][0] > num[i][1])
{
score[0] += num[i][0] + num[i][1];
} else if (num[i][0] == num[i][1])
{
score[0] += num[i][0];
score[1] += num[i][1];
} else{
score[1] += num[i][0] + num[i][1];
}
}
cout << score[0] << " " << score[1] << endl;
}
return 0;
} | #include<iostream>
int main(){
while(1){
int n,A,B,Ap=0,Bp=0;
std::cin>>n;
if(n==0)
break;
for(int i=0;i<n;++i){
std::cin>>A>>B;
if(A>B)
Ap+=A+B;
else if(A==B){
Ap+=A;
Bp+=B;
}
else Bp+=A+B;
}
std::cout<<Ap<<' '<<Bp<<std::endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(i,a,n) for(ll i=(ll)a;i<(ll)n;i++)
#define RFOR(i,a,n) for(ll i=(ll)n-1;i >= (ll)a;i--)
#define rep(i,n) FOR(i,0,n)
#define rrep(i,n) RFOR(i,0,n)
#define ALL(v) v.begin(), v.end()
ll MOD = 1000000007;
ll INF = 200000000000000000;
double EPS = 1e-12;
double PI = 3.141592653589793238;
template<typename T>
void remove(std::vector<T>& vector, unsigned int index){
vector.erase(vector.begin() + index);
}
using Graph = vector<vector<ll>>;
int main(){
ll N,K;
cin >> N >> K;
cout << N - K + 1 << endl;
}
| #include<iostream>
#include<string>
using namespace std;
class dice
{
private:
int asp[6];
string order;
public:
void setdice( int* j ); //サイコロの値を格納
void dice_print(); //サイコロの値を出力
void exchange( int& x, int& y ); //サイコロの場所を交換
void orderX( string x ); //転がす命令を行う
void up_print(){ cout << asp[0] << endl; } //上面を出力する関数
};
void dice::setdice( int* j )
{
for( int i = 0; i < 6; i++ )
asp[i] = j[i];
}
void dice::dice_print()
{
for( int i = 0; i < 6; i++ )
cout << asp[i] << " ";
cout << endl;
}
void dice::exchange( int& x, int& y )
{
int temp;
temp = x;
x = y;
y = temp;
}
void dice::orderX( string x )
{
for( int i = 0; i < x.size(); i++ )
{
if( x[i] == 'E')
{
exchange( asp[0], asp[2] );
exchange( asp[0], asp[5] );
exchange( asp[0], asp[3] );
}
else if( x[i] == 'N')
{
exchange( asp[0], asp[4] );
exchange( asp[0], asp[5] );
exchange( asp[0], asp[1] );
}
else if( x[i] == 'S')
{
exchange( asp[0], asp[1] );
exchange( asp[0], asp[5] );
exchange( asp[0], asp[4] );
}
else if( x[i] == 'W')
{
exchange( asp[0], asp[3] );
exchange( asp[0], asp[5] );
exchange( asp[0], asp[2] );
}
else{}
}
}
int main()
{
int d[6];
string ord;
dice dice1;
for( int i = 0; i < 6; i++ )
cin >> d[i];
cin >> ord;
dice1.setdice( d ); //サイコロの面をセット
dice1.orderX( ord ); //命令に従って並び替え
dice1.up_print(); //上面出力
return 0;
}
| 0 |
#include <stdio.h>
int main () {
int H1,M1,H2,M2,K;
scanf("%d%d%d%d%d", &H1,&M1,&H2,&M2,&K);
int sum= ((H2-H1)*60) + (M2-M1) -K;
printf("%d", sum);
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define REP(i,m,n) for(int i=(int)(m); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define RREP(i,m,n) for(int i=(int)(m); i>=(int)(n); i--)
#define rrep(i,n) RREP(i,(n)-1,0)
#define all(v) v.begin(), v.end()
#define endk '\n'
const int inf = 1e9+7;
const ll longinf = 1LL<<60;
const ll mod = 1e9+7;
const ld eps = 1e-10;
template<typename T1, typename T2> inline void chmin(T1 &a, T2 b){if(a>b) a=b;}
template<typename T1, typename T2> inline void chmax(T1 &a, T2 b){if(a<b) a=b;}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int a, b, c, d; cin >> a >> b >> c >> d;
if(a+b > c+d) cout << "Left" << endk;
else if(a+b == c+d) cout << "Balanced" << endk;
else cout << "Right" << endk;
return 0;
}
| 0 |
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <cmath>
#include <map>
#include <queue>
#include <iomanip>
#define MOD 1000000007
typedef long long ll;
using namespace std;
int N,M;
double x[100010];
ll K;
int a[100010];
vector<int> replace(vector<int> A,ll n){
vector<int> B(N+1);
for(int i=1;i<N;i++) B[i]=i;
while(n>0){
if(n&1){
vector<int> C=B;
for(int i=1;i<N;i++){
B[i]=A[C[i]];
}
}
vector<int> D=A;
for(int i=1;i<N;i++){
A[i]=D[D[i]];
}
n>>=1;
}
return B;
}
int main(){
cin>>N;
for(int i=0;i<N;i++) cin>>x[i];
cin>>M>>K;
for(int i=0;i<M;i++) cin>>a[i];
double dif[N+1]={};
for(int i=1;i<N;i++){
dif[i]=x[i]-x[i-1];
}
vector<int> index(N+1);
for(int i=1;i<N;i++) index[i]=i;
for(int i=0;i<M;i++){
swap(index[a[i]],index[a[i]-1]);
}
vector<int> A=replace(index,K);
double ans[N+1]={};
ans[0]=x[0];
for(int i=1;i<N;i++){
ans[i]=ans[i-1]+dif[A[i]];
}
for(int i=0;i<N;i++) cout<<fixed<<setprecision(10)<<ans[i]<<endl;
return 0;
}
| #include<bits/stdc++.h>
#define Rint register int
using namespace std;
typedef long long LL;
const int N = 100003;
int n, m, c[N], d[N], cnt;
LL ans[N], x[N], k;
bool vis[N];
int main(){
scanf("%d", &n);
for(Rint i = 1;i <= n;i ++) scanf("%lld", x + i), c[i] = i;
for(Rint i = n;i;i --) x[i] -= x[i - 1];
scanf("%d%lld", &m, &k);
for(Rint i = 1;i <= m;i ++){
int v; scanf("%d", &v); swap(c[v], c[v + 1]);
}
for(Rint i = 1;i <= n;i ++) if(!vis[i]){
cnt = 0;
for(Rint j = i;!vis[j];j = c[j]) vis[d[cnt ++] = j] = true;
for(Rint j = 0;j < cnt;j ++)
ans[d[j]] = x[d[(j + k) % cnt]];
}
for(Rint i = 1;i <= n;i ++){
ans[i] += ans[i - 1];
printf("%lld.0\n", ans[i]);
}
} | 1 |
#include <bits/stdc++.h>
#define debug(x) cerr<<#x<<'='<<x<<endl
#define set0(x) memset(x,0,sizeof(x))
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pii;
template<typename T> void read(T &x){
x = 0;char ch = getchar();ll f = 1;
while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
template<typename T, typename... Args> void read(T &first, Args& ... args) {
read(first);
read(args...);
}
int n,a[200020];
map<int,int> cmp;
int main() {
read(n);
for(int i=0;i<n;i++){
read(a[i]);
cmp[a[i]]+=1;
}
sort(a,a+n);
int ans =0;
for(int i=n-1;i>=0;i--){
if(!cmp[a[i]])continue;
cmp[a[i]]-=1;
int b = a[i];
b+=b&(-b);
while(b!=(b&(-b)))b+=b&(-b);
if(cmp[b-a[i]]){
ans++;
cmp[b-a[i]]--;
}
}
cout<<ans<<endl;
return 0;
}
| #include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
#include<cmath>
#include<cstdio>
#include<tuple>
#include<bitset>
#include<map>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<=n;++i)
#define ALL(x) x.begin(),x.end()
#define ll long long
typedef pair<int,int> P;
const int inf=1000000007;
const int MOD=1000000007;
signed main(){
int n,m;cin>>n>>m;
vector<int> a(n+1,0);
vector<int> sum(n+5,0);
map<int,int> memo;
memo[0]=1;
rep1(i,n){
cin>>a[i];
sum[i]=sum[i-1]+a[i];
sum[i]%=m;
memo[sum[i]]+=1;
}
int res=0;
for(auto it=memo.begin();it!=memo.end();++it){
res+=it->second*(it->second-1)/2;
}
cout<<res<<"\n";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(I,A,B) for(int I = (A); I < (B); ++I)
typedef pair<int,int> int_pair;
typedef pair<ll,ll> ll_pair;
#define N 1002
#define INF 1e9+1
string s1,s2;
int dp[N][N];
int main(){
FOR(i,0,N)FOR(j,0,N)dp[i][j]=-1;
cin>>s1>>s2;
FOR(i,0,s1.size()+1){
dp[i][0]=i;
}
FOR(i,0,s2.size()+1){
dp[0][i]=i;
}
FOR(i,1,s1.size()+1){
FOR(j,1,s2.size()+1){
int a,b=1;
if(s1[i-1]==s2[j-1])b=0;
a=min(dp[i-1][j]+1,dp[i][j-1]+1);
a=min(a,dp[i-1][j-1]+b);
dp[i][j]=a;
}
}
cout<<dp[s1.size()][s2.size()]<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) REP(i, 0, n)
#define REP(i,k,n) for(int i = k; i < n; i++)
#define mmax(start, end) *max_element(start, end)
#define mmin(start, end) *min_element(start, end)
#define argmax max_element
#define argmin min_element
#define push push_back
#define pop pop_back
#define ALL(x) (x).begin(), (x).end()
typedef long long ll;
typedef string str;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
template<class T = ll> T in() {
T _in;
cin >> _in;
return _in;
}
int dp[1001][1001];
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
string s[2];
int len[2];
rep(i, 2) {
cin >> s[i];
len[i] = s[i].size();
}
// 表埋め
rep(i, len[0]+1) {
dp[i][0] = i;
}
rep(j, len[1]+1) {
dp[0][j] = j;
}
REP(i, 1, len[0]+1) {
REP(j, 1, len[1]+1) {
// if(i==2 && j==1) {
// cout << s[0][i-1] << " " << s[1][j-1] << endl;
// }
int top_left = dp[i-1][j-1];
if(s[0][i-1] != s[1][j-1]) {
top_left++;
}
int top = dp[i-1][j] + 1;
int left = dp[i][j-1] + 1;
dp[i][j] = min(top, min(top_left, left));
}
}
// rep(i, len[0]+1) {
// rep(j, len[1]+1) {
// cout << dp[i][j] << " ";
// }
// cout << endl;
// }
// cout << endl;
cout << dp[len[0]][len[1]] << endl;
return 0;
}
| 1 |
#ifndef _TEMPLATE_ROOT
#define _TEMPLATE_ROOT
#include "bits/stdc++.h"
using namespace std;
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define repl(i, a, b) for(ll i = a; i < (b); ++i)
#define repd(i, a, b) for(int i = a; i >= (b); --i)
#define repdl(i, a, b) for(ll i = a; i >= (b); --i)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
template<typename H> bool chmin(H& v1, const H v2) { if (v1 > v2) { v1 = v2; return true; } return false; }
template<typename H> bool chmax(H& v1, const H v2) { if (v1 < v2) { v1 = v2; return true; } return false; }
#endif
#ifndef _TEMPLATE_IO
#define _TEMPLATE_IO
template<typename H> void read(H& head) { cin >> head; }
template<typename H, typename ...T> void read(H& head, T& ...tail) { cin >> head; read(tail...); }
template<typename H> void write(H head) { cout << head << '\n'; }
template<typename H, typename ...T> void write(H head, T ...tail) { cout << head << " "; write(tail...); }
template<typename ...T> void writef(T ...tail) { write(tail...); cout << flush; }
template<typename ...T> void die(T ...tok) { write(tok...); exit(0); }
template<typename T>
ostream& operator<<(ostream& out, const vector<T>& v) {
if (v.size()) {
rep(i, 0, sz(v) - 1)
out << v[i] << " ";
out << v.back();
}
return out;
}
#endif
#ifndef _TEMPLATE_SEGTREE
#define _TEMPLATE_SEGTREE
#ifndef _TEMPLATE_MONOID
#define _TEMPLATE_MONOID
template<class T>
struct Monoid {
T id;
virtual T op(T a, T b) = 0;
};
#endif
template<typename T, typename M, typename = enable_if<is_base_of<Monoid<T>, M>::value>>
struct SegTree {
M monoid;
vector<T> tree;
int size;
SegTree(vector<T> elems, M monoid) : size(elems.size()), monoid(monoid) {
tree = vector<T>(2 * size);
for (int i = 0; i < size; i++)
tree[size + i] = elems[i];
build();
}
SegTree(int size, M monoid) : size(size), monoid(monoid) {
tree = vector<T>(2 * size, monoid.id);
build();
}
void build() {
for (int i = size - 1; i > 0; --i)
tree[i] = monoid.op(tree[i << 1], tree[i << 1 | 1]);
}
T query(int l, int r) {
T resl = monoid.id, resr = monoid.id;
++r; // handle inclusive query range
for (l += size, r += size; l < r; l >>= 1, r >>= 1) {
if (l & 1) resl = monoid.op(resl, tree[l++]);
if (r & 1) resr = monoid.op(tree[--r], resr);
}
return monoid.op(resl, resr);
}
T get(int p) {
return tree[size + p];
}
void update(int p, T val) {
for (tree[p += size] = val; p >>= 1;)
tree[p] = monoid.op(tree[p << 1], tree[p << 1 | 1]);
}
};
#endif
using namespace std;
struct Query {
int l, r, id, ans;
};
struct SegTreeAdd : public Monoid<int> {
int id = 0;
int op(int a, int b) { return a + b; }
};
int n, q;
int c[500005];
Query p[500005];
int lst[500005];
int main() {
cin.tie(0)->sync_with_stdio(0);
cin.exceptions(cin.failbit);
read(n, q);
rep(i, 1, n + 1) read(c[i]);
rep(i, 1, q + 1) read(p[i].l, p[i].r), p[i].id = i;
sort(p + 1, p + q + 1, [](const Query& p1, const Query& p2) {
return p1.r < p2.r;
});
SegTree<int, SegTreeAdd> segtree(n + 1, SegTreeAdd());
int curr = 0;
rep(i, 1, q + 1) {
while (p[i].r > curr) {
++curr;
if (lst[c[curr]])
segtree.update(lst[c[curr]], 0);
lst[c[curr]] = curr;
segtree.update(lst[c[curr]], 1);
}
p[i].ans = segtree.query(p[i].l, p[i].r);
}
sort(p + 1, p + q + 1, [](const Query& p1, const Query& p2) {
return p1.id < p2.id;
});
rep(i, 1, q + 1)
write(p[i].ans);
}
| #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <queue>
#include <set>
#include <tuple>
#include <vector>
using namespace std;
#define rep(i, n) for (int64_t i = 0; i < (int64_t)(n); i++)
#define irep(i, n) for (int64_t i = 0; i <= (int64_t)(n); i++)
#define rrep(i, n) for (int64_t i = (n)-1; i >= 0; i--)
#define rirep(i, n) for (int64_t i = n; i >= 0; i--)
int main() {
string s;
cin >> s;
vector<int> dp0(s.size() + 1), dp1(s.size() + 1);
dp0[0] = 0;
dp1[0] = 1;
rep(i, s.size()) {
int a = s[i] - '0';
dp0[i + 1] = min(dp0[i] + a, min(dp1[i] + a + 1, dp1[i] + 10 - a));
dp1[i + 1] = dp1[i] + 10 - a - 1;
if (a < 9) {
dp1[i + 1] = min(dp1[i + 1], min(dp0[i] + a + 1, dp1[i] + a + 2));
}
}
// irep(i, s.size()) { cerr << " " << dp0[i] << " " << dp1[i] << "\n"; }
cout << dp0[s.size()] << endl;
return 0;
} | 0 |
#include <stdio.h>
int isprime(int n) {
int i;
for(int i = 2; i * i <= n; i++) {
if(n % i == 0) return 0;
}
return 1;
}
int main() {
int i, k, v,an1,an2,suu;
int MAX_V = 10000;
int prime[MAX_V+1];
for(i = 0; i <= MAX_V; i++) {
prime[i] = 1;
}
for(i = 2; i*i <= MAX_V; i++) {
if(prime[i]) {
for(k = 2 * i; k <= MAX_V; k += i) {
prime[k] = 0;
}
}
}
while(1){
scanf("%d",&suu);
if(suu != 0){
for(k=2;k<=suu;k++){
if(prime[k-2]==1 && prime[k]==1){
an1=k-2;
an2=k;
}
}
printf("%d %d\n",an1,an2);
}
else{
break;
}
}
return 0;
} | #include <iostream>
#include <string>
#include <algorithm>
int main()
{
std::string s;
while (std::cin >> s) {
std::reverse(s.begin(), s.end());
std::cout << s << std::endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef pair < int , int > pii;
typedef long long LL;
#define mpr make_pair
#define FS first
#define SC second
#define PB push_back
template < typename T > T MAX(T a,T b){return (a>b)?a:b;}
template < typename T > T MIN(T a,T b){return (a<b)?a:b;}
template < typename T > void UMAX(T &a,T b){a=(a>b?a:b);}
template < typename T > void UMIN(T &a,T b){a=(a<b?a:b);}
LL readint(){
char c=getchar();
LL ret=0ll;
while(!(c>='0' && c<='9')) c=getchar();
while(c>='0' && c<='9'){
ret=ret*10ll+(LL)(c-'0');
c=getchar();
}
return ret;
}
void putint(LL v){
if(!v){
putchar('0');
return;
}
if(v>=10ll) putint(v/10ll);
putchar('0'+(v%10ll));
}
int n,M,fac[10005],ifac[10005];
int powM(int V,int T){
int R=1;
while(T){
if(T&1) R=(LL)R*(LL)V%(LL)M;
T>>=1;
V=(LL)V*(LL)V%(LL)M;
}
return R;
}
int main(){
int i,j,k;
scanf("%d%d",&n,&M);
fac[0]=1;
for(i=1;i<=10000;++i){
fac[i]=(LL)fac[i-1]*(LL)i%(LL)M;
}
ifac[10000]=powM(fac[10000],M-2);
for(i=9999;i>=0;--i){
ifac[i]=(LL)ifac[i+1]*(LL)(i+1)%(LL)M;
}
int res=0;
for(i=0;i<=n;++i){// # of 3
for(j=0;i+j<=n;++j){// # of 2
int R=(LL)fac[n*3]*(LL)powM(ifac[2],j)%(LL)M*(LL)powM(ifac[3],i)%(LL)M;
R=(LL)R*(LL)ifac[i]%(LL)M*(LL)ifac[j]%(LL)M*(LL)ifac[n*3-i*3-j*2]%(LL)M;
R=(LL)R*(LL)powM(2,i)%(LL)M;
res+=R;
if(res>=M) res-=M;
}
}
printf("%d\n",res);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e5 + 50;
const ll inf = 1e18;
const int mod = 998244353;
int sum,n;
int a[maxn];
ll dp[305][305 * 305];
ll ans = 1;
int main()
{
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
scanf("%d", a + i),sum += a[i], ans = (ans * 3) % mod;
dp[0][0] = 1;
for (int i = 1; i <= n; ++i)
{
for (int j = 0; j <= sum; ++j)
{
dp[i][j] = dp[i - 1][j] * 2 % mod;
if (j >= a[i])
dp[i][j] = (dp[i][j] + dp[i - 1][j - a[i]]) % mod;
}
}
for (int i = (sum + 1) / 2; i <= sum; ++i)
ans = (ans - dp[n][i] * 3 % mod + mod) % mod;
if (sum % 2 == 0)
{
memset(dp, 0, sizeof dp);
dp[0][0] = 1;
for (int i = 1; i <= n; ++i)
{
for (int j = 0; j <= sum; ++j)
{
dp[i][j] = dp[i - 1][j] % mod;
if (j >= a[i])
dp[i][j] = (dp[i][j] + dp[i - 1][j - a[i]]) % mod;
}
}
ans = (ans + dp[n][sum / 2] * 3) % mod;
}
printf("%lld\n", ans);
return 0;
} | 0 |
// includes
#include "bits/stdc++.h"
using namespace std;
// macros
#define ll long long
#define MOD 998244353 //1000000007 // 100000000 //
#define pii pair<ll, ll>
#define piii pair<ll, pii>
#define sz(x) ((ll)(x).size())
#define ft first
#define sd second
#define pb push_back
#define rep(i, n) for(ll i = 0; i < n; i++)
#define repr(i, n) for(ll i = n-1; i >= 0; i--)
#define itr(it, x) for(auto it = x.begin(); it != x.end(); it++)
#define mem(a, b) memset(a, (ll)b, sizeof(a))
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
#define edge(v, x, y) v[x].pb(y); v[y].pb(x);
#define popc __builtin_popcount
#define ANS(s) {cout << s << "\n"; return;}
// functions
template <typename T> void unique(T& c){c.erase(std::unique(c.begin(), c.end()), c.end());}
template <class T>bool chmax(T &a, const T &b){if(a < b){a = b; return 1;} return 0;}
template <class T>bool chmin(T &a, const T &b){if(a > b){a = b; return 1;} return 0;}
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){for(int i = 0; i < vec.size(); i++){ os << vec[i]; if(i + 1 != vec.size())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const set<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const unordered_set<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const multiset<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T> ostream &operator<<(ostream &os, const unordered_multiset<T>& st){for(auto itr = st.begin(); itr != st.end(); ++itr){ os << *itr; auto titr = itr; if(++titr != st.end())os << " ";} return os;}
template <typename T1, typename T2> ostream &operator<<(ostream &os, const pair<T1, T2> &p){os << "(" << p.first << ", " << p.second << ")"; return os;}
template <typename T1, typename T2> ostream &operator<<(ostream &os, const map<T1, T2> &mp){for(auto itr = mp.begin(); itr != mp.end(); ++itr){ os << "(" << itr->first << ", " << itr->second << ")"; auto titr = itr; if(++titr != mp.end())os << " "; } return os;}
template <typename T1, typename T2> ostream &operator<<(ostream &os, const unordered_map<T1, T2> &mp){for(auto itr = mp.begin(); itr != mp.end(); ++itr){ os << "(" << itr->first << ", " << itr->second << ")"; auto titr = itr; if(++titr != mp.end())os << " "; } return os;}
// constants
const ll N = 1e5+5, M = 1e6+5, A = 1e7+5, inf = 1e9;
const long long linf = 1LL << 60;
const double er = 1e-10, pi = 3.141592653589793238463;
const ll lx[4] = {0, 1, -1, 0};
const ll ly[4] = {1, 0, 0, -1};
const ll dx[8] = {0, 0, 1, -1, 1, -1, 1, -1};
const ll dy[8] = {1, -1, 0, 0, 1, 1, -1, -1};
// io
struct fast_io{
fast_io(){ios_base::sync_with_stdio(false); cin.tie(0); cout << fixed << setprecision(20);}
} fast_io_;
void solve()
{
ll n, m;
cin >> n >> m;
vector<ll> a(n); cin >> a;
ll ans = inf;
ll l = 0, r = m-1;
rep(i, n)
{
if(a[r] <= 0){
ans = min(ans, abs(a[l]));
}
else if(a[l] >= 0){
ans = min(ans, a[r]);
}
else{
ans = min({ans, abs(a[l])*2 + a[r], abs(a[l]) + a[r]*2 });
}//cout << ans << " ";
l++, r++;
if(r == n) break;
}
cout << ans;
}
int main(int argc, char const* argv[])
{
ll t = 1; //cin >> t;
while(t--) {
solve();
}
return 0;
}
| #include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<cmath>
#include<bitset>
#include<deque>
#include<functional>
#include<iterator>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<utility>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
#define a first
#define b second
#define sz(x) (ll)((x).size())
#define pb push_back
#define mp make_pair
#define bg begin()
#define ed end()
#define all(x) (x).bg,(x).ed
#define rep(i,n) for(ll i=0;i<(n);i++)
#define rep1(i,n) for(ll i=1;i<=(n);i++)
#define rrep(i,n) for(ll i=(n)-1;i>=0;i--)
#define rrep1(i,n) for(ll i=(n);i>=1;i--)
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
const ll MOD=1000000007;
const ll INF=1000000000000000;
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 maxx(ll x,ll y,ll z){return max(max(x,y),z);}
ll minn(ll x,ll y,ll z){return min(min(x,y),z);}
ll gcd(ll x,ll y){if(x%y==0) return y;else return gcd(y,x%y);}
ll lcm(ll x,ll y){return x*(y/gcd(x,y));}
ll digsz(ll x){if(x==0) return 1;else{ll ans=0;while(x){x/=10;ans++;}return ans;}}
ll digsum(ll x){ll sum=0;while(x){sum+=x%10;x/=10;}return sum;}
vector<ll> pw2(62,1);vector<ll> pw10(19,1);
ll dx[8]={0,0,-1,1,-1,1,-1,1};
ll dy[8]={1,-1,0,0,1,1,-1,-1};
vector<vector<ll> > c(10,vector<ll>(10,0));
int main(){
{rep1(i,61) pw2[i]=2*pw2[i-1];}
{rep1(i,18) pw10[i]=10*pw10[i-1];}
ll N,K; cin>>N>>K;
vector<ll> minus;
vector<ll> plus;
vector<ll> zero;
rep(i,N){
ll x; cin>>x;
if(x<0) minus.pb(x);
else if(x==0) zero.pb(x);
else plus.pb(x);
}
ll m=sz(minus),p=sz(plus),need=K-sz(zero);
minus.pb(0);
plus.pb(0);
sort(all(minus),greater<ll>());
sort(all(plus));
ll ans=INF;
rep(i,min(need,m)+1){
if(need-i > p) continue;
ll X=-minus[i];
ll Y=plus[need-i];
chmin(ans,max(X,Y)+min(X,Y)*2);
}
cout<<ans<<endl;
}
| 1 |
#include <iostream>
using namespace std;
int main(void){
int a, b, c; cin >> a >> b >> c;
if ((a <= c && c <= b) || (b <= c && c <= a)) {
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
} | # include <iostream>
# include <string>
using namespace std;
int main(){
int n;
string s, t;
cin >> n >> s >> t;
int maxLen = 0;
for(int i=1; i<=n; i++){
if(s.substr(n-i) == t.substr(0,i))
maxLen = max(maxLen, i);
}
cout << 2*n - maxLen << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int R, G;
cin>>R>>G;
int res = G + (G-R);
cout<<res<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int r,g;
double p;
cin >> r >> g;
//g = (r + p) / 2
p = 2 * g - r;
cout << p << endl;
}
| 1 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
using namespace std;
#define INF (1<<29)
int G[101][101];
int n, k;
void init(){
for(int i = 0 ; i < n ; i++){
for(int j = 0 ; j < n ; j++){
G[i][j] = INF;
if(i == j) G[i][j] = 0;
}
}
}
int main(){
while(cin >> n >> k){
if(n == 0 && k == 0) break;
init();
int op, a, b, e;
for(int cs = 0 ; cs < k ; cs++){
cin >> op;
if(op == 1){
cin >> a >> b >> e;
a--, b--;
G[a][b] = min(G[a][b], e);
G[b][a] = min(G[b][a], e);
// Warshall_Floyd();
for(int i = 0 ; i < n ; i++){
for(int j = 0 ; j < n ; j++){
G[i][j] = min(G[i][j], G[i][a] + G[a][b] + G[b][j]);
G[j][i] = G[i][j];
}
}
}
else if(op == 0){
cin >> a >> b;
a--, b--;
if(G[a][b] == INF) cout << -1 << endl;
else cout << G[a][b] << endl;
}
}
}
return 0;
} | #include <iostream>
#include <map>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long Int;
int main(){
map<int,Int> table;
vector<int> ids;
int n;
bool flug;
while(cin >> n, n != 0){
flug = false;
table.clear();
ids.clear();
for(int i=1; i<=n; i++){
int id;
Int tanka;
Int number;
cin >> id >> tanka >> number;
table[id] += (tanka*number);
vector<int>::iterator fIter = find(ids.begin(), ids.end(), id);
if(fIter == ids.end()){
ids.push_back(id);
}
}
for(vector<int>::iterator Iter = ids.begin(); Iter != ids.end(); Iter++){
if(table[*Iter] >= 1000000){
cout << *Iter << endl;
flug = true;
}
}
if(flug == false){
cout << "NA" << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i, a, n) for(int i = a; i < n; i++)
#define repb(i, a, b) for(int i = a; i >= b; i--)
#define all(a) a.begin(), a.end()
#define int long long
using namespace std;
signed main(){
string s, t, u, p;
int n, a, b;
cin >> s >> n;
rep(i, 0, n){
cin >> t >> a >> b;
if(t == "print"){
u = s.substr(a, b - a + 1);
cout << u << endl;
}else if(t == "reverse"){
reverse(s.begin() + a, s.begin() + b + 1);
}else{
cin >> p;
s.replace(a, b - a + 1, p);
}
}
} | #include <cstdio>
#include <iostream>
using namespace std;
int main()
{
int len[10];
int v1,v2;
while( scanf("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d", &len[0],&len[1],&len[2],&len[3],&len[4],&len[5],&len[6],&len[7],&len[8],&len[9],&v1,&v2) != EOF ){
int accum[10] = {0};
accum[0] = len[0];
for(int i=1;i<10;i++){
accum[i] += accum[i-1] + len[i];
}
// accum[9] は合計の距離
double t = (double)accum[9]/(v1 + v2);
double dist = (double) v1*t;
for(int i=0;i<10;i++){
if( dist <= accum[i] ){
cout<<i+1<<endl;
break;
}
}
}
return 0;
} | 0 |
#include "bits/stdc++.h"
#define REP(i,num) for(int i=0;i<(num);++i)
#define ALL(c) c.begin(),c.end()
#define LOOP(i) while(i--)
#define PRINTALL(c) for(auto& x:c){cout<<x<<' ';}cout<<endl;
#define PAIRCOMP(c,comp) [](const pair<ll,ll>& lhs,const pair<ll,ll>& rhs){return lhs.c comp rhs.c;}
using namespace std;
using ll = long long;
constexpr ll atcoder_mod = 1e9+7;
template<typename T=int>
T in(){T x; cin >> x; return (x);}
template<typename T=int,typename C=vector<T>>
C vecin(int N){C x(N);REP(i,N){x[i]=in<T>();}return move(x);}
void vout(){cout << endl;}
template<typename Head,typename... Tail>
void vout(Head&& h,Tail&&... t){cout << ' ' << h;vout(forward<Tail>(t)...);}
void out(){cout << endl;}
template<typename Head,typename... Tail>
void out(Head&& h,Tail&&... t){cout << h;vout(forward<Tail>(t)...);}
class ConnectNodeInfo{
vector<vector<pair<ll,ll>>> graph;
public:
ConnectNodeInfo(int node_num){
graph.resize(node_num);
}
void AddNonDirectionalConnection(ll u,ll v,ll w){
graph[u].emplace_back(v,w);
graph[v].emplace_back(u,w);
}
void AddDirectionalConnection(ll u,ll v,ll w){
graph[u].emplace_back(v,w);
}
vector<pair<ll,ll>>& operator[](ll index){
return graph[index];
}
size_t size(){return graph.size();}
};
class UnionFind{
vector<ll> rank;
vector<ll> diff_weight;
vector<ll> num;
public:
vector<ll> par;
UnionFind(ll N):par(N),num(N),rank(N),diff_weight(N){
for(ll i=0;i<N;i++){
par[i]=i;
num[i]=1;
rank[i]=0;
diff_weight[i]=0;
}
}
ll root(ll x){
if(par[x]==x){
return x;
}
ll r = root(par[x]);
diff_weight[x]+=diff_weight[par[x]];
return par[x]=r;
}
void unite(ll x,ll y){
ll rx = root(x);
ll ry = root(y);
if (rx == ry) return;
if(rank[rx]<rank[ry]) swap(rx,ry);
if(rank[rx]==rank[ry]) ++rank[rx];
par[ry] = rx;
num[rx] += num[ry];
}
void relate(ll x,ll y,ll w){
w+=weight(x),w-=weight(y);
ll rx = root(x);
ll ry = root(y);
if (rx == ry) return;
if(rank[rx]<rank[ry]){
swap(rx,ry);
w = -w;
}
if(rank[rx]==rank[ry]) ++rank[rx];
par[ry] = rx;
diff_weight[ry] = w;
num[rx] += num[ry];
}
bool same(ll x,ll y){
ll rx = root(x);
ll ry = root(y);
return rx == ry;
}
ll getsize(ll x){
return num[root(x)];
}
ll weight(ll x){
root(x);
return diff_weight[x];
}
ll diff(ll x,ll y){
return weight(y)-weight(x);
}
};
void FirstDFS(int child,int& post_count,vector<int>& post,ConnectNodeInfo& connect,vector<int>& memo){
memo[child] = 1;
for(auto& x:connect[child]){
if(!memo[x.first]){
FirstDFS(x.first,post_count,post,connect,memo);
}
}
post[child] = post_count++;
}
void SecondDFS(int start,int child,ConnectNodeInfo& connect,UnionFind& uf,vector<int>& memo){
uf.unite(start,child);
memo[child] = 1;
for(auto& x:connect[child]){
if(!memo[x.first]){
SecondDFS(start,x.first,connect,uf,memo);
}
}
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(10);
int N=in(),M=in();
ConnectNodeInfo connect(N),inverse_connect(N);
REP(i,M){
int u=in(),v=in();
connect.AddDirectionalConnection(u,v,1);
inverse_connect.AddDirectionalConnection(v,u,1);
}
int post_count=0;
vector<int> post(N,-1);
vector<int> memo(N,0);
REP(i,N){
if(!memo[i]) FirstDFS(i,post_count,post,connect,memo);
}
vector<pair<int,int>> new_order(N);
REP(i,N){
new_order[i].first=i;
new_order[i].second=post[i];
}
sort(ALL(new_order),PAIRCOMP(second,>));
UnionFind uf(N);
fill(ALL(memo),0);
REP(i,N){
if(!memo[new_order[i].first]) SecondDFS(new_order[i].first,new_order[i].first,inverse_connect,uf,memo);
}
int Q=in();
LOOP(Q){
int u=in(),v=in();
out(uf.same(u,v)?1:0);
}
return 0;
}
| #include <algorithm>
#include <iostream>
#include <set>
#include <vector>
class TEdge;
struct TNode
{
int TreeIndex;
std::set<const TEdge*> Connected;
TNode();
void SetIndex(int Index, const TEdge* Edge);
};
class TEdge
{
std::pair<TNode*, TNode*> FEnds;
int FWeight;
public:
TEdge(TNode* EndA, TNode* EndB, int Weight);
bool operator<(const TEdge& Other)const;
int Weight()const {return FWeight;}
bool ToMekeCycle()const;
void JoinTree(int TreeIndex)const;
};
TNode::TNode()
:TreeIndex(0)
{
}
void TNode::SetIndex(int Index, const TEdge* Edge)
{
if(TreeIndex >= Index) return;
TreeIndex = Index;
for(std::set<const TEdge*>::const_iterator It = Connected.begin(); It != Connected.end(); ++It){
(*It)->JoinTree(Index);
}
Connected.insert(Edge);
}
TEdge::TEdge(TNode* EndA, TNode* EndB, int Weight)
:FEnds(EndA, EndB), FWeight(Weight)
{
}
bool TEdge::operator<(const TEdge& Other)const
{
return Weight() < Other.Weight();
}
bool TEdge::ToMekeCycle()const
{
return FEnds.first->TreeIndex > 0 && FEnds.first->TreeIndex == FEnds.second->TreeIndex;
}
void TEdge::JoinTree(int TreeIndex)const
{
FEnds.first->SetIndex(TreeIndex, this);
FEnds.second->SetIndex(TreeIndex, this);
}
class TGraph
{
std::vector<TNode> FNodes;
std::vector<TEdge> FEdges;
public:
TGraph(int NodeCount);
void AddEdge(int NodeIndexA, int NodeIndexB, int Weight);
int WeightMinimumSpanningTree();
};
TGraph::TGraph(int NodeCount)
:FNodes(NodeCount)
{
}
void TGraph::AddEdge(int NodeIndexA, int NodeIndexB, int Weight)
{
if(NodeIndexA <= NodeIndexB || Weight < 0) return;
FEdges.push_back(TEdge(&FNodes[NodeIndexA], &FNodes[NodeIndexB], Weight));
}
int TGraph::WeightMinimumSpanningTree()
{
std::sort(FEdges.begin(), FEdges.end());
unsigned int TreeCount = 0;
int Weight = 0;
for(std::vector<TEdge>::iterator It = FEdges.begin(); It != FEdges.end() && TreeCount < FNodes.size() - 1; ++It){
if(It->ToMekeCycle()) continue;
It->JoinTree(TreeCount + 1);
Weight += It->Weight();
++TreeCount;
}
return Weight;
}
int main()
{
int NodeCount;
std::cin >> NodeCount;
TGraph Graph(NodeCount);
for(int i = 0; i < NodeCount; ++i)
{
for(int j = 0; j < NodeCount; ++j){
int Weight;
std::cin >> Weight;
Graph.AddEdge(i, j, Weight);
}
}
std::cout << Graph.WeightMinimumSpanningTree() << std::endl;
return 0;
} | 0 |
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<cstdlib>
#include<queue>
#include<set>
#include<cstdio>
using namespace std;
#define ll long long
#define rep(i, n) for(int i = 0; i < n; i++)
#define P pair<int, int>
typedef vector<int> vec;
typedef vector<vec> mat;
const ll mod = 1000000007;
mat mul(mat &A, mat &B){
mat C(A.size(), vec(B[0].size()));
for (int i = 0; i < A.size(); i++){
for (int k = 0; k < B.size(); k++){
for (int j = 0; j < B[0].size(); j++){
C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % mod;
}
}
}
return C;
}
mat pow(mat A, ll n){
mat B(A.size(), vec(A.size()));
for (int i = 0; i < A.size(); i++){
B[i][i] = 1;
}
while(n > 0){
if(n & 1) B = mul(B, A);
A = mul(A, A);
n >>= 1;
}
return B;
}
int main(){
int n, l;
cin >> n >> l;
int sm = 0;
int ans = 1000000;
rep(i, n){
sm += l + i;
}
// cout << sm << endl;
rep(i, n){
int sm_ = 0;
rep(j, n){
if(i == j) continue;
sm_ += l + j;
}
if(abs(ans - sm) > abs(sm_ - sm)) ans = sm_;
}
cout << ans << endl;
} | #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define fastio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define gcd(a,b) __gcd((a),(b))
#define lcm(a,b) ((a)*(b))/gcd((a),(b))
const int maxn = 1e9 + 5;
#define INF 100000000000
const int MOD = 1e9+7;
const double PI = 3.14159265358979323846264338;
const ll MAXN = 1e18;
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
fastio
int a,b;
cin >> a >> b;
int l = b;
int r = b+a-1;
int eat = 0;
if(r<=0){
eat = r;
}else if(l>=0){
eat=l;
}else{
eat=0;
}
int ans = ((r+l)*(r-l+1)/2)-eat;
cout << ans << endl;
return 0;
}
//l,l+1,l+2 ... l+n-1
//^-^ | 1 |
#include "iostream"
using namespace std;
int main(){
int a; int b;
cin>>a>>b;
if(a==b){
cout<<2*a<<endl;
}
else if(a>b){
cout<<a+(a-1)<<endl;
}
else{
cout<<b+(b-1)<<endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
int main(){
int a, b, maior, res = 0;
cin >> a >> b;
rep(i,2){
if (a > b){
maior = a;
a--;
}else{
maior = b;
b--;
}
res += maior;
}
cout << res;
} | 1 |
//Love and Freedom.
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<cstring>
#define ll long long
#define inf 20021225
using namespace std;
int read()
{
int s=0,t=1; char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-') t=-1; ch=getchar();}
while(ch>='0' && ch<='9') s=s*10+ch-'0',ch=getchar();
return s*t;
}
bool np[10010]; int pri[5010],cnt;
void getprime(int n)
{
for(int i=2;i<=n;i++)
{
if(!np[i]) pri[++cnt]=i;
for(int j=1;j<=cnt&&pri[j]*i<=n;j++)
{
np[pri[j]*i]=1;
if(i%pri[j]==0) break;
}
}
}
#define N 510
ll a[N][N];
ll lcm(ll x,ll y){if(!x||!y)return x+y;return x/__gcd(x,y)*y;}
int main()
{
getprime(1e4); int n=read();
if(n==2) return puts("4 7\n23 10"),0;
for(int i=1;i<=n;i++) for(int j=1;j<=n;j++)
if(!((i+j)&1)) a[i][j]=1ll*pri[i+j>>1]*pri[n+(i-j>>1)+(n+1>>1)];
for(int i=1;i<=n;i++) for(int j=1;j<=n;j++)
if((i+j)&1) a[i][j]=lcm(lcm(a[i-1][j],a[i+1][j]),lcm(a[i][j-1],a[i][j+1]))+1;
for(int i=1;i<=n;i++,puts("")) for(int j=1;j<=n;j++)
printf("%lld ",a[i][j]);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
const int MOD = 1e9+7;
string s;
ll d, n;
ll dp[10005][101][2]; // k = 0, cannot cross limit, k = 1 can
ll solve(ll i, ll sum, ll k){
if(i == n) return sum == 0;
if(dp[i][sum][k] == -1) {
ll dig = s[i] - '0';
if(k) dig = 9;
ll res = 0;
for(int j = 0; j <= dig; j++){
res += solve(i+1, (sum + j)%d, (k == 1 || (k == 0 && j < dig ) ? 1 : 0) );
res %= MOD;
}
dp[i][sum][k] = res;
}
return dp[i][sum][k];
}
int main(){
cin >> s >> d;
n = s.size();
memset(dp, -1, sizeof(dp));
cout << (solve(0, 0, 0) - 1 + MOD)%MOD;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> pll;
#define FOR(i, n, m) for (ll(i) = (m); (i) < (n); ++(i))
#define REP(i, n) FOR(i, n, 0)
#define OF64 std::setprecision(10)
const ll MOD = 1000000007;
const ll INF = (ll)1e15;
int main()
{
ll K;
cin >> K;
const ll size = 50;
vector<ll> v(50);
ll n = K / size;
ll m = K % size;
REP(i, size)
{
v[i] = size - 1 + n;
if (i < m)
v[i]++;
else
v[i] -= m;
}
cout << size << endl;
REP(i, size)
{
cout << v[i] << " ";
}
cout << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
ll n,a,b;
cin>>n;
cout<<50<<endl;
a=n/50;
b=n%50;
for(int i=0;i<b;i++){
cout<<50+a-i<<" ";
}
for(int i=b;i<50;i++){
cout<<max(0LL,49+a-i)<<" ";
}
} | 1 |
#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
const int mod=998244353;
int n,m,f[1000005],inv[1000005];
long long C(int n,int m){
return 1LL*f[n]*inv[m]%mod*inv[n-m]%mod;
}
long long quick_pow(long long a,int b){
long long ans=1;
for(;b;b>>=1,a=a*a%mod)
if(b&1) ans=ans*a%mod;
return ans;
}
int main(){
scanf("%d%d",&n,&m);
if(n<m) swap(n,m);
f[0]=f[1]=inv[0]=inv[1]=1;
for(int i=2;i<=1000002;i++) f[i]=1LL*f[i-1]*i%mod,inv[i]=1LL*(mod-mod/i)*inv[mod%i]%mod;
for(int i=1;i<=1000002;i++) inv[i]=1LL*inv[i]*inv[i-1]%mod;
long long ans=0;
for(int i=1;i<=m;i++){
ans=(ans+C(i+i,i)*C(n-i+m-i,n-i))%mod;
}
ans=(ans*quick_pow(2*C(n+m,n),mod-2)+n)%mod;
printf("%lld",ans);
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;
int main() {
ll x, y; cin >> x >> y;
ll ans = LINF;
if (x <= y) ans = min(ans, y - x);
if (-x <= y) ans = min(ans, y + x + 1);
if (x <= -y) ans = min(ans, -y - x + 1);
if (-x <= -y) ans = min(ans, -y + x + 2);
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template<typename T>
istream &operator>>(istream &is, vector<T> &v) {
for (auto &x : v) is >> x;
return is;
}
const long long mod = 998244353;
int main() {
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int n; cin >> n;
vector<int> a(n); cin >> a;
map<int, int> m;
for (int x : a) m[x]++;
if (m[0] != 1 || a[0] != 0) {
cout << "0\n";
return 0;
}
int mx = *max_element(a.begin(), a.end());
long long ans = 1;
for (int i = 1; i <= mx; i++) {
long long res = 1;
for (int j = 0; j < m[i]; j++) {
res *= m[i - 1];
res %= mod;
}
ans *= res;
ans %= mod;
}
cout << ans << '\n';
}
| #include<bits/stdc++.h>
using namespace std;
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds ;
template <typename PB>
using ordered_set = tree<PB,null_type,less<PB>,rb_tree_tag,tree_order_statistics_node_update> ;
*/
#define Boost ios::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL)
#define all(cont) cont.begin(),cont.end()
#define rall(cont) cont.rbegin(),cont.rend()
#define foreach(cont) for(auto &val: cont)
#define dbg(args...) do { cerr << #args << "-> " ; show(args); } while(0); cerr<< endl ;
#define TS template < typename T >
#define TP template < typename F, typename S >
#define TM template<typename T1, typename... T2>
#define flush cin.ignore(numeric_limits<streamsize>::max(), '\n')
#define memz(cont) memset(cont, 0, sizeof cont)
#define memn(cont) memset(cont, -1, sizeof cont)
#define Case cout<< "Case "<< ++cs <<": "
#define PI 3.1415926535897932384
#define pf printf
#define sf scanf
#define mp make_pair
#define pb push_back
#define ff first
#define ss second
typedef long long ll ;
typedef unsigned long long ull ;
typedef pair <int, int> pii ;
/** Debugging Tool **/
TS void show(const T& v) { cerr << v << ' ' ;}
TM void show(const T1& first,const T2&... rest){show(first);show(rest...);}
TP ostream& operator<<(ostream& os,const pair<F,S>& p){return os<<"("<<p.ff<<", "<<p.ss<<")";}
TS ostream& operator<<(ostream& os,const vector<T>& v){os << "{"; typename vector< T >::const_iterator it;
for(it=v.begin();it!=v.end();it++){if( it != v.begin() )os<<", ";os<<*it;}return os<<"}";}
TS ostream& operator<<(ostream& os,const set<T>& v){os<<"[";typename set<T>::const_iterator it;
for(it=v.begin();it!=v.end();it++){if(it!=v.begin())os<<", ";os<<*it;}return os<<"]";}
TP ostream& operator<<(ostream& os,const map<F,S>& v){os<<"[";typename map<F,S>::const_iterator it;
for(it=v.begin();it!=v.end();it++){if(it!=v.begin())os<<", ";os<<it->ff<<" = "<<it->ss;}return os<<"]";}
/** Ends **/
const double eps = 1e-9 ;
/*
int const dr[] = { 0, 0, 1, -1, -1, -1, 1, 1 } ;
int const dc[] = { 1, -1, 0, 0, -1, 1, -1, 1 } ;
int const drH[] = { 2, 1, -1, -2, -2, -1, 1, 2 } ;
int const dcH[] = { 1, 2, 2, 1, -1, -2, -2, -1 } ;
*/
const ll mod = 998244353 ;
ll bigMod(ll a,ll p){
a %= mod ;
ll res = 1 ;
while(p!=0){
if(p&1) res = (res * a) %mod ;
a = (a*a) % mod ;
p >>= 1 ;
}
return res ;
}
void solve(){
ll n,mx=INT_MIN ;
bool flag = false ;
cin>> n ;
vector<ll> arr(n),cnt(n+5) ;
for(int i=0; i<n; i++){
cin>> arr[i] ;
ll val = arr[i] ;
mx = max(mx,val) ;
cnt[val]++ ;
if((i==0 && val!=0) || (i!=0 && val==0)) flag = true ;
}
ll ans = 1 ;
for(int i=1; i<=mx; i++)
ans = ((ans%mod)*bigMod(cnt[i-1],cnt[i])%mod) % mod ;
if(flag) cout<< "0\n" ;
else cout<< ans << "\n" ;
}
int main()
{
Boost;
int t = 1,cs = 0 ;
//cin>> t ;
while(t--){
//Case ;
solve() ;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pp;
typedef pair<ll,ll> pll;
void read(int& x){ scanf("%d",&x); }
void read(ll& x){ scanf("%lld",&x); }
template<typename T,typename... Args>
void read(T& a,Args&... b){ read(a); read(b...); }
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define eb emplace_back
#define x first
#define y second
int n, m;
int x, y;
int a[110][110];
char buf[110];
void in(){
read(n, m);
for(int i=1; i<=n; ++i){
scanf("%s", buf+1);
for(int j=1; j<=m; ++j){
a[i][j]=a[i-1][j]+a[i][j-1]-a[i-1][j-1];
if(buf[j] == 'o'){
++a[i][j];
} else if(buf[j] == 'E'){
x=i; y=j;
}
}
}
}
int dp[102][102][102][102];
int rect(int L1, int R1, int D1, int U1, int L2, int R2, int D2, int U2){
int L=max(L1, L2);
int R=min(R1, R2);
int D=max(D1, D2);
int U=min(U1, U2);
if(L>R || D>U) return 0;
if(0) printf("%d %d %d %d\n", L, R, D, U);
return a[R][U]-a[L-1][U]-a[R][D-1]+a[L-1][D-1];
}
int main()
{
in();
for(int w=1; w<=n; ++w){
for(int h=1; h<=m; ++h){
for(int l=1; l+w-1<=n; ++l){
int r=l+w-1;
if(x<l || r<x) continue;
for(int d=1; d+h-1<=m; ++d){
int u=d+h-1;
if(y<d || u<y) continue;
int me=dp[l][r][d][u];
auto f = [&](int A, int B, int C, int D){
int I=l+A;
int J=r+B;
int K=d+C;
int L=u+D;
int nv = rect(1+(r-x), n-(x-l), 1+(u-y), m-(y-d),
(A||B)?(A?I:J):(I),
(A||B)?(A?I:J):(J),
(C||D)?(C?K:L):(K),
(C||D)?(C?K:L):(L)
);
int& T=dp[I][J][K][L];
if(T < me+nv){
if(0) printf("upd from %d-%d, %d-%d to df %d %d %d %d : %d+%d = %d\n",
l,r,d,u, A,B,C,D, me, nv, me+nv);
}
T=max(T, me+nv);
};
if(1 < l) f(-1, 0, 0, 0);
if(r < n) f(0, 1, 0, 0);
if(1 < d) f(0, 0, -1, 0);
if(u < m) f(0, 0, 0, 1);
}
}
}
}
printf("%d\n", dp[1][n][1][m]);
return 0;
}
| #define _USE_MATH_DEFINES
#include <cstdio>
#include <iostream>
#include <sstream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <complex>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <limits>
#include <climits>
#include <cfloat>
#include <functional>
using namespace std;
// 累積和（2次元）
template <class T>
class cumulativeSum
{
private:
int ny, nx;
vector<vector<T> > sum;
public:
cumulativeSum(const vector<vector<T> >& a)
{
ny = a.size();
nx = a[0].size();
sum.assign(ny+1, vector<T>(nx+1, 0));
for(int i=0; i<ny; ++i){
for(int j=0; j<nx; ++j){
sum[i+1][j+1] = a[i][j] + sum[i][j+1] + sum[i+1][j] - sum[i][j];
}
}
}
T getSum(int y1, int x1, int y2, int x2)
{
y1 = max(y1, 0);
x1 = max(x1, 0);
y2 = min(y2, ny-1);
x2 = min(x2, nx-1);
if(y1 > y2 || x1 > x2)
return 0;
return sum[y2+1][x2+1] - sum[y1][x2+1] - sum[y2+1][x1] + sum[y1][x1];
}
};
int main()
{
int h, w;
cin >> h >> w;
vector<vector<int> > s(h, vector<int>(w, 0));
int ey, ex;
for(int y=0; y<h; ++y){
for(int x=0; x<w; ++x){
char c;
cin >> c;
if(c == 'E'){
ey = y;
ex = x;
}
else if(c == 'o'){
s[y][x] = 1;
}
}
}
cumulativeSum<int> cs(s);
int up = ey;
int down = h - 1 - ey;
int left = ex;
int right = w - 1 - ex;
vector<vector<vector<vector<int> > > > dp(up+1, vector<vector<vector<int> > >(down+1, vector<vector<int> >(left+1, vector<int>(right+1, 0))));
int ans = 0;
for(int u=0; u<=up; ++u){
for(int d=0; d<=down; ++d){
for(int l=0; l<=left; ++l){
for(int r=0; r<=right; ++r){
ans = max(ans, dp[u][d][l][r]);
int y1 = max(ey - u, d);
int y2 = min(ey + d, h - 1 - u);
if(ex - 1 - l >= r)
dp[u][d][l+1][r] = max(dp[u][d][l+1][r], dp[u][d][l][r] + cs.getSum(y1, ex - 1 - l, y2, ex - 1 - l));
if(ex + 1 + r <= w - 1 - l)
dp[u][d][l][r+1] = max(dp[u][d][l][r+1], dp[u][d][l][r] + cs.getSum(y1, ex + 1 + r, y2, ex + 1 + r));
int x1 = max(ex - l, r);
int x2 = min(ex + r, w - 1 - l);
if(ey - 1 - u >= d)
dp[u+1][d][l][r] = max(dp[u+1][d][l][r], dp[u][d][l][r] + cs.getSum(ey - 1 - u, x1, ey - 1 - u, x2));
if(ey + 1 + d <= h - 1 - u)
dp[u][d+1][l][r] = max(dp[u][d+1][l][r], dp[u][d][l][r] + cs.getSum(ey + 1 + d, x1, ey + 1 + d, x2));
}
}
}
}
cout << ans << endl;
return 0;
} | 1 |
#include <iostream>
#include <cstring>
using namespace std;
int main()
{
int n, i, j, k, c, x;
char s[1001], r[1001], t[8] = "Hoshino";
cin >> n;
cin.ignore(1024, '\n');
for (i = 0; i < n; i++)
{
cin.getline(s, sizeof(s));
c = 0;
for (j = 0; j < strlen(s); j++)
{
r[c] = s[j];
c++;
if (s[j] == 'H')
{
for (k = j+1, x = 0; k < j+7; k++, c++)
{
if (s[k] == t[k-j])
{
if (k == j+6)
r[c] = 'a';
else
r[c] = t[k-j];
x++;
}
else
{
r[c] = s[k];
break;
}
}
j+=x;
}
}
r[strlen(s)] = '\0';
cout << r << endl;
}
} | #include <iostream>
#include <iomanip>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
using namespace std;
int main() {
int n;
string str;
getline(cin, str);
n = atoi(str.c_str());
for (int i = 0; i < n; i++) {
getline(cin, str);
while (1) {
size_t pos = str.find("Hoshino");
if (pos == string::npos)
break;
str.replace(pos, 7, "Hoshina");
}
cout << str << endl;
}
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
uint N;
long long x;
cin >> N >> x;
vector<long long> a(N, 0);
long long sum = 0;
for (auto &c: a) {
cin >> c;
sum += c;
}
if (sum < x) {
cout << a.size() - 1 << endl;
}
else if (sum == x) {
cout << a.size() << endl;
}
// sum > x
else {
sort(a.begin(), a.end());
int numHappy = 0;
for (size_t i=0; i<a.size(); ++i) {
x -= a[i];
if (x >= 0) ++numHappy;
else break;
}
cout << numHappy << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
const int64_t MOD = 1000000007;
typedef int64_t ll;
typedef uint64_t ull;
#define FOR(i, start, end) for(uint64_t i=start; i<end; i++)
#define REP(i, n) FOR(i, 0, n)
// 最大公約数gcd
// 最小公倍数lcm=m*n/gcd
uint64_t gcd(uint64_t m, uint64_t n) {
uint64_t temp;
while (m % n != 0){
temp = n;
n = m % n;
m = temp;
}
return n;
}
uint64_t lcm(uint64_t m, uint64_t n) {
return (m*n)/gcd(m,n);
}
// vector<vector<uint64_t> > v(n+1, vector<uint64_t>(n+1, 0))
// v[n][k]に組み合わせ数が入る。
void comb(vector<vector <uint64_t> > &v){
for(uint64_t i = 0;i <v.size(); i++){
v[i][0]=1;
v[i][i]=1;
}
for(uint64_t k = 1;k <v.size();k++){
for(uint64_t j = 1;j<k;j++){
v[k][j]=(v[k-1][j-1]+v[k-1][j]);
}
}
}
// 掛け算オーバーフロー判定
bool is_product_overflow(uint64_t a, uint64_t b) {
uint64_t prod = a * b;
return (prod / b != a);
}
//素因数分解
void primeFactorization(uint64_t a, list<uint64_t> &factors){ //素因数分解を出力するプログラム
long i,sq;
if(a%2==0){ //偶数の場合
factors.push_back(2);
primeFactorization(a/2,factors); //2で割った値で再帰
return;
}
sq = sqrt(a);
for(i=3;i<=sq;i+=2){ //3以上√a以下の奇数の場合
if(a%i==0){
factors.push_back(i);
primeFactorization(a/i,factors); //割れた値で再帰
return;
}
}
//偶数でも3以上√a以下の奇数の場合でも割り切れない場合
if(a!=1){ //aが1でないなら、a自身は素数
factors.push_back(a);
}
}
// フェルマーの小定理
// mod. m での a の逆元 a^{-1} を計算する
// (a/b)%m = a*movinv(b,m)%m
int64_t modinv(int64_t a, int64_t m) {
int64_t b = m, u = 1, v = 0;
while (b) {
int64_t t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
// 円周率
// M_PI
// #include <iomanip> // setprecisionを使用するのに必要
// cout << std::fixed << std::setprecision(15) << y << endl;
// 昇順
// priority_queue<int, vector<int>, greater<int> > queue;
ll pCount(int x){
if(x==0) return 1;
return pCount(x-1)*2 + 1;
}
ll allCount(int x){
if(x==0) return 1;
return allCount(x-1)*2 + 3;
}
signed main() {
int h,w;
cin >> h >> w;
vector< vector<int> > a(h,vector<int>(w));
for(int y=0;y<h;y++){
for(int x=0;x<w;x++){
cin >> a[y][x];
}
}
int count = 0;
vector<string> outStrV;
for(int y=0;y<h;y++){
for(int x=0;x<w;x++){
if(a[y][x]%2==1){
if(x<w-1){
outStrV.push_back(
to_string(y+1) + " " + to_string(x+1)
+ " " + to_string(y+1) + " " + to_string(x+2) );
a[y][x]--;a[y][x+1]++;
}
else if(y<h-1){
outStrV.push_back(
to_string(y+1) + " " + to_string(x+1)
+ " " + to_string(y+2) + " " + to_string(x+1) );
a[y][x]--;a[y+1][x]++;
}
}
}
}
cout << outStrV.size() << endl;
for(auto s:outStrV){
cout << s << endl;
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pi 3.141592653589793238
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define MOD 1000000007
int main()
{
fast;
ll arr[5],k;
for(int i=0;i<5;i++)
cin>>arr[i];
cin>>k;
if(arr[4]-arr[0]>k)
{
cout<<":(";
return 0;
}
else
{
for(int i=0;i<5;i++)
for(int j=i+1;j<5;j++)
if(arr[j]-arr[i]>k)
{
cout<<":(";
return 0;
}
}
cout<<"Yay!";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
int main() {
ios:: sync_with_stdio(false);
cin.tie();
int x;
cin >> x;
int mi = x;
int mx = x;
for (int i = 0; i < 4; i++) {
cin >> x;
mi = min(mi, x);
mx = max(mx, x);
}
int k;
cin >> k;
cout << ((mx - mi) <= k ? "Yay!" : ":(");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
//#define f(i,a,n) for(ll i=a;i<n;i++)
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
ll isPrime(int n)
{
// Corner cases
if (n <= 1)
return 1;
if (n <= 3)
return 2;
// This is checked so that we can skip
// middle five numbers in below loop
if (n % 2 == 0 || n % 3 == 0)
return 1;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return 1;
return 2;
}
ll fact(ll n){ll res = 1;for (ll i = 2; i <= n; i++)res = res * i,res%=1000000007;
return res; }
int main()
{
fast;
ll t=1;
//cin>>t;
while(t--)
{
ll n,k,sum=0;
cin>>n>>k;
ll A[n];
for(ll i=0;i<n;i++)
{
cin>>A[i];
}
sort(A,A+n);
for(ll i=0;i<k;i++)
{
sum=sum+A[n-1-i];
}
cout<<sum;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
template<typename T>
void out(T x) { cout << x << endl; exit(0); }
#define watch(x) cout << (#x) << " is " << (x) << endl
using ll = long long;
const ll mod = 1e9+7;
const int maxn = 1e6 + 5;
void add(ll& x, ll y) {
if (x>=mod) x%=mod;
if (y>=mod) y%=mod;
x += y;
if (x>=mod) x%=mod;
}
int n, x;
int a[maxn];
const int N = 1e5;
int main() {
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin>>n>>x;
for (int i=0; i<n; i++) {
cin>>a[i];
}
sort(a,a+n);
reverse(a,a+n);
vector<ll> dp(N+10, 0);
dp[x] = 1;
for (int i=0; i<n; i++) {
vector<ll> _dp(N+10);
for (int x=0; x<=N; x++) {
if (dp[x]==0) continue;
// use a[i]
add(_dp[x%a[i]], dp[x]);
// don't use a[i]
add(_dp[x], 1ll*(n-i-1)*dp[x]%mod);
}
swap(_dp, dp);
}
ll res = 0;
for (int x=0; x<=N; x++) {
add(res, 1ll*x*dp[x]);
}
cout<<res<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N, M;
int tr[21][21];
while(true){
scanf("%d", &N);
if(N == 0) break;
for(int i = 0; i <= 20; i++){
fill(tr[i], tr[i] + 21, 0);
}
for(int i = 0; i < N; i++){
int x, y;
scanf("%d%d", &x, &y);
tr[x][y] = 1;
}
scanf("%d", &M);
int cnt = 0;
int rx = 10, ry = 10;
for(int i = 0; i < M; i++){
char d; int s;
scanf(" %c%d", &d, &s);
int dx, dy;
if(d == 'N'){
dx = 0, dy = 1;
}else if(d == 'E'){
dx = 1, dy = 0;
}else if(d == 'S'){
dx = 0, dy = -1;
}else{
dx = -1, dy = 0;
}
while(s--){
rx += dx;
ry += dy;
if(tr[rx][ry] == 1){
tr[rx][ry] = 0;
cnt += 1;
}
}
}
if(cnt == N){
puts("Yes");
}else{
puts("No");
}
}
return 0;
} | #include <stdio.h>
typedef struct _Gem{
int x;
int y;
bool hit;
} Gem;
static void
pick_gem(Gem* g, int n, int x, int y)
{
for (int i = 0; i < n; i++) {
if (!g[i].hit && g[i].x == x && g[i].y == y) {
g[i].hit = true;
return;
}
}
}
static bool
check_gem(Gem* g, int n)
{
for (int i = 0; i < n; i++) {
if (g[i].hit == false) {
return false;
}
}
return true;
}
int
main(void)
{
char line[80];
int n;
int m;
Gem g[20];
char d[30];
int l[30];
while (true) {
if (fgets(line, sizeof line, stdin) == NULL) {
return 1;
}
if (sscanf(line, "%d", &n) != 1) {
return 1;
}
if (n == 0) {
break;
}
for (int i = 0; i < n; i++) {
if (fgets(line, sizeof line, stdin) == NULL) {
return 1;
}
if (sscanf(line, "%d %d", &(g[i].x), &(g[i].y)) != 2) {
return 1;
}
g[i].hit = false;
}
if (fgets(line, sizeof line, stdin) == NULL) {
return 1;
}
if (sscanf(line, "%d", &m) != 1) {
return 1;
}
for (int i = 0; i < m; i++) {
if (fgets(line, sizeof line, stdin) == NULL) {
return 1;
}
if (sscanf(line, "%c %d", &(d[i]), &(l[i])) != 2) {
return 1;
}
}
int x = 10;
int y = 10;
for (int i = 0; i < m; i++) {
if (d[i] == 'N') {
for (int k = 1; k <= l[i]; k++) {
pick_gem(g, n, x, ++y);
}
} else if (d[i] == 'S') {
for (int k = 1; k <= l[i]; k++) {
pick_gem(g, n, x, --y);
}
} else if (d[i] == 'E') {
for (int k = 1; k <= l[i]; k++) {
pick_gem(g, n, ++x, y);
}
} else {
for (int k = 1; k <= l[i]; k++) {
pick_gem(g, n, --x, y);
}
}
}
printf("%s\n", (check_gem(g, n) ? "Yes" : "No"));
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
#define rep(i, n) for(ll i = 0; i < ll(n); i++)
ll div_2(ll a) {
ll ans = 0;
while(a % 2 == 0) {
ans++;
a /= 2;
}
return ans;
}
int main() {
int N;
cin >> N;
vector<ll> A(N);
ll min = 1000000000;
rep(i, N) {
cin >> A[i];
if(min > div_2(A[i])) {
min = div_2(A[i]);
}
}
cout << min << endl;
}
| #include "bits/stdc++.h"
using namespace std;
using ll = long long;
#define Rep(i, n) for (int i = 0; i < (int)(n); i++)
#define BitRep(i, n) for (int i = 0; i < (int)(1 << n); i++)
#define All(vec) vec.begin(), vec.end()
#define Sum(vec) accumulate(vec.begin(), vec.end(), 0)
#define Sort(vec) sort(vec.begin(), vec.end())
#define Reverse(vec) reverse(vec.begin(), vec.end())
#define Next_permutation(vec) next_permutation(vec.begin(), vec.end())
#define PI acos(-1)
int main() {
int N;
cin >> N;
vector<int> A(N);
Rep(i, N) cin >> A[i];
Sort(A);
int index = A.size() - 1;
ll e1 = 0, e2 = 0;
while (index >= 1) {
if (A[index] == A[index - 1]) {
e1 = A[index];
index -= 2;
break;
}
index--;
}
while (index >= 1) {
if (A[index] == A[index - 1]) {
e2 = A[index];
break;
}
index--;
}
cout << e1 * e2 << endl;
return 0;
} | 0 |
#define _CRT_SECURE_NO_WARNINGS
#pragma comment(linker, "/STACK:108777216")
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <string>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <vector>
#include <bitset>
#include <queue>
#include <deque>
#include <utility>
#include <algorithm>
#include <ctime>
using namespace std;
int const MAX_N = 128;
int const MX_CNT = 2200000;
double x[MAX_N], y[MAX_N];
int cnt[MAX_N];
int main() {
//freopen("input.txt","r",stdin);
//freopen("output.txt","w",stdout);
int n;
cin>>n;
for (int i=0; i<n; i++) cin>>x[i]>>y[i];
double R = 1e11;
double ang_part = R / MX_CNT;
int sum = 0;
for (int i=0; i<MX_CNT; i++) {
double xx = R*cos(ang_part*i);
double yy = R*sin(ang_part*i);
double mn_val = 1e150;
int mn_ind = -1;
for (int j=0; j<n; j++) {
double val = (xx - x[j])*(xx - x[j]) + (yy - y[j])*(yy - y[j]);
if (val < mn_val) {
mn_val = val;
mn_ind = j;
}
}
cnt[mn_ind]++;
sum++;
}
for (int i=0; i<n; i++) printf("%.6lf\n",cnt[i]/((double) sum));
return 0;
} | #include <bits/stdc++.h>
#include <cmath>
using namespace std;
struct point{
int x, y;
}w[110];
int n;
double P[210];
const double PI = acos(-1.0);
int main()
{
cin >> n;
for(int i = 1; i <= n; i++)
{
cin >> w[i].x >> w[i].y;
}
for(int i = 1; i <= n; i++)
{
int cnt = 0;
for(int j = 1; j <= n; j++)
{
if(i == j) continue;
P[cnt++] = atan2(w[j].y - w[i].y, w[j].x - w[i].x);
}
sort(P, P+cnt);
for(int j = 0; j < cnt; j++) P[j + cnt] = P[j]+2* PI;
double res = 0.0;
for(int j = 0; j < cnt; j++) {
res = max(res, PI - P[j + cnt - 1] + P[j]);
}
printf("%.10f\n", res/(2*PI));
}
return 0;
} | 1 |
#include <iostream>
#include <cstdint>
#include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cctype>
#include <cassert>
#include <climits>
#include <string>
#include <bitset>
#include <cfloat>
#include <unordered_set>
#pragma GCC optimize("Ofast")
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
typedef vector<vector<ll>> vvll;
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define rrep(i, n) for (ll i = 1; i <= (n); ++i)
#define irep(it, stl) for (auto it = stl.begin(); it != stl.end(); it++)
#define drep(i, n) for (ll i = (n)-1; i >= 0; --i)
#define mes(a) cout << (a) << endl
#define dmes(a, b) cout << (a) << " " << (b) << endl
#define re0 return 0
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define rSort(a) sort(a.rbegin(), a.rend())
#define Rev(a) reverse(a.begin(), a.end())
#define MATHPI acos(-1)
#define itn int
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
template <class T>
inline bool chmax(T &a, T b)
{
if (a < b)
{
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T &a, T b)
{
if (a > b)
{
a = b;
return 1;
}
return 0;
}
struct io
{
io()
{
ios::sync_with_stdio(false);
cin.tie(0);
}
};
const int INF = INT_MAX;
const ll LLINF = 1LL << 60;
const ll MOD = 1000000007;
const double EPS = 1e-19;
signed main() {
ll n;
cin >> n;
string s;
cin >> s;
vi s2(n);
ll r = 0;
ll g = 0;
ll b = 0;
ll ans = 0;
rep(i, n) {
if (s[i] == 'R') {
r++;
s2[i] = 1;
}
if (s[i] == 'G') {
g++;
s2[i] = 2;
}
if (s[i] == 'B') {
b++;
s2[i] = 4;
}
}
ans = r*g*b;
rep(i, n) {
for (int j = 1; j < n; j++) {
if (i+j >= n || i+2*j >= n) continue;
if (s2[i] + s2[i+j] + s2[i+2*j] == 7) ans--;
}
}
mes(ans);
} | #include<iostream>
#include<string>
using namespace std;
int main()
{
char s[5000];
long long n,i,j,k,total=0,red[5000]={0},green[5000]={0},blue[5000]={0},r=0,g=0,b=0,x,y;
cin>>n;
for(i=1;i<=n;i++)
{
cin>>s[i];
}
for(i=1;i<=n;i++)
{
if(s[i]=='R')
{
r++;
red[i]=red[i-1]+1;
blue[i]=blue[i-1];
green[i]=green[i-1];
}
else if(s[i]=='G')
{
g++;
green[i]=green[i-1]+1;
red[i]=red[i-1];
blue[i]=blue[i-1];
}
else if(s[i]=='B')
{
b++;
blue[i]=blue[i-1]+1;
red[i]=red[i-1];
green[i]=green[i-1];
}
}
for(i=1;i<=n;i++)
{
for(j=i+1;j<=n;j++)
{
if((s[i]=='R'&&s[j]=='G')||(s[i]=='G'&&s[j]=='R'))
{
x=b-blue[j];
y=(j-i)+j;
if(s[y]=='B'&&x>0&&y<=n)
{
x--;
}
if(x>0)
{
total=total+x;
}
}
else if((s[i]=='R'&&s[j]=='B')||(s[i]=='B'&&s[j]=='R'))
{
x=g-green[j];
y=(j-i)+j;
if(s[y]=='G'&&x>0&&y<=n)
{
x--;
}
if(x>0)
{
total=total+x;
}
}
else if((s[i]=='B'&&s[j]=='G')||(s[i]=='G'&&s[j]=='B'))
{
x=r-red[j];
y=(j-i)+j;
if(s[y]=='R'&&x>0&&y<=n)
{
x--;
}
if(x>0)
{
total=total+x;
}
}
}
}
cout<<total<<endl;
return 0;
} | 1 |
#include<iostream>
#include<string>
using namespace std;
string map[20]={""};
void check(int x,int y);
int main(void){
while(1){
int ans=0;
for(int i=0;i<12;i++){
cin>>map[i];
if(cin.eof())goto end;
}
for(int i=0;i<12;i++){
for(int j=0;j<12;j++){
if(map[i][j]=='1'){
check(i,j);
ans++;
}
}
}
cout<<ans<<endl;
}
end:;
return 0;
}
void check(int x,int y){
map[x][y]='0';
if(x!=11&&map[x+1][y]=='1')check(x+1,y);
if(y!=11&&map[x][y+1]=='1')check(x,y+1);
if(x!=0&&map[x-1][y]=='1')check(x-1,y);
if(y!=0&&map[x][y-1]=='1')check(x,y-1);
return;
} | #include <array>
#include <cstdlib>
#include <iostream>
#include <string>
#include <queue>
#include <vector>
class SSF {
private:
void ScanLine(std::vector<std::string> *map, const char lx, const char rx, const char y, const char oy, std::array<std::queue<char>, 4> *buffer) {
unsigned char i = lx;
while (i <= rx) {
while (i < rx) {
if (map->at(y).at(i) != '0') {
break;
}
++i;
}
if (map->at(y).at(i) == '0') {
break;
}
buffer->at(0).push(i);
while (i <= rx) {
if (map->at(y).at(i) == '0') {
break;
}
++i;
}
buffer->at(1).push(i - 1);
buffer->at(2).push(y);
buffer->at(3).push(oy);
}
return;
}
public:
unsigned char SeedFill(std::vector<std::string> *map, const unsigned char x, const unsigned char y) {
std::array<std::queue<char>, 4> buffer;
unsigned char lx, rx, ly, oy;
if (map->at(y).at(x) == '0' || map->empty() == true) {
return 0;
}
buffer.at(0).push(x);
buffer.at(1).push(x);
buffer.at(2).push(y);
buffer.at(3).push(y);
while (buffer.front().empty() == false) {
char lxsav = buffer.at(0).front() - 1, rxsav = buffer.at(1).front() + 1;
lx = buffer.at(0).front();
buffer.at(0).pop();
rx = buffer.at(1).front();
buffer.at(1).pop();
ly = buffer.at(2).front();
buffer.at(2).pop();
oy = buffer.at(3).front();
buffer.at(3).pop();
if (map->at(ly).at(lx) == '0') {
continue;
}
while (rx < map->at(ly).size() - 1) {
if (map->at(ly).at(rx + 1) == '0') {
break;
}
++rx;
}
while (lx > 0) {
if (map->at(ly).at(lx - 1) == '0') {
break;
}
--lx;
}
for (unsigned char i = lx; i <= rx; ++i) {
map->at(ly).at(i) = '0';
}
if (ly - 1 >= 0) {
if (ly - 1 == oy) {
ScanLine(map, lx, lxsav, ly - 1, ly, &buffer);
ScanLine(map, rxsav, rx, ly - 1, ly, &buffer);
}
else {
ScanLine(map, lx, rx, ly - 1, ly, &buffer);
}
}
if (ly + 1 <= map->size() - 1) {
if (ly + 1 == oy) {
ScanLine(map, lx, lxsav, ly + 1, ly, &buffer);
ScanLine(map, rxsav, rx, ly + 1, ly, &buffer);
}
else {
ScanLine(map, lx, rx, ly + 1, ly, &buffer);
}
}
}
return 1;
}
};
int main() {
while (1) {
SSF ssf;
std::vector<std::string> map;
unsigned short count = 0;
do {
map.resize(count + 1);
std::getline(std::cin, map.at(count));
if (map.at(count).empty() == true) {
std::getline(std::cin, map.at(count));
if (map.at(count).empty() == true) {
return EXIT_SUCCESS;
}
}
map.at(count).resize(map.front().size(), '0');
map.at(count).shrink_to_fit();
} while (++count < map.front().size());
map.shrink_to_fit();
count = 0;
for (unsigned char j = 0; j < map.size(); ++j) {
for (unsigned char i = 0; i < map.at(j).size(); ++i) {
count += ssf.SeedFill(&map, i, j);
}
}
std::cout << count << std::endl;
}
return EXIT_SUCCESS;
} | 1 |
#include <iostream>
#include <cmath>
using namespace std;
int main() {
double x[2]{}, y[2]{}, distance{};
cin >> x[0] >> y[0] >> x[1] >> y[1];
distance = sqrt(pow(x[0] - x[1], 2) + pow(y[0] - y[1], 2));
cout << fixed << distance;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if (A == B && B == C) cout << "No" << endl;
else if (A == B || B == C || C == A) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
| 0 |
#include <cstdio>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;
size_t ldistance(string s, string t) {
/* Levenshtein Distance */
size_t slen=s.length(), tlen=t.length();
vector<vector<size_t>> dp(slen+1, vector<size_t>(tlen+1));
for (size_t i=0; i<=slen; ++i)
dp[i][0] = i;
for (size_t j=0; j<=tlen; ++j)
dp[0][j] = j;
for (size_t i=1; i<=slen; ++i)
for (size_t j=1; j<=tlen; ++j) {
size_t cost=(s[i-1]!=t[j-1]);
dp[i][j] = min(min(dp[i-1][j], dp[i][j-1])+1, dp[i-1][j-1]+cost);
}
return dp[slen][tlen];
}
int main() {
char buf[1024];
scanf("%s", buf);
string s1(buf);
scanf("%s", buf);
string s2(buf);
printf("%zu\n", ldistance(s1, s2));
return 0;
} | #include<iostream>
#include<map>
#include<vector>
#include<algorithm>
#include<cmath>
#include<climits>
#include<ctime>
#include<cstring>
#include<stack>
#include<queue>
#include<sstream>
#include<string>
#include<set>
#include<array>
#include<cassert>
#define ALL(v) (v).begin(),(v).end()
#define REP(i,p,n) for(int i=p;i<(int)(n);++i)
#define rep(i,n) REP(i,0,n)
#define DUMP(list) cout << "{ "; for(auto nth : list){ cout << nth << " "; } cout << "}" << endl
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i);
using namespace std;
int dp[1001][1001];//from,to
const int INF=1<<28;
int main(){
string from,to;
cin >> from >> to;
fill_n((int *)dp,sizeof(dp)/sizeof(int),0);
rep(i,from.size()+1) dp[0][i]=i;
rep(i,to.size()+1) dp[i][0]=i;
for(int i=1;i<=to.size();i++){
for(int j=1;j<=from.size();j++){
if(to[i-1]==from[j-1]){
dp[i][j] = min(dp[i-1][j] + 1, min(dp[i][j-1] + 1, dp[i-1][j-1] + 0));
}else{
dp[i][j] = min(dp[i-1][j] + 1, min(dp[i][j-1] + 1, dp[i-1][j-1] + 1));
}
}
}
cout << dp[to.size()][from.size()] << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> x(3);
int k, y;
for(int i=0;i<3;i++) cin >> x.at(i);
cin >> k;
sort(x.begin(), x.end());
y = x.at(2);
for(int i=0;i<k;i++) y = 2*y;
cout << x.at(0) + x.at(1) + y << endl;
}
| #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++)
int main() {
int mod=1000000007;
int n;
cin >> n;
long to=0;
vector<int>a(n);
vector<int>b(n);
vector<int>c(n);
rep(i,n){
cin>>a.at(i)>>b.at(i);
to-=b.at(i);
c.at(i)=a.at(i)+b.at(i);
}
sort(c.begin(),c.end());
reverse(c.begin(),c.end());
rep(i,(n-1)/2+1){
to+=c.at(i*2);
}
cout<<to<<endl;
} | 0 |
#include<bits/stdc++.h>
#define F(i,a,b) for(int i=(a);i<=(b);++i)
int n,x[101],y[101];
const double PI=acos(-1);
double k[101];
int main(){
scanf("%d",&n);
if(n==2){puts("0.5\n0.5");return 0;}
F(i,1,n) scanf("%d%d",x+i,y+i);
F(i,1,n){
int cnt=0;
F(j,1,n) if(j!=i){
k[++cnt]=atan2(x[j]-x[i],y[j]-y[i]);
}
std::sort(k+1,k+cnt+1);
double t;
t=k[1]-k[cnt]+PI+PI;
if(t>=PI) {printf("%.15lf\n",(t-PI)/(PI+PI)); continue;}
bool ok=0;
F(j,1,cnt-1){
t=k[j+1]-k[j];
if(t>=PI) {printf("%.15lf\n",(t-PI)/(PI+PI)); ok=1; break;}
} if(!ok) printf("%.15lf\n",0.);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep2(i, x, n) for(int i = x; i <= n; i++)
#define rep3(i, x, n) for(int i = x; i >= n; i--)
#define elif else if
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
const ll MOD = 1e9+7;
const ll MOD2 = 998244353;
const ll INF = LLONG_MAX;
const string alpha = "abcdefghijklmnopqrstuvwxyz";
//点a,bの距離の2乗
ld dist2(pdd a, pdd b){
ld x = b.first - a.first;
ld y = b.second - a.second;
return x*x + y*y;
}
//点a,bの距離
ld dist(pdd a, pdd b){
return sqrt(dist2(a, b));
}
//内積a・b
ld dot(pdd a, pdd b){
ld x = a.first * b.first;
ld y = a.second * b.second;
return x+y;
}
//a,bを横に並べた行列の行列式
ld det(pdd a, pdd b){
ld x = a.first * b.second;
ld y = a.second * b.first;
return x-y;
}
//b-a
pdd dif(pdd a, pdd b){
pdd p;
p.first = b.first - a.first;
p.second = b.second - a.second;
return p;
}
//点a,bの中点
pdd mid(pdd a, pdd b){
pdd p;
p.first = (a.first + b.first)/2;
p.second = (a.second + b.second)/2;
return p;
}
int main(){
int N;
cin >> N;
pdd p[N];
map<pdd, int> mp;
rep(i, N){
cin >> p[i].first >> p[i].second;
mp[p[i]] = i;
}
sort(p, p+N);
pdd q[N+1];
int k = 1;
q[0] = p[0];
rep2(i, 1, N-1){
if(i < N-1 && p[i-1].first == p[i].first) continue;
while(k > 1 && det(dif(q[k-1], p[i]), dif(q[k-1], q[k-2])) <= 0) k--;
q[k] = p[i], k++;
}
int t = k;
rep3(i, N-2, 0){
if(i > 0 && p[i+1].first == p[i].first) continue;
while(k > t && det(dif(q[k-1], p[i]), dif(q[k-1], q[k-2])) <= 0) k--;
q[k] = p[i], k++;
}
k--;
ld ans[N];
fill_n(ans, N, 0);
ld pi = 3.141592653589793238;
rep(i, k){
int j = (k+i-1)%k, l = (i+1)%k;
pdd x[2];
x[0] = mid(q[i], q[j]);
x[1] = mid(q[i], q[l]);
ld r[3], R[3];
rep(a, 2){
r[a] = dist(q[i], x[a]);
R[a] = dist2(q[i], x[a]);
}
r[2] = dist(x[0], x[1]);
R[2] = dist2(x[0], x[1]);
ld cos = -(R[0]+R[1]-R[2])/(2*r[0]*r[1]);
if(cos > 1) cos = 1;
elif(cos < -1) cos = -1;
ld the = acos(cos);
int n = mp[q[i]];
ans[n] = the/(2*pi);
}
rep(i, N) cout << setprecision(15) << ans[i] << endl;
} | 1 |
#include <iostream>
using namespace std;
int main(){
int l[10];
int v[2];
while(scanf("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d", &l[0], &l[1],
&l[2], &l[3], &l[4], &l[5], &l[6], &l[7], &l[8], &l[9], &v[0], &v[1]) != EOF){
double sum = 0.0;
int i;
for(i=0; i<10; ++i) sum += l[i];
double l1 = sum * v[0] / (v[0] + v[1]);
sum = 0.0;
for(i=0; i<10; ++i){
sum += l[i];
if(l1 <= sum) break;
}
cout << i+1 << endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long llint;
typedef long double ld;
#define inf 1e18
#define mod 1000000007
priority_queue<llint,vector<llint>,greater<llint> > que;
priority_queue<llint> q;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
void solve(){
llint n,a,b;
cin >> n >> a >> b;
vector<llint>x(n);
for(int i=0;i<n;i++)cin >> x[i];
llint ans=0;
for(int i=1;i<n;i++){
ans+=min((x[i]-x[i-1])*a,b);
}
cout << ans << endl;
}
int main(int argc, char *argv[]) {
solve();
return 0;
}
| 0 |
#include<cstdio>
int main(){
int n;
scanf("%d",&n);
for(int i=0;i<n;i++){
int point=0;
int base=0;
int out=0;
while(out!=3){
char s[8];
scanf(" %s",s);
switch(s[1]){
case 'I':
base++;
if(base==4){
point++;
base--;
}
break;
case 'U':
out++;
break;
case 'O':
point+=base+1;
base=0;
break;
}
}
printf("%d\n",point);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,n)for(int i=0;i<(n);i++)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define pb push_back
using ll = long long;
using P = pair<int, int>;
int main(){
int n; cin >> n;
vector<int> A;
A.push_back(0);
rep(i,n){
int a; cin >> a;
A.push_back(a);
}
A.push_back(0);
int sum = 0;
rep(i,n+1) sum += abs(A[i+1] - A[i]);
for(int i = 1; i <= n; i++){
int ans = sum;
ans -= abs(A[i] - A[i-1]);
ans -= abs(A[i+1] - A[i]);
ans += abs(A[i+1] - A[i-1]);
cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
#define assem99 ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define ll long long
#define ld long double
#define endll '\n'
#define sz(a) (int)(a).size()
#define RWFile freopen("input.txt","r",stdin); freopen("output.txt","w",stdout);
int dx[] = { 0, -1, 0, 1, -1, 1, -1, 1 };
int dy[] = { -1, 0, 1, 0, 1, -1, -1, 1 };
const int MOD = 1e9 + 7, N = 2e6 + 5, oo = 1e9;
const double pi = acos(-1);
using namespace std;
int main()
{
assem99
int n, m; cin>>n>>m;
ll ans = 0, cnt = 1, sum = 0;
map<int, int> freq;
freq[0] = 1;
for(int i = 0; i < n; i++)
{
ll a; cin>>a;
sum += a;
sum %= m;
ans += freq[sum]++;
}
cout<<ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int,int> P;
int INF = 1e18;
int mod = 1e9+7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
signed main() {
int N,M;
cin >> N >> M;
vector<int>A(N+1);
for(int i = 1; i <= N; i++) {
cin >> A[i];
A[i] += A[i-1];
A[i]%=M;
}
sort(A.begin(),A.end());
int ans = 0;
int cnt = 1;
for(int i = 1; i <= N; i++) {
if(A[i] == A[i-1]) {
cnt++;
}
else {
ans += cnt*(cnt-1)/2;
cnt = 1;
}
}
ans += cnt*(cnt-1)/2;
cout << ans << endl;
} | 1 |
#include<iostream>
using namespace std;
typedef long long ll;
const int MAX_N = 303;
const int MAX_A = 303;
const ll MOD = 998244353;
ll A[MAX_N], dp[MAX_N][MAX_N * MAX_A], sub_dp[MAX_N][MAX_N * MAX_A];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
ll sum = 0;
for (int i = 1; i <= N; i++) {
cin >> A[i];
sum += A[i];
}
// main
dp[0][0] = 1;
for (int i = 1; i <= N; i++) {
for (int j = 0; j <= sum; j++) {
dp[i][j] = (dp[i][j] + (dp[i - 1][j] * 2) % MOD) % MOD;
if (j - A[i] >= 0) dp[i][j] = (dp[i][j] + dp[i - 1][j - A[i]]) % MOD;
}
}
// sub
sub_dp[0][0] = 1;
for (int i = 1; i <= N; i++) {
for (int j = 0; j <= sum; j++) {
sub_dp[i][j] = (sub_dp[i][j] + sub_dp[i - 1][j]) % MOD;
if (j - A[i] >= 0) sub_dp[i][j] = (sub_dp[i][j] + sub_dp[i - 1][j - A[i]]) % MOD;
}
}
ll not_ans = (MOD - (sum % 2 == 0 ? sub_dp[N][sum / 2] : 0)) % MOD;
for (int i = (sum + 1) / 2; i <= sum; i++) {
not_ans = (not_ans + dp[N][i]) % MOD;
}
ll ans = 1;
for (int i = 0; i < N; i++) ans = (ans * 3) % MOD;
cout << (ans - (3 * not_ans) % MOD + MOD) % MOD << endl;
return 0;
} | #include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int mod=998244353;
#define N 321
inline int read(){
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9'){
if(c=='-')f=-1;
c=getchar();
}
while(c>='0'&&c<='9'){
x=(x<<1)+(x<<3)+c-'0';
c=getchar();
}
return x*f;
}
int n,a[N],dp[N*N],sum,ans;
int main(){
n=read();
ans=1;
for(int i=1;i<=n;++i){
a[i]=read();
ans=3LL*ans%mod;
}
dp[0]=1;
for(int i=1;i<=n;++i){
sum+=a[i];
for(int j=sum;j>=0;--j){
(dp[j]<<=1)%=mod;
if(j>=a[i])dp[j]=(dp[j]+dp[j-a[i]])%mod;
}
}
for(int i=sum;sum-i<=i;--i){
ans=(ans-3LL*dp[i]%mod+mod)%mod;
}
if(!(sum&1)){
memset(dp,0,sizeof(dp));
dp[0]=1;
for(int i=1;i<=n;++i){
for(int j=sum;j>=a[i];--j){
dp[j]=(dp[j]+dp[j-a[i]])%mod;
}
}
ans=(ans+3LL*dp[sum>>1])%mod;
}
printf("%d\n",ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<(n);i++)
#define rrep(i,n) for(ll i = 1; i <= (n); ++i)
#define drep(i,n) for(ll i = (n)-1; i >= 0; --i)
#define all(v) v.begin(),v.end()
#define len(x) (ll)(x).length()
#define maxs(x,y) x = max(x,y)
#define mins(x,y) x = min(x,y)
#define pb push_back
#define sz(x) (ll)(x).size()
#define v(T) vector<T>
#define vv(T) vector<vector<T>>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<P> vp;
ll gcd(ll a,ll b){if(a%b==0){return b;}else{return(gcd(b,a%b));}}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
const int INF=1e9;
const ll MX = 1e18;
const ll MOD=INF+7;
const int di[] = {-1,0,1,0};
const int dj[] = {0,-1,0,1};
const double PI=acos(-1);
const string tr="abcdefghijklmnopqrstuvwxyz";
#define dame { puts("-1"); return 0;}
#define yn {puts("Yes");}else{puts("No");}
#define YN {puts("YES");}else{puts("NO");}
const ll MAX = 1000001;
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {fac[0] = fac[1] = 1;finv[0] = finv[1] = 1;inv[1] = 1;for (ll i = 2; i < MAX; i++){fac[i] = fac[i - 1] * i % MOD;inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;finv[i] = finv[i - 1] * inv[i] % MOD;}}
long long COM(ll n, ll k){if (n < k) return 0;if (n < 0 || k < 0) return 0;return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;}
ll llpow(ll n,ll i){ll cnt=n; for(ll j=0;j<i-1;j++){n*=cnt;}return n;}
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;}
int digit(ll N) {int ans = 0;while (N) {++ans;N /= 10;}return ans;}
int main() {
ll N;
cin >> N;
ll res = MX;
for (ll A = 1; A * A <= N; ++A) {
if (N % A == 0) {
ll B = N / A;
ll cnt = max(digit(A),digit(B));
res = min(res, cnt);
}
}
cout << res << endl;
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/priority_queue.hpp>
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using pi = pair<int, int>;
using pll = pair<ll, ll>;
constexpr int INF = 0x3f3f3f3f; constexpr ll LLINF = 0x3f3f3f3f3f3f3f3f;
#define db(x) { cerr << #x << " = " << x << endl; }
template <typename T> void _dbarr(T* a, size_t sz){ for(int i = 0; i < sz; i++) cerr << a[i] << " \n"[i == sz-1]; }
template <typename T> void _dbarr(vector<T> a, size_t sz){ for(int i = 0; i < sz; i++) cerr << a[i] << " \n"[i == sz-1]; }
#define dbarr(x, n) {cerr << #x << ": "; _dbarr((x),(n));}
#define all(x) begin(x), end(x)
#define pb push_back
#define eb emplace_back
#define mpr make_pair
#define fs first
#define sn second
int main(){
cin.tie(0)->sync_with_stdio(0);
//freopen("in.txt","r", stdin);
int a;
cin >> a;
cout << a + a*a + a*a*a << "\n";
}
| 0 |
#include<bits/stdc++.h>
int main(){
using namespace std;
unsigned long N, M;
cin >> N >> M;
vector<unsigned long> uf(2 * N), sz(2 * N);
iota(uf.begin(), uf.end(), 0UL);
fill(sz.begin(), sz.begin() + N, 1);
const auto& find = [&uf](unsigned long i) -> unsigned long {
while(i != uf[i])i = uf[i] = uf[uf[i]];
return i;
};
const auto& unite = [&uf, &sz, &find](unsigned long i, unsigned long j) -> unsigned long {
i = find(i);
j = find(j);
if(i == j)return 0;
if(sz[i] < sz[j])swap(i, j);
sz[i] += sz[j];
uf[j] = i;
return 1;
};
const auto& add_edge = [&N, &unite](unsigned long i, unsigned long j) -> void { unite(i, j + N); unite(i + N, j); };
for(unsigned long i{0}, u, v; i < M; ++i){
cin >> u >> v;
add_edge(u - 1, v - 1);
}
if(find(0) == find(N))cout << N * (N - 1) / 2 - M << endl;
else cout << sz[find(0)] * sz[find(N)] - M << endl;
return 0;
} | #include <bits/stdc++.h>
#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 reps(i, n) for (int i = 1; i <= int(n); i++)
#define rreps(i, n) for (int i = int(n); i >= 1; i--)
#define repc(i, n) for (int i = 0; i <= int(n); i++)
#define rrepc(i, n) for (int i = int(n); i >= 0; i--)
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define repic(i, a, b) for (int i = int(a); i <= int(b); i++)
#define each(x, y) for (auto &x : y)
#define all(a) (a).begin(), (a).end()
#define bit32(x) (1 << (x))
#define bit64(x) (1ll << (x))
#define sz(v) ((int) v.size())
using namespace std;
using i64 = long long;
using f80 = long double;
using vi32 = vector<int>;
using vi64 = vector<i64>;
using vf80 = vector<f80>;
using vstr = vector<string>;
inline void yes() { cout << "Yes" << endl; exit(0); }
inline void no() { cout << "No" << endl; exit(0); }
inline i64 gcd(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); if (a % b == 0) return b; return gcd(b, a % b); }
inline i64 lcm(i64 a, i64 b) { if (min(a, b) == 0) return max(a, b); return a / gcd(a, b) * b; }
template <typename T> class pqasc : public priority_queue<T, vector<T>, greater<T>> {};
template <typename T> class pqdesc : public priority_queue<T, vector<T>, less<T>> {};
template <typename T> inline void amax(T &x, T y) { x = max(x, y); }
template <typename T> inline void amin(T &x, T y) { x = min(x, y); }
template <typename T> inline T exp(T x, i64 n, T e = 1) { T r = e; while (n > 0) { if (n & 1) r *= x; x *= x; n >>= 1; } return r; }
template <typename T> istream& operator>>(istream &is, vector<T> &v) { each(x, v) is >> x; return is; }
template <typename T> ostream& operator<<(ostream &os, vector<T> &v) { rep(i, v.size()) { if (i) os << ' '; os << v[i]; } return os; }
void solve(); int main() { ios::sync_with_stdio(0); cin.tie(0); cout << fixed << setprecision(16); solve(); return 0; }
void solve() {
int n, m;
cin >> n >> m;
vector<vi32> g(n);
rep(i, m) {
int u, v;
cin >> u >> v;
u--, v--;
g[u].emplace_back(v);
g[v].emplace_back(u);
}
vi32 dist(n, 1e9);
auto dfs = [&](auto dfs, int u, int d) -> bool {
if (dist[u] != 1e9) {
return dist[u] % 2 == d % 2;
}
dist[u] = d;
for (auto v : g[u]) {
if (!dfs(dfs, v, d + 1)) return false;
}
return true;
};
if (dfs(dfs, 0, 0)) {
int a = 0;
rep(i, n) a += dist[i] % 2 == 0;
int b = n - a;
cout << (i64) a * b - m << endl;
} else {
cout << (i64) n * (n - 1) / 2 - m << endl;
}
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define maxn 240000
typedef long long LL;
const LL mod = 1000000007;
LL A[maxn], D;
LL mi[2][maxn * 4];
void build(int p, int o, int l, int r){
if(l == r){
mi[p][o] = p ? D * l + A[l] : - D * l + A[l];
return;
}
int m = (l + r) >> 1;
build(p, o * 2, l, m);
build(p, o * 2 + 1, m + 1, r);
mi[p][o] = min(mi[p][o * 2], mi[p][o * 2 + 1]);
}
LL ask(int p, int o, int l, int r, int L, int R){
if(l >= L && r <= R) return mi[p][o];
int m = (l + r) >> 1;
LL ret = 1E18;
if(L <= m) ret = min(ret, ask(p, o * 2, l, m, L, R));
if(R > m) ret = min(ret, ask(p, o * 2 + 1, m + 1, r, L, R));
return ret;
}
void update(int p, int o, int l, int r, int i){
if(l == r) mi[p][o] = 1E18;
else{
int m = (l + r) >> 1;
if(i <= m) update(p, o * 2, l, m, i);
else update(p, o * 2 + 1, m + 1, r, i);
mi[p][o] = min(mi[p][o * 2], mi[p][o * 2 + 1]);
}
}
vector<pair<LL, int> > v;
int main(){
int N;
cin >> N >> D;
LL ans = D * (N - 1);
for(int i = 1; i <= N; i += 1){
cin >> A[i];
ans += A[i] << 1;
}
ans -= A[1] + A[N];
for(int i = 2; i < N; i += 1) v.push_back(make_pair(A[i], i));
sort(v.begin(), v.end());
build(0, 1, 1, N);
build(1, 1, 1, N);
for(auto p : v){
int i = p.second;
LL L = ask(0, 1, 1, N, 1, i - 1) + D * i - A[i];
LL R = ask(1, 1, 1, N, i + 1, N) - D * i - A[i];
if(L >= 0 && R >= 0) continue;
ans += min(L, R);
update(0, 1, 1, N, i);
update(1, 1, 1, N, i);
}
cout << ans;
} | #include<iostream>
#include<algorithm>
#include<functional>
#include<vector>
#include<queue>
using namespace std;
#define LL long long
#define LP pair<LL, LL>
const LL inf = 1e17;
struct segtree {
int n = 1;
vector<LP> node;//cost, place
void init(int N) {
node.clear();
while (N > n) n *= 2;
node.resize(n * 2, { inf, inf });
}
void update(int k, LL x, int a) {
k += n - 1;
node[k] = { x, a };
while (k > 0) {
k = (k - 1) / 2;
int l = k * 2 + 1;
int r = k * 2 + 2;
if (node[l].first < node[r].first) node[k] = node[l];
else node[k] = node[r];
}
}
LP mini(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0) r = n;
if (b <= l || r <= a) return { inf, inf };
if (a <= l && r <= b) return node[k];
LP ln = mini(a, b, k * 2 + 1, l, (l + r) / 2);
LP rn = mini(a, b, k * 2 + 2, (l + r) / 2, r);
if (ln.first < rn.first) return ln;
else return rn;
}
};
struct edge {
LL to;
LL cost;
bool operator<(const edge &e1) const {
return e1.cost < cost;
}
};
int N;
int idx[200010];
LL D;
bool used[200010];
vector<LL> A;
vector<LP> B;
vector<edge> G[200010];
LL prim() {
priority_queue<edge> pq;
pq.push(edge{ 0, 0 });
LL total = 0;
while (!pq.empty()) {
edge e = pq.top();
pq.pop();
if (!used[e.to]) {
used[e.to] = true;
total += e.cost;
for (auto u : G[e.to]) {
if (!used[u.to]) pq.push(u);
}
}
}
return total;
}
void build() {
segtree seg;
seg.init(N);
for (int i = 0; i < N; i++) {
seg.update(idx[i], A[i] + D * (N - i - 1), idx[i]);
if (i != 0) {
LP lp = seg.mini(0, idx[i]);
if (lp.first == inf) continue;
lp.first -= D * (N - i - 1) - A[i];
G[B[lp.second].second].push_back(edge{ i, lp.first });
G[i].push_back(edge{ B[lp.second].second, lp.first });
}
}
seg.init(N);
for (int i = N - 1; i >= 0; i--) {
seg.update(idx[i], A[i] + D * i, idx[i]);
if (i != N - 1) {
LP lp = seg.mini(0, idx[i]);
if (lp.first == inf) continue;
lp.first -= D * i - A[i];
G[B[lp.second].second].push_back(edge{ i, lp.first });
G[i].push_back(edge{ B[lp.second].second, lp.first });
}
}
}
void init() {
cin >> N >> D;
for (int i = 0; i < N; i++) {
LP tmp;
cin >> tmp.first;
tmp.second = i;
A.push_back(tmp.first);
B.push_back(tmp);
}
sort(B.begin(), B.end());
for (int i = 0; i < N; i++) {
idx[B[i].second] = i;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
init();
build();
cout << prim() << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define il inline
#define gc getchar()
#define ll long long
#define int long long
#define ri register int
#define rc register char
#define rb register bool
#define rp(i,x,y) for(ri i=x;i<=y;++i)
#define my(i,x,y) for(ri i=x;i>=y;--i)
const int N=200000+10,inf=1e18;
int n,q,pre,nw,tag[N<<2];
ll tr1[N<<2],tr2[N<<2];
il int read()
{
rc ch=gc;ri x=0;rb y=1;
while(ch!='-' && (ch>'9' || ch<'0'))ch=gc;
if(ch=='-')ch=gc,y=0;
while(ch>='0' && ch<='9')x=(x<<1)+(x<<3)+(ch^'0'),ch=gc;
return y?x:-x;
}
void pushdown(ri nw)
{
if(!tag[nw])return;
tag[nw<<1]+=tag[nw];tag[nw<<1|1]+=tag[nw];
tr1[nw<<1]+=tag[nw];tr1[nw<<1|1]+=tag[nw];
tr2[nw<<1]+=tag[nw];tr2[nw<<1|1]+=tag[nw];
tag[nw]=0;
}
void modify(ri nw,ri l,ri r,ri to,ll dat)
{
if(l==r){tr1[nw]=min(tr1[nw],dat-to),tr2[nw]=min(tr2[nw],dat+to);return;}
pushdown(nw);ri mid=(l+r)>>1;to<=mid?modify(nw<<1,l,mid,to,dat):modify(nw<<1|1,mid+1,r,to,dat);
tr1[nw]=min(tr1[nw<<1],tr1[nw<<1|1]);tr2[nw]=min(tr2[nw<<1],tr2[nw<<1|1]);
}
ll query1(ri nw,ri l,ri r,ri to_l,ri to_r)
{
if(to_l<=l && r<=to_r)return tr1[nw];
pushdown(nw);ri mid=(l+r)>>1;ll ret=inf;
if(to_l<=mid)ret=query1(nw<<1,l,mid,to_l,to_r);
if(mid<to_r)ret=min(ret,query1(nw<<1|1,mid+1,r,to_l,to_r));
return ret;
}
ll query2(ri nw,ri l,ri r,ri to_l,ri to_r)
{
if(to_l<=l && r<=to_r)return tr2[nw];
pushdown(nw);ri mid=(l+r)>>1;ll ret=inf;
if(to_l<=mid)ret=query2(nw<<1,l,mid,to_l,to_r);
if(mid<to_r)ret=min(ret,query2(nw<<1|1,mid+1,r,to_l,to_r));
return ret;
}
ll query(ri nw,ri l,ri r)
{
if(l==r)return tr1[nw]+l;
pushdown(nw);ri mid=(l+r)>>1;return min(query(nw<<1,l,mid),query(nw<<1|1,mid+1,r));
}
signed main()
{
// freopen("2558.in","r",stdin);//freopen("2558.out","w",stdout);
n=read();q=read();pre=read();memset(tr1,63,sizeof(tr1));memset(tr2,63,sizeof(tr2));modify(1,1,n,read(),0);
while(q--)
{
nw=read();ll dat=min(query1(1,1,n,1,nw)+nw,query2(1,1,n,nw,n)-nw);
tag[1]+=abs(nw-pre);tr1[1]+=abs(nw-pre);tr2[1]+=abs(nw-pre);modify(1,1,n,pre,dat);pre=nw;
}
printf("%lld\n",query(1,1,n));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define SIZE 262144
#define int long long
#define INF 1000000000000000000LL
class segtree{
public:
int seg[SIZE * 2];
void update(int a, int b){
a += SIZE;
seg[a] = b;
while(true){
a /= 2;
if (a == 0)break;
seg[a] = min(seg[a * 2], seg[a * 2 + 1]);
}
}
int query(int beg, int end, int node, int lb, int ub){
if (ub < beg || end < lb)return INF;
if (beg <= lb&&ub <= end)return seg[node];
return min(query(beg, end, node * 2, lb, (lb + ub) / 2), query(beg, end, node * 2 + 1, (lb + ub) / 2 + 1, ub));
}
};
int dp[SIZE];
segtree tree1, tree2;
signed main(){
ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
int n, q, a, b;
cin >> n >> q >> a >> b;
a--, b--;
int curb = b;
fill(dp, dp + n, INF);
dp[a] = 0;
for (int i = 0; i < n; i++){
tree1.update(i, dp[i] + i);
}
for (int i = 0; i < n; i++){
tree2.update(i, dp[i] - i);
}
int dif = 0;
for (int p = 0; p < q; p++){
int z;
cin >> z;
z--;
int t1 = tree2.query(0, z, 1, 0, SIZE - 1) + dif + z;
int t2 = tree1.query(z, n - 1, 1, 0, SIZE - 1) + dif - z;
dif += abs(z - curb);
if (dp[curb] + dif > min(t1, t2)){
dp[curb] = min(t1, t2) - dif;
tree1.update(curb, dp[curb] + curb);
tree2.update(curb, dp[curb] - curb);
}
curb = z;
}
int mn = INF;
for (int i = 0; i < n; i++){
mn = min(mn, dp[i] + dif);
}
cout << mn;
} | 1 |
//#pragma GCC optimize("Ofast")
//#pragma GCC target("avx,avx2,fma")
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define db long double
#define pb push_back
#define ppb pop_back
#define fi first
#define se second
#define mp make_pair
#define all(x) (x).begin(), (x).end()
void dout() { cerr << '\n'; }
template <typename Head, typename... Tail>
void dout(Head H, Tail... T) {
cerr << " " << H;
dout(T...);
}
#ifdef LOCAL
#define dbg(...) cerr << #__VA_ARGS__, dout(__VA_ARGS__)
#else
#define dbg(...) ;
#endif
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
typedef pair <int, int> pii;
const int N = 2007;
int n, m, adj[N][N], good[N][N];
int f[N][N], l[N][N], r[N][N];
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
#ifdef LOCAL
freopen("input.txt", "r", stdin);
#endif
cin >> n >> m;
char ch;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> ch;
if (ch == '.') {
adj[i][j] = 1;
}
}
}
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
good[i][j] = 1;
if (adj[i][j] ^ adj[i][j + 1] ^ adj[i + 1][j] ^ adj[i + 1][j + 1]) {
good[i][j] = 0;
}
}
}
for (int j = 1; j < m; j++) {
for (int i = 1; i < n; i++) {
if (good[i][j]) {
f[i][j] = f[i - 1][j] + 1;
}
}
}
stack <int> st;
int ans = max(n, m);
for (int i = 1; i < n; i++) {
for (int j = 1; j < m; j++) {
while (!st.empty() && f[i][st.top()] >= f[i][j]) {
st.pop();
}
if (st.empty()) {
l[i][j] = 1;
} else {
l[i][j] = st.top() + 1;
}
st.push(j);
}
while (!st.empty()) {
st.pop();
}
for (int j = m - 1; j >= 1; j--) {
while (!st.empty() && f[i][st.top()] >= f[i][j]) {
st.pop();
}
if (st.empty()) {
r[i][j] = m - 1;
} else {
r[i][j] = st.top() - 1;
}
st.push(j);
ans = max(ans, (r[i][j] - l[i][j] + 2) * (f[i][j] + 1));
}
while (!st.empty()) {
st.pop();
}
}
cout << ans;
}
| #include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
using namespace std;
int main() {
int n;
long long int m;
while (cin >> n >> m) {
if (n == 0 && m == 0) {
break;
}
long long int b;
vector<long long int> ss;
ss.push_back(0);
for (int i = 0; i < n; i++) {
cin >> b;
if (b <= m) {
ss.push_back(b);
}
}
vector<long long int> ss2;
for (long long int i = 0; i < ss.size(); i++) {
ss2.push_back(ss[i]);
for (long long int j = i; j < ss.size(); j++) {
if (ss[i]+ss[j] <= m) {
ss2.push_back(ss[i]+ss[j]);
}
}
}
sort(ss2.begin(), ss2.end());
/*for (long long int i = 0; i < ss2.size(); i++) {
cout << ss2[i] << endl;
}*/
long long int MAX = 0;
long long int sz = ss2.size();
for (long long int j = 0; j < sz; j++) {
long long int a = m;
for (long long int i = 0; i < 2; i++) {
vector<long long int>::iterator ite = upper_bound(ss2.begin(), ss2.end(), a);
if (ite != ss.begin()) {
ite--;
a -= *(ite);
}
}
vector<long long int>::iterator ite2 = ss2.end();
ss2.erase(ite2-1);
MAX = max(MAX, m-a);
}
cout << MAX << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#include<algorithm>
using namespace std;
#define ll long long
int main() {
ll a,b;
cin >> a >> b;
vector<ll> ay;
vector<ll> by;
for(ll i = 1; i <= sqrt(a);i++){
if(a%i == 0){
ay.push_back(i);
if(i != a/i){
ay.push_back(a/i);
}
}
}
for(ll i = 1; i <= sqrt(b);i++){
if(b%i == 0){
by.push_back(i);
if(i != b/i){
by.push_back(b/i);
}
}
}
//cout << ay.size() << " " << by.size() << endl;
vector<ll> kys;
for(int i = 0;i<ay.size();i++){
for(int j = 0;j<by.size();j++){
if(ay[i]==by[j]){
kys.push_back(ay[i]);
//cout << ay[i] << " " << by[j]<< endl;
}
}
}
int res = 0;
int flg = 0;
sort(kys.begin(),kys.end(),greater<ll>());
for(int i = 0;i<kys.size();i++){
flg = 0;
for(int j = i+1;j<kys.size();j++){
if(__gcd(kys[i],kys[j]) != 1){
flg = 1;
break;
}
}
if(flg == 0){res++;}
}
cout << res;
} | #include<iostream>
#include<algorithm>
#include<string>
#include<vector>
#include<cstdlib>
#include<queue>
#include<set>
#include<cstdio>
using namespace std;
#define ll long long
#define rep(i, n) for(int i = 0; i < n; i++)
#define P pair<int, int>
typedef vector<int> vec;
typedef vector<vec> mat;
const ll mod = 1000000007;
vector<pair<ll, ll> > prime;
void prime_fuct(ll x){
for (ll i = 2; i * i <= x; i++){
if(x % i == 0){
pair<ll, ll> p = make_pair(i, 0);
while (x % i == 0){
x /= i;
p.second++;
}
prime.push_back(p);
}
}
if(x > 1){
pair<ll, ll> p = make_pair(x, 1);
prime.push_back(p);
}
}
ll gcd(ll x, ll y){
if(y == 0) return x;
else return gcd(y, x % y);
}
int main(){
ll a, b;
cin >> a >> b;
ll n = gcd(a, b);
prime_fuct(n);
ll ans = (ll)prime.size() + 1;
cout << ans << endl;
} | 1 |
#include<bits/stdc++.h>
typedef long long int ll;
using namespace std;
void solve()
{
int n, m;
cin >> n >> m;
cout << n * m << endl;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
ll t;
solve();
return 0;
}
| #define _USE_MATH_DEFINES
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
void abc_160a();
void abc_161a();
void abc_162a();
void abc_163a();
void abc_164a();
void abc_165a();
void abc_166a();
void abc_167a();
void abc_168a();
void abc_169();
int main()
{
//abc_160a();
//abc_161a();
//abc_162a();
//abc_163a();
//abc_164a();
//abc_165a();
//abc_166a();
//abc_167a();
//abc_168a();
abc_169();
}
void abc_160a()
{
string S;
cin >> S;
if (S[2] == S[3] && S[4] == S[5]) cout << "Yes\n";
else cout << "No\n";
}
void swap(int& a, int& b)
{
int tmp;
tmp = a;
a = b;
b = tmp;
}
void abc_161a()
{
int x, y, z;
cin >> x >> y >> z;
swap(x, y);
swap(x, z);
cout << x << " " << y << " " << z << "\n";
}
void abc_162a()
{
string s;
cin >> s;
for (char c : s)
{
if (c == '7')
{
cout << "Yes\n";
return;
}
}
cout << "No\n";
}
void abc_163a()
{
int R;
cin >> R;
cout << (double)(2 * R * M_PI);
}
void abc_164a()
{
int s, w;
cin >> s >> w;
if (s <= w) cout << "unsafe\n";
else cout << "safe\n";
}
void abc_165a()
{
int k, a, b;
cin >> k >> a >> b;
for (int i = a; i <= b; ++i)
{
if (i % k == 0)
{
cout << "OK\n";
return;
}
}
cout << "NG\n";
}
void abc_166a()
{
string s;
cin >> s;
if (s == "ABC") cout << "ARC\n";
if (s == "ARC") cout << "ABC\n";
}
void abc_167a()
{
string s, t;
cin >> s >> t;
for (int i = 0; i < s.size(); ++i)
{
if (s[i] != t[i])
{
cout << "No\n";
return;
}
}
if ('a' <= t[t.size() - 1] && t[t.size() - 1] <= 'z') cout << "Yes\n";
else cout << "No\n";
}
void abc_168a()
{
string s;
cin >> s;
if (s[s.size() - 1] == '3') cout << "bon\n";
else if (s[s.size() - 1] == '0' ||
s[s.size() - 1] == '1' ||
s[s.size() - 1] == '6' ||
s[s.size() - 1] == '8') cout << "pon\n";
else cout << "hon\n";
}
void abc_169()
{
int a, b;
cin >> a >> b;
cout << a * b << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const static ll INF = 1e15;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
// __uint128_t
const ll MOD = 1e9+7;
int main(){
ll H, W; cin >> H >> W;
vector<string> S(H); for(int i = 0; i < H; i++) cin >> S[i];
ll bs = 0;
for(int i = 0; i < H; i++){
for(int j = 0; j < W; j++) if(S[i][j] == '#') bs++;
}
vector<vector<ll>> V(H, vector<ll>(W, INF));
queue<ll> qh, qw;
qh.push(0); qw.push(0);
V[0][0] = 0;
int dh[] = {0, 1, 0, -1};
int dw[] = {1, 0, -1, 0};
while(!qh.empty()){
ll h = qh.front(), w = qw.front();
qh.pop(), qw.pop();
for(int i = 0; i < 4; i++){
ll nh = h+dh[i], nw = w+dw[i];
if(0<=nh && nh < H && 0<=nw && nw<W && S[nh][nw] == '.' && V[h][w]+1<V[nh][nw]){
qh.push(nh);
qw.push(nw);
V[nh][nw] = V[h][w]+1;
}
}
}
if(V[H-1][W-1] == INF) cout << -1 << endl;
else cout << H*W-bs-V[H-1][W-1]-1 << endl;
}
| #include<iostream>
#include<vector>
#include<string>
#include<cmath>
#include<algorithm>
#include<functional>
#include<numeric>
#include<queue>
#include<stack>
#include<map>
#include<unordered_map>
#include<set>
#include<bitset>
#include<random>
#pragma region
using namespace std;
#define FOR(i,r,n) for(ll i = (ll)(r); i < (ll)(n); i++)
#define rep(i,n) FOR(i,0LL,n)
#define RFOR(i,r,n) for(ll i=(ll)(n-1);i>=r;i--)
#define rrep(i,n) RFOR(i,0LL,n)
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define COUNT(a,y,x) upper_bound(all(a), y) - lower_bound(all(a), x)
#define UNIQUE(a) sort(all(a)); a.erase(unique(all(a)), a.end())
#define pb push_back
typedef long long int ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<string> vs;
typedef map<ll, ll> MAP;
const ll inf = 2222222222222222222LL;
const ll mod = 1000000007LL;
ll n = 0, m = 0, ans = 0, tmp = 0, ma = -inf, mi = inf;
string s;
bool ok;
ll dx[9] = { 0,1,-1,0,0,1,1,-1,-1 }, dy[9] = { 0,0,0,1,-1,1,-1,1,-1 };
#define endl '\n'
#pragma endregion
#define MAX 222222
ll dp[MAX];
vll fac, inv, invfac;
void comb_set(ll x = MAX) {
fac.resize(x + 1, 0);
invfac.resize(x + 1, 0);
inv.resize(x + 1, 0);
fac[0] = inv[1] = invfac[0] = 1;
FOR(i, 1, x + 1) (fac[i] = fac[i - 1] * i) %= mod;
FOR(i, 2, x + 1) (inv[i] = (mod - mod / i) * inv[mod%i]) %= mod;
FOR(i, 1, x + 1) (invfac[i] = invfac[i - 1] * inv[i]) %= mod;
}
ll comb(ll x, ll y) {
if (x < y) return 0;
return fac[x] * invfac[x - y] % mod * invfac[y] % mod;
}
int main(void) {
ios::sync_with_stdio(false); cin.tie(0);
cin >> n >> m;
vll v(n);
rep(i, n) cin >> v[i];
sort(rall(v));
comb_set(MAX);
dp[m] = fac[n];
rep(i, n) {
FOR(j, v[i], m + 1) {
(dp[j%v[i]] += inv[n - i] * dp[j]) %= mod;
(dp[j] = (((n - i - 1) * inv[n - i]) % mod) * dp[j]) %= mod;
}
}
rep(i, m + 1) (ans += i * dp[i]) %= mod;
cout << ans << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(ll i=0;i<n;i++)
#define repl(i,l,r) for(ll i=(l);i<(r);i++)
#define per(i,n) for(ll i=n-1;i>=0;i--)
#define perl(i,r,l) for(ll i=r-1;i>=l;i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x,vector<x>,greater<x>>
#define all(x) (x).begin(),(x).end()
#define CST(x) cout<<fixed<<setprecision(x)
#define rev(x) reverse(x);
using ll=long long;
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
using pl=pair<ll,ll>;
using vpl=vector<pl>;
using vvpl=vector<vpl>;
const ll MOD=1000000007;
const ll MOD9=998244353;
const int inf=1e9+10;
const ll INF=4e18;
const ll dy[8]={1,0,-1,0,1,1,-1,-1};
const ll dx[8]={0,-1,0,1,1,-1,1,-1};
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main(){
ll n;cin >> n;
vvl g(n,vl(n));rep(i,n)rep(j,n)cin >> g[i][j];
vl sum(1<<n);
rep(bit,1<<n){
ll ret=0;
rep(i,n)repl(j,i+1,n)if((bit&(1<<i))&&(bit&(1<<j)))ret+=g[i][j];
sum[bit]=ret;
}
//rep(i,1<<n)cout << sum[i] <<" ";cout << endl;
rep(bit,1<<n){
vl z;rep(i,n)if(bit&(1<<i))z.pb(i);
rep(cit,1<<z.size()){
ll d=0,e=0;
rep(j,z.size()){
if(cit&(1<<j))d+=1<<z[j];
else e+=1<<z[j];
}
if(d>e)break;
//cout << bit <<" " << d << " " << e <<endl;
chmax(sum[bit],sum[d]+sum[e]);
}
}
//rep(i,1<<n)cout << sum[i] <<" ";cout << endl;
cout << sum[(1<<n)-1] <<endl;
} | #include <bits/stdc++.h>
#define WHOLE(v) (v).begin(), (v).end()
#define REV_WHOLE(v) (v).rbegin(), (v).rend()
using i64 = int64_t;
using namespace std;
template<class F>auto recursive(F f){return[f](auto...a){return f(f,a...);};}
template<class T>using rev_priority_queue=priority_queue<T,vector<T>,greater<T>>;
template<class T>using vector2d=vector<vector<T>>;
struct fixprec{int p;fixprec(int p):p(p){}};
ostream&operator<<(ostream&o,fixprec f){return o<<fixed<<setprecision(f.p);}
int main() {
int N, M, lK;
i64 K;
cin >> N;
vector<i64> x(N), dx(N - 1), y(N);
for(i64 &x_ : x) cin >> x_;
for(int i = 0; i < N - 1; i++) {
dx[i] = x[i + 1] - x[i];
}
cin >> M >> K;
vector<int> perm_base(N - 1), perm_ans(N - 1), perm_tmp(N - 1);
for (int i = 0; i < N - 1; i++) {
perm_base[i] = perm_ans[i] = i;
}
for(int i = 0; i < M; i++) {
int a;
cin >> a;
a--;
swap(perm_base[a - 1], perm_base[a]);
}
// 繰り返し二乗法
for(int b = 0; (1ll << b) <= K; b++) {
if (K & (1ll << b)) {
for (int i = 0; i < N - 1; i++) {
perm_ans[i] = perm_base[perm_ans[i]];
}
}
for (int i = 0; i < N - 1; i++) perm_tmp[i] = i;
for (int i = 0; i < N - 1; i++) {
perm_tmp[i] = perm_base[perm_base[i]];
}
swap(perm_tmp, perm_base);
}
for(int i = 0; i < N; i++) {
y[i] = i ? dx[perm_ans[i - 1]] + y[i - 1] : x[0];
cout << y[i] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> ii;
const int N = 1001, M = 2001;
int n, m, a, b;
vector<int> edge[N];
vector<int> path;
unordered_map<int, int> mp;
bool check(int from, int to) {
int s = mp[from];
int e = mp[to];
// index [s, e] in path
for (int i = s; i <= e; ++i) {
int cur = path[i];
int next = (i == e ? path[s] : path[i + 1]);
for (int v : edge[cur]) {
if (v != next) {
if (mp.count(v) && mp[v] >= s) {
return false;
}
}
}
}
return true;
}
void dfs(int u) {
for (int v : edge[u]) {
if (mp.count(v)) {
// find cycle
if (check(v, u)) {
int s = mp[v];
int e = mp[u];
cout << e - s + 1 << endl;
for (int i = s; i <= e; ++i) {
cout << path[i] << endl;
}
exit(0);
}
} else {
path.push_back(v);
mp[v] = path.size() - 1;
dfs(v);
mp.erase(v);
path.pop_back();
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> a >> b;
edge[a].push_back(b);
}
for (int i = 1; i <= n; ++i) {
path.push_back(i);
mp[i] = 0;
dfs(i);
mp.erase(i);
path.pop_back();
}
cout << -1 << endl;
return 0;
}
| #include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <cmath>
#include <cstdio>
int fact(int k) {
int w = 1;
for (int i = 2; i <= k; i++)
w *= i;
return w;
}
int main() {
double sum = 0;
std::vector<int> k;
int n, x, y;
std::cin >> n;
std::vector<std::pair<int, int>> v(n);
for (int i = 0; i < n; i++) {
std::cin >> x >> y;
v[i].first = x, v[i].second = y;
k.push_back(i);
}
for (int i = 0; i < n - 1; i++) {
sum += std::sqrt((v[k[i]].first - v[k[i + 1]].first) * (v[k[i]].first - v[k[i + 1]].first) +
(v[k[i]].second - v[k[i + 1]].second) * (v[k[i]].second - v[k[i + 1]].second));
}
while (std::next_permutation(k.begin(), k.end())) {
for (int i = 0; i < n - 1; i++) {
sum += std::sqrt((v[k[i]].first - v[k[i + 1]].first) * (v[k[i]].first - v[k[i + 1]].first) +
(v[k[i]].second - v[k[i + 1]].second) * (v[k[i]].second - v[k[i + 1]].second));
}
}
printf("%.10f", sum / fact(n));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i = 0; i < (n); ++i)
#define REP(i,x,n) for(int i = (x); i < (n); ++i)
#define ll long long
#define P pair<ll,ll>
#define all(v) (v).begin(),(v).end()
#define rall(v) (v).rbegin(),(v).rend()
const ll mod = 1e9+7;
const ll INF = 1e18;
const double pi = acos(-1);
int main(void)
{
ll l, r, ans=INF;
cin >> l >> r;
r = min(r, l+4038);
for(ll i=l;i<=r;i++)for(ll j=i+1;j<=r;j++){
ll tmp = ((i%2019)*(j%2019))%2019;
ans = min(ans, tmp);
ans %= 2019;
}
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
long long l,r;
int main()
{
scanf("%lld%lld",&l,&r);
long long ans=2019;
for(long long i=l;i<=r;++i)
{
for(long long j=i+1;j<=r;++j)
{
ans=min(ans,(i*j)%2019);
if(ans==0)
{
cout<<ans<<endl;
return 0;
}
}
}
cout<<ans<<endl;
return 0;
} | 1 |
#include <iostream>
#include <complex>
#include <sstream>
#include <string>
#include <algorithm>
#include <deque>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <vector>
#include <set>
#include <limits>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <ctime>
using namespace std;
#define REP(i, j) for(int i = 0; i < (int)(j); ++i)
#define FOR(i, j, k) for(int i = (int)(j); i < (int)(k); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define REVERSE(v) reverse((v).begin(), (v).end())
typedef complex<double> P;
void dfs(int u, int prev, int *cnt, int *visited, int *prenum, int *lowest, int *parent, vector< vector<int> > &v){
visited[u] = true;
prenum[u] = lowest[u] = *cnt;
REP(i, v[u].size()){
int next = v[u][i];
if(!visited[next]){
parent[next] = u;
++(*cnt);
dfs(next, u, cnt, visited, prenum, lowest, parent, v);
lowest[u] = min(lowest[u], lowest[next]);
} else if(next != prev)
lowest[u] = min(lowest[u], prenum[next]);
}
}
vector<int> articulation_points(int V, int E, vector< vector<int> > &v){
int visited[V], prenum[V], lowest[V], parent[V];
memset(visited, 0, sizeof(visited));
parent[0] = -1;
int tmp = 1;
dfs(0, -1, &tmp, visited, prenum, lowest, parent, v);
//cout <<"prenum" <<endl;
//REP(i, V) cout <<i <<" : " <<prenum[i] <<endl;
//cout <<"parent" <<endl;
//REP(i, V) cout <<i <<" : " <<parent[i] <<endl;
//cout <<"lowest" <<endl;
//REP(i, V) cout <<i <<" : " <<lowest[i] <<endl;
vector<int> ret;
int cnt = 0, used[V];
memset(used, 0, sizeof(used));
FOR(i, 1, V){
if(parent[i] == 0) ++cnt;
if(parent[i] > 0 && !used[parent[i]] && prenum[parent[i]] <= lowest[i]){
used[parent[i]] = true;
ret.push_back(parent[i]);
}
}
if(cnt >= 2) ret.push_back(0);
return ret;
}
int main() {
int V, E; cin >>V >>E;
vector< vector<int> > es(V);
REP(i, E){
int f, t; cin >>f >>t;
es[f].push_back(t);
es[t].push_back(f);
}
vector<int> ans = articulation_points(V, E, es);
SORT(ans);
REP(i, ans.size()) cout <<ans[i] <<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF 1LL<<62
#define inf 1000000007
bool ch[82][82][13000];
int main() {
ll h,w;
cin>>h>>w;
ll a[82][82],b[82][82];
for(ll i=0;i<h;i++){
for(ll j=0;j<w;j++){
cin>>a[i][j];
}
}
for(ll i=0;i<h;i++){
for(ll j=0;j<w;j++){
cin>>b[i][j];
}
}
ll c[82][82];
for(ll i=0;i<h;i++){
for(ll j=0;j<w;j++){
c[i][j]=abs(a[i][j]-b[i][j]);
// cout << c[i][j];
}
// cout <<endl;
}
ch[0][0][c[0][0]]=true;
for(ll i=0;i<h;i++){
for(ll j=0;j<w;j++){
for(ll k=0;k<13000;k++){
if(i!=0&&ch[i-1][j][k]==true){
ll now=c[i][j];
ch[i][j][k+now]=true;
ch[i][j][abs(k-now)]=true;
}
if(j!=0&&ch[i][j-1][k]==true){
ll now=c[i][j];
ch[i][j][k+now]=true;
ch[i][j][abs(k-now)]=true;
}
}
}
}
for(ll i=0;i<13000;i++){
if(ch[h-1][w-1][i]){
cout <<i<<endl;
return 0;
}
}
// your code goes here
return 0;
} | 0 |
#include<cstdio>
#define RI int
#define CI const int&
using namespace std;
const int N=6005;
int n,mod,f[N][N<<1],ans;
inline void inc(int& x,CI y)
{
if ((x+=y)>=mod) x-=mod;
}
int main()
{
RI i,j,k,t; scanf("%d%d",&n,&mod); n*=3; f[0][n]=1;
for (i=0;i<n;++i) for (j=-i;j<=i;++j) if (f[i][n+j])
inc(f[i+1][n+j-1],f[i][n+j]),
inc(f[i+2][n+j+1],1LL*f[i][n+j]*(i+1)%mod),
inc(f[i+3][n+j],1LL*f[i][n+j]*(i+2)%mod*(i+1)%mod);
for (i=-n;i<=0;++i) inc(ans,f[n][n+i]); return printf("%d",ans),0;
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <set>
using namespace std;
int main(){
int N, MOD;
while(cin >> N >> MOD){
const int maxSize = 3*N+1;
vector<long long> inv(maxSize);
vector<long long> fact(maxSize);
for(int i=0;i<2;i++) inv[i] = fact[i] = 1;
for(int i=2;i<maxSize;i++){
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
fact[i] = fact[i-1] * i % MOD;
}
vector<vector<long long>> dp(maxSize, vector<long long>(4*N+1, 0));
dp[0][N] = 1;
for(int i=0;i<3*N;i++){
for(int j=0;j<=4*N;j++){
int dj[] = {1, -1, 0};
for(int k=0;k<3;k++){
if(j+dj[k] < 0 || 4*N < j+dj[k]) continue;
if(i+k+1 > 3*N) continue;
dp[i+k+1][j+dj[k]] += dp[i][j] * inv[i+k+1];
dp[i+k+1][j+dj[k]] %= MOD;
}
}
}
long long res = 0;
for(int i=N;i<=4*N;i+=3) res = (res + dp[3*N][i]) % MOD;
cout << (fact[3*N] * res) % MOD << endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll MOD = 1000000007;
const ld PI = acos(-1);
const ld EPS = 0.0000000001;
const ll LINF = 1001002003004005006ll;
const int INF = 1001001001;
#define rep(i, n) for(ll i=0; i<(ll)(n); i++)
#define repd(i, n) for(ll i=n-1; 0<=i; i--)
#define FOR(i, a, b) for(ll i=a; i<(ll)(b); i++)
#define FORD(i, a, b) for(ll i=a-1; (ll)(b)<=i; i--)
#define ALL(x) x.begin(), x.end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
double dp[310][310][310];
ll n;
double calc(int x, int y, int z){
double ret=0.0;
if(0<=dp[x][y][z]) return dp[x][y][z];
if(!x && !y && !z) return 0.0;
if(0<x) ret += calc(x-1, y, z)*x;
if(0<y) ret += calc(x+1, y-1, z)*y;
if(0<z) ret += calc(x, y+1, z-1)*z;
ret += n;
ret *= 1.0/(x+y+z);
return dp[x][y][z] = ret;
}
int main(){
cin >> n;
vector<ll> a(n);
ll c1=0, c2=0, c3=0;
rep(i, n){
ll x; cin >> x;
if(x==1) c1++;
else if(x==2) c2++;
else c3++;
}
memset(dp, -1, sizeof(dp));
cout << fixed << setprecision(20) << calc(c1, c2, c3) << endl;
}
| #include "bits/stdc++.h"
#define ll long long
#define mp(a, b) make_pair(a, b)
using namespace std;
typedef pair<ll, ll> pairs;
typedef pair<ll, pairs> tpl;
ll c[4];
double dp[301][301][301];
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
ll n, a;
cin >> n;
for (ll i = 0; i < n; i++)
cin >> a, c[a]++;
dp[0][0][0] = 0;
for (ll i = 0; i <= n; i++)
{
for (ll j = 0; j <= n; j++)
{
for (ll k = 0; k <= n; k++)
{
double z = n - (i + j + k), val = 1;
if (z == n)
continue;
if (i + j + k > n)
continue;
if (i > 0)
val += (1.0 * i / n) * dp[i - 1][j + 1][k];
if (j > 0)
val += (1.0 * j / n) * dp[i][j - 1][k + 1];
if (k > 0)
val += (1.0 * k / n) * dp[i][j][k - 1];
if (z > 0)
val /= (1.0 - 1.0 * z / n);
dp[i][j][k] = val;
}
}
}
cout << setprecision(9) << fixed << dp[c[3]][c[2]][c[1]];
} | 1 |
#include <bits/stdc++.h>
#include <iomanip>
#include <math.h>
//#include <unistd.h>
//#include <stdio.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);
}
//素数判定O(sqrt(N))
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;
}
}
ll fac[510000], finv[510000], inv[510000];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < 510000; i++){
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod%i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
// 二項係数計算
ll COM(ll n, ll k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % mod) % mod;
}
//nのm乗をMODで割ったあまりO(logN)
ll modpow(ll n,ll m,ll MOD){
ll res = 1;
while(m){
if(m & 1)res = (res * n) % MOD;
m >>= 1;
n *= n;
n %= MOD;
}
return res;
}
//printf("%.10f\n", N);
/* vector<ll> vec = {1,2,5,6,8,9,10};
cout << binary_search(all(vec),5) << endl; -> true*/
/*
vector<ll> vec = {1,2,5,6,8,9,10};
auto n = upper_bound(all(vec),4);
cout << *n << endl; -> 5*/
/*
cout << fixed << setprecision(15);
*/
int main(){
string S;
cin >> S;
if(S.size() == 2){
cout << S << endl;return 0;
}
else{
reverse(all(S));
cout << S << endl;
}
}
| const int LG = 21;
const int FN = 400005;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int> > G;
#define forn(i, n) for (int (i) = 0; (i) != (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define popcount(x) __builtin_popcount(x)
#define popcountll(x) __builtin_popcountll(x)
#define fi first
#define se second
#define re return
#define pb push_back
#define uniq(x) sort(all(x)); (x).resize(unique(all(x)) - (x).begin())
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " " << #x << " " << x << endl
#define ln cerr << __LINE__ << endl
#else
#define dbg(x) void(0)
#define ln void(0)
#endif // LOCAL
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
string Ans[2] = {"No", "Yes"};
string ANS[2] = {"NO", "YES"};
ll inq(ll x, ll y)
{
if (!y) re 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) re l * l % MOD * x % MOD;
re l * l % MOD;
}
ll rev(ll x)
{
return inq(x, MOD - 2);
}
bool __precomputed_combinatorics = 0;
vector<ll> __fact, __ufact, __rev;
void __precompute_combinatorics()
{
__precomputed_combinatorics = 1;
__fact.resize(FN);
__ufact.resize(FN);
__rev.resize(FN);
__rev[1] = 1;
for (int i = 2; i < FN; i++) __rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = 1; i < FN; i++) __fact[i] = __fact[i - 1] * i % MOD, __ufact[i] = __ufact[i - 1] * __rev[i] % MOD;
}
ll fact(int x)
{
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[x];
}
ll cnk(int n, int k)
{
if (k < 0 || k > n) return 0;
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
int Root(int x, vector<int> &root)
{
if (x == root[x]) return x;
return root[x] = Root(root[x], root);
}
void Merge(int v, int u, vector<int> &root, vector<int> &sz)
{
v = Root(v, root), u = Root(u, root);
if (v == u) return;
if (sz[v] < sz[u])
{
sz[u] += sz[v];
root[v] = u;
}
else
{
sz[v] += sz[u];
root[u] = v;
}
}
int ok(int x, int n)
{
return 0 <= x && x < n;
}
void bfs(int v, vi &dist, vector<vi> &graph)
{
fill(all(dist), -1);
dist[v] = 0;
vi q = {v};
for (int i = 0; i < q.size(); i++)
{
for (auto u : graph[q[i]])
{
if (dist[u] == -1)
{
dist[u] = dist[q[i]] + 1;
q.push_back(u);
}
}
}
}
int t;
void dfs(int v, int p, G &graph, vi &in, vi &up)
{
up[v] = in[v] = t;
t++;
for (auto u : graph[v])
{
if (u == p) continue;
if (in[u] == 0)
{
dfs(u, v, graph, in, up);
}
up[v] = min(up[v], up[u]);
}
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
if (s.size() == 3) reverse(all(s));
cout << s;
}
/* Note:
Check constants at the beginning of the code.
N is set to 4e5 but be careful in problems with large constant factor.
Setting N in every problem is more effective.
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
| 1 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cctype>
#include <queue>
#include <vector>
using namespace std;
inline int read()
{
int x=0,f=1;char ch=getchar();
while (!isdigit(ch)){if (ch=='-') f=-1;ch=getchar();}
while (isdigit(ch)){x=x*10+ch-48;ch=getchar();}
return x*f;
}
int n,D1,D2,id[650][650],col[400000][3];
vector <pair <int,int>> d[3];
inline void dfs(int u,int c)
{
int x=(u-1)/(2*n)+1,y=(u-1)%(2*n)+1;
//cout << x << " " << y << endl;
for (int i=0;i<d[c].size();i++)
{
pair <int,int> rhs=d[c][i];
int nx=x+rhs.first,ny=y+rhs.second;
if (nx>=1 && nx<=2*n && ny>=1 && ny<=2*n)
{
int rid=id[nx][ny];
if (!col[rid][c])
{
col[rid][c]=col[u][c]==1?2:1;
dfs(rid,c);
}
}
}
}
int main()
{
n=read(),D1=read(),D2=read();
for (int i=0;i<=D1;i++)
{
int j=sqrt(D1-i*i);
if (i*i+j*j==D1)
{
d[1].push_back({i,j});
d[1].push_back({-i,j});
d[1].push_back({i,-j});
d[1].push_back({-i,-j});
//if (i!=0)
// break;
}
}
for (int i=0;i<=D2;i++)
{
int j=sqrt(D2-i*i);
if (i*i+j*j==D2)
{
d[2].push_back({i,j});
d[2].push_back({-i,j});
d[2].push_back({i,-j});
d[2].push_back({-i,-j});
//if (i!=0)
// break;
}
}
for (int i=1;i<=n*2;i++)
{
for (int j=1;j<=n*2;j++)
id[i][j]=(i-1)*2*n+j;
}
for (int i=1;i<=n*2;i++)
{
for (int j=1;j<=n*2;j++)
{
int rhs=id[i][j];
if (!col[rhs][1])
{
col[rhs][1]=1;
dfs(rhs,1);
}
if (!col[rhs][2])
{
col[rhs][2]=1;
dfs(rhs,2);
}
}
}
int cnt=0;
for (int i=1;i<=n*2;i++)
{
for (int j=1;j<=n*2;j++)
{
int rid=id[i][j];
if (col[rid][1]==1 && col[rid][2]==1)
{
cout << i-1 << " " << j-1 << endl;
cnt++;
}
if (cnt==n*n)
return 0;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int,int> pi;
#define f first
#define s second
#define FAST ios_base::sync_with_stdio(0); cin.tie(0);
#define all(x) x.begin(),x.end()
const int maxn = 6010;
const int mod = 998244353;
int fac[maxn];
map <int,int> mp;
int expo(int x, int exp) {
int res = 1, base = x;
while (exp) {
if (exp & 1) res = (res * base) % mod;
base = (base*base) % mod;
exp >>= 1;
}
return res;
}
int inv(int x) {
if (mp.find(x) != mp.end()) return mp[x];
else return mp[x] = expo(x,mod-2);
}
int choose(int N, int k) {
return fac[N] * inv(fac[k]*fac[N - k] % mod) % mod;
}
int K,n;
int32_t main() {
FAST
cin >> K >> n;
fac[0] = 1;
for (int i =1; i<maxn;i++) fac[i] = fac[i-1] * i % mod;
for (int i = 2;i <= 2 * K; i++) {
int ans = 0;
int pairs = i/2 - max(1ll, i - K) + 1;
for (int x = 0; x <= pairs; x++) {
if (n < x * 2) break;
int v = choose(n - x*2 + K -1, n - x * 2) * choose(pairs,x) % mod;
if (x % 2 == 0) ans = (ans + v) % mod;
else ans = (ans - v + mod) % mod;
//cout << i << " " << x << " " << v << " " << ans << "\n";
}
cout << ans << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> a(n, vector<int>(m));
rep(i, n) rep(j, m) cin >> a[i][j];
set<int> excluded;
int ans = 1e6;
for (int k = 0; k < m; k++) {
vector<int> counter(m + 1, 0);
int toBeExcluded = 0;
for (int i = 0; i < n; i++) {
int j = 0;
while (j < m && excluded.count(a[i][j])) {
j++;
}
counter[a[i][j]]++;
if (counter[toBeExcluded] < counter[a[i][j]]) {
toBeExcluded = a[i][j];
}
}
ans = min(ans, counter[toBeExcluded]);
excluded.insert(toBeExcluded);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define inf 0x3f3f3f3f3f3f3f3f
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define fi first
#define se second
#define N 305
using namespace std;
typedef pair<int,int> Pair;
const int mod = 1e9 + 7;
inline int add(int x, int y) { return (x += y) - (x >= mod ? mod : 0); }
inline void inc(int &x, int y) { (x += y) -= (x >= mod ? mod : 0); }
inline int mul(int x, int y) { return 1ll * x * y % mod; }
template <class T> inline T input() {
int x; char ch; while (!isdigit(ch = getchar()));
for (x = ch ^ 48; isdigit(ch = getchar()); x = x * 10 + (ch ^ 48));
return x;
}
template <class T> inline void chkmin(T &x, T &y) { x = x < y ? x : y; }
template <class T> inline void chkmax(T &x, T &y) { x = x > y ? x : y; }
struct {
inline operator int () { return input<int>(); }
inline operator long long () { return input<long long>(); }
template <class T> inline void operator () (T &x) { x = *this; }
template<class T, class ...A> inline void operator () (T &x, A &...a)
{ x = *this; this -> operator ()(a...); }
} read;
int n, m, ans = inf;
int a[N][N];
int cnt[N];
bool vis[N];
void calc() {
memset(cnt, 0, sizeof cnt);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (vis[a[i][j]]) {
++cnt[a[i][j]];
break;
}
}
int main() {
read(n, m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
read(a[i][j]);
for (int i = 1; i <= m; ++i) vis[i] = true;
calc();
for (int i = 1; i <= m; ++i) {
int pos = max_element(cnt + 1, cnt + m + 1) - cnt;
ans = min(ans, cnt[pos]);
vis[pos] = false;
calc();
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <iomanip>
#include <queue>
#include <deque>
#include <map>
#include <unordered_map>
#define rep(i,n) for(int i=0;i<n;i++)
#define repn(i,n) for(int i=1;i<=n;i++)
#define repr(e,x) for(auto& e:x)
using namespace std;
typedef long long ll;
typedef pair<ll,int> P;
ll N;
ll A[100000], B[100000];
ll sum[100000];
int main(){
cin>>N;
rep(i,N){
cin>>A[i]>>B[i];
sum[i]=A[i]+B[i];
}
ll ans=0;
rep(i,N) ans-=B[i];
sort(sum,sum+N,greater<>());
for(int i=0;i<N;i+=2) ans+=sum[i];
cout<<ans<<endl;
} | #include <bit>
#include <bitset>
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <sstream>
#include <iostream>
#include <set>
#include <map>
#include <vector>
#include <math.h>
#include <stdlib.h>
#include <queue>
#include <stack>
typedef long double ld;
typedef long long ll;
using namespace std;
struct dish {
ll x, y;
dish(ll tx = 0, ll ty = 0) {
x = tx;
y = ty;
}
void read() {
cin >> x >> y;
}
bool operator<(const dish & d) const {
return (x + y > d.x + d.y);
}
};
#define MAXN (1 << 17)
dish a[MAXN];
int n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
a[i].read();
}
sort(a, a + n);
ll ret = 0;
for (int i = 0; i < n; i++) {
if (i & 1) {
ret -= a[i].y;
} else {
ret += a[i].x;
}
}
cout << ret << endl;
return 0;
}
| 1 |
#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>
using namespace std;
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
typedef long long ll;
typedef pair<int, int> pii;
#define mp make_pair
const ll MOD = 998244353;
ll add(ll x, ll y) {
x += y;
if (x >= MOD) return x - MOD;
return x;
}
ll sub(ll x, ll y) {
x -= y;
if (x < 0) return x + MOD;
return x;
}
ll mult(ll x, ll y) {
return (x * y) % MOD;
}
ll bin_pow(ll x, ll p) {
if (p == 0) return 1;
if (p & 1) return mult(x, bin_pow(x, p - 1));
return bin_pow(mult(x, x), p / 2);
}
ll Rev(ll x) {
return bin_pow(x, MOD - 2);
}
ll W;
const int LOG = 20;
const int N = 1 << 20;
ll w[N];
int rev[N];
void initFFT() {
for (ll x = 2;; x++) {
ll y = x;
for (int i = 1; i < LOG; i++)
y = mult(y, y);
if (y == MOD - 1) {
W = x;
break;
}
}
w[0] = 1;
for (int i = 1; i < N; i++)
w[i] = mult(w[i - 1], W);
rev[0] = 0;
for (int mask = 1; mask < N; mask++) {
int k = 0;
while(((mask >> k) & 1) == 0) k++;
rev[mask] = rev[mask ^ (1 << k)] ^ (1 << (LOG - 1 - k));
}
}
ll F[2][N];
void FFT(ll *A) {
for (int i = 0; i < N; i++)
F[0][rev[i]] = A[i];
int t = 0, nt = 1;
for (int lvl = 0; lvl < LOG; lvl++) {
int len = 1 << lvl;
for (int st = 0; st < N; st += (len << 1))
for (int i = 0; i < len; i++) {
ll ad = mult(F[t][st + len + i], w[i << (LOG - 1 - lvl)]);
F[nt][st + i] = add(F[t][st + i], ad);
F[nt][st + len + i] = sub(F[t][st + i], ad);
}
swap(t, nt);
}
for (int i = 0; i < N; i++)
A[i] = F[t][i];
}
ll f[N], rf[N];
ll a[N];
ll getC(int n, int k) {
if (k < 0 || k > n) return 0;
return mult(f[n], mult(rf[k], rf[n - k]));
}
int main()
{
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
initFFT();
f[0] = 1;
for (int i = 1; i < N; i++)
f[i] = mult(f[i - 1], i);
rf[N - 1] = Rev(f[N - 1]);
for (int i = N - 1; i > 0; i--)
rf[i - 1] = mult(rf[i], i);
for (int k = 0; k < N / 2; k++) {
a[k] = mult(f[2 * k], mult(rf[k], rf[k]));
}
FFT(a);
for (int i = 0; i < N; i++)
a[i] = mult(a[i], a[i]);
FFT(a);
reverse(a + 1, a + N);
ll rN = Rev(N);
for (int i = 0; i < N; i++) {
a[i] = mult(a[i], rN);
a[i] = mult(a[i], mult(rf[2 * i], mult(f[i], f[i])));
a[i] = sub(a[i], 1);
a[i] = mult(a[i], (MOD + 1) / 2);
a[i] += i;
}
int n, m;
scanf("%d%d", &n, &m);
if (n < m) swap(n, m);
if (n == m) {
printf("%lld\n", a[n]);
return 0;
}
ll ans = 0;
for (int k = 0; k <= m; k++) {
int L = n - m + k - 1;
ll p = getC(L + k, k);
if (k > 0)
p = sub(p, getC(L + k, k - 1));
p = mult(p, getC(2 * (m - k), m - k));
ans = add(ans, mult(p, add(L + 1, a[m - k])));
}
ans = mult(ans, mult(rf[n + m], mult(f[n], f[m])));
printf("%lld\n", ans);
return 0;
}
| #include<bits/stdc++.h>
const int N=1e6+9,mo=998244353;
int f[N/2],f2[N/2],G[N/2],mi[N],vf[N],inv[N],fac[N],i,n,m,z,ans;
inline int C(int x,int y){return x<y?0:1ll*vf[y]*vf[x-y]%mo*fac[x]%mo;}
int main(){
*f=*f2=1;
for(i=*mi=*vf=*fac=1;i<N;++i)mi[i]=4ll*mi[i-1]%mo,inv[i]=i==1?1:1ll*(mo-mo/i)*inv[mo%i]%mo,
fac[i]=1ll*i*fac[i-1]%mo,vf[i]=1ll*vf[i-1]*inv[i]%mo;
scanf("%d%d",&n,&m);if(n>m)std::swap(n,m);
for(i=0;i<n;++i)f[i+1]=1ll*inv[i+1]*(4*i+2)%mo*f[i]%mo;
for(i=0;i<n;++i)f2[i+1]=1ll*inv[2*i+2]%mo*(8*i+12)%mo*f2[i]%mo;
for(i=1;i<=n;++i)G[i]=(1ll*inv[2]*(mi[i]+mo-f[i])+f2[i-1]*2)%mo;
if(n==m)ans=G[n];else for(i=0,z=m-n;i<=n;++i)ans=(ans+1ll*(G[n-i]+
1ll*(i+z)*C(n*2-i*2,n-i))%mo*(C(z-1+i*2,i)+mo-C(z-1+i*2,i+z)))%mo;
ans=1ll*fac[n]*fac[m]%mo*vf[n+m]%mo*ans%mo;
printf("%d\n",ans);
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define fast_io ios_base::sync_with_stdio(false) ; cin.tie(0); cout.tie(0);
int main() {
fast_io;
long long x;
cin>>x;
long long thousand=(x/500)*1000;
long long rest=(x%500)/5*5;;
long long ans=thousand+rest;
cout<<ans<<endl;
}
| #include<bits/stdc++.h>
// Begin Header {{{
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i,n) for(ll i=0; i<n; i++)
#define loop(i, j, n) for(ll i=j; i<n; i++)
#define all(x) (x).begin(), (x).end()
constexpr int INF = 0x3f3f3f40;
const long long mod=2e9+7;
const long double PI = acos(0);
// }}} End Header
int main() {
ll x, ans=0;
cin >> x;
ans+=1000*(x/500);
x%=500;
ans+=5*(x/5);
cout << ans << endl;
return 0;
}
| 1 |
#include "bits/stdc++.h"
#define MOD 1000000007
#define rep(i, n) for(ll i=0; i < (n); i++)
#define rrep(i, n) for(ll i=(n)-1; i >=0; i--)
#define ALL(v) v.begin(),v.end()
#define rALL(v) v.rbegin(),v.rend()
#define FOR(i, j, k) for(ll i=j;i<k;i++)
#define debug_print(var) cerr << #var << "=" << var <<endl;
#define DUMP(i, v)for(ll i=0;i<v.size();i++)cerr<<v[i]<<" "
#define fi first
#define se second
using namespace std;
typedef long long int ll;
typedef vector<ll> llvec;
typedef vector<double> dvec;
typedef pair<ll, ll> P;
typedef long double ld;
struct edge{ll x, c;};
ll mod(ll a, ll mod){
ll res = a%mod;
if(res<0)res=res + mod;
return res;
}
ll modpow(ll a, ll n, ll mod){
ll res=1;
while(n>0){
if(n&1) res=res*a%mod;
a=a*a%mod;
n>>=1;
}
return res;
}
ll modinv(ll a, ll mod){
ll b=mod, u=1, v=0;
while(b){
ll t=a/b;
a-=t*b; swap(a, b);
u-=t*v; swap(u, v);
}
u%=mod;
if(u<0)u+=mod;
return u;
}
ll gcd(ll a, ll b){
ll r = a%b;
if(r==0) return b;
else return gcd(b, a%b);
}
bool is_prime(ll n){
ll i = 2;
if(n==1)return false;
if(n==2)return true;
bool res = true;
while(i*i <n){
if(n%i==0){
res = false;
}
i = i+1;
}
//if(i==1)res = false;
if(n%i==0)res=false;
return res;
}
struct UnionFind{
ll N;
llvec p;
llvec cnt;
UnionFind(ll n){
N = n;
p=llvec(N);
cnt=llvec(N, 0);
rep(i, N){
p[i] = i;
cnt[i] = 1;
}
}
void con(ll a, ll b){
P at = root(a);
P bt = root(b);
if(at.second!=bt.second){
if(at.first>bt.first){
swap(at, bt);
swap(a, b);
}
p[at.second] = bt.second;
cnt[bt.second]+=cnt[at.second];
p[a]=bt.second;
}
}
P root(ll a){
ll atmp = a;
ll c=0;
while(atmp!=p[atmp]){
atmp = p[atmp];
c++;
}
p[a] = atmp;
return {c, atmp};
}
bool is_con(ll a, ll b){
P at=root(a);
P bt=root(b);
return at.second == bt.second;
}
};
struct dijkstra{
ll N;
llvec d;
vector<vector<edge>> e;
dijkstra(ll n){
N = n;
//d = llvec(N, 1e18);
e = vector<vector<edge>>(N);
}
void add_edge(ll from, ll to, ll cost){
e[from].push_back({to, cost});
}
void run(ll start){
priority_queue<P, vector<P>, greater<P>> que;
que.push({0, start});
d = llvec(N, 1e18);
d[start]=0;
while(!que.empty()){
P q = que.top();que.pop();
ll dc = q.first;
ll x = q.second;
if(dc>d[x]){
continue;
}else{
for(auto ip: e[x]){
if(d[ip.x]<=d[x]+ip.c){
continue;
}else{
d[ip.x]= d[x]+ip.c;
que.push({d[ip.x], ip.x});
}
}
}
}
}
};
/**************************************
** A main function starts from here **
***************************************/
int main(){
ll a, b;
cin >> a >> b;
ll k;
cin >> k;
for(ll i=0;i<k;i++){
if(a%2==1)a-=1;
b += a/2;
a/=2;
i++;
if(i==k)break;
if(b%2==1)b-=1;
a += b/2;
b/=2;
}
cout << a << " " << b << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rng(i, a, b) for (int i = int(a); i < int(b); i++)
#define rep(i, b) rng(i, 0, b)
#define gnr(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define per(i, b) gnr(i, 0, b)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n, k;
cin >> n >> k;
vector<int> x(n);
rep(i, n) cin >> x.at(i);
vector<int> minus;
vector<int> plus;
rep(i, n) {
int xx = x.at(i);
if (xx >= 0) {
plus.push_back(xx);
} else {
minus.push_back(-xx);
}
}
reverse(minus.begin(), minus.end());
ll res = 1L << 30;
// マイナスから折り返す
rep(i, min((int) minus.size(), k)) {
ll tmp = 0;
tmp += 2 * minus.at(i);
int plusCnt = k - 1 - i;
if (plusCnt > (int) plus.size()) {
continue;
}
if (plusCnt > 0) {
tmp += plus.at(plusCnt - 1);
}
res = min(res, tmp);
}
// プラスから折り返す
rep(i, min((int) plus.size(), k)) {
ll tmp = 0;
tmp += 2 * plus.at(i);
int minusCnt = k - 1 - i;
if (minusCnt > (int) minus.size()) {
continue;
}
if (minusCnt > 0) {
tmp += minus.at(minusCnt - 1);
}
res = min(res, tmp);
}
// 全部どちらかの場合
if ((int) minus.size() >= k) {
res = min(res, (ll) minus.at(k - 1));
}
if ((int) plus.size() >= k) {
res = min(res, (ll) plus.at(k - 1));
}
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int m;
cin >> m;
vector<int> nodes;
vector<pair<int, int>> child;
int n = 0;
for (int i = 0; i < m; i++){
string q;
cin >> q;
if (q == "insert"){
int k;
cin >> k;
if (n != 0){
int v = 0;
while (1){
if (k < nodes[v]){
if (child[v].first != -1){
v = child[v].first;
} else {
child[v].first = nodes.size();
break;
}
} else {
if (child[v].second != -1){
v = child[v].second;
} else {
child[v].second = nodes.size();
break;
}
}
}
}
nodes.push_back(k);
child.push_back(make_pair(-1, -1));
n++;
}
if (q == "find"){
int k;
cin >> k;
if (n == 0){
cout << "no" << endl;
} else {
int v = 0;
while (1){
if (k < nodes[v]){
if (child[v].first == -1){
cout << "no" << endl;
break;
} else {
v = child[v].first;
}
} else if (k > nodes[v]){
if (child[v].second == -1){
cout << "no" << endl;
break;
} else {
v = child[v].second;
}
} else {
cout << "yes" << endl;
break;
}
}
}
}
if (q == "delete"){
int k;
cin >> k;
int v = 0;
int u;
while (1){
if (k < nodes[v]){
u = v;
v = child[v].first;
} else if (k > nodes[v]){
u = v;
v = child[v].second;
} else {
break;
}
}
if (child[v].first != -1 && child[v].second != -1){
u = v;
int w = child[v].second;
while (child[w].first != -1 || child[w].second != -1){
u = w;
if (child[w].first != -1){
w = child[w].first;
} else {
w = child[w].second;
}
}
swap(nodes[v], nodes[w]);
v = w;
}
if (child[v].first != -1 && child[v].second == -1){
int w = child[v].first;
nodes[v] = nodes[w];
child[v].first = child[w].first;
child[v].second = child[w].second;
} else if (child[v].second != -1 && child[v].first == -1){
int w = child[v].second;
nodes[v] = nodes[w];
child[v].first = child[w].first;
child[v].second = child[w].second;
} else {
if (child[u].first == v){
child[u].first = -1;
} else {
child[u].second = -1;
}
}
n--;
}
if (q == "print"){
//Inorder
if (n != 0){
stack<int> S;
vector<int> t(nodes.size(), 0);
S.push(0);
while (!S.empty()){
int v = S.top();
S.pop();
if (t[v] == 1){
cout << ' ' << nodes[v];
}
if (t[v] == 0){
S.push(v);
if (child[v].second != -1){
S.push(child[v].second);
}
S.push(v);
if (child[v].first != -1){
S.push(child[v].first);
}
}
t[v]++;
}
}
cout << endl;
//Preorder
if (n != 0){
stack<int> S;
vector<int> t(nodes.size(), 0);
S.push(0);
while (!S.empty()){
int v = S.top();
S.pop();
if (t[v] == 0){
cout << ' ' << nodes[v];
}
if (t[v] == 0){
S.push(v);
if (child[v].second != -1){
S.push(child[v].second);
}
S.push(v);
if (child[v].first != -1){
S.push(child[v].first);
}
}
t[v]++;
}
}
cout << endl;
}
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct Node{
ll key;
Node *parent,*left,*right;
};
struct Tree{
Node *nil,*root;
void init(){
root=nil;
}
void add(ll key){
Node *newnode;
Node *p;
newnode = (Node*)malloc(sizeof(Node));
newnode->key = key;
newnode->parent = newnode->right = newnode->left = nil;
Node *pa = find_node(key);
if(pa == nil){
root = newnode;
}else if(key < pa->key){
pa->left = newnode;
newnode->parent = pa;
}else{
pa->right = newnode;
newnode->parent = pa;
}
}
Node *find_node(ll key){
Node *pa=nil;
Node *loc=root;
while(loc != nil){
pa = loc;
if(key < loc->key){
loc = loc->left;
}else{
loc = loc->right;
}
}
return pa;
}
Node *find_x(ll x){
Node *p=root;
while(p != nil){
if(x == p->key){
break;
}else if(x < p->key){
p = p->left;
}else{
p = p->right;
}
}
return p;
}
ll find_rightmin(Node *r){
Node *rmin = r->right;
while(rmin->left != nil){
rmin = rmin->left;
}
return rmin->key;
}
void del(ll k){
Node *loc=find_x(k);
Node *p=loc->parent;
if(loc->left==nil && loc->right == nil){
//leafだったら
if(p==nil)root=nil;
else if(p->key > loc->key)p->left=nil;
else p->right=nil;
free(loc);
}else if(loc->left == nil || loc->right==nil){
//片方だったら
if(loc->left == nil){
if(p == nil)root=loc->right, loc->right->parent=root;
else if(p->key > loc->key)p->left=loc->right, loc->right->parent=p;
else p->right=loc->right, loc->right->parent=p;
}else{
if(loc->parent == nil)root=loc->left, loc->left->parent=nil;
else if(p->key > loc->key)p->left=loc->left, loc->left->parent=p;
else p->right=loc->left, loc->left->parent=p;
}
free(loc);
}else{
//二分木の根だったら
ll rmin=find_rightmin(loc);
del(rmin);
loc->key=rmin;
}
}
void print_in(Node *r){
if(r==nil)return;
else{
print_in(r->left);
cout << " " << r->key;
print_in(r->right);
}
}
void print_pre(Node *r){
if(r==nil)return;
else{
cout << " " << r->key;
print_pre(r->left);
print_pre(r->right);
}
}
void print(){
print_in(root);
cout << endl;
print_pre(root);
cout << endl;
}
};
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
Tree tree;
tree.init();
int n;
cin >> n;
string s;
for(int i=0;i<n;i++){
cin >> s;
if(s=="insert"){
ll k;
cin >> k;
tree.add(k);
}else if(s=="find"){
ll k;
cin >> k;
Node *p = tree.find_x(k);
if(p != tree.nil)cout << "yes\n";
else cout << "no\n";
}else if(s=="delete"){
ll k;
cin >> k;
tree.del(k);
}else {
tree.print();
}
}
return 0;
}
| 1 |
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <sstream>
#include <cmath>
#include <queue>
using namespace std;
int main(){
int n;
while(true){
cin >> n;
if(n == 0){
break;
}
for(int i = 0; i < n; i++){
int a, b, c;
cin >> a >> b >> c;
if(a == 100 || b == 100 || c == 100){
cout << "A" << endl;
}else if(a + b >= 180){
cout << "A" << endl;
}else if(a + b + c >= 240){
cout << "A" << endl;
}else if(a + b + c >= 210){
cout << "B" << endl;
}else if(a + b + c >= 150 && (a >= 80 || b >= 80)){
cout << "B" << endl;
}else{
cout << "C" << endl;
}
}
}
return 0;
} | /*
* src.cpp
*
* Created on: 2016/08/04
* Author: joi
*/
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,a) FOR(i,0,a)
const int MAX_N=1e4;
int n;
int p[3];
char out[MAX_N+5];
int main(){
do{
cin>>n;
if (n){
REP(i,n){
int ave=0;
bool f=false;
REP(j,3){
cin>>p[j];
ave+=p[j];
if (p[j]==100){
f=true;
}
}
if (f){
out[i]='A';
}else if (p[0]+p[1]>=180){
out[i]='A';
}else if (ave>=80*3){
out[i]='A';
}else if (ave>=70*3){
out[i]='B';
}else if (ave>=50*3 && (p[0]>=80 || p[1]>=80)){
out[i]='B';
}else{
out[i]='C';
}
}
REP(i,n){
cout<<out[i]<<endl;
}
}
}while (n);
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main () {
int n;
vector<int> values;
cin >> n;
cin.ignore();
for (int i = 1; i <= n; i++){
string tmp_value;
if(i == n)
getline(cin, tmp_value);
else
getline(cin, tmp_value, ' ');
values.push_back(stoi(tmp_value));
}
for (int i = n; i != 0; i--){
if (i == 1)
cout << values[i - 1] << endl;
else
cout << values[i - 1] << ' ';
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
int b,a[100];
cin>>b;
for(int i=0;i<b;i++){
cin>>a[i];
}
for(int i=b-1;i>=0;i--){
cout<<a[i];
if(i!=0)cout<<" ";
}
cout<<endl;
return 0;
}
| 1 |
/* */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")
#define sti set<int>
#define stpii set<pair<int, int> >
#define mpii map<int,int>
#define vi vector<int>
#define pii pair<int,int>
#define vpii vector<pair<int,int> >
#define rep(i, a, n) for (int i=a;i<n;++i)
#define per(i, a, n) for (int i=n-1;i>=a;--i)
#define clr clear
#define pb push_back
#define mp make_pair
#define fir first
#define sec second
#define all(x) (x).begin(),(x).end()
#define SZ(x) ((int)(x).size())
#define lson l, mid, rt<<1
#define rson mid+1, r, rt<<1|1
#define getBits(x) __builtin_popcount(x)
#define getBitIdx(x) __builtin_ffs(x)
typedef long long LL;
const int maxn = 45;
int s[maxn][maxn];
int dir[4][2] = {
-1,0, 1,0, 0,-1, 0,1
};
int n, m;
int stx, sty, edx, edy;
int ansd;
inline bool judge(int x, int y) {
return x<0 || x>=n || y<0 || y>=m;
}
void init() {
rep(i, 0, n) {
rep(j, 0, m) {
if (s[i][j] == 2) {
stx = i;
sty = j;
s[i][j] = 0;
} else if (s[i][j] == 3) {
edx = i;
edy = j;
s[i][j] = 0;
}
}
}
}
void dfs(int dep, int x, int y) {
if (dep >= ansd) return;
if (x==edx && y==edy) {
ansd = dep;
return ;
}
int xx, yy;
int flag;
rep(i, 0, 4) {
xx = x;
yy = y;
if (judge(xx+dir[i][0], yy+dir[i][1]) || s[xx+dir[i][0]][yy+dir[i][1]] == 1) continue;
flag = 1;
while (true) {
if (judge(xx+dir[i][0], yy+dir[i][1])) {
flag = 0;
break;
}
if (s[xx+dir[i][0]][yy+dir[i][1]] == 1) {
flag = -1;
break;
}
xx += dir[i][0];
yy += dir[i][1];
if (xx==edx && yy==edy) {
break;
}
}
if (flag == 0) continue;
if (flag == -1) {
s[xx+dir[i][0]][yy+dir[i][1]] = 0;
}
dfs(dep+1, xx, yy);
if (flag == -1) {
s[xx+dir[i][0]][yy+dir[i][1]] = 1;
}
}
}
void solve() {
init();
ansd = 11;
dfs(0, stx, sty);
if (ansd == 11) ansd = -1;
printf("%d\n", ansd);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// #ifndef ONLINE_JUDGE
// freopen("data.in", "r", stdin);
// freopen("data.out", "w", stdout);
// #endif
while (scanf("%d %d", &m,&n)!=EOF && (n||m)) {
rep(i, 0, n)
rep(j, 0, m)
scanf("%d", &s[i][j]);
solve();
}
// #ifndef ONLINE_JUDGE
// printf("time = %ldms.\n", clock());
// #endif
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
typedef vector <int> VI;
typedef vector <VI> VVI;
const int dx[5] = { 0, 0, 0, 1, -1 };
const int dy[5] = { 0, 1, -1, 0, 0 };
int w, h;
int sx, sy, gx, gy;
VVI M;
int answer;
//==================================================
// Tõ
//==================================================
void dfs( int x, int y, int a, int d )
{
if ( d > 10 ) return;
if ( M[y][x] == 3 )
{
if ( answer == -1 )
answer = d;
else
answer = min( answer, d );
}
if ( a > 0 )
{
int nx = x + dx[a];
int ny = y + dy[a];
if ( nx < 0 || nx >= w || ny < 0 || ny >= h )
return;
if ( M[ny][nx] == 1 )
{
M[ny][nx] = 0;
dfs( x, y, 0, d );
M[ny][nx] = 1;
}
else
dfs( nx, ny, a, d );
}
else
{
for ( int i = 1; i < 5; i++ )
{
int nx = x + dx[i];
int ny = y + dy[i];
if ( nx < 0 || nx >= w || ny < 0 || ny >= h )
continue;
if ( M[ny][nx] == 0 || M[ny][nx] == 3 )
{
dfs( nx, ny, i, d+1 );
}
}
}
}
int main( void )
{
while ( cin >> w >> h && w && h )
{
//==================================================
// Ï
//==================================================
M = VVI( h, VI( w, 0 ) );
answer = -1;
//==================================================
// }bvÌüÍ
//==================================================
for ( int i = 0; i < h; i++ )
{
for ( int j = 0; j < w; j++ )
{
int& s = M[i][j];
cin >> s;
// X^[gES[
if ( s == 2 )
{
sx = j;
sy = i;
s = 0;
}
else if ( s == 3 )
{
gx = j;
gy = i;
}
}
}
//==================================================
//
//==================================================
dfs( sx, sy, 0, 0 );
//==================================================
// oÍ
//==================================================
cout << answer << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define rep(i, n) FOR(i, 0, n)
#define rep1(i, n) FOR(i, 1, n+1)
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define whole(x) (x).begin(),(x).end()
#define rwhole(x) (x).rbegin(), (x).rend()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
#define P pair<int, int>
#define debug(var) cerr << "[" << #var << "] " << var << endl
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define eb emplace_back
const ll mod = 1000000007;
const int dx[] = {-1,0,1,0};
const int dy[] = {0,-1,0,1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
int n = s.size();
rep(i, n) {
if (i==0) continue;
if (s[i]==s[i-1]) {
cout << i << " " << i+1 << endl;
return 0;
}
}
rep(i, n) {
if (i<=1) continue;
if (s[i]==s[i-2]) {
cout << i-1 << " " << i+1 << endl;
return 0;
}
}
cout << "-1 -1" << endl;
return 0;
}
| //vec[i]の範囲外エラー表示
#define _GLIBCXX_DEBUG
//includeとusing
#include <bits/stdc++.h>
using namespace std;
//型名省略
using ll = long long;
using st = string;
using vl = vector<long long>;
using vvl = vector<vector<long long>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
using vs = vector<string>;
using pll = pair<ll, ll>;
using pcc = pair<char, char>;
//定数
const ll INF = 1e9;
const ll MOD = 1e9+7;
const vl dx = {1,0,-1,0,1,0,-1,0};
const vl dy = {0,1,0,-1,0,1,0,-1};
//マクロ
#define rep(i,n) for(ll i = 0; i < (ll) n; i++)
#define rrep(i,n) for(ll i = (ll) n - 1; i >= 0;i--)
#define REP(i,x,n) for(ll i = (ll) x; i < (ll) n; i++)
#define RREP(i,x,n) for(ll i = (ll) n - 1; i >= x; i--)
#define each(i,A) for(ll i: (vl) A)
#define all(A) A.begin(), A.end()
#define Size(A) ll(A.size())
//入力
template<typename T> T input() {T x; cin >> x; return x;}
//正誤判定
void Yes(bool ans){cout << (ans? "Yes" : "No") << endl;}
void YES(bool ans){cout << (ans? "YES" : "NO") << endl;}
//余り切り上げ
ll ceil(ll a,ll b) {return (a + b - 1) / b;}
//最大値・最小値
template <typename T> bool chmax(T &a, const T& b) {if(a < b) {a = b; return true;} return false;}
template <typename T> bool chmin(T &a, const T& b) {if(a > b) {a = b; return true;} return false;}
//最大公約数
ll gcd(ll a,ll b){if(a<b)swap(a,b); if(a%b==0)return b; return gcd(b,a%b);}
//最小公倍数
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
//n乗の余り
ll modPow(ll x,ll n,ll mod){if(n==0)return 1; if(n%2==0)return modPow(x*x,n/2,mod)%mod; return x%mod*modPow(x,n-1,mod)%mod;}
/*--------------------------------------------------------------------------*/
//main関数
int main() {
st s; cin >> s;
bool flag = false;
rep(i,3){
if(s[i] == '7') flag = true;
}
Yes(flag);
}
| 0 |
#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#define pi 3.141592653589793238
#define int long long
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
vector<vector<int>> adj;
int dp[100005];
int k,ans=0;
int parent[1000005];
void dfs(int ver,int pr)
{
parent[ver]=pr;
int mx=-1;
for(auto i:adj[ver])
{
dfs(i,ver);
mx=max(mx,dp[i]);
}
dp[ver]=mx+1;
if(dp[ver]==k-1 &&parent[ver]!=1)
{
dp[ver]=-1;
ans++;
}
}
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
#ifndef ONLINE_JUDGE
if(fopen("INPUT.txt","r"))
{
freopen ("INPUT.txt" , "r" , stdin);
freopen ("OUTPUT.txt" , "w" , stdout);
}
#endif
int n;
cin>>n>>k;
adj.resize(n+1);
int x;
cin>>x;
fill_n(dp,100004,-1);
if(x!=1)
ans++;
for(int i=0;i<n-1;i++)
{
cin>>x;
adj[x].push_back(i+2);
}
dfs(1,1);
cout<<ans;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define REP(i, n) for(int (i) = 0; (i) < (n); ++(i))
#define REPR(i, n) for(int (i) = (n); (i) >= 0; --(i))
#define FOR(i, n, m) for(int (i) = (n); (i) < (m); ++(i))
// constexpr int INF = 1e9;
constexpr ll INF = 1LL<<61;
constexpr ll mod = 1e9+7;
ll dp[1000005][2];
int main(){
string S;
cin >> S;
int N = S.size();
REP(i, N+1){
REP(j, 2){
dp[i][j] = INF;
}
}
dp[0][0] = 0;
dp[0][1] = 1;
REP(i, N){
int d = S[i] - '0';
dp[i+1][0] = min(dp[i][0]+d, dp[i+1][0]);
dp[i+1][0] = min(dp[i][1]+10-d, dp[i+1][0]);
dp[i+1][1] = min(dp[i][0]+d+1, dp[i+1][1]);
dp[i+1][1] = min(dp[i][1]+10-d-1, dp[i+1][1]);
}
cout << dp[N][0] << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vector<int>>
#define all(x) (x).begin(),(x).end()
#define rep(i, n) for (int i = 0; i < n; i++)
#define Rep(i, n) for (int i = 1; i <= n; i++)
typedef pair<int, int> P;
const ll INF = 1ll<<60;
typedef struct{int to, cost;} edge;
int N, Q, K;
vector<edge> G[100100];
vll d(100100, INF);
void nya(int s){
priority_queue<P, vector<P>, greater<P> >que;
d[s] = 0ll;
que.push(P(0, s));
while(!que.empty()){
P p = que.top(); que.pop();
int v = p.second;
if(d[v] < p.first) continue;
rep(i, G[v].size()){
edge e = G[v][i];
if(d[e.to] > d[v] + e.cost){
d[e.to] = d[v] + e.cost;
que.push(P(d[e.to], e.to));
}
}
}
return;
}
int main(){
cin >> N;
rep(i, N)if(i){
int a, b, c;
cin >> a >> b >> c;
a--; b--;
edge tmp;
tmp.to = b;
tmp.cost = c;
G[a].push_back(tmp);
tmp.to = a;
G[b].push_back(tmp);
}
cin >> Q >> K;
nya(K - 1);
while(Q--){
int x, y;
cin >> x >> y;
x--; y--;
cout << d[x] + d[y] << endl;
}
return 0;
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
using namespace std;
typedef long long int ll;
typedef unsigned long long int sll;
typedef double ld;
#define A 1000000007ll
#define D 1000000000ll
#define B 998244353ll
#define C 1000000000000000000ll
#define FAST ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define oset tree<pair<ll,ll>, null_type,less<pair<ll,ll>>, rb_tree_tag,tree_order_statistics_node_update>
#define pb push_back
#define puf push_front
#define pob pop_back
#define pof pop_front
#define mxe(v) *max_element(v.begin(),v.end())
#define mne(v) *min_element(v.begin(),v.end())
#define bs binary_search
#define lb lower_bound
#define ub upper_bound
#define ve vector
#define br break
#define PI 3.14159265358979323
#define subt cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC << "ms\n"
ll dp[7007];
int main()
{
FAST;
ll n,t;
cin>>n>>t;
pair<ll,ll> a[n];
ll x,y;
for(int i=0;i<n;i++)
{
cin>>x>>y;
a[i]={x,y};
}
sort(a,a+n);
for(int i=1;i<7007;i++)
dp[i]=-1;
for(int i=0;i<n;i++)
for(int j=t-1;j>=0;j--)
if(dp[j]!=-1)
dp[a[i].first+j]=max(dp[a[i].first+j],dp[j]+a[i].second);
ll ans=0;
for(int i=0;i<7007;i++)
ans=max(ans,dp[i]);
cout<<ans;
subt;
return 0;
} | 0 |
#include<bits/stdc++.h>
const int MOD = 1e9 + 7;
using namespace std;
int main(){
string K;
cin >> K;
int D;
cin >> D;
vector<vector<vector<long long>>> dp(K.size() + 1, vector<vector<long long>>(D, vector<long long>(2, 0)));
dp[0][0][1] = 1;
for(int i = 0; i < (int)K.size(); i++){
for(int j = 0; j < D; j++){
for(int k = 0; k < 10; k++){
dp[i + 1][(j + k) % D][0] += dp[i][j][0];
if(k < K[i] - '0'){
dp[i + 1][(j + k) % D][0] += dp[i][j][1];
}else if(k == K[i] - '0'){
dp[i + 1][(j + k) % D][1] += dp[i][j][1];
}
dp[i + 1][(j + k) % D][0] %= MOD;
dp[i + 1][(j + k) % D][1] %= MOD;
}
}
}
cout << ((dp[K.size()][0][0] + dp[K.size()][0][1] - 1) % MOD + MOD) % MOD << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
int pref[250005], suff[250005], ans, prefix[250005], h , w, a, b;
const int mod = 1e9 + 7;
int BinPow(int x,int n){
if(n == 0)
return 1;
if(n == 1)
return x;
else{
int sum = BinPow(x, n / 2) % mod;
sum*=sum; sum%=mod;
if(n % 2 != 0)
sum *= x, sum%=mod;
return sum;
}
}
int C(int x,int n){
if(x < 0 || x > n || n < 0) return 0;
int sum = pref[n] * suff[x]; sum %= mod;
sum*=suff[n - x]; sum %= mod;
return sum;
}
signed main(){
cin.tie(0), ios::sync_with_stdio(0);
cin >> h >> w >> a >> b;
pref[0] = 1;
for(int i = 1; i <= 250000; i++){
pref[i] = pref[i - 1]*i;
pref[i] %= mod;
}
suff[0] = 1;
for(int i = 1; i <= 250000; i++)
suff[i] = BinPow(pref[i], mod - 2);
for(int i = 1; i <= 100000; i++){
if(i >= h - a + 1){
prefix[i] += C(b - 1, i + b - 2);
pref[i] %= mod;
prefix[i] += prefix[i - 1];
}
}
ans = C(h - 1,h + w - 2);
for(int i = 1; i <= h; i++){
if(i >= h - a + 1){
int dist = w - b;
int dist1 = h - i + 1;
ans -= C(b - 1, i + b - 2)*C(dist1 - 1,dist + dist1 -2 );
ans %= mod;
if(ans < 0) ans += mod;
}
}
cout << ans;
} | 0 |
#include <iostream>
#include <algorithm>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<ctime>
#include<set>
#include<iomanip>
#define sqr(x) (x)*(x)
#define fz1(i,n) for ((i)=1;(i)<=(n);(i)++)
#define fd1(i,n) for ((i)=(n);(i)>=1;(i)--)
#define fz0g(i,n) for ((i)=0;(i)<=(n);(i)++)
#define fd0g(i,n) for ((i)=(n);(i)>=0;(i)--)
#define fz0k(i,n) for ((i)=0;(i)<(n);(i)++)
#define fd0k(i,n) for ((i)=(long long)((n)-1);(i)>=0;(i)--)
#define fz(i,x,y) for ((i)=(x);(i)<=(y);(i)++)
#define fd(i,y,x) for ((i)=(y);(i)>=(x);(i)--)
#define ff(c,itr) for (__typeof((c).begin()) itr=(c).begin();itr!=(c).end();itr++)
#define rdst(st,len){static char ss[len];scanf(" %s",ss);(st)=ss;}
//#define T_ int
using namespace std;
//struct bit{T_ arr[1000005];int lowbit(int x){return x&(-x);}void add(int x,T_ y){for (int i=x;i<=n;i+=lowbit(i)) arr[i]+=y;}T_ query(int x){T_ s=0;for (int i=x;i>0;i-=lowbit(i)) s+=arr[i];return s;}};
//struct seg{struct treedot{int l,r;T_ sum,add;void update(T_ x){sum+=(r-l+1)*x; add+=x;}}c[800005];void pushdown(int id){if (c[id].add){c[id*2].update(c[id].add);c[id*2+1].update(c[id].add);c[id].add=0;}}void pushup(int id){c[id].sum=c[id*2].sum+c[id*2+1].sum;}void build(int id,int l,int r){if (l>r) return;c[id].l=l;c[id].r=r;c[id].sum=0;c[id].add=0;if (l==r) c[id].sum=0;else{int mid=l+(r-l)/2;build(id*2,l,mid);build(id*2+1,mid+1,r);pushup(id);}}void update(int id,int le,int ri,T_ x){if (le>c[id].r||ri<c[id].l) return;if (le<=c[id].l&&c[id].r<=ri) c[id].update(x);else{pushdown(id);update(id*2,le,ri,x);update(id*2+1,le,ri,x);pushup(id);}}T_ query(int id,int le,int ri){if (ri<c[id].l||c[id].r<le) return 0;if (le<=c[id].l&&c[id].r<=ri) return c[id].sum;T_ ans=0;pushdown(id);ans+=query(id*2,le,ri);ans+=query(id*2+1,le,ri);pushup(id);return ans;}};
//struct bit_2d{T_ a[2005][2005];int lowbit(int x){return x&(-x);}void add(int x,int y,T_ z){int i,j;for (i=x;i<=2000;i+=lowbit(i)){for (j=y;j<=2000;j+=lowbit(j)){a[i][j]+=z;}}}T_ query(int x,int y){int i,j;T_ s=0;for (i=x;i;i-=lowbit(i)){for (j=y;j;j-=lowbit(j)){s+=a[i][j];}}return s;}T_ query(int x,int y,int xx,int yy){return query(xx,yy)-query(x-1,yy)-query(xx,y-1)+query(x-1,y-1);}};
long long n,m,i,j,f[200005],g[200005],a[200005],ans;
int main()
{
scanf("%lld%lld",&n,&m);
ans=m*(n-1);
fz1(i,n)
{
scanf("%lld",&a[i]);
ans+=a[i];
}
f[0]=g[n+1]=(1ll<<60);
fz1(i,n)
{
f[i]=min(a[i],f[i-1]+m);
}
fd1(i,n)
{
g[i]=min(a[i],g[i+1]+m);
}
fz(i,2,n-1) ans+=min(f[i],g[i]);
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define INF 2e9
#define MOD 1000000007
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
using P = pair<int,int>;
int main()
{
ll N,A,B;
cin >> N >> A >> B;
vector<ll> X(N);
REP(i, N) cin >> X[i];
ll ans=0;
REP(i,N-1){
if((X[i+1]-X[i])*A>=B){
ans+=B;
}else{
ans+=(X[i+1]-X[i])*A;
}
}
cout << ans << endl;
} | 0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <string>
#include <queue>
#include <fstream>
#include <string>
#include <math.h>
#include <set>
#include <string>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
//typedef pair<ll, P> T;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define revrep(i, n) for (ll i = (n) - 1; i >= 0; i--)
#define f first
#define s second
#define pb push_back
ll mod = 2147483647;
const ll INF = 100000000000010000;
const ull B = 998244353;
//ll bit[200010];
//ll kai[3010];
//void pres(double A, ll x = 20) { printf("%.20f\n", x); }
/*ll sum(ll i)
{
i += 1;
ll t = 0;
while (i > 0)
{
t += bit[i];
i -= i & -i;
}
return t;
}
void update(ll i, ll x)
{
i += 1;
while (i <= 200005)
{
bit[i] += x;
i += i & -i;
}
}*/
/*`ll SAIKI(ll S) {
for (ll T = S; ; T = (T - 1) & S) {
}
}*/
void test() {
cout << "888888888888888888888888" << endl;
}
ll gcd(ll x, ll y) {
if (y == 0) return x;
return gcd(y, x % y);
}
ll pow_mod(ll x, ll y) {
if (y == 0) return 1;
if (y % 2 == 1) {
return x * pow_mod(x, y - 1) % mod;
}
else {
ll half = pow_mod(x, y / 2);
return half * half % mod;
}
}
ll div_mod(ll x) {
return pow_mod(x, mod - 2);
}
/*ll com(ll x, ll y) {
return kai[x] * div_mod(kai[y] * kai[x - y] % mod) % mod;
//毎回オーダーlog(n)かかる
}*/
/*void kaijo() {
kai[0] = 1;
for (ll i = 1; i <= 3004; i++) {
kai[i] = kai[i - 1] * i % mod;
}
}*/
ll N, A[100010], sum, resum;
ll hakidashi[60];
vector<P> trans;
ll ans;
void solve() {
cin >> N;
rep(i, N) cin >> A[i];
rep(i, N) sum ^= A[i];
resum = sum ^ ((1LL << 60) - 1);
rep(i, N) A[i] &= resum;
priority_queue<ll> que;
ll bit = 59;
rep(i, N)if (A[i] != 0) que.push(A[i]);
while (que.size()) {
ll lar = que.top(); que.pop();
while ((lar & (1LL << bit)) == 0 && bit >= 0) bit--;
if (bit < 0) break;
hakidashi[bit] = lar;
while (que.size() && que.top() > (1LL << bit)) {
ll a = que.top(); que.pop();
que.push(a ^ hakidashi[bit]);
}
}
rep(i, 60)if (hakidashi[i] != 0) trans.pb(P(hakidashi[i], i));
for (ll i = 0; i < trans.size(); i++) {
for (ll j = i + 1; j < trans.size(); j++) {
P p = trans[i], q = trans[j];
if ((q.f & (1LL << p.s)) != 0) trans[j].f ^= p.f;
}
}
for (P p : trans) ans ^= p.f;
ans = ans * 2 + sum;
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
ll N;
cin >> N;
} | #include <bits/stdc++.h>
#define syosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
typedef pair<double,double> pdd;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<string> vs;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef vector<pll> vpll;
typedef pair<ll,pll> pip;
typedef vector<pip> vip;
const int inf=1<<30;
const ll INF=1ll<<60;
const double pi=acos(-1);
const double eps=1e-9;
const ll mod=1e9+7;
const int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
const int M=60,N=100000;
ll n,cnt[M],ID=0;
vl a;
vp d;
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
cin>>n;
a=vl(n);
vector<bitset<N+1>> b;
for(auto &i:a){
cin>>i;
for(int j=0;j<M;j++) if(i&1ll<<j) cnt[j]++;
}
ll sum=0;
for(int i=M-1;i>=0;i--){
ll cnt=0,t=1ll<<i;
bitset<N+1> c;
c[N]=1;
for(int j=0;j<n;j++) if(a[j]&t){
c[j]=1;
cnt++;
}
if(cnt%2==1){
sum+=t;
continue;
}
sort(d.begin(),d.end());
for(auto p:d){
int tmp=p.first,id=p.second;
if(c[tmp]) c^=b[id];
}
bitset<N+1> beet;
beet[N]=1;
if(c==beet) continue;
int I;
for(int j=0;j<=N;j++) if(c[j]){
d.push_back({j,ID});
ID++;
b.push_back(c);
I=j;
break;
}
for(int j=0;j<d.size();j++){
int tmp=d[j].first,id=d[j].second;
if(tmp<I&&b[id][I]) b[id]^=c;
}
sum+=t*2;
}
cout<<sum<<endl;
} | 1 |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int bubble_sort(int n,vector<int> &vec);
int main() {
int n,count;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
count=bubble_sort(n,a);
for (int i = 0; i < n; i++) {
cout << a[i];
if (i != n - 1) { cout << " "; }
}
cout << "\n" << count << endl;
}
int bubble_sort(int n,vector<int> &vec) {
int count = 0;
bool flag = true;
while (flag) {
flag = false;
for (int j = 1; j < n; j++) {
if (vec[j] < vec[j - 1]) {
swap(vec[j], vec[j - 1]);
count++;
flag = true;
}
}
}
return count;
}
| #include <cstdio>
void printArray(int A[], int N) {
for (int i = 0; i < N; i++) {
if (i != N-1) {
printf("%d ", A[i]);
} else {
printf("%d", A[i]);
}
}
printf("\n");
}
void bubbleSort(int A[], int N) {
bool unsorted = 1;
int i = 0;
int counter = 0;
while (unsorted) {
unsorted = 0;
for (int j = N-1; j >= i; j--) {
if (A[j] < A[j-1]) {
int tmp = A[j];
A[j] = A[j-1];
A[j-1] = tmp;
unsorted = 1;
counter++;
}
}
i++;
}
printArray(A, N);
printf("%d\n", counter);
}
int main() {
int N;
int A[100];
scanf("%d", &N);
for (int i = 0; i < N; i++) {
int input;
scanf("%d", &input);
A[i] = input;
}
bubbleSort(A, N);
} | 1 |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long ll;
int main()
{
ll n;
cin >> n;
ll a[n], b[n], c[n];
for(int i=0; i<n; i++) cin >> a[i];
for(int i=0; i<n; i++) cin >> b[i];
for(int i=0; i<n; i++) cin >> c[i];
sort(a, a+n);
sort(b, b+n);
sort(c, c+n);
ll ans = 0;
for(ll i=0; i<n; i++){
ll u = upper_bound(a, a+n, b[i]-1) - a;
ll l = lower_bound(c, c+n, b[i]+1) - c;
ans += u * (n-l);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
const LL INF = 0x3f3f3f3f3f3f3f3fLL;
const LL MOD = 1e9 + 7;
const int MAXV = 1e5 + 5;
double solve(int a, int b, int c, auto &dp, int n) {
if (dp[a][b][c] != -1) return dp[a][b][c];
double sum = 0;
if (a - 1 >= 0)
sum += solve(a - 1, b, c, dp, n) / n * a;
if (b - 1 >= 0)
sum += solve(a + 1, b - 1, c, dp, n) / n * b;
if (c - 1 >= 0)
sum += solve(a, b + 1, c - 1, dp, n) / n * c;
sum++;
sum *= n, sum /= a + b + c;
return dp[a][b][c] = sum;
}
void marmot0814() {
int n; cin >> n;
vector<LL> cnt(3, 0);
for (int i = 0 ; i < n ; i++) {
int v; cin >> v; v--;
cnt[v]++;
}
vector<vector<vector<double>>> dp(n + 1, vector<vector<double>>(n + 1, vector<double>(n + 1, -1)));
dp[0][0][0] = 0;
cout << fixed << setprecision(20) << solve(cnt[0], cnt[1], cnt[2], dp, n) << '\n';
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
int t = 1, kase = 0; // cin >> t;
while (t--) {
// cout << "Case #" << ++kase << ":";
marmot0814();
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
#define ll long long
#define ull unsigned long long
// #define ordered_set tree<pair<ll, ll>, null_type, less<pair<ll, ll>>, rb_tree_tag, tree_order_statistics_node_update>
ll mod=1e9+7;
#define PI 3.1415926535897932385
#define inf 9e18
#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);
string char_to_str(char c){string tem(1,c);return tem;}
typedef pair<long long, long long> ii;
#define S second
#define F first
ll max(ll a,ll b){if(a>b){return a;}return b;}
ll min(ll a,ll b){if(a<b){return a;}return b;}
#define MAXN 200005
// Comment this out for interactice problem
// #define endl '\n'
// string to integer stoi() Remember: it takes string not character
// string to long long stoll()
// string.substr(position,length);
// integer to string to_string();
// To compile--> g++ -std=c++0x -o output one.cpp
// To run--> ./output
double dp[305][305][305];
int main()
{
fastio;
// freopen("input.txt","r",stdin);
// freopen("output.txt","w",stdout);
ll n;
cin>>n;
ll a[n];
ll one=0;
ll two=0;
ll three=0;
for (int i = 0; i < n; ++i)
{
cin>>a[i];
if(a[i]==1){
one++;
}
else if(a[i]==2){
two++;
}
else{
three++;
}
}
for (int c = 0; c<=n; ++c)
{
for (int b = 0; b<=n; ++b)
{
for (int a = 0; a<=n; ++a)
{
ll k = a+b+c;
if(k==0){
continue;
}
if(k>n){
continue;
}
dp[a][b][c] += (1.0 * n)/k;
if(a){
dp[a][b][c] += (1.0 * a)/k * dp[a - 1][b][c];
}
if(b){
dp[a][b][c] += (1.0 * b)/k * dp[a + 1][b - 1][c];
}
if(c){
dp[a][b][c] += (1.0 * c)/k * dp[a][b + 1][c - 1];
}
}
}
}
cout<<fixed<<setprecision(10)<<dp[one][two][three]<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std; inline void fileio(const char* in, const char* out) { freopen(in, "r", stdin); freopen(out, "w", stdout); }
#define TD typedef
#define forx(i,n) for(int i = 0; i < (n); ++i)
#define forxr(i,n) for(int i = (n)-1; i >= 0; --i)
TD long long ll; TD long double ld; TD pair<int,int> pii; TD pair<ll,ll> pll; TD vector<int> VI; TD vector<bool> VB; TD vector<ll> VL;
const char nl = '\n'; const int INF = 0x3f3f3f3f; const ll LINF = 0x3f3f3f3f3f3f3f3fll; const ld EPS = 1e-9, PI = acos(-1);
#define ff first
#define ss second
#define all(c) c.begin(),c.end()
const int N = 17;
int a[N][N], n;
struct bm {
int v; bm(int val=0) : v(val) {}
bool operator[](int i) const { return v & 1 << i; }
bm set(int i) const { return bm(v | 1 << i); }
bm invert() const { return bm(v ^ -1); }
};
#define for_submasks(s, m) for (int s=m, l=1<<__builtin_popcount(m); l--; s=(s-1)&m)
ll dp[1 << N];
ll s[1<<N];
ll score(bm mask) {
ll ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i+1; j < n; ++j) {
if (mask[i] && mask[j]) {
ans += a[i][j];
}
}
}
return ans;
}
void pre() {
for (int i = 0; i < (1 << n); ++i) {
s[i] = score(i);
}
}
int main() { // Emily <3
atexit([](){ cerr << "Time: " << (ld)clock() / CLOCKS_PER_SEC << nl; });
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
cout << fixed << setprecision(12);
cin >> n;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
cin >> a[i][j];
}
}
pre();
memset(dp, -INF, sizeof dp);
dp[0] = 0;
for (int mask = 0; mask < (1<<n); ++mask) {
for_submasks(sm, mask) {
if (sm == mask) continue;
dp[mask] = max(dp[mask], dp[sm] + s[mask ^ sm]);
}
}
cout << dp[(1 << n)-1] << nl;
return 0;
}
| 0 |
#define _LIBCPP_DEBUG 0
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
const long long INF = 1LL << 60;
ll MOD = 1e9+7;
int main() {
int A,B; cin>>A>>B;
cout<<A*B<<endl;
} | #include <bits/stdc++.h>
using namespace std;
#define fast_IO ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl '\n'
typedef long long int lli;
typedef long long ll;
typedef long double ld;
signed main(){
fast_IO;
int t=1;
//cin>>t;
while(t--){
ld n,b;
cin>>n>>b;
ll nb = b*100+0.5;
cout<<(n*nb)/100;
}
return 0;
}
| 1 |
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
typedef vector <string> vs;
int main(void){
map <char, int> m;
int num[] = {1,5,10,50,100,500,1000};
for (int i=0; i<7; i++)
m["IVXLCDM"[i]] = num[i];
char c;
string r;
while (cin>>r){
int tmp, tmp2= m[r[0]],s=0;
int n=r.size();
for (int i=0; i<n; i++){
tmp = m[r[i]];
if (tmp2<tmp)
s-= tmp2*2;
s += tmp;
tmp2 = tmp;
}
cout<<s<<endl;
}
} | #pragma GCC optimize ("O3")
#pragma GCC target ("sse4")
#pragma GCC optimize("Ofast")
//*********************************************DO IT NOW****************************************************************
#include<bits/stdc++.h>
#include<random>
#define int long long
#define pp pair<int,int>
#define ss second
#define ff first
#define pb push_back
#define mod 1000000007
#define pi 3.14159265359
#define mk(arr,n,type) type *arr=new type[n];
#define sl s1.length();
#define yes cout<< "YES"<<endl
#define no cout<< "NO"<<endl
#define all(v) (v).begin(),(v).end()
#define s(v) sort(v,v+n)
#define mt mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define read(a,n) for(int i=0;i<n;i++)cin>>a[i]
#define print(a,n) for(int i=0;i<n;i++)cout<<a[i]<<" "
#define for1(i,a,n) for(int i=0;i<n;i++)
#define rep(i, c) for(int i = 0; i < (int)c; i++)
using namespace std;
//**********************************************DO IT NOW***************************************************************
void fastio()
{
#ifndef ONLINE_JUDGE
freopen("INPUT.txt","r",stdin);
freopen("OUTPUT.txt","w",stdout);
#endif
ios_base :: sync_with_stdio(false);
cin.tie(NULL) ;
cout.tie(NULL);
}
int dp[101][1001],ans1=1e9,dp1[1000001];
int num[10];
int a[1000000];
signed main()
{
fastio();
int t=1;
// cin>>t;
while(t--)
{
int n;
cin>>n;
cout<<2*pi*n;
}
}
// 🍪 🍪 🍪
| 0 |
#include<iostream>
using namespace std;
int main(){
int w[10],k[10],tmp,i,j;
for(i=0;i<10;i++){
cin>>w[i];
}
for(i=0;i<10;i++){
cin>>k[i];
}
for(i=0;i<9;i++){
for(j=9;j>i;j--){
if(w[j]>=w[j-1]){
tmp=w[j];
w[j]=w[j-1];
w[j-1]=tmp;
}
if(k[j]>=k[j-1]){
tmp=k[j];
k[j]=k[j-1];
k[j-1]=tmp;
}
}
}
cout<<w[0]+w[1]+w[2]<<" "<<k[0]+k[1]+k[2]<<endl;
return 0;
} | #include <cstdio>
#include <queue>
using namespace std;
int main(void)
{
priority_queue <int> w, k;
int tmp;
for (int i = 0; i < 10; i++){
scanf("%d", &tmp);
w.push(tmp);
}
for (int i = 0; i < 10; i++){
scanf("%d", &tmp);
k.push(tmp);
}
int sumw = 0, sumk = 0;
for (int i = 0; i < 3; i++){
sumw += w.top();
w.pop();
sumk += k.top();
k.pop();
}
printf("%d %d\n", sumw, sumk);
return (0);
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.