code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#define INF 0x3FFFFFFF
#define MN 2005
using namespace std;
int a[MN][MN],len[MN][MN],q[MN];
int n,m,p,ans,tp;
char c[MN];
inline int read()
{
int n=0,f=1; char c=getchar();
while (c<'0' || c>'9') {if(c=='-')f=-1; c=getchar();}
while (c>='0' && c<='9') {n=n*10+c-'0'; c=getchar();}
return n*f;
}
int main()
{
register int i,j;
n=read(); m=read();
for (i=1;i<=n;++i)
{
scanf("%s",c+1);
for (j=1;j<=m;++j) a[i][j]=(c[j]=='#'?1:0);
}
for (i=1;i<n;++i)
for (j=1;j<=m;++j) a[i][j]=a[i][j]^a[i+1][j];
for (i=1;i<n;++i)
for (j=1;j<m;++j) a[i][j]=a[i][j]^a[i][j+1];
for (i=1;i<n;++i)
for (j=1;j<m;++j)
if (a[i][j]) len[i][j]=0;
else len[i][j]=len[i-1][j]+1;
// for (i=1;i<n;++i)
// for (j=1;j<m;++j)
for (i=1;i<n;++i)
{
for (j=1;j<m;++j)
{
for (;tp&&len[i][j]<=len[i][q[tp]];--tp) ans=max(ans,(j-1-q[tp-1]+1)*(len[i][q[tp]]+1));
q[++tp]=j;
}
for (;tp;--tp) ans=max(ans,(m-1-q[tp-1]+1)*(len[i][q[tp]]+1));
}
printf("%d",max(ans,n));
} | #include <bits/stdc++.h>
#define l_ength size
const int inf = (1<<30);
const int mod = 1000000007;
using ll = long long;
using namespace std;
const int bound = 1000*1000+10;
bool besucht[bound];
void init(){
for( int i = 0; i < bound; ++i ) besucht[i] = false;
}
int no(){
cout << 0 << endl;
return 0;
}
int main(){
int n, m; cin >> n >> m;
vector<int> a(n);
vector<int> b(m);
for( auto &k : a ){
cin >> k;
if( besucht[k] ) return no();
besucht[k] = true;
}
init();
for( auto &k : b ){
cin >> k;
if( besucht[k] ) return no();
besucht[k] = true;
}
sort( a.begin(), a.end() );
sort( b.begin(), b.end() );
ll ans = 1;
for( int k = 1; k <= n*m; ++k ){
bool ares = binary_search( a.begin(), a.end(), k );
bool bres = binary_search( b.begin(), b.end(), k );
ll comb = 1;
if( !bres ) comb *= (b.end() - lower_bound( b.begin(), b.end(), k ));
if( !ares ) comb *= (a.end() - lower_bound( a.begin(), a.end(), k ));
if( !ares && !bres ) comb -= n*m-k;
ans *= comb;
ans %= mod;
}
cout << ans << endl;
} | 0 |
#include<stdio.h>
int main() {
int row, col, n;
scanf("%d %d %d", &row, &col, &n);
int bucket;
if (row >= col){
bucket = row;
} else {
bucket = col;
}
int i = 0, j;
int count = 0;
while (i < n){
count++;
i += bucket;
}
printf("%d\n", count);
return 0;
}
| // clang-format off
#include <bits/stdc++.h>
#define int long long
#define main signed main()
// #define main int main()
#define loop(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) loop(i, 0, n)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define prec(n) fixed << setprecision(n)
#define stlice(from, to) substr(from, (to) - (from) + 1)
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
using namespace std;
using pii = pair<int, int>;
using vi = vector<int>;
using vd = vector<double>;
using vc = vector<char>;
using vb = vector<bool>;
using vs = vector<string>;
using vpii = vector<pii>;
using vvi = vector<vi>;
using vvb = vector<vb>;
using vvpii = vector<vpii>;
template<typename A> using fn = function<A>;
constexpr int INF = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
constexpr int MOD = 1000000007;
constexpr double PI = acos(-1);
template<typename A, typename B> bool cmin(A &a, const B &b) { return a > b ? (a = b, true) : false; }
template<typename A, typename B> bool cmax(A &a, const B &b) { return a < b ? (a = b, true) : false; }
constexpr bool odd(const int &n) { return n & 1; }
constexpr bool even(const int &n) { return !odd(n); }
void solve();
main { solve(); return 0; }
// clang-format on
void solve() {
vi a(10), b(10);
rep(i, 10) cin >> a[i];
rep(i, 10) cin >> b[i];
sort(rall(a)), sort(rall(b));
cout << a[0] + a[1] + a[2] << ' ' << b[0] + b[1] + b[2] << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define all(x) x.begin(),x.end()
#define vi vector<int>
#define vll vector<ll>
#define print(x) for(auto it=x.begin();it!=x.end();it++) cout<<*it<<' '; cout<<'\n';
#define debug(a,b,c) cout << a << " " << b << " " << c << endl;
#define in(x,n) for(int e=0;e<n;e++){int y;cin>>y;x.pb(y);}
#define inl(x,n) for(int e=0;e<n;e++){ll y;cin>>y;x.pb(y);}
#define lower(sl) transform(sl.begin(), sl.end(), sl.begin(), ::tolower);
#define endl "\n";
#define pi pair<int,int>
#define vpi vector<pair<int,int>>
#define vvi vector<vector<int>>
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
//code here
int n;
cin >> n;
vi a; in(a,n);
ll res = 0;
for(int i=1;i<n;i++){
if(a[i]<a[i-1]){
res += (a[i-1]-a[i]);
a[i] = a[i-1];
}
}
cout << res << endl;
} | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define vv(T) std::vector<std::vector<T>>
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
using namespace std;
using ll = long long;
int main(void)
{
int n;
cin >> n;
vector<bool> seen(1'000'000'000);
bool ans = true;
for (int i = 0; i < n; ++i)
{
int a;
cin >> a;
if (seen[a])
ans = false;
seen[a] = true;
}
cout << (ans ? "YES" : "NO") << endl;
}
| 0 |
#define _USE_MATH_DEFINES
#define INF 100000000
#include <bits/stdc++.h>
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
static const double EPS = 1e-8;
int path[101][101];
int dijkstra(int s,int g,int n){
int d[101];
bool used[101];
memset(d,0x3f,sizeof(d));
memset(used,0,sizeof(used));
d[s] = 0;
while(1){
int v=-1;
for(int u=1;u<=n;u++){
if(!used[u] && (v==-1 || d[u] < d[v])) v=u;
}
if(v==-1) break;
used[v] = true;
for(int u=1;u<=n;u++){
d[u] = min(d[u],d[v] + path[v][u]);
}
}
return d[g];
}
int main(){
int n,k;
while(~scanf("%d %d",&n,&k)){
if(n==k && k==0) break;
memset(path,0x3f,sizeof(path));
for(int i=0;i<k;i++){
int ch;
scanf("%d",&ch);
if(ch){
int a,b,val;
scanf("%d %d %d",&a,&b,&val);
path[a][b] = path[b][a] = min(val,path[a][b]);
}
else{
int a,b,res;
scanf("%d %d",&a,&b);
res = dijkstra(a,b,n);
printf("%d\n",res > INF ? -1 : res);
}
}
}
} | #include <bits//stdc++.h>
using namespace std;
int main(void){
while(1){
long long i,j,a,b,c,k,l;
cin>>a>>b;
if(a==0&&b==0)
break;
long long island[a][a];
for(i=0;i<a;i++){
for(j=0;j<a;j++){
if(i==j)
island[i][j]=0;
else
island[i][j]=LLONG_MAX/2;
}
}
int frag=0;
for(l=0;l<b;l++){
cin>>c;
if(c){
long long d,e,f;
cin>>d>>e>>f;
if(island[d-1][e-1]>f){
island[d-1][e-1]=f;
island[e-1][d-1]=f;
frag=1;
}
}
else{
if(frag){
frag=0;
for(k=0;k<a;k++){
for(j=0;j<a;j++){
for(i=0;i<a;i++)
island[i][j]=min(island[i][j],island[i][k]+island[k][j]);
}
}
}
long long d,e;
cin>>d>>e;
long long ans=island[d-1][e-1];
if(ans<LLONG_MAX/2)
cout<<ans<<endl;
else
cout<<"-1"<<endl;
}
}
}
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <bitset>
#include <utility>
#include <string>
#include <queue>
#include <stack>
#include <algorithm>
#include <cmath>
#include <map>
#include <set>
using namespace std;
typedef long long ll;
int main(){
ll N;
cin >> N;
vector<ll> a(N);
for(ll i=0;i<N;i++) cin >> a[i];
vector<ll> si(N);
ll sum=0;
for(ll i=0;i<N;i++){
sum+=a[i];
si[i]=sum;
}
ll p,q,r,s;
ll n,m;
ll ans=sum;
for(ll i=1;i<N-2;i++){
n=0;
m=i;
while(n+1<m){
if(si[(n+m)/2]*2<si[i]){
n=(n+m)/2;
}else{
m=(n+m)/2;
}
}
if(abs(2*si[m]-si[i])<abs(2*si[n]-si[i])) n=m;
p=si[n];q=si[i]-si[n];
n=i+1;
m=N-2;
while(n+1<m){
if((si[(n+m)/2]-si[i])*2<si[N-1]-si[i]){
n=(n+m)/2;
}else{
m=(n+m)/2;
}
}
if(abs(si[N-1]-2*si[m]+si[i])<abs(si[N-1]-2*si[n]+si[i])) n=m;
r=si[n]-si[i];s=si[N-1]-si[n];
ans=min(ans, max({p,q,r,s})-min({p,q,r,s}));
}
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <string>
using namespace std;
int main(){
string ibe;
int n;
int score=0,out=0;
int hit=0;
cin >> n;
for(int i=0;i<n;i++){
while(1){
if(out >= 3)break;
cin >> ibe;
if(ibe=="HIT"){
hit++;
if(hit==4){
score++;
hit--;
}
}
else if(ibe=="HOMERUN"){
score=hit+1+score;
hit=0;
}
else if(ibe=="OUT"){
out++;
}
}
cout << score << endl;
out=0;
hit=0;
score=0;
}
} | 0 |
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <cmath>
#include <numeric>
#include <iomanip>
#include <stack>
#include <complex>
#include <functional>
#include <tuple>
using namespace std;
#define Rep(i,a,b) for(ll i = a; i < b; ++i)
#define rep(i,b) Rep(i,0,b)
#define allof(a) (a).begin(), (a).end()
#define Yes(q) ((q) ? "Yes" : "No")
#define YES(q) ((q) ? "YES" : "NO")
#define Possible(q) ((q) ? "Possible" : "Impossible")
#define POSSIBLE(q) ((q) ? "POSSIBLE" : "IMPOSSIBLE")
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll infll = 1ll << 60ll;
constexpr ll mod = 1e9 + 7;
// 0~3までは右下左上 4~7までは斜め
constexpr int dx[] = { 1, 0, -1, 0, 1, -1 };
constexpr int dy[] = { 0, 1, 0, -1, 1, 1 };
namespace {
template<typename T> bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<typename T> bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
// 標準出力
void Write(long long x, const char* end = "\n") { std::cout << x << end; }
template <typename T> void Write(const T& x, const char* end = "\n") { std::cout << x << end; }
template <typename T, typename U> void Write(const T& x, const U& y, const char* end = "\n") { std::cout << x << " " << y << end; }
template <typename T, typename U, typename V> void Write(const T& x, const U& y, const V& z, const char* end = "\n") { std::cout << x << " " << y << " " << z << end; }
//template <typename... Args> void Write(Args const&... args) { bool a = true; for (auto const& x : { args... }) { if (a) a = false; else std::cout << " "; std::cout << x; } std::cout << "\n"; }
template <typename T> void Write(const std::vector<T>& x, const char* sep = " ", const char* end = "\n") { for (std::size_t i = 0, sz = x.size(); i < sz; ++i) { std::cout << x[i] << (i == sz - 1 ? end : sep); } }
template <typename T> void Write(const std::vector<std::vector<T>>& x, const char* sep = " ", const char* end = "\n") { for (auto v : x) Write(v, sep, end); }
// 標準入力
struct Read {
std::size_t szi, szj;
Read(std::size_t _szi = 1, std::size_t _szj = 1) : szi(_szi), szj(_szj) {}
template <typename T> operator T () const { T a; std::cin >> a; return a; }
template <typename T> operator std::vector<T>() const { std::vector<T> a(szi); for (std::size_t i = 0; i < szi; ++i) std::cin >> a[i]; return a; }
template <typename T> operator std::vector<std::vector<T>>() const {
std::vector<std::vector<T>> a(szi, std::vector<T>(szj));
for (std::size_t i = 0; i < szi; ++i) for (std::size_t j = 0; j < szj; ++j) cin >> a[i][j]; return a;
}
template <typename T, typename U> operator std::vector<std::pair<T, U>>() const {
std::vector<std::pair<T, U>> a(szi);
for (std::size_t i = 0; i < szi; ++i) std::cin >> a[i].first >> a[i].second; return a;
}
};
struct Reads {
template <typename T> Reads(T& a) { std::cin >> a; }
template <typename T, typename U> Reads(T& a, U& b) { std::cin >> a >> b; }
template <typename T, typename U, typename V> Reads(T& a, U& b, V& c) { std::cin >> a >> b >> c; }
template <typename T, typename U, typename V, typename W> Reads(T& a, U& b, V& c, W& d) { std::cin >> a >> b >> c >> d; }
};
Read read;
}
int main() {
int n, m, d; Reads(n, m, d);
double ans;
// 隣同士の差がdであるものの個数の平均
ans = (double)((n - d) * 2) / (n * (double)n) * (m - 1);
if (d == 0) ans /= 2.0;
cout << fixed << setprecision(8) << ans << endl;
return 0;
}
| #include <iostream>
#include <vector>
#include <limits.h>
#include <algorithm>
#include <string>
#include <math.h>
#include <limits.h>
#include <queue>
#include <map>
#include <set>
#include <iomanip>
#include <bitset>
#include <cassert>
#include <random>
#include <functional>
#include <stack>
#include <iomanip>
#include <cassert>
//#include <boost/multiprecision/cpp_int.hpp>
#include <complex>
#include <cstdio>
#include <list>
#include <bitset>
//< in.txt > out.txt
using namespace std;
//std::ios::sync_with_stdio(false);
//std::cin.tie(0);
const long long MOD = 998244353;
const long long INF = 1e18;
typedef long long LL;
typedef long double LD;
typedef pair<LL, LL> PLL;
typedef pair<LD, LL> pdl;
typedef pair<LD, LD> pdd;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef unsigned long long ULL;
//typedef boost::multiprecision::cpp_int bigint;
LL calc(LL N, LL M, LL D) {
VLL V(M,1);
LL ans = 0;
while (true) {
for (LL m = 0; m < M - 1; m++) {
if (abs(V[m] - V[m + 1]) == D)ans++;
}
LL m = M-1;
for (; m >= 0; m--) {
if (V[m] != N)break;
}
if (m == -1)return ans;
V[m]++;
for (LL mm = m + 1; mm < M; mm++)V[mm] = 1;
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
//for (LL n = 1; n <= 10; n++) {
// for (LL m = 2; m <= 6; m++) {
// for (LL d = 0; d < n; d++) {
// //cout << "n,m,d = " << n << "," << m << "," << d << ":";
// //cout << calc(n, m, d) << "/(n^m);\n";
// LL d0 = calc(n, m, d);
// LL d1 = 2*(m-1);
// for (LL p = 0; p < m - 2; p++)d1 *= n;
// d1 *= n - d;
// if (d0 != d1) {
// cout << "n,m,d = " << n << "," << m << "," << d << ":";
// cout << d0 << "vs" << d1 << "\n";
// }
// }
// cout << "\n";
// }
// cout << "####################\n";
//}
LL N, M, D;
cin >> N >> M >> D;
LD ans = (LD)2 * (M - 1) * (N - D) / N / N;
if (D == 0)ans /= 2;
cout << setprecision(12) << ans << "\n";
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
bool isEven(int x){return x%2==0;}
bool solve(vector<int> a){
int n=a.size();
int oneCnt=count(a.begin(),a.end(),1);
int evenCnt=count_if(a.begin(),a.end(),isEven);
if(oneCnt || evenCnt<n-1){
return !isEven(evenCnt);
}
else{
int g=a[0];
for(int i=0;i<n;i++) g=__gcd(a[i]/2,g);
for(int i=0;i<n;i++) a[i]/=(g*2);
return !solve(a);
}
}
void output(bool x){
cout<<(x ? "First" : "Second")<<endl;
}
int main(){
int n;
cin>>n;
vector<int> a(n);
for(int i=0;i<n;i++) cin>>a[i];
if(n==1){
output(a[0]!=1);
}
else if(n==2){
output(isEven(a[0]) || isEven(a[1]));
}
else{
output(solve(a));
}
return 0;
} | #include <bits/stdc++.h>
#define REP(i,n) for (int i = 0; i <(n); ++i)
#define REP2(i,x,n) for (int i = x; i <(n); ++i)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using P = pair<int,int>;
static const double PI = acos(-1);
static const int INF = 1e9+7;
int main(){
int n;
cin >> n;
map<int, bool> mp;
REP(i,n){
int a;
cin >> a;
if(mp[a]) mp[a] = false;
else mp[a] = true;
}
int cnt = 0;
for(auto x: mp){
if(x.second) cnt++;
}
cout << cnt << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for(int i = n-1; i >= 0; i--)
#define all(x) (x).begin(),(x).end() // 昇順ソート
#define rall(v) (v).rbegin(), (v).rend() // 降順ソート
#define FastIO ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
typedef long long ll;
using P = pair<int,int>;
using VI = vector<int>;
using VVI = vector<vector<int>>;
using VL = vector<ll>;
using VVL = vector<vector<ll>>;
using VP = vector<P>;
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return true; } return false; }
int main(){
int n, k;
cin >> n >> k;
int ans = 1;
rep(i,n){
if (ans * 2 > ans + k) ans += k;
else ans *= 2;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i,s,n) for (int i = (s); i < n; ++i)
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> x(n);
rep(i,0,n) cin >> x[i];
int ans = 1000000000;
rep(i,0,n-k+1) {
int a = x[i], b = x[i+k-1];
if (b < 0) {
ans = min(ans, abs(a));
} else if (a >= 0) {
ans = min(ans, b);
} else {
ans = min(ans, b-a + min(abs(a), abs(b)));
}
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long int
#define ld long double
#define pb push_back
#define pll pair<ll, ll>
#define tri pair<pll, ll>
#define vl vector<ll>
#define vvl vector< vector<ll> >
#define vlp vector< pair<ll, ll> >
#define vllp vector<pair<pll, ll> >
#define mll map<ll, ll>
#define rep(i,a) for(ll i=0; i< a; i++)
#define rep1(i,a) for(ll i = 1; i< a; i++)
#define foi(i, a, b) for(ll i = a; i<b ; i++)
#define fod(i, a, b) for(ll i = a; i>=b ; i--)
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fst first
#define sec second
#define ff first.first
#define fs first.second
#define max3(a, b, c) max(max(a, b), c)
#define min3(a, b, c) min(min(a, b), c)
#define MAX 1000005
#define MOD 1000000007
// #define MOD 998244353
#define endl "\n"
#define INF (ll)1e18
#define s(v) (ll)v.size()
#define e(v) v.empty()
#define bscount(x) __builtin_popcountll(x)
// #define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
using namespace std;
// using namespace __gnu_pbds;
ll gcd(ll a, ll b){if(b==0)return a;return gcd(b, a%b);}
ll cpow(ll a, ll b, ll M){ll ans = 1;while(b){if(b&1) ans = ans*a%M; b/=2;a=a*a%M;}return ans;}
void ingraph(vvl& graph, ll m){ll x, y;rep(i, m){cin>>x>>y;x--, y--;graph[x].pb(y);graph[y].pb(x);}}
ll modify(ll n){ll res = n;res%=MOD;res+=MOD;res%=MOD;return res;}
ll fexp(ll a, ll b) {return cpow(a, b, MOD);}
ll cinv(ll a, ll p){return cpow(a, p-2, p);}
ll inverse(ll a) {return cinv(a, MOD);}
int main(){
// #ifndef ONLINE_JUDGE
// freopen("../input.txt", "r", stdin);
// freopen("../output.txt", "w", stdout);
// #endif
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
ll t;
// cin>>t;
t = 1;
ll tc = 0;
while(tc++ < t){
ll n, m, d;
cin>>n>>m>>d;
ld ans = 1.0*(m-1)*(n-d)/(n*1.0*n);
if(d > 0) ans *= 2.0;
cout<<fixed<<setprecision(10)<<ans;
}
} | #include<bits/stdc++.h>
using namespace std;
#define FOR(i,l,r) for(long long i=(l);i<(r);++i)
#define REP(i,n) FOR(i,0,n)
#define REPS(i,n) FOR(i,1,n+1)
#define RFOR(i,l,r) for(long long i=(l);i>=(r);--i)
#define RREP(i,n) RFOR(i,n-1,0)
#define RREPS(i,n) RFOR(i,n,1)
#define int long long
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define SZ(x) ((int)(x).size())
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
template<class T> inline bool chmin(T& a, T b) {if (a > b) {a = b; return true; }return false; }
template<class T> inline bool chmax(T& a, T b) {if (a < b) {a = b; return true; }return false; }
const int INF = 1e18;
signed main(){
double n, m, d; cin >> n >> m >> d;
double ans = max(n-d,0.0)*(d !=0 ? 2 : 1) / (n*n) * (m-1);
cout << fixed << setprecision(20.20) << ans << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main(){
int A,B;
cin >> A >> B;
string S;
cin >> S;
for(int i=0;i<(int)S.size();i++){
if(i==A){
if(S[i]!='-'){
cout << "No" << endl;
return 0;
}
}
else{
if(!(S[i]-'0'>=0 && S[i]-'0'<=9)){
cout << "No" << endl;
return 0;
}
}
}
cout << "Yes" << endl;
} | #include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define sc(x) scanf("%lld",&x);
int main(){
ll n, a, b;
sc(n) sc(a) sc(b)
ll X[n];
for (int i = 0; i < n; i++) sc(X[i])
ll x,ans = 0;
for (int i = 0; i < n - 1; i++){
x = (X[i + 1] - X[i]) * a;
ans += min(x, b);
}
cout << ans << endl;
return 0;
} | 0 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <deque>
#include <queue>
#include <string.h>
#include <stack>
using namespace std;
#define rep(i, a, b) for(int i = a; i < (b); ++i)
typedef long long ll;
typedef pair<int,int> P;
int main() {
int n,m;
cin >> n;
map<string, int>blue;
map<string, int>red;
rep(i, 0, n){
string in;
cin >> in;
blue[in]++;
}
cin>>m;
rep(i, 0, m){
string in;
cin >> in;
red[in]++;
}
int ans = 0;
for(auto i: blue){
int blucnt =i.second;
if(red[i.first] != 0){
blucnt-=red[i.first];
}
ans = max(ans, blucnt);
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
int n, m;
cin >> n;
vector<string> s(n);
for(int i=0; i<n; i++){
cin >> s.at(i);
}
cin >> m;
vector<string> t(m);
for(int i=0; i<m; i++){
cin >> t.at(i);
}
vector<int> num(n);
for(int i=0; i<n; i++){
for(int j=i; j<n; j++){
if(s.at(i)==s.at(j)){
num.at(i)++;
}
}
}
for(int i=0; i<n; i++){
for(int j=0; j<m; j++){
if(s.at(i)==t.at(j)){
num.at(i)--;
}
}
}
sort(num.begin(), num.end());
reverse(num.begin(), num.end());
if(num.at(0)>=0){
cout << num.at(0) << endl;
}
if(num.at(0)<0){
cout << 0 << endl;
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll ;
typedef double db;
const double pi = 3.141592654;
#define pb push_back
#define forab(i,a,b) for(int i=(a);i<=(b);i++)
#define CIN ios_base::sync_with_stdio(0); cin.tie(0)
#define pcase(z,x) printf("Case %ld: %lld\n",z,x)
#define nw "\n"
int main(void)
{
CIN;
ll tc,l,k,sum=0,x=0,y,z=0,m=1,n=0,ans=0,cnt=0;
cin>>n>>m;
for(ll i=n;i<=m;i++){
if((i/10000==i%10) && (i/1000%10==i%100/10))ans++;
}
cout<<ans<<nw;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int L;
string S;
cin >> L >> S;
if (S.size() <= L) {
cout << S << endl;
} else {
cout << S.erase(L) << "..." << endl;
}
} | 0 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <cmath>
using namespace std;
void trace(int A[], int N)
{
int i;
for (i = 0; i < N; i++) {
if(i > 0) cout << " ";
cout << A[i];
}
cout << endl;
}
int bubbleSort(int A[], int N){
bool flag = 1;
int cnt = 0;
while (flag){
flag = 0;
for (int i=N-1; i >= 1; i--) {
if (A[i] < A[i-1]) {
swap(A[i], A[i-1]);
cnt += 1;
flag = 1;
}
}
}
trace(A, N);
return cnt;
}
int main() {
int n, num_sec[101]={}, cnt=0;
cin >> n;
for (int i = 0; i < n; i++) cin >> num_sec[i];
cnt=bubbleSort(num_sec, n);
cout << cnt << endl;
}
| /* HARD WORK FOREVER PAYS */
#include<bits/stdc++.h>
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define turbo(){ \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
}
using namespace std;
typedef long long ll;
typedef pair<int,int> PII;
typedef unsigned long long int ull;
vector<ull> allPrimes;
void sieve(int n)
{
vector<bool> prime(n+1, true);
for (int p=2; p*p<=n; p++)
{
if (prime[p] == true)
{
for (int i=p*2; i<=n; i += p)
prime[i] = false;
}
}
for (int p=2; p<=n; p++)
if (prime[p])
allPrimes.push_back(p);
}
ull factorialDivisors(ull n)
{
sieve(n);
ull result = 1;
for (int i=0; i < allPrimes.size(); i++)
{
ull p = allPrimes[i];
ull exp = 0;
while (p <= n)
{
exp = exp + (n/p);
p = p*allPrimes[i];
}
result = result*(exp+1)%1000000007;
}
return result;
}
int main()
{
int n;
cin>>n;
cout << factorialDivisors(n)<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 50 + 5, mod = 1e9 + 7;
int n, k;
int a[N], dp[N][N][102];
int solve(int l, int r, int left)
{
if (l > r)
return 0;
if (dp[l][r][left] != -1)
return dp[l][r][left];
int ans = 0;
if (a[l] < 0)
{
if (left > 0)
ans = max(ans, solve(l + 1, r, left - 1) + a[l]);
if (left > 1)
ans = max(ans, solve(l + 1, r, left - 2));
}
if (a[l] >= 0 && left > 0)
ans = max(ans, solve(l + 1, r, left - 1) + a[l]);
if (a[r] < 0)
{
if (left > 0)
ans = max(ans, solve(l, r - 1, left - 1) + a[r]);
if (left > 1)
ans = max(ans, solve(l, r - 1, left - 2));
}
if (a[r] >= 0 && left > 0)
ans = max(ans, solve(l, r - 1, left - 1) + a[r]);
return dp[l][r][left] = ans;
}
int main()
{
//ios::sync_with_stdio(false);cin.tie(nullptr);ios_base::sync_with_stdio(false);
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> a[i];
memset(dp, -1, sizeof dp);
cout << solve(0, n - 1, k);
return 0;
} | #include <bits/stdc++.h>
#include <math.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rrep(i, n) for(int i = 0; i <= (n); i++)
using namespace std;
typedef long long ll;
const int MOD = 1000000007;
const ll INF = 1LL<<60;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
using Graph = vector<vector<int>>;
typedef pair<int, int> P;
typedef priority_queue<int, vector<int>, greater<int>> PQ;
int main(){
int N, K; cin >> N >> K;
int ans = 0;
deque<int> deq;
vector<int> v(N,0);
rep(i,N){
cin >> v[i];
}
// 左から取る個数
for (int l = 0; l <= K; l++){
// 右から取る個数
for (int r = 0; r <= K; r++){
// 取る回数がKを越した場合はNG
if (l + r > K) continue;
int d = K - l - r;
priority_queue<int, vector<int>, greater<int>> tmp;
// 左から取る
rep(i,l){
// dequeの右端に達した場合
if (i >= N) break;
tmp.push(v[i]);
}
// 右から取る
rep(i,r){
int index = N-1-i;
// dequeの左端もしくはすでに左から取られている場合
if (index < 0 || index <= l) break;
tmp.push(v[index]);
}
// 手から宝石をつめる
rep(i,d){
// 手に持っていない場合
if (tmp.empty()) break;
// 価値は正の場合はつめない
if (tmp.top() >= 0) break;
tmp.pop();
}
int now = 0;
while (!tmp.empty()){
now += tmp.top(); tmp.pop();
}
ans = max(now, ans);
}
}
cout << ans << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair< ll, ll > Pi;
#define rep(i,n) for(int i=0;i<(n);i++)
#define rep2(i,n) for(int i=1;i<=(n);i++)
#define rep3(i,i0,n) for(int i=i0;i<(n);i++)
#define pb push_back
#define mod 1000000007
#define INF 200000000000
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
ll gcd(ll a, ll b) {return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) {return a/gcd(a,b)*b;}
#define all(x) x.begin(), x.end()
#define mp make_pair
bool compare(pair<int, int> a, pair<int, int> b) {
if(a.first != b.first){
return a.first < b.first;
}else{
return a.second < b.second;
}
}
bool In_map(ll y,ll x,ll h,ll w){
if(y<0 || x<0 || y>=h || x>=w){
return 0;
}else{
return 1;
}
}
const vector<ll> dx{1,0,-1,0};
const vector<ll> dy{0,1,0,-1};
int main() {
ll H,W;
cin>>H>>W;
vector<vector<char>> G(H,vector<char>(W));
ll cnt = 0;
rep(i,H){
rep(j,W){
cin>>G[i][j];
if(G[i][j] == '.'){
cnt++;
}
}
}
vector<vector<ll>> dist(H,vector<ll>(W,-1));
queue<Pi> que;
dist[0][0] = 0;
que.push(mp(0,0));
ll dis=-1;
while(!que.empty()){
Pi v =que.front();
que.pop();
if(v.first == H-1 && v.second == W-1){
//flag =1;
dis = dist[v.first][v.second];
break;
}
rep(dir,4){
ll ny = v.first + dy[dir];
ll nx = v.second + dx[dir];
if(!In_map(ny,nx,H,W)) continue;
if(dist[ny][nx] != -1) continue;
if(G[ny][nx] == '#') continue;
dist[ny][nx] = dist[v.first][v.second]+1;
que.push(mp(ny,nx));
}
}
if(dis == -1){
cout<<-1<<endl;
}else{
cout<<cnt-dis-1<<endl;
}
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include<stdio.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < n; i++)
#define REP(i,j,n) for(int i = j; i < n; i++)
int main() {
vector<int> result(1000);
for (int i = 0; i < 1000; ++i) {
vector< vector<int> > map(21, vector<int>(21, 0));
vector< vector<int> > map2(21, vector<int>(21, 0));
int px = 10, py = 10;
int N;
cin >> N;
if (N == 0) {
break;
}
vector<int> tx(N);
vector<int> ty(N);
rep(i, N) {
cin >> tx[i];
cin >> ty[i];
map2[ty[i]][tx[i]] = 1;
}
int M;
cin >> M;
string str;
int v;
rep(i, M) {
cin >> str >> v;
if (str == "N") {
for (int i = py; i <= py + v; i++) {
map[i][px] = 1;
}
py += v;
}
else if (str == "E") {
for (int i = px; i <= px + v; i++) {
map[py][i] = 1;
}
px += v;
}
else if (str == "S") {
for (int i = py; i >= py - v; i--) {
map[i][px] = 1;
}
py -= v;
}
else if (str == "W") {
for (int i = px; i >= px - v; i--) {
map[py][i] = 1;
}
px -= v;
}
// rep(i,21){
// rep(j,21){
// cout << map[i][j] << " ";
// }
// cout << endl;
// }
// cout << endl;
}
int sum = 0;
rep(i, 21) {
rep(j, 21) {
if (map[i][j] == 0 && map2[i][j] == 1) {
sum++;
}
}
}
if (sum == 0) {
cout << "Yes" << endl;
}
else {
cout << "No" << endl;
}
result[i] = sum;
}
return 0;
} | 0 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<cmath>
#include<cstdio>
#include<queue>
#include<deque>
#include<map>
#include<stack>
#include<set>
#include<utility>
using namespace std;
typedef pair<int,int> pii;
typedef pair<int,pii> pipii;
typedef long long ll;
typedef pair<ll,ll> pll;
int dy[]={1,0,-1,0};
int dx[]={0,1,0,-1};
const int MAXN=100000;
const int MAXE=100000;
const int MAXV=10000;
const ll INF=2e9;
const ll MOD=1e9+7;
struct edge{
int to;
int cost;
};
int main(){
int N,M,Q;cin>>N>>M>>Q;
vector<vector<int> > S(N+1,vector<int>(N+1,0));
for(int i=0;i<M;++i){
int L,R;cin>>L>>R;
S[L][R]++;
}
for(int i=0;i<N;++i){
for(int j=0;j<=N;++j){
S[i+1][j]+=S[i][j];
}
}
for(int j=0;j<N;++j){
for(int i=0;i<=N;++i){
S[i][j+1]+=S[i][j];
}
}
while(Q--){
int p,q;cin>>p>>q;
cout<<S[q][q]-S[p-1][q]-S[q][p-1]+S[p-1][p-1]<<endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int N,M,Q,m;
const int maxn=600000+5;
int siz;
int C[maxn],a[maxn],ret[maxn];
struct node{
int l,r,id;
bool operator<(const node& other)const{
return other.r > r;
}
}x[maxn],y[maxn];
void add(int x,int v){
for(int i=x;i<=m;i+=i&-i) C[i]+=v;
}
int sum(int x){
int ret=0;
for(int i=x;i;i-=i&-i) ret+=C[i];
return ret;
}
int main(){
cin>>N>>M>>Q;
for(int i=0;i<M;i++){
cin>>x[i].l>>x[i].r;
a[siz++]=x[i].l;
a[siz++]=x[i].r;
}
for(int i=0;i<Q;i++){
cin>>y[i].l>>y[i].r;
y[i].id=i;
a[siz++]=y[i].l;
a[siz++]=y[i].r;
}
sort(a,a+siz);
m=unique(a,a+siz)-a;
for(int i=0;i<M;i++){
x[i].l=lower_bound(a,a+m,x[i].l)-a+1;
x[i].r=lower_bound(a,a+m,x[i].r)-a+1;
}
for(int i=0;i<Q;i++){
y[i].l=lower_bound(a,a+m,y[i].l)-a+1;
y[i].r=lower_bound(a,a+m,y[i].r)-a+1;
}
sort(x,x+M);
sort(y,y+Q);
int j=0;
for(int i=0;i<Q;i++){
while(j<M&&x[j].r<=y[i].r) add(x[j++].l,1);
ret[y[i].id]=j-sum(y[i].l-1);
}
for(int i=0;i<Q;i++) cout<<ret[i]<<endl;
return 0;
} | 1 |
#include <stdio.h>
#include <algorithm>
#include <utility>
#include <functional>
#include <cstring>
#include <queue>
#include <stack>
#include <cmath>
#include <iterator>
#include <vector>
#include <string>
#include <set>
#include <iostream>
#include <random>
#include <map>
#include <iomanip>
#include <stdlib.h>
#include <list>
#include <typeinfo>
#include <list>
#include <set>
#include <cassert>
#include <fstream>
#include <unordered_map>
#include <cstdlib>
#include <complex>
#include <cctype>
#include <bitset>
using namespace std;
using ll = long long;
using vll = vector<long long>;
using pll = pair<long long, long long>;
#define rep(i,n) for(long long i(0);(i)<(n);(i)++)
void solve(long long N, std::string Str){
//* left half record
map< pair<string, string>, ll > rec;
rep(S, 1<<N){
string red, blue;
rep(i, N){
if(S >> i & 1){
red.push_back(Str.at(i));
}
else{
blue.push_back(Str.at(i));
}
}
rec[make_pair(red, blue)]++;
}
ll cnt = 0;
rep(S, 1<<N){
string red, blue;
rep(i, N){
if(S >> i &1){
red.push_back(Str.at(i+N));
}
else{
blue.push_back(Str.at(i+N));
}
}
reverse(red.begin(), red.end());
reverse(blue.begin(), blue.end());
if(rec.count(make_pair(blue, red)))
cnt += rec[make_pair(blue, red)];
}
cout << cnt << endl;
}
int main(){
long long N;
scanf("%lld",&N);
std::string S;
std::cin >> S;
solve(N, S);
return 0;
}
| #include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <algorithm>
#include <set>
#include <map>
#define vv(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))
typedef unsigned long long ull;
#define vvi std::vector<std::vector<int> >
#define vvu std::vector<std::vector<ull> >
#define MODs 1000000007;
typedef long long int ll;
using namespace std;
int main(int argc, char const *argv[]) {
int N;
ull B = 10000007;
ll ans = 0;
string s, S, t, T="";
std::cin >> N;
std::cin >> s;
S = s.substr(0, N);
t = s.substr(N);
for(int i=0;i<N;i++) T+=t[N-1-i];
std::vector<int> num(26, 0);
for(int i=0;i<N;i++) num[S[i]-'a']++, num[T[i]-'a']--;
bool flag = true;
for(int i=0;i<26;i++) if(num[i]!=0) flag = false;
vvu hash = vv(0, 2, 0, ull);
for(int i=0;i<(1<<N);i++){
int n = i+(1<<20), count=0;
ull ah = 0, bh = 0;
while(count<N){
if(n%2==1) ah = ah * B + T[count];
if(n%2==0) bh = bh * B + T[count];
count++;
n/=2;
}
hash.push_back(std::vector<ull>{ah, bh});
}
sort(hash.begin(), hash.end());
for(int i=0;i<(1<<N);i++){
int n = i + (1<<20), count=0;
ull ah = 0, bh = 0;
while(count<N){
if(n%2==1) ah = ah * B + S[count];
if(n%2==0) bh = bh * B + S[count];
count++;
n/=2;
}
auto itr = lower_bound(hash.begin(), hash.end(), std::vector<ull> {ah, bh});
auto itr2 = lower_bound(hash.begin(), hash.end(), std::vector<ull> {ah, bh+1});
ans += itr2 - itr;
}
std::cout << (!flag?0:ans) << '\n';
return 0;
}
| 1 |
/** Created by: Marcos Portales
Codeforces User: marcosportales
Country: Cuba
**/
#include<bits/stdc++.h>
using namespace std;
/// Macros:
#define int long long
#define f first
#define s second
#define db(x) cerr << #x << ": " << (x) << '\n';
#define pb push_back
#define lb lower_bound
#define up upper_bound
#define all(x) x.begin() , x.end()
#define rall(x) x.rbegin() , x.rend()
#define enl '\n'
#define vi vector<int>
#define sz size
#define rep(i,n) for(int i=(0);i<(n);i++)
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
typedef pair<int,int> ii;
typedef long double ld;
typedef unsigned long long ull;
/// Constraints:
const int maxn = 1e5+1;
const int mod = 1000000009;
const ld eps = 1e-9;
const int inf = ((1ll<<31ll)-1ll);
const int INF = 10000000000000000ll;
const ld pi = acos(-1);
/// Prime Numbers:
// 2, 173, 179, 181, 197, 311, 331, 737, 1009, 2011, 2027, 3079, 4001, 10037, 10079, 20011, 20089;
// 100003, 100019, 100043, 200003, 200017, 1000003, 1000033, 1000037, 1000081;
// 2000003, 2000029, 2000039, 1000000007, 1000000021, 2000000099;
/// Functions:
#define lg2(x) 31 - __builtin_clz(x)
#define lgx(x,b) ( log(x) / log(b) )
/// Red-Black Tree Template ---------------------------------
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
//typedef tree < long long , null_type , less<long long> , rb_tree_tag , tree_order_statistics_node_update > ordered_set;
/// Quick Pow------------------------------------------------
int qpow(int b,int e){
if(!e)return 1;
if(e&1) return qpow(b,e-1)*b;
int pwur=qpow(b,e>>1);
return pwur*pwur;
}
/// My Code -------------------------------------------------
int32_t main(){
ios_base::sync_with_stdio(0); cin.tie(0);
cout.setf(ios::fixed); cout.precision(0);
srand(time(NULL));
//freopen("a.in","r",stdin);
//freopen("a.out","w",stdout);
int n,m;
cin>>n;
vector<string>s(n);
map<string,int>mp;
rep(i,n){cin>>s[i];mp[s[i]]++;}
cin>>m;
vector<string>t(m);
rep(i,m){cin>>t[i];mp[t[i]]--;}
int ans=0;
for(auto it:mp)ans=max(ans,it.s);
cout<<ans<<enl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
int N, M;
cin >> N >> M;
vector<int> A[300];
for(int i=0; i<N; i++){
for(int j=0; j<M; j++){
int a;
cin >> a;
A[i].push_back(a-1);
}
reverse(A[i].begin(), A[i].end());
}
int ans = 1e9;
bitset<300> removed;
int rem = 0;
while(rem < M){
vector<int> num(M);
for(int i=0; i<N; i++){
while(removed[A[i].back()]) A[i].pop_back();
num[A[i].back()]++;
}
int mx = max_element(num.begin(), num.end()) - num.begin();
ans = min(ans, num[mx]);
removed[mx] = 1;
rem++;
}
cout << ans << endl;
} | 0 |
#include<iostream>
using namespace std;
#include<stdio.h>
class union_find // union find.
{
int* U;
public:
union_find(int n){ U = new int [n + 1]; for(int i = 1; i <= n; i++) U[i] = i; }
int root(int a){ if(U[a] == a){ return a; } U[a] = root(U[a]); return U[a]; }
bool same(int a, int b){ return root(a) == root(b); }
void join(int a, int b){ int x = root(a), y = root(b); U[x] = y; }
~union_find(){ delete [] U; }
};
struct edge{ int v1, v2; int weight; }; // edge.
edge init(){
edge e;
e.v1 = 0; e.v2 = 0; e.weight = -1;
return e;
}
edge init(int a, int b, int w){
edge e;
e.v1 = a; e.v2 = b; e.weight = w;
return e;
}
void swap_e(edge e1, edge e2)
{
swap(e1.v1, e2.v1); swap(e1.v2, e2.v2); swap(e1.weight, e2.weight);
}
class edge_heap // heap.
{
edge* E;
int edge_n;
public:
edge_heap(int n){ E = new edge [n + 1]; edge_n = 0; }
void min_heap(int i);
void insert_heap(edge e); // sorting.
void insert_nl(edge e); // no sorting.
edge delete_min();
bool isEmpty(){ return edge_n == 0; }
int total_weight();
~edge_heap(){ delete [] E; }
};
void edge_heap::min_heap(int i)
{
int l = 2 * i, r = 2 * i + 1;
if(l > edge_n && r > edge_n) return;
int minid = i;
if(l <= edge_n){ if(E[l].weight < E[minid].weight) minid = l; }
if(r <= edge_n){ if(E[r].weight < E[minid].weight) minid = r; }
if(minid == i) return;
swap(E[minid], E[i]);
min_heap(minid);
}
void edge_heap::insert_heap(edge e)
{
edge_n++;
int w = e.weight;
int i = edge_n;
while(i > 1){
if(w < E[i / 2].weight){
E[i] = E[i / 2];
}else{ break; }
i /= 2;
};
E[i] = e;
}
void edge_heap::insert_nl(edge e){ edge_n++; E[edge_n] = e; }
edge edge_heap::delete_min()
{
edge e = E[1];
E[1] = E[edge_n]; edge_n--;
min_heap(1);
return e;
}
int edge_heap::total_weight()
{
int tw = 0;
for(int i = 1; i <= edge_n; i++) tw += E[i].weight;
return tw;
}
int main()
{
int n, i, j, w;
scanf("%d", &n);
edge_heap EH(n * (n + 1) / 2); // All Edge heap.
edge e;
for(i = 1; i <= n; i++){
for(j = 1; j <= n; j++){
scanf("%d", &w);
if(j <= i || w < 0) continue;
e = init(i, j, w);
EH.insert_heap(e);
}
}
edge_heap TH(n); // Tree heap.
union_find VG(n); // vertex group.
while(!EH.isEmpty()){
e = EH.delete_min();
if(!VG.same(e.v1, e.v2)){
VG.join(e.v1, e.v2);
TH.insert_nl(e);
};
};
printf("%d\n", TH.total_weight());
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, matrix[100][100];
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> matrix[i][j];
}
}
bool visit[100] = {
true
};
int sum = 0;
while (1) {
int min = 2001, mini = -1;
for (int i = 0; i < n; i++) {
if (visit[i] == true) {
for (int j = 0; j < n; j++) {
if (matrix[i][j] > -1 && matrix[i][j] < min && visit[j] == false) {
min = matrix[i][j];
mini = j;
}
}
}
}
if (mini == -1) {
break;
}
else {
sum += min;
visit[mini] = true;
}
}
cout << sum << endl;
return 0;
} | 1 |
#pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
using vi = vector<int>;
constexpr char newl = '\n';
constexpr double eps = 1e-10;
#define FOR(i,a,b) for (int i = (a); i < (b); i++)
#define F0R(i,b) FOR(i,0,b)
#define RFO(i,a,b) for (int i = ((b)-1); i >=(a); i--)
#define RF0(i,b) RFO(i,0,b)
#define fi first
#define se second
#define show(x) cout << #x << " = " << x << '\n';
#define rng(a) a.begin(),a.end()
#define rrng(a) a.rbegin(),a.rend()
#define sz(x) (int)(x).size()
#define YesNo {cout<<"Yes";}else{cout<<"No";}
#define YESNO {cout<<"YES";}else{cout<<"NO";}
#define v(T) vector<T>
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; }
template<class T> bool lcmp(const pair<T, T>& l, const pair<T, T>& r) {
return l.first < r.first;
}
template<class T> istream& operator>>(istream& i, v(T)& v) {
F0R(j, sz(v)) i >> v[j];
return i;
}
template<class A, class B> istream& operator>>(istream& i, pair<A, B>& p) {
return i >> p.first >> p.second;
}
template<class A, class B, class C> istream& operator>>(istream& i, tuple<A, B, C>& t) {
return i >> get<0>(t) >> get<1>(t) >> get<2>(t);
}
template<class T> ostream& operator<<(ostream& o, const vector<T>& v) {
F0R(i, v.size()) {
o << v[i] << ' ';
}
o << newl;
return o;
}
template<class T1, class T2> ostream& operator<<(ostream& o, const map<T1, T2>& m) {
for (auto& p : m) {
o << p.first << ": " << p.second << newl;
}
o << newl;
return o;
}
#if 1
// INSERT ABOVE HERE
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
unordered_map<int, int> a, b;
F0R(i, n) {
int v;
cin >> v;
if (i & 1) {
++a[v];
}
else {
++b[v];
}
}
vector<pair<int,int>> c, d;
for (auto& p : a) c.emplace_back(p.second, p.first);
for (auto& p : b) d.emplace_back(p.second, p.first);
sort(rrng(c), lcmp<int>);
sort(rrng(d), lcmp<int>);
c.emplace_back(0, -1);
d.emplace_back(0, -1);
int r;
if (c[0].second != d[0].second)
r = n - c[0].first - d[0].first;
else {
r = n - max(c[0].first + d[1].first, c[1].first + d[0].first);
}
cout << r;
}
#endif
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef pair<ll, P> PP;
static const double EPS = 1e-8;
static const double PI = 4.0 * atan(1.0);
static const ll INF = 1023456789;
#define REP(i,n) for(int i=0;i<n;++i)
#define REPR(i,n) for(int i=n-1;i>=0;--i)
#define FOR(i,s,n) for(int i=s;i<n;++i)
#define FORR(i,s,n) for(int i=n-1;i>=s;--i)
#define ALL(c) (c).begin(),(c).end()
#define CLEAR(v) memset(v,0,sizeof(v))
#define MP(a,b) make_pair((a),(b))
#define ABS(a) ((a)>0?(a):-(a))
#define F first
#define S second
ll n, v[100000];
P a[100001], b[100001];
int main(int argc, char **argv) {
cin >> n;
REP(i, n) cin >> v[i];
REP(i, 100001) a[i] = b[i] = P{0, i};
REP(i, n/2) ++a[v[i*2]].F;
REP(i, n/2) ++b[v[i*2+1]].F;
sort(a, a+100001); reverse(a, a+100001);
sort(b, b+100001); reverse(b, b+100001);
if (a[0].S == b[0].S) cout << min(n - a[0].F - b[1].F, n - b[0].F - a[1].F) << endl;
else cout << (n - a[0].F - b[0].F) << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define sidha(i,a,b) for(int i=a;i<b;i++)
#define vi vector<int>
#define pb push_back
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n,m,p;cin>>n>>m>>p;
cout<<min({n+m,m+p,n+p})<<endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
const int MAX_N=1e6;
int seg_tree[2*MAX_N+5],n;
void build()
{
for(int i=n-1; i>0; --i)
seg_tree[i]=__gcd(seg_tree[i<<1],seg_tree[i<<1|1]);
}
void modify(int pos,int val)
{
for(seg_tree[pos+=n]=val; pos>1; pos>>=1)
seg_tree[pos>>1]=__gcd(seg_tree[pos],seg_tree[pos^1]);
}
int query(int l,int r)
{
int ans(1);
for(l+=n,r+=n; l<r; l>>=1,r>>=1)
{
if(l&1)
ans=__gcd(ans,seg_tree[l++]);
if(r&1)
ans=__gcd(ans,seg_tree[--r]);
}
return ans;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int a,b,c;
cin>>a>>b>>c;
cout<<min({a,b,c})+(a+b+c-min({a,b,c})-max({a,b,c}));
} | 1 |
#include <algorithm>
#include <iostream>
#include <string>
#include <random>
#include <cassert>
#include <cstring>
#include <chrono>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
int main()
{
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
int s = accumulate(a.begin(), a.end(), 0);
int best = 1 << 30;
int bestI = -1;
for (int i = 0; i < n; ++i) {
int x = a[i];
int cur = abs(x * n - s);
if (cur < best) {
best = cur;
bestI = i;
}
}
cout << bestI << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define ArraySizeOf(array) (sizeof(array) / sizeof(array[0]))
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for(int i=1;i<n;i++)
#define rev(i,n) for(int i=n-1;i>=0;i--)
#define REV(i,n) for(int i=n-1;i>0;i--)
#define req(i,n,m) for(int i=n;i<m;i++)
#define REQ(i,n,m,l) for(int i=n;i<m;i+=l)
#define _GLIBCXX_DEBUG
int INF = 1e9 + 7;
unsigned NthDayOfWeekToDay(unsigned n, unsigned dow, unsigned dow1)
{
unsigned day;
if (dow < dow1) dow += 7;
day = dow - dow1;
day += 7 * n - 6;
return day;
}
signed gcd(int x, int y) {
if (y == 0)return x;
return gcd(y, x % y);
}
signed lcm(int x, int y) {
return x / gcd(x, y) * y;
}
unsigned DayToWeekNumber(unsigned day)
{
return (day - 1) / 7 + 1;
}
unsigned AnotherDayOfWeek(unsigned day, unsigned day0, unsigned dow0)
{
return (dow0 + 35 + day - day0) % 7;
}
using namespace std;
signed main() {
int N; cin >> N;
vector<double>a(N);
long double count = 0;
rep(i, N) {
cin >> a[i];
count += a[i];
}
vector<long double>b(N);
rep(i, N)b[i] = abs(a[i] - count/N);
sort(b.begin(), b.end());
double ans1 = abs(b[0] - count / N);
double ans2 = b[0] + count / N;
rep(i, N) {
if (a[i]==ans1 || a[i]==ans2) {
cout << i << endl;
return 0;
}
}
} | 1 |
#include <bits/stdc++.h>
#include <cassert>
typedef long long int ll;
using namespace std;
#define DEBUG 0
#if DEBUG
#define DLOG(...) fprintf(stderr, __VA_ARGS__)
#else
#define DLOG(...)
#endif
void debug(auto f) {
#if DEBUG
f();
#endif
}
ll mPrime = 1000*1000*1000 + 7;
ll n, x;
vector<ll> s;
vector<ll> facts;
vector<ll> invFacts;
vector<int> tbl;
ll mAdd(ll x, ll y) {
ll z = x + y;
if (z < mPrime) return z;
else return (z - mPrime);
}
ll mSub(ll x, ll y) {
ll z = x - y;
if (z >= 0) return z;
else return (z + mPrime);
}
ll mMul(ll x, ll y) {
return (x * y) % mPrime;
}
ll eGCD(ll a, ll b, ll& s, ll& t) {
if (a == 0) {
s = 0;
t = 1;
return b;
}
ll u;
ll g = eGCD(b % a, a, t, u);
s = u - (b / a) * t;
return g;
}
ll mInv(ll x) {
ll s, t;
eGCD(x, mPrime, s, t);
return s < 0 ? s + mPrime : s;
}
int main() {
cin >> n >> x;
s.resize(n);
for (ll i = 0; i < n; i++) {
cin >> s.at(i);
}
facts.resize(n+1);
invFacts.resize(n+1);
facts.at(0) = invFacts.at(0) = 1;
for (ll i = 1; i <= n; i++) {
facts.at(i) = mMul(i, facts.at(i-1));
invFacts.at(i) = mInv(facts.at(i));
}
sort(s.begin(), s.end());
tbl.resize(x+1, 0);
tbl.at(x) = 1;
ll lim = x;
for (ll k = n; k >= 1; k--) {
ll newLim = 0;
for (ll r = 1; r <= lim; r++) {
ll weight = tbl.at(r);
if (weight == 0) continue;
newLim = r;
ll rem = k;
for (ll t : s) {
if (r < t) break;
rem--;
ll newR = r % t;
tbl.at(newR) = mAdd(tbl.at(newR), weight);
}
tbl.at(r) = mMul(tbl.at(r), rem);
}
lim = newLim;
}
ll ans = 0;
for (ll r = 1; r <= lim; r++) {
ans = mAdd(ans, mMul(tbl.at(r), r));
}
cout << ans << endl;
return 0;
}
| #include<bits/stdc++.h>
#include<ctype.h>
# define pb push_back
#define fst first
#define sec second
#define For(i,a,b) for(int i=a;i<b;i++)
#define ll long long int
#define ull unsigned long long int
#define mod 1000000007
#define fo(i,n) for(ll i=0;i<n;i++)
#define endl "\n"
#define rev(i,n) for(ll i=n-1;i>=0;i--)
#define fo1(i,n) for(ll i=1;i<=n;i++)
#define boolsize 1000001
#define pi pair<ll,ll>
#define vi vector<ll>
#define vii vector<pi>
using namespace std;
template<typename T>
void showvector(vector <T> v)
{
for(T x:v)
cout<<x<<" ";
cout<<endl;
}
template<typename T>
void showvector1(vector <T> v)
{
ll n=v.size();
fo1(i,n-1)
cout<<v[i]<<endl;
}
template<typename T>
void showset(set <T> s)
{
for(T x: s)
cout<<x<<" ";
cout<<endl;
}
template<class T>
void showvectorpair(vector<T> v)
{
for(auto it=v.begin();it!=v.end();it++)
cout<<it->first<<" "<<it->second<<endl;
cout<<endl;
}
template<typename T,typename P>
void showmap(map <T,P> m)
{
for(auto it=m.begin();it!=m.end();it++)
cout<<it->first<<" "<<it->second<<endl;
cout<<endl;
}
template<typename T>
bool comp(T a,T b)
{
return (a>b);
}
template<class T>
bool comppair(T a,T b)
{
if(a.first==b.first)
return(a.second>b.second);
return (a.first>b.first);
}
bool sameparity(ll a,ll b)
{
return (a%2==b%2);
}
bool difparity(ll a,ll b)
{
return !(a%2==b%2);
}
bool isprime(ll x)
{ if(x<=1)
return false;
for(ll i=2;i<=sqrt(x);i++)
{
if(x%i==0)
return false;
}
return true;
}
bool iseven(ll x)
{
return !(x%2);
}
bool isodd(ll x)
{
return (x%2);
}
//vector <bool> prime(boolsize,1);
//void seive()
//{
// ll n=boolsize;
// prime[0]=prime[1]=0;
// for(ll i=2;i<=sqrt(boolsize);i++)
// {
// if(prime[i]==1)
// {
// for(ll j=i*i;j<=n;j+=i)
// {
// prime[j]=0;
// }
// }
// }
//}
/// check for test case before submitting
void vfun()
{
ll n,k;
cin>>n>>k;
vi v(n);
fo(i,n)
cin>>v[i];
sort(v.begin(),v.end(),comp<ll>);
ll sum=0;
fo(i,k)
sum+=v[i];
cout<<sum<<endl;
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0); ///cant use scanf, printf
cin.tie(0);cout.tie(0); /// no longer auto flush cout before each cin, remove for interactive
//cout << fixed << setprecision(11); /// no scientific output
ll test=1;
//cin>>test;
while(test--)
{
//fun();
vfun();
// if(vfun())
// cout<<"YES\n";
// else
// cout<<"NO\n";
}
}
///before sub
/// check for value of zero and single input in array
///loop vars,1LL in mult, equal, one, bounds, int v ll, endl, finish taking inputs
/// check whether test cases are given or not
| 0 |
#include <iostream>
#include <string>
#include <vector>
#include <cstdio>
#include <stdio.h>
using namespace std;
int main(){
string str;
while(cin>>str){
int num=0;
vector<int> roman;
for(int i=0;i<str.length();i++){
if(str[i]=='I'){
roman.push_back(1);
}else if(str[i]=='V'){
roman.push_back(5);
}else if(str[i]=='X'){
roman.push_back(10);
}else if(str[i]=='L'){
roman.push_back(50);
}else if(str[i]=='C'){
roman.push_back(100);
}else if(str[i]=='D'){
roman.push_back(500);
}else if(str[i]=='M'){
roman.push_back(1000);
}
}
for(int i=0;i<roman.size();i++){
if(i==roman.size()-1){
num += roman[roman.size()-1];
}else{
if(roman[i]<roman[i+1]){
num += roman[i+1]-roman[i];
i++;
}else{
num += roman[i];
}
}
}
cout<<num<<endl;
}
return 0;
} | //Author: Fuadul Hasan([email protected])
#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int N = 2e5 + 5;
int main(){
int n,k;
cin>>n>>k;
int sum = 0;
if(k < 0){
int last = (n + k - 1);
if(last>=0){
for(int i=k;i<=last;i++)
sum += i;
}else{
for(int i=k;i<last;i++){
sum += i;
}
}
}else{
for(int i=k+1;i<n+k;i++){
sum+=i;
}
}
cout<<sum<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
class StronglyConnectedComponentDecomposition
{
private:
int V; // ????????°
vector<vector<int>> G; // ??°???????????£??\???????????¨???
vector<vector<int>> rG; // ?????????????????????????????°??????
vector<int> vs; // ??°?????????????????????
vector<bool> used; // ?????§???????????????
public:
vector<int> cmp; // ?±????????????£????????????????????????????????????
StronglyConnectedComponentDecomposition( int N = 0 ) {
V = N;
G = vector<vector<int>>( V );
rG = vector<vector<int>>( V );
used = vector<bool>( V );
cmp = vector<int>( V );
}
void add_edge( int from, int to ) {
G[from].push_back( to );
rG[to].push_back( from );
}
void dfs( int v ) {
used[v] = true;
for( int i = 0; i < G[v].size(); i++ ) {
if( !used[G[v][i]] ) dfs( G[v][i] );
}
vs.push_back( v );
}
void rdfs( int v, int k ) {
used[v] = true;
cmp[v] = k;
for( int i = 0; i < rG[v].size(); i++ ) {
if( !used[rG[v][i]] ) rdfs( rG[v][i], k );
}
}
int scc() {
used = vector<bool>( V );
vs.clear();
for( int v = 0; v < V; v++ ) {
if( !used[v] ) dfs( v );
}
used = vector<bool>( V );
int k = 0;
for( int i = vs.size() - 1; i >= 0; i-- ) {
if( !used[vs[i]] ) rdfs( vs[i], k++ );
}
return k;
}
};
int main() {
long long int V, E;
cin >> V >> E;
StronglyConnectedComponentDecomposition SCCD( V );
for( size_t i = 0; i < E; i++ ) {
int s, t;
cin >> s >> t;
SCCD.add_edge( s, t );
}
SCCD.scc();
long long int N;
cin >> N;
for( size_t i = 0; i < N; i++ ) {
int u, v;
cin >> u >> v;
cout << (SCCD.cmp[u] == SCCD.cmp[v]) << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, v;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
char d;
char ds[] = "NESW";
while(cin >> n, n) {
int rx = 10, ry = 10, cnt = 0;
int graph[21][21];
memset(graph, 0, sizeof(graph));
for(int i = 0, x, y; i < n; ++i) {
cin >> x >> y;
graph[y][x] = 1;
}
cin >> m;
for(int i = 0; i < m; ++i) {
cin >> d >> v;
for(int j = 0; j < 4; ++j) {
if(d == ds[j]) {
for(int k = 1; k <= v; ++k) {
rx += dx[j];
ry += dy[j];
if(graph[ry][rx] == 1) {
graph[ry][rx] = 0;
++cnt;
}
}
break;
}
}
}
cout << (cnt == n ? "Yes" : "No") << endl;
}
} | 0 |
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <stdio.h>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <utility>
#include <tuple>
#include <math.h>
#include <set>
#include <map>
using namespace std ;
using ll = long long ;
using ld = long double ;
using vll = vector<ll> ;
using vvll = vector<vll> ;
using vc = vector<char> ;
using vvc = vector<vc> ;
using vb = vector<bool> ;
using vvb = vector<vb> ;
using pll = pair<ll,ll> ;
#define all(v) v.begin(),v.end()
const ll INF = 1e18 ;
const ll mod = 1e9+7 ;
const double pie = acos(-1);
vll dx4 = {-1,0,1,0} ;
vll dy4 = {0,-1,0,1} ;
vll dx8 = {-1,0,1,1,1,0,-1,-1} ;
vll dy8 = {-1,-1,-1,0,1,1,1,0} ;
void fix_cout(){cout << fixed << setprecision(20) ; }
ll gcd(ll a,ll b){if(b==0) return a ; return gcd(b,a%b) ; }
ll lcm(ll a,ll b){return a/gcd(a,b)*b ; }
void chmax(ll &a,ll b){if(a<b) a = b ; }
void chmin(ll &a,ll b){if(a>b) a = b ; }
int main(){
ll h,w ;
cin >> h >> w ;
map<ll,ll> gs,dis ;
for(int i=1;i<=w;i++) gs[i] = i ;
gs[w+10] = -1 ;
dis[0] = w ;
for(int i=1;i<=h;i++){
ll a,b ;
cin >> a >> b ;
ll mx = -1 ;
for(auto it=gs.lower_bound(a);it->first<=b+1;it=gs.erase(it)){
ll g = it->first ;
ll s = it->second ;
chmax(mx,s) ;
if(dis.count(g-s)){
dis[g-s]-- ;
if(dis[g-s]==0) dis.erase(g-s) ;
}
}
if(mx>=0&&b<w){
gs[b+1] = mx ;
dis[b+1-mx]++ ;
}
ll ans = -1 ;
if(!dis.empty()){
ans = i+dis.begin()->first ;
}
cout << ans << endl ;
}
}
| #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;
int main(){
int n, K;
cin >> n >> K;
int v[n];
rep(i, n) cin >> v[i];
int mx = min(n, K);
int ans = 0;
for (int i = 0; i <= mx; i++){
for (int j = 0; j <= i; j++){
vec v_s;
for (int k = 0; k < j; k++){
v_s.push_back(v[k]);
}
for (int k = n - 1; k > (n - 1) - (i - j); k--){
v_s.push_back(v[k]);
}
sort(v_s.begin(), v_s.end());
// for (int k = 0; k < v_s.size(); k++){
// cout << v_s[k] << " ";
// }cout << endl;
int sm = 0;
rep(k, v_s.size()){
if(k < K - i && v_s[k] < 0) continue;
sm += v_s[k];
}
// cout << sm << endl;
ans = max(sm, ans);
}
}
cout << ans << endl;
} | 0 |
//BISMILLAHIR RAHMANIR RAHIM
//SOTO MEAW
//SOTO SONDESH
#include<bits/stdc++.h>
#define ls ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define ll long long
#define __ <<" "<<
#define loop(m,n) for(m=0;m<n;m++)
#define rloop(m,n) for(m=n-1;m>=0;m--)
#define case(z) "Case " << z++ << ": "
#define yes cout << "YES" << endl
#define no cout << "NO" << endl
#define quit return 0
using namespace std;
bool isprime(int n)
{
for (int i = 2; i <= n/2; i++)
{
if (n % i == 0)
return false;
}
return true;
}
void showmyDS(set<int> ds)
{
set<int> ::iterator it;
for (it=ds.begin();it!=ds.end();it++)
{
cout << *it << endl ;
}
cout << endl;
}
int main()
{
ls
//freopen("in.txt","r",stdin);
//freopen("out.txt","w",stdout);
//int t,l=1;cin>>t;while(t>0){
vector<char>s;
int j;
string s1;
cin>>s1;
loop(j,s1.size()) s.push_back(s1[j]);
int n,i,c=0;
cin>>n;
char a[n];
int p,index[255];
memset(index,0,sizeof(index));
loop(i,n)
{
cin>>a[i];
p=(int)a[i];
index[p]=1;
}
loop(i,s.size())
{
p=(int)s[i];
if(c==1)
p=48;
again:
if(index[p]==1 && p==57)
{
if(i!=0)
p=48;
else
p=49;
s.push_back('0');
c=1;
}
if(index[p]==1)
{
p++;
c=1;
goto again;
}
else
{
cout<<(char)p;
}
}
cout<<endl;
//t--;}
quit;
}
| /*------------------------------------
........Bismillahir Rahmanir Rahim....
..........created by Abdul Aziz.......
------------------------------------*/
#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <cstring>
#include <unordered_map>
#include <queue>
#define mod 998244353
#define int long long
#define ld long double
#define pb push_back
#define vi vector<int>
#define dbg(x) cerr << #x << " = " << x << '\n'
#define sz(x) (int)x.size()
#define all(a) (a.begin(),a.end())
#define ff first
#define ss second
#define pii pair<int,int>
#define lcm(a,b) (a*b)/__gcd(a,b)
using namespace std;
int n,k;
map <int,bool> mp;
bool fun(int a){
while (a){
if (mp[a%10]) return false;
a /= 10;
}
return true;
}
inline void solve(){
cin >> n >> k ;
for (int i=1;i<=k;i++) {
int a; cin >> a;
mp[a] = true;
}
while (true){
if (fun(n)){
cout << n << endl;
return;
} n++ ;
}
}
signed main()
{
int n=1; // cin>>n;
while (n--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define For(i, j, k) for (int i = j; i <= k; ++ i)
#define Forr(i, j, k) for (int i = j; i >= k; -- i)
using namespace std;
inline int read() {
int x = 0, p = 1; char c = getchar();
for (; !isdigit(c); c = getchar()) if (c == '-') p = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return x * p;
}
inline void File() {
freopen("D.in", "r", stdin);
freopen("D.out", "w", stdout);
}
const int N = 1e2 + 10;
int a[N], sta[N], tp, n, m, lst, sum, cnt, ans[N];
int main() {
n = read(), m = read();
For(i, 1, m) {
a[i] = read();
if (a[i] & 1) sta[++ tp] = i;
}
if (tp > 2) return puts("Impossible"), 0;
if (tp > 0) swap(a[1], a[sta[1]]);
if (tp > 1) swap(a[m], a[sta[2]]);
if (m == 1) {
if (a[1] == 1) return printf("1\n1\n1\n"), 0;
return printf("%d\n2\n%d %d\n", a[1], a[1] - 1, 1), 0;
}
For(i, 1, m) printf("%d ", a[i]); puts("");
ans[cnt = 1] = lst = a[1] - 1; sum = 1;
For(i, 1, m) sum += a[i], ans[++ cnt] = sum - lst, lst = sum;
ans[cnt] -= 1;
int tt = 0; For(i, 1, cnt) if (ans[i] == 0) ++ tt;
printf("%d\n", cnt - tt);
For(i, 1, cnt) if (ans[i]) printf("%d ", ans[i]); puts("");
return 0;
}
| #include<bits/stdc++.h>
#define ll long long
#define inf(x) (ll)(1e##x)
using namespace std;
template<typename tn> void read(tn &a){
tn x=0,f=1; char c=' ';
for(;!isdigit(c);c=getchar()) if(c=='-') f=-1;
for(;isdigit(c);c=getchar()) x=x*10+c-'0';
a=x*f;
}
int n,m;
vector<int> v[3];
int main(){
read(n);read(m);
for(int i=1;i<=m;i++){
int x;read(x);
v[x&1].push_back(x);
}
if(v[1].size()>2){puts("Impossible");return 0;}
if(m==1){
int p=v[0].size()?v[0][0]:v[1][0];
cout<<p<<'\n';
cout<<p/2+1<<'\n';
if(p&1){
for(int i=1;i<=p/2;i++) cout<<2<<' ';
cout<<1<<'\n';
}
else{
for(int i=1;i<=p/4;i++) cout<<2<<' ';
cout<<1<<' ';
for(int i=1;i<=(p-2)/4;i++) cout<<2<<' ';
cout<<1<<'\n';
}
return 0;
}
if(v[1].size()) v[2].push_back(v[1][0]);
for(int x:v[0]) v[2].push_back(x);
if(v[1].size()>1) v[2].push_back(v[1][1]);
for(int x:v[2]) cout<<x<<' ';cout<<'\n';
cout<<v[2].size()-(v[2].back()==1)<<'\n';
cout<<v[2][0]+1<<' ';
for(int i=1;i+1<v[2].size();i++) cout<<v[2][i]<<' ';
if(v[2].back()>1) cout<<v[2].back()-1<<'\n';
return 0;
} | 1 |
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "math.h"
#include "utility"
#include "string"
#include "map"
#include "unordered_map"
#include "iomanip"
#include "random"
using namespace std;
const long long int MOD = 1000000007;
long long int power(long long int x, long long int n, long long int M) {
long long int tmp = 1;
if (n > 0) {
tmp = power(x, n / 2, M);
if (n % 2 == 0) tmp = (tmp*tmp) % M;
else tmp = (((tmp*tmp) % M)*x) % M;
}
return tmp;
}
long long int N, M, K, Q, W, H, L, R;
long long int ans;
int main() {
ios::sync_with_stdio(false);
cin >> N;
while (N) {
set<pair<long double, string> >s;
for (int i = 0; i < N; i++) {
string t;
long double p, a, b, c, d, e, f, n, m;
cin >> t >> p >> a >> b >> c >> d >> e >> f >> n >> m;
s.insert({ 1000-((f*n*m - p) / (a + b + c + d*m + e*m)) ,t });
}
for (auto i : s) {
cout << i.second << endl;
}
cout << "#\n";
cin >> N;
}
return 0;
} | #include <cassert>
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <ccomplex>
#include <cfenv>
#include <cinttypes>
#include <cstdbool>
#include <cstdint>
#include <ctgmath>
#include <cwchar>
#include <cwctype>
// C++
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
//#include <boost/foreach.hpp>
//#include <boost/range/algorithm.hpp>
#define rep(i,j,k) for(int i=(int)j;i<(int)k;i++)
#define ll long long
#define Sort(v) sort(all(v))
#define INF 1e9
#define LINF 1e18
#define END return 0
#define pb push_back
#define se second
#define fi first
#define pb push_back
#define all(v) (v).begin() , (v).end()
#define MP make_pair
#define MOD 1000000007LL
#define int long long
using namespace std;
int day[12]={31,28,31,30,31,30,31,31,30,31,30,31};
int dx[]={0,1,0,-1};
int dy[]={1,0,-1,0};
struct edge{int to,cost;};
typedef pair<int,int> P;
bool isupper(char c){if('A'<=c&&c<='Z')return 1;return 0;}
bool islower(char c){if('a'<=c&&c<='z')return 1;return 0;}
bool isPrime(int x){if(x==1)return 0;if(x==2)return 1;if(x%2==0)return 0;for(int i=3;i*i<=x;i++)if(x%i==0)return 0;return 1;}
bool iskaibun(string s){for(int i=0;i<s.size()/2;i++)if(s[i]!=s[s.size()-i-1])return 0;return 1;}
bool isnumber(char c){return ('0'<=c&&c<='9');}
bool isalpha(char c){return (isupper(c)&&islower(c));}
void printvi(vector<int> v){rep(i,0,v.size()){if(i)cout<<" ";cout<<v[i];}cout<<endl;}
void printvil(vector<int> v){rep(i,0,v.size()){cout<<v[i]<<endl;}}
void printvvi(vector<vector<int>> v){
rep(i,0,v.size()){
rep(j,0,v[i].size())cout<<v[i][j];
cout<<endl;
}
}
void printvstr(vector<string> v){
rep(i,0,v.size()){
cout<<v[i]<<endl;
}
}
struct S{
string name;
double value;
};
signed main (){
int n;
while(1){
cin>>n;
if(n==0)break;
vector<S> v(n);
rep(i,0,n){
cin>>v[i].name;
v[i].value=0;
double p,a,b,c,d,e,f,s,m;
cin>>p>>a>>b>>c>>d>>e>>f>>s>>m;
double time=(a+b+c+d+e)+(m-1)*(d+e);
double profit=f*s*m-p;
v[i].value=profit/time;
}
auto cmp=[&](S a,S b){
return (a.value==b.value?a.name<b.name:a.value>b.value);
};
sort(all(v),cmp);
rep(i,0,n){
cout<<v[i].name<<endl;
}
cout<<"#"<<endl;
}
}
/*
Aで目が出る
Bでわかば
Cで葉
Dで花
Eで実
F個の実
１つあたりSで売れる
M回実をつける
収入効率＝収入/時間
多作期の時、(M-1)(D+E)の時間 + A+B+C+D+Eの時間
収入はF*M*S
降順ソート
*/
| 1 |
#include <cstdio>
#include <cstring>
#include <algorithm>
const int MOD = 998244353;
const int MAXN = 5e5 + 10;
int n, m;
namespace {
inline int add(int x) { return x >= MOD ? x - MOD : x; }
inline int sub(int x) { return x < 0 ? x + MOD : x; }
inline int mul(int x, int y) { return 1ll * x * y % MOD; }
inline int pwr(int x, int y) {
int ans = 1;
for (; y; y >>= 1, x = mul(x, x)) {
if (y & 1) ans = mul(ans, x);
}
return ans;
}
}
int fact[MAXN << 1], invf[MAXN << 1];
int choose(int x, int y) {
return x < y ? 0 : mul(fact[x], mul(invf[y], invf[x - y]));
}
int main() {
scanf("%d%d", &n, &m);
fact[0] = 1, invf[0] = 1;
if (n < m) std::swap(n, m);
for (int i = 1; i <= 2 * n; i++) {
fact[i] = mul(fact[i - 1], i);
invf[i] = pwr(fact[i], MOD - 2);
}
int ans = 0;
for (int i = 1; i <= m; i++) {
ans = add(ans + mul(choose(2 * i - 1, i), choose(n + m - 2 * i, n - i)));
}
printf("%d\n", add(n + mul(ans, pwr(choose(n + m, n), MOD - 2))));
}
| #include<bits/stdc++.h>
using namespace std;
int main(){
int K;
string S;
cin >> K >> S;
if(S.size()<=K){
cout << S << endl;
return 0;
}
string T=S.substr(0,K);
T+="...";
cout << T << endl;
}
| 0 |
#include <bits/stdc++.h>
#define clr(x) memset(x,0,sizeof (x))
#define For(i,a,b) for (int i=(a);i<=(b);i++)
#define Fod(i,b,a) for (int i=(b);i>=(a);i--)
#define fi first
#define se second
#define kill _z_kill
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define outval(x) cerr<<#x" = "<<x<<endl
#define outv(x) cerr<<#x" = "<<x<<" "
#define outtag(x) cerr<<"--------------"#x"---------------"<<endl
#define outarr(a,L,R) cerr<<#a"["<<L<<".."<<R<<"] = ";\
For(_x,L,R) cerr<<a[_x]<<" ";cerr<<endl;
#define User_Time ((double)clock()/CLOCKS_PER_SEC)
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef unsigned uint;
typedef long double LD;
typedef vector <int> vi;
typedef pair <int,int> pii;
LL read(){
LL x=0,f=0;
char ch=getchar();
while (!isdigit(ch))
f=ch=='-',ch=getchar();
while (isdigit(ch))
x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
return f?-x:x;
}
const int mod=998244353;
int Pow(int x,int y){
int ans=1;
for (;y;y>>=1,x=(LL)x*x%mod)
if (y&1)
ans=(LL)ans*x%mod;
return ans;
}
void Add(int &x,int y){
if ((x+=y)>=mod)
x-=mod;
}
void Del(int &x,int y){
if ((x-=y)<0)
x+=mod;
}
int Add(int x){
return x>=mod?x-mod:x;
}
int Del(int x){
return x<0?x+mod:x;
}
void ckmax(int &x,int y){
if (x<y)
x=y;
}
void ckmin(int &x,int y){
if (x>y)
x=y;
}
const int N=305;
int n,k;
char s[N];
int dp[N][N][N];
int a[N],b[N];
int c0=0,c1=0;
int main(){
cin>>(s+1);
n=strlen(s+1);
k=read();
// n=300;
// For(i,1,n)
// s[i]=rand()%2?'1':'0';
// k=300;
For(i,1,n)
if (s[i]=='1')
c0++;
else
a[++c1]=c0,b[c1]=a[c1]-a[c1-1];
k=min(k,c0);
dp[0][0][0]=1;
// outval(c0),outval(c1);
// outarr(a,0,c1);
For(i,1,c1)
For(j,0,c0)
For(t,0,k){
// outval(i);
int v=dp[i-1][j][t];
if (!v||j<a[i-1])
continue;
// printf("dp[%d][%d][%d] = %d\n",i-1,j,t,v);
int ub=min(c0-j,k-t+b[i]);
For(now,0,ub){
if (now<=b[i])
Add(dp[i][j+now][t],v);
else
Add(dp[i][j+now][t+now-b[i]],v);
}
}
int ans=0;
For(j,a[c1],c0)
For(t,0,k){
// if (dp[c1][j][t])
// printf("dp[%d][%d][%d] = %d\n",c1,j,t,dp[c1][j][t]);
Add(ans,dp[c1][j][t]);
}
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using PII = pair<int, int>;
using VI = vector<int>;
const int mod = 998244353;
inline int add(int u, int v) {
return u + v >= mod ? u + v - mod : u + v;
}
inline int sub(int u, int v) {
return u >= v ? u - v : u - v + mod;
}
inline int mul(ll u, int v) {
return u * v % mod;
}
const int N = 303, M = 1000;
int choose[M][M];
inline int partition(int n, int k) {
return choose[n + k - 1][k - 1];
}
int ways[N][N][N]; // ways[i][j][f] = last i, j moves, f free ones
int solve(VI& ones, int k) {
const int n = ones.size();
if (n == 0) return 1;
ways[n][0][0] = 1;
for (int i = n; i >= 1; i--) {
const int len = ones[i - 1];
for (int j = 0; j <= k; j++) {
for (int f = 0; f < N; f++) {
ways[i - 1][j][f] = ways[i][j][f];
}
}
for (int j = 0; j <= k; j++) {
for (int f = N - 2; f >= 0; f--) {
ways[i - 1][j][f] = add(ways[i - 1][j][f], ways[i - 1][j][f + 1]);
}
}
for (int j = 0; j <= k; j++) {
for (int cur = 1; cur <= len && j + cur <= k; cur++) {
for (int f = 0; f + cur < N; f++) {
ways[i - 1][j + cur][f + cur] = add(ways[i - 1][j + cur][f + cur], ways[i][j][f]);
}
}
}
}
int ans = 0;
for (int j = 0; j <= k; j++) {
for (int f = 0; f < N; f++) {
ans = add(ans, ways[0][j][f]);
}
}
return ans;
}
int main() {
#ifdef LOCAL_EXEC
// freopen("sample.in", "r", stdin);
// freopen("sample.out", "w", stdout);
#else
ios_base::sync_with_stdio(false); cin.tie(NULL);
#endif
string s; cin >> s;
int k; cin >> k;
vector<int> ones;
int f = 0;
bool seen = false;
for (char c: s) {
if (c == '1') {
f++;
}
if (c == '0') {
if (seen) {
ones.push_back(f);
}
f = 0;
seen = true;
}
}
if (f > 0 && seen) {
ones.push_back(f);
}
for (int n = 0; n < M; n++) {
choose[n][0] = choose[n][n] = 1;
for (int r = 1; r < n; r++) {
choose[n][r] = add(choose[n - 1][r], choose[n - 1][r - 1]);
}
}
k = min(k, 300);
cout << solve(ones, k) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n);i++)
#define sz(x) int(x.size())
typedef long long ll;
typedef pair<int,int> P;
constexpr int mod = 1e9+7;
int dp[88][88][14000];
int main(){
int h, w;
cin >> h >> w;
vector<vector<int>> a(h, vector<int>(w)), b(h, vector<int>(w));
rep(i,h) rep(j,w) cin >> a[i][j];
rep(i,h) rep(j,w) cin >> b[i][j];
dp[0][0][7000 + (a[0][0] - b[0][0])] = 1;
dp[0][0][7000 + (b[0][0] - a[0][0])] = 1;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
for (int k = 200; k <= 13000; k++) {
if (i > 0) {
dp[i][j][k + (a[i][j] - b[i][j])] |= dp[i - 1][j][k];
dp[i][j][k + (b[i][j] - a[i][j])] |= dp[i - 1][j][k];
}
if (j > 0) {
dp[i][j][k + (a[i][j] - b[i][j])] |= dp[i][j - 1][k];
dp[i][j][k + (b[i][j] - a[i][j])] |= dp[i][j - 1][k];
}
}
}
}
int res = 2e9;
for (int k = 0; k < 14000; k++) {
if (!dp[h - 1][w - 1][k]) continue;
res = min(res, abs(7000 - k));
}
cout << res << endl;
return 0;
} | #include<bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (n); i++)
#define rrep(i,n) for(int i = (n)-1; i >= 0; i--)
#define rep1(i,n) for(int i = 1; i <= (n); i++)
#define rrep1(i,n) for(int i = (n); i > 0; i--)
#define ll long long
#define pi pair<int, int>
#define pll pair<ll, ll>
#define MOD 1000000007
#define INF 1000000000000000LL
using namespace std;
#define MAXN 88
#define MAXS 13000
int dp[MAXN][MAXN][MAXS];
int main(){
int h,w;cin>>h>>w;
vector<vector<int>> scores(h);
rep(i, h)rep(j, w){
int a;cin>>a;
scores[i].push_back(a);
}
rep(i, h)rep(j, w){
int a;cin>>a;
scores[i][j] -= a;
if(scores[i][j] < 0)scores[i][j] *= -1;
}
dp[0][0][scores[0][0]] = 1;
rep(i, h)rep(j, w)rep(k, MAXS){
int s = scores[i][j];
int mpre = k-s;
if(mpre<0)mpre *= -1;
if(i && dp[i-1][j][mpre]==1)dp[i][j][k]=1;
if(j && dp[i][j-1][mpre]==1)dp[i][j][k]=1;
int ppre = k+s;
if(ppre<=7000){
if(i && dp[i-1][j][ppre]==1)dp[i][j][k]=1;
if(j && dp[i][j-1][ppre]==1)dp[i][j][k]=1;
}
}
int result = 0;
rrep(i, MAXS)if(dp[h-1][w-1][i])result = i;
cout<<result<<endl;
return 0;
rep(i, h){
rep(j, w)cout<<scores[i][j]<<' ';cout<<endl;
}
cout<<"###"<<endl;
rep(k, 15){
cout<<k<<endl;
rep(i, h){
rep(j, w)cout<<dp[i][j][k]<<' ';cout<<endl;
}
cout<<"---"<<endl;
}
return 0;
}
| 1 |
#include<stdio.h>
int main()
{
int A, B;
scanf("%d %d", &A, &B);
int sum = A + B + 1;
char str[sum];
scanf("%s", &str);
int ctr = 0;
for(int i = 0; i < sum; i++){
if(i == A){
if(str[i] != '-'){
printf("No\n");
return 0;
}
}else{
if(str[i] >= '0' && str[i] <= '9'){
++ctr;
}
}
}
if(ctr == A+B){
printf("Yes\n");
}else{
printf("No\n");
}
} | #include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <cmath>
#include <numeric>
#include <iomanip>
#include <stack>
#include <complex>
#include <functional>
#include <tuple>
using namespace std;
#define Rep(i,a,b) for(ll i = a; i < b; ++i)
#define rep(i,b) Rep(i,0,b)
#define allof(a) (a).begin(), (a).end()
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll infll = 1ll << 60ll;
constexpr ll mod = 1e9 + 7;
// 0~3までは右左下上 4~7までは斜め
constexpr int dx[] = { 1, 0, -1, 0, 1, 1, -1, -1 };
constexpr int dy[] = { 0, -1, 0, 1, 1, -1, -1, 1 };
template<typename T> void chmax(T & a, T b) { a = std::max(a, b); }
template<typename T> void chmin(T & a, T b) { a = std::min(a, b); }
int main() {
int a, b;
cin >> a >> b;
if (abs(a - b) <= 1) cout << "Yay!" << endl;
else cout << ":(" << endl;
return 0;
} | 0 |
// #pragma GCC optimize("O3,unroll-loops")
// #pragma GCC target("avx2")
#include <iostream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <cstring>
#include <chrono>
#include <vector>
#include <map>
#include <random>
#include <set>
#include <algorithm>
#include <math.h>
#include <cstdio>
#include <stdio.h>
#include <queue>
#include <bitset>
#include <cstdlib>
#include <deque>
#include <cassert>
#include <stack>
using namespace std;
#define mp make_pair
#define f first
#define se second
#define pb push_back
#define ppb pop_back
#define ll long long
#define ull unsigned long long
#define cntbit(x) __builtin_popcount(x)
#define endl '\n'
#define uset unordered_set
#define umap unordered_map
#define all(x) x.begin(), x.end()
#define pii pair<int, int>
#define ld long double
#define pll pair<long long, long long>
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline void setin(string s) {
freopen(s.c_str(), "r", stdin);
}
inline void setout(string s) {
freopen(s.c_str(), "w", stdout);
}
template <typename T> inline T range(T l, T r) {
return uniform_int_distribution <T>(l, r)(rng);
}
template <typename T> void Min(T &a, T b) {
a = min(a, b);
}
template <typename T> void Max(T &a, T b) {
a = max(a, b);
}
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int N = 45;
const int K = 17;
int n, x, y, z;
bool good[1 << K];
int pw[K];
int dp[N][1 << K];
int ans;
inline int add(int a, int b) {
a += b;
if(a >= mod)
a -= mod;
if(a < 0)
a += mod;
return a;
}
inline int mt(int a, int b) {
return 1ll * a * b % mod;
}
inline void add_t(int &a, int b) {
a = add(a, b);
}
inline void precalc() {
for(int mask = 0; mask < (1 << K); ++mask) {
good[mask] = true;
string s = "";
for(int j = 0; j < K; ++j) {
if(1 << j & mask)
s += '1';
else
s += '0';
}
while(s.back() == '0')
s.ppb();
// reverse(s.begin(), s.end());
// if(mask == (1 << 4) + (1 << 11) + (1 << 16))
// cout << s << endl;
int cur = 0;
// if(mask % 1000 == 0)
// cout << s << endl;
vector <int> is = {};
for(int i = 0; i < s.size(); ++i) {
int j = i;
while(j < s.size() && s[j] != '1')
++j;
// if(s[j] != '0')
is.pb(j - i + 1);
// if(mask % 1000 == 0)
// cout << j - i + 1 << ' ';
// if(mask == (1 << 4) + (1 << 11) + (1 << 16))
// cout << j - i + 1 << ' ';
i = j;
}
reverse(is.begin(), is.end());
for(int i = 1; i < is.size(); ++i)
is[i] += is[i-1];
for(int i = 0; i < is.size(); ++i) {
for(int j = i + 1; j < is.size(); ++j) {
for(int k = j + 1; k < is.size(); ++k) {
int sum1 = is[j-1] - (i == 0 ? 0 : is[i-1]);
int sum2 = is[k-1] - is[j-1];
int sum3 = is.back() - is[k-1];
if(sum1 == x && sum2 == y && sum3 == z) {
good[mask] = false;
break;
}
}
}
}
// if(mask % 1000 == 0)
// cout << endl;
// if(mask == (1 << 4) + (1 << 11) + (1 << 16))
// cout << endl;
}
}
main() {
for(int i = 1; i < K; ++i)
pw[i] = 1 << (i - 1);
ios_base::sync_with_stdio(0); cout.tie(0); cin.tie(0);
// setin("input.txt");
cin >> n >> x >> y >> z;
precalc();
for(int i = 1; i <= 10; ++i)
if(good[pw[i]])
dp[1][pw[i]] = 1;
for(int i = 2; i <= n; ++i) {
for(int mask = 0; mask < (1 << K); ++mask) {
for(int j = 1; j <= 10; ++j) {
int new_mask = ((1 << K) - 1) & ((mask << j) | pw[j]);
if(good[new_mask])
add_t(dp[i][new_mask], dp[i-1][mask]);
}
}
}
int ans = 1;
for(int i = 1; i <= n; ++i)
ans = mt(ans, 10);
for(int mask = 0; mask < (1 << K); ++mask) {
add_t(ans, -dp[n][mask]);
}
// cout << dp[n][(1 << 4) + (1 << 11) + (1 << 16)] << endl;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define SZ(x) (int)(x.size())
using ll = long long;
using ld = long double;
const ld eps = 1e-9;
const ll MOD = 1000000007;
const int INF = 1000000000;
const ll LINF = 1ll<<50;
template <typename T1, typename T2>
void chmax(T1 &a, const T2 &b) {
if(a < b) a = b;
}
template <typename T1, typename T2>
void chmin(T1 &a, const T2 &b) {
if(a > b) a = b;
}
template<typename T>
void printv(const vector<T>& s) {
for(int i=0;i<(int)(s.size());++i) {
cout << s[i];
if(i == (int)(s.size())-1) cout << endl;
else cout << " ";
}
}
template<typename T1, typename T2>
ostream& operator<<(ostream &os, const pair<T1, T2> p) {
os << p.first << ":" << p.second;
return os;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
int n, m, q; cin >> n >> m >> q;
vector<string> s(n);
for(int i=0;i<n;++i) {
string tmp; cin >> tmp;
s[i] = tmp;
}
vector<vector<int>> ver(n+1, vector<int>(m+1, 0));
vector<vector<int>> tate(n+1, vector<int>(m+1, 0)), yoko(n+1, vector<int>(m+1, 0));
for(int i=0;i<n;++i) {
for(int j=0;j<m;++j) {
ver[i+1][j+1] = s[i][j] == '1';
}
}
for(int i=0;i<n;++i) {
for(int j=0;j<m;++j) {
ver[i+1][j+1] += ver[i+1][j] + ver[i][j+1] - ver[i][j];
}
}
for(int i=0;i<n-1;++i) {
for(int j=0;j<m;++j) {
tate[i+1][j+1] = s[i][j] == '1' && s[i+1][j] == '1';
}
}
for(int i=0;i<n-1;++i) {
for(int j=0;j<m;++j) {
tate[i+1][j+1] += tate[i+1][j] + tate[i][j+1] - tate[i][j];
}
}
for(int i=0;i<n;++i) {
for(int j=0;j<m-1;++j) {
yoko[i+1][j+1] = s[i][j] == '1' && s[i][j+1] == '1';
}
}
for(int i=0;i<n;++i) {
for (int j = 0; j < m - 1; ++j) {
yoko[i + 1][j + 1] += yoko[i + 1][j] + yoko[i][j + 1] - yoko[i][j];
}
}
while(q--) {
int x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2;
int tmpv = ver[x2][y2] - ver[x2][y1-1] - ver[x1-1][y2] + ver[x1-1][y1-1];
int tmptate = tate[x2-1][y2] - tate[x2-1][y1-1] - tate[x1-1][y2] + tate[x1-1][y1-1];
int tmpyoko = yoko[x2][y2-1] - yoko[x2][y1-1] - yoko[x1-1][y2-1] + yoko[x1-1][y1-1];
cout << tmpv - tmptate - tmpyoko << endl;
}
}
| 0 |
#include "bits/stdc++.h"
using namespace std;
#define int long long
#define FOR(i, a, b) for(int i=(a);i<(b);i++)
#define RFOR(i, a, b) for(int i=(b-1);i>=(a);i--)
#define REP(i, n) for(int i=0; i<(n); i++)
#define RREP(i, n) for(int i=(n-1); i>=0; i--)
#define REP1(i, n) for(int i=1; i<=(n); i++)
#define RREP1(i, n) for(int i=(n); i>=1; i--)
#define ALL(a) (a).begin(),(a).end()
#define UNIQUE_SORT(l) sort(ALL(l)); l.erase(unique(ALL(l)), l.end());
#define CONTAIN(a, b) find(ALL(a), (b)) != (a).end()
#define out(...) printf(__VA_ARGS__)
#if DEBUG
#define debug(...) printf(__VA_ARGS__)
#else
#define debug(...) /* ... */
#endif
template<class T>bool chmax(T &a,const T &b){if(a<b){a=b;return true;}return false;}
template<class T>bool chmin(T &a,const T &b){if(b<a){a=b;return true;}return false;}
void solve();
signed main()
{
#if DEBUG
std::ifstream in("input.txt");
std::cin.rdbuf(in.rdbuf());
#endif
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
/*================================*/
#if DEBUG
#define SIZE 1000
#else
#define SIZE 423450
#endif
int N,Q,K;
set<int> um[2][SIZE],dm[2][SIZE];
int BASE = SIZE/2;
struct Item2 {
int x,y;
char u;
};
vector<Item2> V;
set<int> ds[SIZE],ls[SIZE];
void solve() {
cin>>N;
int x,y;
char u;
REP(i,N) {
cin>>x>>y>>u;
if (u=='D') {
dm[0][y-x+BASE].insert(x);
dm[1][y+x].insert(x);
}
if (u=='U') {
um[0][y-x+BASE].insert(x);
um[1][y+x].insert(x);
}
V.push_back({x,y,u});
if (u=='D') ds[x].insert(y);
if (u=='L') ls[y].insert(x);
}
int ans = INT_MAX;
REP(i,N) {
auto p = V[i];
if (p.u=='R') {
{
auto s = &dm[0][p.y-p.x+BASE];
auto it = s->upper_bound(p.x);
if (it != s->end()) chmin(ans, (*it - p.x) * 10);
}
{
auto s = &um[1][p.y+p.x];
auto it = s->upper_bound(p.x);
if (it != s->end()) chmin(ans, (*it - p.x) * 10);
}
{
auto s = &ls[p.y];
auto it = s->upper_bound(p.x);
if (it != s->end()) {
chmin(ans, (*it - p.x) * 5);
}
}
}
if (p.u=='L') {
{
auto s = &um[0][p.y-p.x+BASE];
auto it = s->lower_bound(p.x);
if (it != s->begin()) chmin(ans, (p.x - *(--it))*10);
}
{
auto s = &dm[1][p.y+p.x];
auto it = s->lower_bound(p.x);
if (it != s->begin()) chmin(ans, (p.x - *(--it))*10);
}
}
if (p.u=='U') {
auto s = &ds[p.x];
auto it = s->upper_bound(p.y);
if (it != s->end()) {
chmin(ans, (*it - p.y)*5);
}
}
}
if (ans==INT_MAX) {
cout << "SAFE" << endl;
} else {
cout << ans << endl;
}
}
| #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef pair <int , int> pii;
const int MAXN = 4e5 + 10 , INF = 202020;
int ans = 1e9;
vector <pii> v[MAXN];
int x[MAXN] , y[MAXN] , t[MAXN];
int tu(char c){
if(c == 'U') return 0;
else if(c == 'R') return 1;
else if(c == 'D') return 2;
return 3;
}
void check(int m){
for(int i = 0 ; i <= 400000 ; ++ i)
if((int)v[i].size() > 0){
sort(v[i].begin() , v[i].end());
int la = -INF;
for(int k = 0 ; k < (int)v[i].size() ; ++ k)
if(v[i][k].second == -1){
if(la != -INF)
ans = min(ans , (v[i][k].first - la) * m);
}
else
la = v[i][k].first;
v[i].resize(0);
}
}
int main(){
int N;
scanf("%d" , &N);
for(int i = 1 ; i <= N ; ++ i){
char s[2];
scanf("%d%d%s" , &x[i] , &y[i] , s);
// cout << i << " " << x[i] + y[i] << " " << x[i] - y[i] << " " << t[i] << endl;
t[i] = tu(s[0]);
}
for(int i = 1 ; i <= N ; ++ i)
if(t[i] % 2 == 0)
v[x[i]].push_back(make_pair(y[i] , (t[i] == 0 ? 1 : -1)));
check(5);
for(int i = 1 ; i <= N ; ++ i)
if(t[i] % 2 == 1)
v[y[i]].push_back(make_pair(x[i] , (t[i] == 1 ? 1 : -1)));
check(5);
for(int i = 1 ; i <= N ; ++ i)
if(t[i] == 0 || t[i] == 3)
v[y[i] - x[i] + 200000].push_back(make_pair(x[i] , (t[i] == 0 ? 1 : -1)));
check(10);
for(int i = 1 ; i <= N ; ++ i)
if(t[i] == 1 || t[i] == 2)
v[y[i] - x[i] + 200000].push_back(make_pair(x[i] , (t[i] == 1 ? 1 : -1)));
check(10);
for(int i = 1 ; i <= N ; ++ i)
if(t[i] == 0 || t[i] == 1)
v[x[i] + y[i]].push_back(make_pair(x[i] , (t[i] == 1 ? 1 : -1)));
check(10);
for(int i = 1 ; i <= N ; ++ i)
if(t[i] == 2 || t[i] == 3)
v[x[i] + y[i]].push_back(make_pair(x[i] , (t[i] == 2 ? 1 : -1)));
check(10);
if(ans == 1e9)
cout << "SAFE" << endl;
else
cout << ans << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
#define fi first
#define se second
#define rep(i, n) for(int (i) = 0; (i) < (n); (i)++)
#define rrep(i, n) for (int (i) = 1; (i) <= (n); (i++))
#define rng(a) a.begin(),a.end()
#define rrng(a) a.rbegin(),a.rend()
#define pb push_back
#define eb emplace_back
#define yn {puts("Yes");}else {puts("No");}
#define printd(x) printf("%.12f\n", ans);
template<class T> bool chmin(T& a, const T& b) {if (a > b) {a = b; return 1;} return 0;}
template<class T> bool chmax(T& a, const T& b) {if (a < b) {a = b; return 1;} return 0;}
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main(void) {
ll a, b, k;
cin >> a >> b >> k;
rep (i, k) {
if (i % 2 == 0) {
if (a % 2 == 1) {
a--;
}
a /= 2;
b += a;
}
else {
if ( b % 2) {
b--;
}
b /= 2;
a += b;
}
}
cout << a << " " << b << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll N = 4e5 + 5;
const ll mod = 998244353;
ll fac[N], inv[N];
ll power(ll x, ll y)
{
ll res = 1;
while (y)
{
if (y & 1)
res = res * x % mod;
x = x * x % mod;
y >>= 1;
}
return res;
}
void init()
{
fac[0] = inv[0] = 1;
for (ll i = 1; i < N; i++)
{
fac[i] = i * fac[i - 1] % mod;
inv[i] = power(fac[i], mod - 2);
}
}
ll ncr(ll n, ll r)
{
if (r < 0 || r > n)
return 0;
return fac[n] * inv[r] % mod * inv[n - r] % mod;
}
// https://betrue12.hateblo.jp/entry/2020/05/11/093054
signed main()
{
init();
ll n, m, k;
cin >> n >> m >> k;
ll ans = 0;
for (ll i = 0; i <= k; i++)
{
ll curr = ncr(n - 1, i) * m % mod * power(m - 1, n - 1 - i) % mod;
ans = (ans + curr) % mod;
}
cout << ans << endl;
return 0;
} | 0 |
// c
#include <bits/stdc++.h>
#include <string>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
typedef long long ll;
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
//定数
#define INF 1000000000 //10^9:極めて大きい値,∞
//略記
#define PB push_back //vectorヘの挿入
#define MP make_pair //pairのコンストラクタ
#define F first //pairの一つ目の要素
#define S second //pairの二つ目の要素
int main(){
int n;
cin>>n;
vector<pair<int,int>> a(n),b(n);
bool ac[n]={};
rep(i,n) cin>>a[i].first>>a[i].second;
rep(i,n) cin>>b[i].first>>b[i].second;
sort(a.begin(),a.end());
sort(b.begin(),b.end());
int j=0;
int ans=0;
rep(i,n){
pair<int,int> sel_b=b[i];
int max_y=-1;
int sel_a;
rep(j,n){
if(ac[j])continue;
if(a[j].first<sel_b.first && a[j].second<sel_b.second){
if(a[j].second>max_y){
max_y=a[j].second;
sel_a=j;
}
}
}
if(max_y>-1){
ans++;
ac[sel_a]=true;
}
}
cout<<ans<<endl;
return 0;
} | #include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include <functional>
#include <cmath>
#include <set>
#include <queue>
#include <deque>
#include <vector>
#include <climits>
#include <sstream>
#include <iomanip>
#include <map>
#include <stack>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
struct EdgeMF
{
int to;
ll capacity;
int reverse;
};
void addEdgeForFlow(vector<vector<EdgeMF>>& G, int from, int to, ll capacity, ll reverseCapacity)
{
G[from].push_back({ to, capacity, (int)G[to].size() });
G[to].push_back({ from, reverseCapacity, (int)G[from].size() - 1 });
}
ll dfsForFlow(vector<vector<EdgeMF>>& G, vector<bool>& used, int u, int t, ll f)
{
if (u == t)
{
return f;
}
used[u] = true;
for (auto& e : G[u])
{
if (used[e.to] || e.capacity <= 0)
{
continue;
}
auto d = dfsForFlow(G, used, e.to, t, min(f, e.capacity));
if (d > 0)
{
e.capacity -= d;
G[e.to][e.reverse].capacity += d;
return d;
}
}
return 0;
}
ll calcMaxFlow(vector<vector<EdgeMF>>& G, int s, int t)
{
auto f = 0ll;
while (true)
{
vector<bool> used((int)G.size());
auto d = dfsForFlow(G, used, s, t, LLONG_MAX);
if (d <= 0)
{
break;
}
f += d;
}
return f;
}
int main()
{
int N;
cin >> N;
vector<int> x(2 * N);
vector<int> y(2 * N);
for (auto i = 0; i < 2 * N; ++i)
{
cin >> x[i] >> y[i];
}
vector<vector<EdgeMF>> G(2 * N + 2);
for (auto i = 0; i < N; ++i)
{
for (auto j = N; j < 2 * N; ++j)
{
if (x[i] < x[j] && y[i] < y[j])
{
addEdgeForFlow(G, i, j, 1, 0);
}
}
}
int s = 2 * N;
int t = s + 1;
for (auto i = 0; i < N; ++i)
{
addEdgeForFlow(G, s, i, 1, 0);
addEdgeForFlow(G, i + N, t, 1, 0);
}
cout << calcMaxFlow(G, s, t) << endl;
return 0;
} | 1 |
/************************************************************************
* -> Bismillahir Rahmanir Rahim <- *
* *
* *
* *
* *
* __________ .___ .__ ____ ________ *
* \______ \_____ __| _/ ______| |__ _____ /_ |\_____ \ *
* | | _/\__ \ / __ | / ___/| | \ \__ \ | | / ____/ *
* | | \ / __ \_/ /_/ | \___ \ | Y \ / __ \_ | |/ \ *
* |______ /(____ /\____ | /____ >|___| /(____ / |___|\_______ \ *
* \/ \/ \/ \/ \/ \/ \/ *
* *
* *
* *
* .=., *
* ;c =\ *
* __| _/ *
* .'-'-._/-'-._ *
* /.. ____ \ *
* /' _ [<BF>] ) \ *
* ( / \--\_>/-/'._ ) *
* \-;_/\__;__/ _/ _/ *
* '._}|==o==\{_\/ *
* / /-._.--\ \_ *
* // / /| \ \ \ *
* / | | | \; | \ \ *
* / / | :/ \: \ \_\ *
* / | /.'| /: | \ \ *
* | | |--| |--| \_\ *
* / _/ \ | | /___--._) \ *
* |_(---'-| > | | '-' *
* /_/ \_\ *
* *
***********************************************************************/
#include<bits/stdc++.h>
using namespace std;
#define pi acos(-1)
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned un;
//defined taking input;
#define sf scanf
#define si(a) sf("%d",&a)
#define sc(a) sf("%c",&a)
#define sii(a,b) sf("%d %d",&a,&b)
#define siii(a,b,c) sf("%d %d %d",&a,&b,&c)
#define sl(a) sf("%lld",&a)
#define sll(a,b) sf("%lld %lld",&a,&b);
#define slll(a,b,c) sf("%lld %lld %lld",&a,&b,&c);
#define pf printf
#define pfi(a) pf("%d\n",a)
#define pfii(a,b) pf("%d %d\n",a,b)
#define pfl(a) pf("%ld\n",a)
#define pfn pf("\n")
#define pfyes pf("YES\n")
#define pfno pf("NO\n")
#define pfYes pf("Yes\n")
#define pfNo pf("No\n")
#define wh while
#define wht(t) while(t--)
#define vi vector<int>
#define vl vector<long long>
#define endl "\n"
#define input freopen("input.txt","r",stdin);
#define output freopen("output.txt","w",stdout);
int main()
{
int n,r;
cin>>n>>r;
int a = 100*(10-n);
if(a>=0){
cout<<r+a<<endl;
}else{
cout<<r<<endl;
}
return 0;
}
| #define _USE_MATH_DEFINES
#include <iostream>
#include <algorithm>
#include <climits>
#include <vector>
#include <string>
#include <cstring>
#include <stack>
#include <queue>
#include <cmath>
#include <iomanip>
#include <set>
#include <map>
#include <new>
#include <cstdint>
#include <cctype>
#include <cstdio>
using namespace std;
#define rep(i,n) for(int i = 0; i < n; i++)
#define lrep(i,n,m) for(int i = n; i < m; i++)
using ll = long long;
using ld = long double;
using Vii = vector<vector<int> >;
using Gjudge = vector<vector<bool>>;
using Vi = vector<int>;
using Vl = vector<ll>;
using Vd = vector<double>;
using Vld = vector<long double>;
using Vll = vector<vector<ll> >;
using Vldd = vector<vector<ld> >;
using Vs = vector<string>;
using Vb = vector<bool>;
using Pi = pair<int, int>;
using Pl = pair<ll, ll>;
using Pli = pair<ll, int>;
using VPi = vector<Pi>;
using VPl = vector<Pl>;
using VPli = vector<Pli>;
using Ti = tuple<int, int, int>;
using Tl = tuple<ll, ll, ll>;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int Mod = static_cast<int>(1e9 + 7);
const int INF = INT_MAX / 10;
const ll LINF = LLONG_MAX / 10;
const int dx[4] = { 1,0,-1,0 };
const int dy[4] = { 0,1,0,-1 };
int main()
{
int n, r;
cin >> n >> r;
if (n >= 10) cout << r << endl;
else {
r += 100 * (10 - n);
cout << r << endl;
}
}
| 1 |
#include<bits/stdc++.h>
#define rep(i,f,n) for(ll i=(f); (i) < (n); i++)
#define repe(i,f,n) for(ll i=(f); (i) <= (n); i++)
using namespace std;
using ll = long long;
ll INF = 1LL << 60;
using G = vector<map<int, int>>;
void
dfs(int node, ll count, G &arr, vector<bool> seen, vector<long> &to_K)
{
seen[node] = true;
for(auto child: arr[node]){
if(seen[child.first]) continue;
to_K[child.first] = count + child.second;
dfs(child.first, count + child.second, arr, seen, to_K);
}
}
int
main() {
int N; cin >> N;
G arr(N + 1);
rep(i, 0, N - 1){
int a, b, c; cin >> a >> b >> c;
arr[a][b] = c;
arr[b][a] = c;
}
vector<long> to_K(N + 1);
int Q, K; cin >> Q >> K;
vector<pair<int, int>> q(Q);
rep(i, 0, Q){
cin >> q[i].first;
cin >> q[i].second;
}
vector<bool> seen(N + 1, false);
//dfs(K, 0, arr, seen, to_K);
queue<int> que;
que.push(K);
seen[K] = true;
to_K[K] = 0;
while(!que.empty()){
int node = que.front();
que.pop();
for(auto child : arr[node]){
if(seen[child.first]) continue;
to_K[child.first] = arr[node][child.first] + to_K[node];
seen[child.first] = true;
que.push(child.first);
}
}
rep(i, 0, Q){
cout << to_K[q[i].first] + to_K[q[i].second] << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
int N, M;
cin >> N >> M;
vector<vector<int>> tree(N);
vector<int> n_in(N);
for (int i = 0; i < N - 1 + M; i++)
{
int Ai, Bi;
cin >> Ai >> Bi;
Ai--;
Bi--;
tree.at(Ai).push_back(Bi);
n_in.at(Bi) += 1;
}
int r;
for (int i = 0; i < N; i++)
{
if (n_in.at(i) == 0)
{
r = i;
break;
}
}
vector<int> l;
queue<int> q;
q.push(r);
while (q.size())
{
int n = q.front();
q.pop();
l.push_back(n);
for (auto &&e : tree.at(n))
{
n_in.at(e)--;
if (n_in.at(e) == 0)
{
q.push(e);
}
}
}
vector<int> p(N, 0);
for (auto &&n : l)
{
for (auto &&e : tree.at(n))
{
p.at(e) = n + 1;
}
}
for (int i = 0; i < N; i++)
{
cout << p.at(i) << endl;
}
} | 0 |
#include <iostream>
#include <algorithm>
#include <map>
#include <vector>
#include <string>
#include <cstdio>
#include <cmath>
using namespace std;
int main(void)
{
int wsd[10], ko[10];
for(int i=0; i<10; i++) cin>>wsd[i];
for(int i=0; i<10; i++) cin>>ko[i];
sort(wsd, wsd+10);
sort(ko, ko+10);
printf("%d %d\n",wsd[9]+wsd[8]+wsd[7], ko[9]+ko[8]+ko[7]);
return 0;
} | #include<stdio.h>
int main(void)
{
int W_t[3];
int K_t[3];
int i,p,l,n,m;
int K_p=0,W_p=0;
for(i=0;i<3;i++){
scanf("%d",&p);
W_t[i]=p;
}
for(i=3;i<10;i++){
for(l=0;l<2;l++)
for(m=l+1;m<3;m++){
if(W_t[l]<W_t[m]){
n=W_t[l];
W_t[l]=W_t[m];
W_t[m]=n;
}
}
scanf("%d",&p);
if(W_t[2]<p)
W_t[2]=p;
}
for(i=0;i<3;i++){
scanf("%d",&p);
K_t[i]=p;
}
for(i=3;i<10;i++){
for(l=0;l<2;l++)
for(m=l+1;m<3;m++){
if(K_t[l]<K_t[m]){
n=K_t[l];
K_t[l]=K_t[m];
K_t[m]=n;
}
}
scanf("%d",&p);
if(K_t[2]<p)
K_t[2]=p;
}
for(i=0;i<3;i++){
K_p+=K_t[i];
W_p+=W_t[i];
}
printf("%d %d\n",W_p,K_p);
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
LL n,k;
const LL mof=1e9+7;
LL p=mof;
const LL maxn=200007;
inline LL pow_mod(LL a,LL k,LL mo)
{
LL ans=1;
while(k)
{
if(k%2) ans=ans*a%mo;
a=a*a%mo;
k>>=1;
}
return ans%mo;
}
LL jc[maxn+7];
inline LL inv(LL x)
{
return pow_mod(x,mof-2,mof);
}
LL Inv[maxn+7];
LL C(LL N,LL k)
{
if(k>N||k<0)return 0;
if(k==0||k==N)return 1;
LL ans=1;
ans=ans*jc[N]*Inv[k]%mof*Inv[N-k]%mof;
return ans;
}
void init()
{
jc[1]=jc[0]=1;
for(LL i=2; i<=maxn; ++i) jc[i]=jc[i-1]*i%mof;
for(int i=0; i<=maxn; ++i) Inv[i]=inv(jc[i]);
}
const long long MOD = 1000000007;
void solve(long long H, long long W, long long A, long long B){
LL ans = 0;
LL h = H-A;
for(LL w=B+1;w<=W;++w)
{
ans += C(h+w-2,h-1) * C(H-h+W-w-1,H-h-1);
ans %= mof;
}
cout<<ans<<endl;
}
int main(){
init();
long long H;
scanf("%lld",&H);
long long W;
scanf("%lld",&W);
long long A;
scanf("%lld",&A);
long long B;
scanf("%lld",&B);
solve(H, W, A, B);
return 0;
}
| #include <iostream>
#include <cmath>
#include <iomanip>
int main() {
double x1, y1, x2, y2;
std::cin >> x1 >> y1 >> x2 >> y2;
std::cout << std::fixed << std::setprecision(6)
<< std::sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
<< std::endl;
}
| 0 |
#include<iostream>
#include<cassert>
#include<stdexcept>
#include<utility>
#include<functional>
#include<numeric>
#include<cmath>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<array>
#include<stack>
#include<queue>
#include<deque>
#include<vector>
#include<complex>
#include<set>
#include<map>
#include<unordered_map>
#include<unordered_set>
#include<string>
#include<bitset>
#include<memory>
#include<iomanip>
using namespace std;
using ll=long long;
#include<complex>
namespace Geometry{
using namespace std;
using ld=double;
using Point=complex<ld>;
struct Line{
Point a,b;
};
struct Circle{
Point p;
ld r;
};
const ld EPS=1e-6;
inline bool EQ(Point a,Point b){return abs(a-b)<EPS;}
ld dot(Point a,Point b){return real(a)*real(b)+imag(a)*imag(b);}
ld cross(Point a,Point b){return real(a)*imag(b)-imag(a)*real(b);}
const int CCW=1;
const int CW=-1;
const int BAC=2;
const int ACB=-2;
const int ABC=0;
int ccw(Point a,Point b,Point c){
b-=a,c-=a;
if(cross(b,c)>EPS) return CCW; // counter clockwise
if(cross(b,c)<-EPS) return CW; //clockwise
if(dot(b,c)<-EPS) return BAC; //b-a-c
if(abs(b)<abs(c)) return ACB; //a-c-b
return ABC; //a-b-c (abs(b)>abs(c))
}
}
#include<vector>
#include<algorithm>
namespace Geometry{
vector<Point> convexFull(const vector<Point>& _ps){
vector<Point> ps=_ps;
int n=ps.size();
if(n<=1) return ps;
auto cmp=[](const Point &lhs,const Point &rhs){
return real(lhs)==real(rhs) ? imag(lhs)<imag(rhs) : real(lhs)<real(rhs);
};
sort(ps.begin(),ps.end(),cmp);
int k=0;
vector<Point> qs(n*2);
for(int i=0;i<n;i++){
while(k>=2 && ccw(qs[k-2],qs[k-1],ps[i])<=0) --k;
qs[k++]=ps[i];
}
int t=k;
for(int i=n-2;i>=0;i--){
while(k>t && ccw(qs[k-2],qs[k-1],ps[i])<=0) --k;
qs[k++]=ps[i];
}
qs.resize(k-1);
return qs;
}
}
using namespace Geometry;
const double pi=acos(-1);
int main(){
int n;
cin>>n;
vector<Point> ps(n);
for(int i=0;i<n;i++){
int x,y;
cin>>x>>y;
ps[i]={x,y};
}
cout<<setprecision(10)<<fixed;
vector<Point> cps=convexFull(ps);
vector<double> res(n);
if(cps.size()<=2){
for(int j=0;j<cps.size();j++){
for(int i=0;i<n;i++){
if(cps[j]==ps[i]){
res[i]=1./cps.size();
}
}
}
for(int i=0;i<n;i++) cout<<res[i]<<endl;
return 0;
}
auto divd=[&](Point lhs,Point rhs){
return (lhs-rhs)*Point(0,1);
};
for(int i=0;i<cps.size();i++){
auto pre=cps[(i+cps.size()-1)%cps.size()];
auto nex=cps[(i+1)%cps.size()];
auto t1=divd(pre,cps[i]);
auto t2=divd(cps[i],nex);
auto theta=arg(t2/t1);
for(int j=0;j<n;j++){
if(cps[i]==ps[j]){
res[j]=theta/(2*pi);
}
}
}
for(int i=0;i<n;i++){
cout<<res[i]<<endl;
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int n,m,x[100],y[100],i=0,j,k;
double ans,d[205],P=acos(-1);
main(){
cin>>n;m=n;
while(m--)cin>>x[n-m-1]>>y[n-m-1];
for(i=0;i<n;i++){
k=ans=0;
for(j=0;j<n;j++)if(i-j)d[k++]=atan2(y[j]-y[i],x[j]-x[i]);
sort(d,d+k);
for(j=0;j<k;j++)d[j+k]=d[j]+2*P;
for(j=0;j<k;j++)ans=max(ans,P-d[j+k-1]+d[j]);
cout<<ans/2./P<<'\n';
}
} | 1 |
#include<iostream>
#include<string.h>
using namespace std;
int main()
{
char s1[1001],s2[1001];
int ss[1002][1002],u;
cin>>s1>>s2;
for(int i=0;i<=strlen(s2)+1;i++)ss[i][0]=i;
for(int i=1;i<=strlen(s1)+1;i++)ss[0][i]=i;
for(int i=1;i<=strlen(s2);i++){
for(int j=1;j<=strlen(s1);j++){
if(s1[j-1]==s2[i-1]){
u=min(ss[i-1][j-1],ss[i-1][j]+1);
ss[i][j]=min(u,ss[i][j-1]+1);
}
else{
u=min(ss[i-1][j-1],ss[i-1][j]);
ss[i][j]=min(u,ss[i][j-1])+1;
}
}
}
cout<<ss[strlen(s2)][strlen(s1)]<<endl;
return 0;
} | #include <bits/stdc++.h>
#define R register
#define ll long long
#define sum(a, b, mod) (((a) + (b)) % mod)
const int mod = 1e9 + 7;
const int MaxN = 3e5 + 10;
char s[MaxN];
ll n, f[MaxN][3][3];
void add(ll &a, ll b) {a += b, ((a > mod) ? (a -= mod) : 0); }
int main()
{
f[0][0][0] = 1;
scanf("%s", s + 1), n = strlen(s + 1);
for(int i = 0; i < n; i++)
{
for(int j = 0; j < 3; j++)
{
for(int k = 0; k < 3; k++)
{
if(s[i + 1] != '0')
{
if(k)
add(f[i + 1][j][k - 1], f[i][j][k]);
else add(f[i + 1][std::min(j + 1, 2)][k], f[i][j][k]);
}
if(s[i + 1] != '1')
{
if(k == 2)
add(f[i + 1][j][1], f[i][j][k]);
else add(f[i + 1][j][k + 1], f[i][j][k]);
}
}
}
}
ll ans = 0;
for(int i = 0; i < 3; i++)
for(int j = 0; j <= i; j++)
add(ans, f[n][i][j]);
printf("%lld\n", ans);
return 0;
}
| 0 |
#include<bits/stdc++.h>
template< typename G >
struct StronglyConnectedComponents {
using UnWeightedGraph=std::vector<std::vector<int>>;
const G &g;
UnWeightedGraph gg, rg;
std::vector< int > comp, order, used;
StronglyConnectedComponents(G &g) : g(g), gg(g.size()), rg(g.size()), comp(g.size(), -1), used(g.size()) {
for(int i = 0; i < g.size(); i++) {
for(auto e : g[i]) {
gg[i].emplace_back((int) e);
rg[(int) e].emplace_back(i);
}
}
}
int operator[](int k) {
return comp[k];
}
void dfs(int idx) {
if(used[idx]) return;
used[idx] = true;
for(int to : gg[idx]) dfs(to);
order.push_back(idx);
}
void rdfs(int idx, int cnt) {
if(comp[idx] != -1) return;
comp[idx] = cnt;
for(int to : rg[idx]) rdfs(to, cnt);
}
void build(UnWeightedGraph &t) {
for(int i = 0; i < gg.size(); i++) dfs(i);
reverse(begin(order), end(order));
int ptr = 0;
for(int i : order) if(comp[i] == -1) rdfs(i, ptr), ptr++;
t.resize(ptr);
for(int i = 0; i < g.size(); i++) {
for(auto &to : g[i]) {
int x = comp[i], y = comp[to];
if(x == y) continue;
t[x].push_back(y);
}
}
}
};
int main(){
int N,M;
std::cin>>N>>M;
std::vector<std::vector<bool>> to(N,std::vector<bool>(N,false));
std::vector<std::vector<int>> graph(N),t;
std::vector<int> ans;
for(int _=0;_<M;++_){
int u,v;
std::cin>>u>>v;
u--;v--;
if(ans.empty()){
graph[u].push_back(v);
StronglyConnectedComponents<std::vector<std::vector<int>>> scc(graph);
scc.build(t);
std::vector<std::vector<int>> tmp(N);
for(int i=0;i<N;++i) tmp[scc[i]].push_back(i);
int ok=-1;
for(int i=0;i<N;++i) if(tmp[i].size()>1) ok=i;
if(ok!=-1){
int now=v;
while(now!=u){
ans.push_back(now);
for(auto e:graph[now]) if(scc[e]==ok){
now=e;
break;
}
}
ans.push_back(u);
}
for(int i=0;i<N;++i) if(to[v][i]) to[u][i]=true;
}
else if(std::find(ans.begin(),ans.end(),u)!=ans.end()&&
std::find(ans.begin(),ans.end(),v)!=ans.end()){
int ch=std::find(ans.begin(),ans.end(),v)-ans.begin();
int sz=ans.size();
std::vector<int> tmp;
while(ans[ch]!=u){
tmp.push_back(ans[ch]);
ch=(ch+1)%sz;
}
tmp.push_back(u);
ans=tmp;
}
}
if(ans.empty()){
std::cout<<-1<<std::endl;
return 0;
}
std::cout<<ans.size()<<std::endl;
for(auto a:ans) std::cout<<a+1<<std::endl;
} | #include <stdio.h>
#include <algorithm>
#include <tuple>
#include <vector>
#include <queue>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int n, m;
vector<int> e[1010];
int v[1010], last[1010];
vector<int> r(2000, 0);
void bfs(int node) {
queue<int> q;
for (int x : e[node])
q.emplace(x), v[x] = last[x] = node;
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int x : e[cur])
if (v[x] != node)
q.emplace(x), v[x] = node, last[x] = cur;
}
if (v[node] != node)
return;
int pop = node;
vector<int> path;
path.emplace_back(node);
while (last[pop] != node) {
path.emplace_back(last[pop]);
pop = last[pop];
}
if (path.size() < r.size())
r.swap(path);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
e[a].emplace_back(b);
}
for (int i = 1; i <= n; i++)
bfs(i);
if (n < r.size())
printf("-1\n");
else {
printf("%d\n", r.size());
for (int v : r)
printf("%d\n", v);
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long ans = 0;
for(int i = 1; i <= n; i++){
if(i % 3 == 0 && i % 5 == 0) {
//FizzBuzz
} else if(i % 3 == 0) {
//Fizz
} else if(i % 5 == 0) {
//Buzz
} else {
ans = ans + i;
}
}
cout << ans;
}
| #include <bits/stdc++.h>
using namespace std;
long long f(long long n, long long x){
long long y = x / n;
if(x < n){
return 0;
} else {
return y * (n + y * n) / 2;
}
}
int main(void){
long long n;
cin >> n;
cout << f(1,n) - f(3,n) - f(5,n) + f(15,n) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
/*
提出前に確認!
- setとmultisetを間違えない
*/
/*
26進数で考えればいい
*/
void solve(long long num)
{
if (num == 0) return ;
num--;
solve(num / 26);
cout << (char)(num % 26 + 'a');
}
int main(void)
{
long long n;
cin >> n;
solve(n);
cout << endl;
return (0);
}
| #include <bits/stdc++.h>
#include <set>
using namespace std;
using pii = pair<int,int>;
using pll = pair<long long, long long>;
const long long INF = 1<<29;
const int MOD = 1000000007;
long long ruizyou(long long m,long long n){
if(m == 0)return 0;
if(m == 1)return 1;
long long ans = 1;
long long tmp = m;
for(int i=0;i<=30;i++){
if(n & (1<<i)){
ans *= tmp;
ans %= MOD;
}
tmp *= tmp;
tmp %= MOD;
}
return ans;
}
long long kaizyou(long long x){
if(x == 0)return 1;
return x * kaizyou(x-1) % MOD;
}
long long comb(long long x,long long y){
long long bunsi = kaizyou(x);
long long bunbo = kaizyou(x-y) * kaizyou(y) % MOD;
return bunsi * ruizyou(bunbo,MOD-2) % MOD;
}
struct unionfind{
vector<int> par;
vector<vector<int>> children;
vector<int> hukasa;
vector<int> kazu;
unionfind(int n){
par = vector<int>(n);
hukasa = vector<int>(n,0);
kazu = vector<int>(n,1);
for(int i=0;i<n;i++){
par.at(i) = i;
}
}
int root(int x){
if(par.at(x) == x)return x;
return root(par.at(x));
}
void unite(int x,int y){
int rx = root(x);
int ry = root(y);
if(rx == ry)return;
if(hukasa.at(rx) >= hukasa.at(ry)){
par.at(ry) = rx;
hukasa.at(rx) = max(hukasa.at(ry) + 1,hukasa.at(rx));
kazu.at(rx) += kazu.at(ry);
}
else{
par.at(rx) = ry;
kazu.at(ry) += kazu.at(rx);
}
}
void newkazu(){
int n = kazu.size();
for(int i=0;i<n;i++){
kazu.at(i) = kazu.at(root(i));
}
}
bool same(int x,int y){
return root(x) == root(y);
}
};
int ctoi(char a){
return a - '0';
}
long long gcd(long long a,long long b){
long long c = max(a,b);
long long d = min(a,b);
if(d % c == 0)return c;
return gcd(c,d%c);
}
long long lcm(long long a,long long b){
return a * b / gcd(a,b);
}
void hukasa(vector<vector<int>> s,vector<vector<int>> table,int &ans,pii frm,int n,int m){
int x,y;
tie(x,y) = frm;
set<pii> se;
if(x-1 >= 0)se.insert(pii(x-1,y));
if(x+1 < n)se.insert(pii(x+1,y));
if(y-1 >= 0)se.insert(pii(x,y-1));
if(y+1 < m)se.insert(pii(x,y+1));
for(auto t:se){
int tx,ty;
tie(tx,ty) = t;
if(s.at(tx).at(ty) && table.at(tx).at(ty) == -1){
table.at(tx).at(ty) = table.at(x).at(y) + 1;
ans = max(ans,table.at(tx).at(ty));
hukasa(s,table,ans,t,n,m);
table.at(tx).at(ty) = -1;
}
}
}
void daiku(int frm,vector<vector<pii>> g,vector<int> &cost,int n){
priority_queue<pii,vector<pii>,greater<pii>> q;
q.push(pii(cost.at(frm),frm));
vector<bool> kakutei(n,false);
while(!q.empty()){
pii now = q.top();
q.pop();
int n1,n2;
tie(n1,n2) = now;
if(kakutei.at(n2))continue;
kakutei.at(n2) = true;
for(auto t:g.at(n2)){
int tx,ty;
tie(tx,ty) = t;
if(cost.at(tx) > n1 + ty){
cost.at(tx) = n1 + ty;
q.push(pii(cost.at(tx),tx));
}
}
}
}
int main(){
long long n;
cin >> n;
long long tmp = 26;
int num = 1;
while(n > tmp){
n -= tmp;
tmp *= 26;
num++;
}
n--;
vector<int> c(num,0);
tmp = 0;
while(n / 26 > 0){
c.at(tmp) = (n % 26);
n /= 26;
tmp++;
}
c.at(tmp) = (n);
reverse(c.begin(),c.end());
for(int i=0;i<c.size();i++){
cout << (char)('a' + c.at(i));
}
cout << endl;
} | 1 |
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <complex>
#include <utility>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <tuple>
#include <cmath>
#include <bitset>
#include <cctype>
#include <set>
#include <map>
#include <unordered_map>
#include <numeric>
#include <functional>
#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(ll i=ll(a);i<ll(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define PRINT(V) cout << V << "\n"
#define SORT(V) sort((V).begin(),(V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
using namespace std;
using ll = long long;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
inline void Yes(bool condition){ if(condition) PRINT("Yes"); else PRINT("No"); }
template<class itr> void cins(itr first,itr last){
for (auto i = first;i != last;i++){
cin >> (*i);
}
}
template<class itr> void array_output(itr start,itr goal){
string ans = "",k = " ";
for (auto i = start;i != goal;i++) ans += to_string(*i)+k;
if (!ans.empty()) ans.pop_back();
PRINT(ans);
}
ll gcd(ll a, ll b) {
return a ? gcd(b%a,a) : b;
}
const ll INF = 1e15;
const ll MOD = 1000000007;
const ll MOD2 = 998244353;
typedef pair<ll,ll> P;
typedef pair<double,double> point;
const ll MAX = 200005;
constexpr ll nx[8] = {1,0,-1,0,1,-1,1,-1};
constexpr ll ny[8] = {0,1,0,-1,1,1,-1,-1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n,m;
cin >> n >> m;
vector<bool> a(m,1);
vector<vector<ll>> sport(n,vector<ll>(m,0));
rep(i,n){
rep(j,m){
cin >> sport[i][j];
sport[i][j]--;
}
}
ll ans = INF;
rep(i,m){
vector<ll> cnt(m,0);
ll ma = 0;
rep(j,n){
rep(k,m){
ll s = sport[j][k];
if (a[s]){
cnt[s]++;
chmax(ma,cnt[s]);
break;
}
}
}
chmin(ans,ma);
rep(j,m){
if (cnt[j] == ma){
a[j] = 0;
break;
}
}
}
PRINT(ans);
}
| #include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
using ll = long long;
using uint = unsigned int;
using graph = std::vector<std::vector<ll>>;
using wGraph = std::vector<std::vector<std::pair<ll,ll>>>;
#define rep(i,n) for (int i=0; i < int(n); i++)
using namespace std;
ll MOD7 = 1000000007;
ll MOD9 = 1000000009;
vector<ll> InputVec(ll N){
vector<ll> A(N);
for (int i = 0; i < N; ++i) {
cin >> A[i];
}
return A;
}
void OutputVec(vector<ll> A){
for (int i = 0; i < A.size(); ++i) {
cout << A[i] << ",";
}
cout << endl;
}
vector<vector<ll>> InputVec2d(ll H,ll W){
vector<vector<ll>> A(H);
for (int yi = 0; yi < H; ++yi) {
A[yi] = vector<ll>(W);
}
for (int yi = 0; yi < H; ++yi) {
for (int xi = 0; xi < W; ++xi) {
cin >> A[yi][xi];
}
}
return A;
}
vector<vector<char>> InputVec2dStr(ll H,ll W){
vector<vector<char>> A(H);
for (int yi = 0; yi < H; ++yi) {
A[yi] = vector<char>(W);
}
for (int yi = 0; yi < H; ++yi) {
string S;
cin >> S;
for (int xi = 0; xi < W; ++xi) {
A[yi][xi] = S[xi];
}
}
return A;
}
void OutputVec2d(vector<vector<ll>> A){
for (int yi = 0; yi < A.size(); ++yi) {
for (int xi = 0; xi < A[yi].size(); ++xi) {
cout << A[yi][xi] << ",";
}
cout << endl;
}
}
graph InputGraph(ll N,ll M){
graph G(N);
for (int i = 0; i < M; ++i) {
ll a,b;
cin >> a >> b;
a--;b--;
G[a].push_back(b);
G[b].push_back(a);
}
return G;
}
graph InputDGraph(ll N,ll M){
graph G(N);
for (int i = 0; i < M; ++i) {
ll a,b;
cin >> a >> b;
a--;b--;
G[a].push_back(b);
}
return G;
}
void OutputGraph(graph G){
for (int i = 0; i < G.size(); ++i) {
cout << i << ":";
for (int j = 0; j < G[i].size(); ++j) {
cout << G[i][j]<< ",";
}
cout << endl;
}
}
void OutputAnswerBool(bool b,bool isUpperCase = false){
if(b){
if(isUpperCase){
cout << "YES" << endl;
}else{
cout << "Yes" << endl;
}
}else{
if(isUpperCase){
cout << "NO" << endl;
}else{
cout << "No" << endl;
}
}
}
int main() {
ll N,M;
cin >> N >> M;
auto A = InputVec2d(N,M);
vector<bool> b(M);
for (int i = 0; i < M; ++i) {
b[i] = true;
}
ll m = N;
for (int i = 0; i < M; ++i) {
vector<ll> bucket(M);
for (int ni = 0; ni < N; ++ni) {
for (int mi = 0; mi < M; ++mi) {
if(b[A[ni][mi]-1]){
bucket[A[ni][mi]-1]++;
break;
}
}
}
ll del = -1;
for (int j = 0; j < M; ++j) {
if(b[j]){
if(del == -1){
del = j;
}
if(bucket[j] >= bucket[del]){
del = j;
}
}
}
m = min(m,bucket[del]);
b[del] = false;
}
cout << m << endl;
}
| 1 |
#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 <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
using namespace std;
struct node{
int key;
node *parent,*left,*right;
};
node *NIL,*root;
void inorder(struct node *u){
if(u==NIL)return;
inorder(u->left);
printf(" %d",u->key);
inorder(u->right);
}
void preorder(struct node *u){
if(u==NIL)return;
printf(" %d",u->key);
preorder(u->left);
preorder(u->right);
}
void pr(){
inorder(root);
printf("\n");
preorder(root);
printf("\n");
}
void insert(int key){
node *y = NIL;
node *x = root;
node *z;
z = (node *)malloc(sizeof(node));
z->key = key;
z->left = NIL;
z->right = NIL;
while(x!=NIL){//when x==NIL break
y = x;
if(z->key < x->key)x = x->left;
else x = x->right;
}
z->parent = y;
if(y == NIL)root = z;//z became root,insert root
else if(z->key < y->key)y->left = z;
else y->right = z;
}
node * find(node *u,int k){
while((u != NIL) && (k != u->key)){
//when you exchange the position of '(u != NIL)' with '(k != u->key)',the program will run failed
//you must make sure that u!=NIl firstly,otherwise k will compare with NIL->key(which is not defined)
if(k < u->key)u = u->left;
else u = u->right;
}
return u;
}
node * treeMinmum(node *x){
while(x->left!=NIL)x = x->left;//"leftmost"
return x;
}
node * treeSuccessor(node *x){
if(x->right != NIL)return treeMinmum(x->right);//exist right tree,find the next node inorder
node *y = x->parent;//not exist,return parent node which acts as left-child node firstly
while(y!=NIL && y->right == x){
x = y;
y = y->parent;
}
return y;
}
void treedelete(node *z){
node *y;//the node to delete
node *x;//child-node of the node needed to be deleted
//make sure wheter z delete or not
if(z->left == NIL || z->right == NIL)y = z;
else y = treeSuccessor(z);
if(y->left != NIL)x = y->left;
else x = y->right;
if(x != NIL )x->parent = y->parent; // make y->parent as x new parent
// make x as y->parent new child
if(y->parent == NIL)root = x;//y was root
else if(y == y->parent->left)y->parent->left = x;
else y->parent->right = x;
if(y!=z)z->key = y->key;
free(y);
}
int main()
{
int n,k;
scanf("%d",&n);
char s[20];
for(int i=0;i<n;++i){
scanf("%s",s);
if(s[0]=='i'){
scanf("%d",&k);
insert(k);
}else if(s[0]=='f'){
scanf("%d",&k);
node *t = find(root,k);
if(t != NIL )printf("yes\n");
else printf("no\n");
}
else if(s[0]=='d'){
scanf("%d",&k);
treedelete(find(root,k));
}
else pr();
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
double n,m,d,l;cin>>n>>m>>d;
l=2*(n-d);
if(d==0)l/=2;
cout<<fixed<<setprecision(15)<<l*(m-1)/n/n<<endl;
} | // AtCoder template
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int i = 0; i < n; ++i)
ll memo[15];
const ll MOD = 1e9+7;
ll fib(ll n){
if(n <= 0) return 1LL;
if(memo[n] > 0) return memo[n];
else return memo[n] = (fib(n-1) + fib(n-2))%MOD;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int h,w,k; cin >> h >> w >> k;
if(w == 1){
cout << 1 << endl;
return 0;
}
--k;
vector<ll> bef(w+1, 0LL), now(w+1, 0LL);
// fib前計算
fib(w);
bef[0] = 1LL;
rep(i,h){
rep(j, w){
if(j == 0){
now[0] = bef[1]*fib(w-3)%MOD + bef[0]*fib(w-2)%MOD;
now[0] %= MOD;
continue;
}
if(j == w-1){
now[w-1] = bef[w-2]*fib(w-3)%MOD + bef[w-1]*fib(w-2)%MOD;
now[w-1] %= MOD;
continue;
}
// 1
now[j] = (( (fib(w-j-2)*fib(j-2))%MOD )*bef[j-1]) % MOD;
now[j] %= MOD;
// 2
now[j] += (( (fib(w-j-3)*fib(j-1))%MOD )*bef[j+1]) % MOD;
now[j] %= MOD;
// 3
now[j] += (( (fib(w-j-2)*fib(j-1))%MOD )*bef[j]) % MOD;
now[j] %= MOD;
}
rep(j,w){
bef[j] = now[j];
now[j] = 0LL;
}
}
cout << bef[k] << endl;
} | 0 |
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int n;
long minimum = 1000000, maximum = -1000000, sum = 0;
cin >> n;
for (int i = 0; i < n; i++){
long a;
cin >> a;
minimum = min(a, minimum);
maximum = max(a, maximum);
sum += a;
}
cout << minimum << " " << maximum << " " << sum << endl;
return 0;
} | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a), i##_max = (b); i < i##_max; ++i)
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define ALL(obj) (obj).begin(), (obj).end()
using namespace std;
constexpr int INF = 1 << 30;
constexpr int MOD = 1000000007;
static vector<int> G;
static int cnt = 0;
void insert_sort(vector<int> &A, int g) {
FOR(i, g, A.size()) {
auto v = A[i];
auto j = i - g;
while (j >= 0 && A[j] > v) {
A[j + g] = A[j];
j -= g;
++cnt;
}
A[j + g] = v;
}
}
void shell_sort(vector<int> &A) {
for(int h = 1;;) {
if (h > A.size()) break;
G.push_back(h);
h = 3*h + 1;
}
reverse(ALL(G));
REP(i, G.size()) insert_sort(A, G[i]);
}
int main() {
int N;
cin >> N;
vector<int> A(N);
REP(i, N) cin >> A[i];
shell_sort(A);
cout << G.size() << endl;
REP(i, G.size()) {
if (i) cout << " ";
cout << G[i];
}
cout << endl << cnt << endl;
for (auto a : A) cout << a << endl;
}
| 0 |
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<functional>
using namespace std;
char s[1000001],ss[1000000];
int suu[1000000],cnt[1000000];
int main(void)
{
int i,j,kazu,max=0,len;
scanf("%s",s);
kazu=0;
cnt[kazu]=1;
ss[kazu]=s[kazu];
len=strlen(s);
for(i=1;i<len;i++) {
if(ss[kazu]==s[i]) cnt[kazu]++;
else {
kazu++;
cnt[kazu]=1;
ss[kazu]=s[i];
}
}
for(i=0;i<=kazu;i++) {
if(ss[i]=='O') {
if(i-1>=0 && i+1<=kazu) {
if(ss[i-1]=='J' && cnt[i-1]>=cnt[i]) {
if(ss[i+1]=='I' && cnt[i+1]>=cnt[i]) {
if(max<cnt[i]) max=cnt[i];
}
}
}
}
}
printf("%d\n",max);
return 0;
} | #include <iostream>
#include<cmath>
using namespace std;
int main()
{
int n,a;
cin>>n;
for(int i=n;i>=1;i--)
{
a=sqrt(i);
if(i%a==0&&i/a==a)
{
cout<<i<<endl;
return 0;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#include <boost/range/adaptors.hpp>
#include <boost/range/irange.hpp>
using namespace std;
using namespace boost;
using namespace boost::adaptors;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
int64_t m = s.size();
vector a(1, 0L);
int64_t t = 0;
for (auto c : s) {
if (c == '0') {
a.push_back(t);
} else {
++t;
}
}
a.push_back(t);
int64_t k;
cin >> k;
k = min(k, a.back());
int64_t n = a.size();
constexpr auto M = 998244353L;
vector dp(vector(k + 1, vector(a.back() + 1, 0L)));
int64_t mk = 0;
dp[0][0] = 1;
for (auto i : irange(0L, n - 1)) {
for (auto j : irange(mk, -1L, -1L)) {
auto r = min(k - j, a[i + 1] - a[i]);
for (auto d : irange(1L, r + 1L)) {
auto w = j + d;
for (auto c : irange(0L, a.back() - a[i + 1] + 1)) {
auto b = c + d;
dp[w][c] += dp[j][b];
if (dp[w][c] >= M) {
dp[w][c] -= M;
}
}
}
for (auto c : irange(1L, a.back() - a[i + 1] + 1)) {
dp[j][c] += dp[j][c - 1];
if (dp[j][c] >= M) {
dp[j][c] -= M;
}
}
}
mk = min(k, mk + a[i + 1] - a[i]);
}
int64_t ans = 0;
for (auto i : irange(0L, mk + 1)) {
ans += dp[i][0];
}
cout << ans % M << "\n";
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
typedef long double ld;
typedef pair<int,int> pii;
#define x first
#define y second
const int N=310,MOD=998244353;
int dp[N][N][N];
int xxm[N][N][N];
int xmp[N][N][N];
#define get(arr) \
int get_##arr(int pos,int mov,int dif) \
{ \
if(pos>=0&&mov>=0&&dif>=0) \
return arr[pos][mov][dif]; \
else \
return 0; \
}
get(dp)
get(xxm)
get(xmp)
signed main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
int k;
cin>>s>>k;
k=min<int>(k,s.size());
vector<int> v{0};
int cur=0;
for(char c:s)
if(c=='0')
v.push_back(cur),
cur=0;
else
cur++;
v.push_back(cur);
int n=v.size()-1;
// cout<<n<<"\n";
// for(int i=1;i<=n;i++)
// cout<<v[i]<<" ";
// cout<<"\n";
dp[0][0][0]=1;
xxm[0][0][0]=1;
xmp[0][0][0]=1;
for(int pos=0;pos<=n;pos++)
for(int mov=0;mov<=k;mov++)
for(int dif=0;dif<=k;dif++)
{
dp[pos][mov][dif]=(get_dp(pos,mov,dif)+
get_xxm(pos-1,mov,dif-1)+
get_xmp(pos-1,mov-1,dif+1)-
get_xmp(pos-1,mov-1-v[pos],dif+1+v[pos])+
get_dp(pos-1,mov,dif))%MOD;
xxm[pos][mov][dif]=(dp[pos][mov][dif]+get_xxm(pos,mov,dif-1))%MOD;
xmp[pos][mov][dif]=(dp[pos][mov][dif]+get_xmp(pos,mov-1,dif+1))%MOD;
// cout<<pos<<" "<<mov<<" "<<dif<<" -> "<<dp[pos][mov][dif]<<"\n";
}
int ans=0;
for(int mov=0;mov<=k;mov++)
ans=(ans+dp[n][mov][0])%MOD;
cout<<(ans+MOD)%MOD;
}
| 1 |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
long n,m,p[1001];
while(cin>>n>>m,n||m){
for(int i=1;i<=n;++i) cin>>p[i];
p[0]=0;
vector<long> s(0),t(0);
for(int i=0;i<=n;++i){
for(int j=0;j<=n;++j) s.push_back(p[i]+p[j]);
}
sort(s.begin(),s.end());
long a=0;
for(vector<long>::iterator it=s.begin();it!=s.end();++it){
if(*it*2>m) break;
a=max(a,*it+*(upper_bound(s.begin(),s.end(),m-*it)-1));
}
cout<<a<<endl;
}
return 0;
} | #include<iostream>
using namespace std;
int getDate(int q,int array[]){
int max=0,key=0;
for(int i=0;i<100000;i++){
if(max<array[i]){
max = array[i];
key = i;
}
}
return (max >= q) ? key : 0;
}
int main(){
int n,q;
int array[100000];
while(1){
cin >> n >> q;
if(n+q==0) break;
for(int i=0;i<100000;i++)
array[i]=0;
for(int i=0;i<n;i++){
int m, date;
cin >> m;
for(int j=0;j<m;j++){
cin >> date;
array[date]++;
}
}
cout << getDate(q,array) << endl;
}
} | 0 |
#include <iostream>
using namespace std;
int main(void){
string s;
cin>>s;
int k=0;
for(int i=0;i<s.size();++i){
if(s[i]=='J'){
int JOI[3]={1,0,0};
while(s[i]=='J'){++JOI[0];++i;}
while(s[i]=='O'){++JOI[1];++i;}
while(s[i]=='I'){++JOI[2];++i;}
if(JOI[0]>=JOI[1] && JOI[2]>=JOI[1]){
if(k<JOI[1]) k=JOI[1];
}
}
}
cout<<k<<endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
inline int read(){
int res=0;
char c;
bool zf=0;
while(((c=getchar())<'0'||c>'9')&&c!= '-');
if(c=='-')zf=1;
else res=c-'0';
while((c=getchar())>='0'&&c<='9')res=(res<<3)+(res<<1)+c-'0';
if(zf)return -res;
return res;
}
int tot[26];
signed main(){
string ss;cin>>ss;int n=ss.size(),s=0;
for(register int i=0;i<n;i++)tot[ss[i]-'a']++,s++;
long long ans=1ll*s*(s-1)/2;for(register int i=0;i<26;i++)ans-=1ll*tot[i]*(tot[i]-1)/2;printf("%lld\n",ans+1);
return 0;
} | 0 |
#include<stdio.h>
int main(void)
{
int n,m;
int a[1001],b[1001];
int c[1001],d;
int max;
int i,j;
scanf("%d %d",&n,&m);
for(i=0;i<n;i++){
scanf("%d",&a[i]);
c[i]=0;
}
for(i=0;i<m;i++){
scanf("%d",&b[i]);
}
for(i=0;i<m;i++){
for(j=0;j<n;j++){
if(a[j]<=b[i]){
c[j]++;
break;
}
}
}
max=c[0];
d=1;
for(i=1;i<n;i++){
if(max<c[i]){
max=c[i];
d=i+1;
}
}
printf("%d\n",d);
return 0;
} | #include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <map>
#include <sstream>
#include <functional>
#include <numeric>
#include <cmath>
#include <cstring>
#include <queue>
#include <stack>
#include <set>
using namespace std;
#define ALL(co) co.begin(), co.end()
typedef long long LL;
typedef pair<int, int> P;
typedef pair<int, P> IP;
typedef pair<P, P> PP;
typedef vector<int> Array;
typedef vector<vector<int> > Array2;
typedef vector<int> LArray;
const int INF = 1 << 29;
const LL LINF = 1LL << 60;
int itiv;
inline int getInt() { return (cin >> itiv, itiv); }
void readAll(Array& vec, int n) { for (int i = 0; i < n; i++) cin >> vec[i]; }
inline bool between(int first, int last, int n) { return first <= n && n <= last; }
inline bool inRange(int begin, int end, int n) { return begin <= n && n < end; }
inline bool inRange(int size, int n) { return 0 <= n && n < size; }
int m, n;
int dx[] = { -1, 0, 1, 0 }, dy[] = { 0, -1, 0, 1 };
int dr[] = { 0, -1, 0, 1 }, dc[] = { -1, 0, 1, 0 };
int main(void)
{
while(cin >> n >> m && n)
{
Array kyougi(n), sinsa(m);
Array hyou(n);
readAll(kyougi, n); readAll(sinsa, m);
for (int i = 0; i < m; i++)
{
for (int j = 0; j < n; j++)
{
if(kyougi[j] <= sinsa[i])
{
hyou[j]++;
break;
}
}
}
cout << (max_element(ALL(hyou)) - hyou.begin()) + 1 << endl;
}
return 0;
} | 1 |
#include <stdio.h>
int main ()
{
int H, W, N;
scanf ("%d", &H);
scanf ("%d", &W);
scanf ("%d", &N);
if (H < W)
{
H=W;
}
if (N % H == 0){
printf ("%d", N/H);
}
else if (N % H != 0){
printf ("%d", (N/H) + 1);
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
int N, K;
double ans = 0;
cin >> N >> K;
vector<double> p(N), E(N), sumE(N, 0);
for(int i = 0; i < N; ++i)cin >> p[i];
double bufe = 0;
for(int i = 0; i < N; ++i){
E[i] = (1/p[i])*(p[i]*(p[i]+1)/2);
}
for(int i = 0; i < N; ++i){
if(i == 0){
for(int i = 0; i < K; ++i) sumE[0] += E[i];
}
else if(i+K-1 < N)sumE[i] = sumE[i-1] - E[i-1] + E[i+K-1];
else break;
}
sort(sumE.begin(), sumE.end(), greater<double>());
cout << setprecision(16) << sumE[0] << endl;
return 0;
} | 0 |
#if 1
#include <bits/stdc++.h>
#else
#include "../../bits/stdc++.h"
#endif
#define FOR(i,a,b) for(int i = (a);i < (b);i++)
#define RFOR(i,a,b) for(int i = (b)-1;i >= (a);i--)
#define REP(i,n) FOR(i,0,(n))
#define RREP(i,n) RFOR(i,0,(n))
using namespace std;
typedef pair<int, int> P;
#define pb push_back
#define mp make_pair
#define ft first
#define sd second
int m, nin, nax;
int p[202];
bool input(){
cin>>m>>nin>>nax;
REP(i, m)cin>>p[i];
return m;
}
void solve(){
int s=0, b=0;
FOR(i, nin-1, nax) {
if(p[i]-p[i+1]>=s){
b=i+1;
s=p[i]-p[i+1];
}
}
cout<<b<<endl;
}
int main(){
cin.tie(0);
while (input()){
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
int m, n1, n2;
while(cin >> m >> n1 >> n2, m || n1 || n2){
int P[201];
for(int i = 0; i < m; i++) cin >> P[i];
int ans = n1;
for(int i = n1; i <= n2; i++){
if(P[ans-1]-P[ans] <= P[i-1]-P[i]) ans = i;
}
cout << ans << endl;
}
return 0;
} | 1 |
#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <cmath>
#include <map>
#include <climits>
#include <algorithm>
#include <utility>
using namespace std;
using Int = long long int;
using UInt = unsigned long long int;
using VI = vector<long long int>;
// 基本的な演算
namespace BasicMath {
// 二つの値の最大値を求める関数
static Int Max(const Int a, const Int b);
// 三つの値の最大値を求める関数
static Int Max(const Int a, const Int b, const Int c);
// 二つの値の最大値を求める関数
Int Max(const Int a, const Int b) {
if (a >= b) {
return a;
} else {
return b;
}
}
// 三つの値の最大値を求める関数
Int Max(const Int a, const Int b, const Int c) {
return Max(a, Max(b, c));
}
}
using namespace BasicMath;
int main(void) {
Int a, b, c;
cin >> a >> b >> c;
cout << a + b + c - Max(a, b, c) << endl;
return 0;
}
| #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <list>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <queue>
#include <iomanip>
#define INF 2147483647
using namespace std;
int main()
{
double x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
cout << fixed << setprecision(8) << sqrt(pow(x2 - x1, 2.0) + pow(y2 - y1, 2.0)) << endl;
return (0);
} | 0 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#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 all(x) (x).begin(),(x).end()
using vl=vector<ll>;
using vvl=vector<vector<ll>>;
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};
using Graph = vector<vector<int>>;
const ll mod=1000000007;
const int MAX_N = 1000; // n の最大値
double nCk(int n, int k) {
double res=1.0;
for(int i=0; i<n; i++){
res*=0.5;}
for(int i=0; i<k; i++){
res*=(double)(n-i);
res/=(double)(k-i);
}
return res;}
int main() {
ll n; cin >> n;
string a, b, c; cin >> a >> b >> c;
ll ca=0;
rep(i,n){
if(a.at(i)==b.at(i)&&b.at(i)==c.at(i)){
continue;}
else if(a.at(i)==b.at(i)||b.at(i)==c.at(i)||c.at(i)==a.at(i)){
ca+=1;}
else ca+=2;}
cout << ca << endl;} | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
using namespace std;
int main() {
int N;
cin >> N;
string a, b, c;
cin >> a >> b >> c;
int ans = 0;
for (int ii = 0; ii < N; ++ii){
map<char, int> m;
m[a[ii]]++;
m[b[ii]]++;
m[c[ii]]++;
int maxVal = max(m[a[ii]], max(m[b[ii]], m[c[ii]]));
ans += 3 - maxVal;
}
cout << ans << "\n";
return 0;
}
| 1 |
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
int main()
{
int n;
cin >> n;
vector<pair<int, int>> red;
vector<pair<int, int>> blue;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
red.emplace_back(b, a);
}
for (int i = 0; i < n; i++) {
int c, d;
cin >> c >> d;
blue.emplace_back(c, d);
}
sort(red.begin(), red.end(), greater<pair<int, int>>());
sort(blue.begin(), blue.end());
int ans = 0;
for (auto bit = blue.begin(); bit != blue.end(); bit++) {
auto it = red.begin();
while (it != red.end()) {
if (it->first < bit->second && it->second < bit->first) {
ans++;
red.erase(it);
break;
}
it++;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
// 型定義
typedef long long ll;
typedef pair<ll, ll> P;
// forループ
#define REP(i,n) for(ll i=0; i<(ll)(n); ++i)
// 定数宣言
const int INF = 1e9;
const int MOD = 1e9+7;
const ll LINF = 1e18;
// グラフ表現
using Graph = vector<vector<int>>;
// グラフの辺表現
using Edge = map<pair<int,int>,int>;
// n次元配列の初期化。第２引数の型のサイズごとに初期化していく。
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){
std::fill( (T*)array, (T*)(array+N), val );
}
// 最大公約数
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*b/gcd(a, b);
}
struct BipartiteMatching {
vector< vector< int > > graph;
vector< int > match, alive, used;
int timestamp;
BipartiteMatching(int n) : graph(n), alive(n, 1), used(n, 0), match(n, -1), timestamp(0) {}
void add_edge(int u, int v) {
graph[u].push_back(v);
graph[v].push_back(u);
}
bool dfs(int idx) {
used[idx] = timestamp;
for(auto &to : graph[idx]) {
int to_match = match[to];
if(alive[to] == 0) continue;
if(to_match == -1 || (used[to_match] != timestamp && dfs(to_match))) {
match[idx] = to;
match[to] = idx;
return true;
}
}
return false;
}
int bipartite_matching() {
int ret = 0;
for(int i = 0; i < graph.size(); i++) {
if(alive[i] == 0) continue;
if(match[i] == -1) {
++timestamp;
ret += dfs(i);
}
}
return ret;
}
void output() {
for(int i = 0; i < graph.size(); i++) {
if(i < match[i]) {
cout << i << "-" << match[i] << endl;
}
}
}
};
int main()
{
cout << fixed << setprecision(15);
ll N;
cin >> N;
vector<ll> A(N);
vector<ll> B(N);
vector<ll> C(N);
vector<ll> D(N);
REP(i, N){
cin >> A[i] >> B[i];
}
REP(i, N){
cin >> C[i] >> D[i];
}
BipartiteMatching bm(N + N);
REP(i, N){
REP(j, N){
// cout << i << " " << j << endl;
if((A[i] < C[j]) && (B[i] < D[j])){
bm.add_edge(i, N + j);
// cout << i << " " << j << endl;
}
}
}
// BipartiteMatching bm(X + Y);
// for(int i = 0; i < E; i++) {
// int a, b;
// cin >> a >> b;
// bm.add_edge(a, X + b);
// }
cout << bm.bipartite_matching() << endl;
return 0;
} | 1 |
//https://atcoder.jp/contests/abc160/tasks/abc160_b
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
ll x;
cin>>x;
ll a;
a=x/500;
ll fin1;
fin1=a*1000;
ll b;
b=x%500;
ll c;
c=b/5;
ll fin2;
fin2=c*5;
ll sum=0;
sum=fin1+fin2;
cout<<sum<<"\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll =long long;
#define all(v) v.begin(),v.end()
int main() {
ll X;
cin>>X;
ll a=X/500;
X-=500*a;
cout<<1000*a+5*(X/5)<<endl;
}
| 1 |
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 1000000000000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
ll N,A,B;
int main(){
scanf("%lld %lld %lld",&N,&A,&B);
ll pre,current;
scanf("%lld",&pre);
ll ans = 0;
for(int i = 1; i < N; i++){
scanf("%lld",¤t);
if(A*(current-pre) < B){
ans += A*(current-pre);
}else{
ans += B;
}
pre = current;
}
printf("%lld\n",ans);
return 0;
}
| #include<bits/stdc++.h>
#include<string.h>
typedef long long int ll;
#define all(x) (x).begin(), (x).end()
using namespace std;
int nxt() {
int x;
cin >> x;
return x;
}
ll nxtl(){
ll x;
cin>>x;
return x;
}
void SieveOfEratosthenes(int n,vector <int> &primes)
{
// Create a boolean array "prime[0..n]" and initialize
// all entries it as true. A value in prime[i] will
// finally be false if i is Not a prime, else true.
bool prime[n+1];
memset(prime, true, sizeof(prime));
for (int p=2; p*p<=n; p++)
{
// If prime[p] is not changed, then it is a prime
if (prime[p] == true)
{
// Update all multiples of p greater than or
// equal to the square of it
// numbers which are multiple of p and are
// less than p^2 are already been marked.
for (int i=p*p; i<=n; i += p)
prime[i] = false;
}
}
// Print all prime numbers
for (int p=2; p<=n; p++)
if (prime[p])
primes.push_back(p);
}
ll max(ll a,ll b)
{
if(a>b)
return a;
return b;
}
ll power(ll x, ll y,ll mod)
{
ll temp;
if( y == 0)
return 1;
temp = power(x, y/2,mod);
if (y%2 == 0)
return (temp*temp)%mod;
else
return (((x*temp)%mod)*temp)%mod;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll n=nxtl(),a=nxtl(),b=nxtl();
vector <int> v(n);
generate(all(v),nxt);
ll test=0;
for(int i=0;i<n-1;i++)
{
test+=min(b,a*(v[i+1]-v[i]));
}
cout<<test<<endl;
return 0;
}
| 1 |
#include"bits/stdc++.h"
#include<unordered_set>
#include<unordered_map>
#include<random>
using namespace std;
typedef long long ll;
const ll MOD = 1'000'000'007LL; /*998'244'353LL;*/
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for(int (i)=0; (i)<(n); (i)++)
int dx[4]={ 1,0,-1,0 };
int dy[4]={ 0,1,0,-1 };
int H, W, N;
signed main(){
cin >> H >> W >> N;
cout << min((N+H-1)/H, (N+W-1)/W) << endl;
} | #include <bits/stdc++.h>
#define debug(...) fprintf(stderr, __VA_ARGS__)
#ifndef AT_HOME
#define getchar() IO::myGetchar()
#define putchar(x) IO::myPutchar(x)
#endif
namespace IO {
static const int IN_BUF = 1 << 23, OUT_BUF = 1 << 23;
inline char myGetchar() {
static char buf[IN_BUF], *ps = buf, *pt = buf;
if (ps == pt) {
ps = buf, pt = buf + fread(buf, 1, IN_BUF, stdin);
}
return ps == pt ? EOF : *ps++;
}
template<typename T>
inline bool read(T &x) {
bool op = 0;
char ch = getchar();
x = 0;
for (; !isdigit(ch) && ch != EOF; ch = getchar()) {
op ^= (ch == '-');
}
if (ch == EOF) {
return false;
}
for (; isdigit(ch); ch = getchar()) {
x = x * 10 + (ch ^ '0');
}
if (op) {
x = -x;
}
return true;
}
inline int readStr(char *s) {
int n = 0;
char ch = getchar();
for (; isspace(ch) && ch != EOF; ch = getchar())
;
for (; !isspace(ch) && ch != EOF; ch = getchar()) {
s[n++] = ch;
}
s[n] = '\0';
return n;
}
inline void myPutchar(char x) {
static char pbuf[OUT_BUF], *pp = pbuf;
struct _flusher {
~_flusher() {
fwrite(pbuf, 1, pp - pbuf, stdout);
}
};
static _flusher outputFlusher;
if (pp == pbuf + OUT_BUF) {
fwrite(pbuf, 1, OUT_BUF, stdout);
pp = pbuf;
}
*pp++ = x;
}
template<typename T>
inline void print_(T x) {
if (x == 0) {
putchar('0');
return;
}
static int num[40];
if (x < 0) {
putchar('-');
x = -x;
}
for (*num = 0; x; x /= 10) {
num[++*num] = x % 10;
}
while (*num){
putchar(num[*num] ^ '0');
--*num;
}
}
template<typename T>
inline void print(T x, char ch = '\n') {
print_(x);
putchar(ch);
}
inline void printStr_(const char *s, int n = -1) {
if (n == -1) {
n = strlen(s);
}
for (int i = 0; i < n; ++i) {
putchar(s[i]);
}
}
inline void printStr(const char *s, int n = -1, char ch = '\n') {
printStr_(s, n);
putchar(ch);
}
}
using namespace IO;
int H, W, N;
int main() {
read(H), read(W), read(N);
print((N - 1) / std::max(H, W) + 1);
}
| 1 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int sx, sy, tx, ty;
cin >> sx >> sy >> tx >> ty;
string ans;
auto move = [&](int h, int w) {
rep(i, abs(h)) ans += (h > 0 ? 'U' : 'D');
rep(i, abs(w)) ans += (w > 0 ? 'R' : 'L');
};
int h1 = ty - sy, w1 = tx - sx;
move(h1, w1);
int h2 = sy - ty, w2 = sx - tx;
move(h2, w2);
int h3 = ty - sy, w3 = tx - sx;
ans += (w3 > 0 ? 'L' : 'R');
h3 += (h3 > 0 ? 1 : -1);
w3 += (w3 > 0 ? 1 : -1);
move(h3, w3);
ans += (h3 > 0 ? 'D' : 'U');
int h4 = sy - ty, w4 = sx - tx;
ans += (w4 > 0 ? 'L' : 'R');
h4 += (h4 > 0 ? 1 : -1);
w4 += (w4 > 0 ? 1 : -1);
move(h4, w4);
ans += (h4 > 0 ? 'D' : 'U');
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
//#include <atcoder/all>
#define ll long long int
#define MOD 1000000007
#define P pair<ll,ll>
#define INF 1000000000000000000
//using namespace atcoder;
using namespace std;
string transform(string t, ll x, ll y){
for (ll i = 0; i < t.size(); i++){
if (t[i] == 'R' && x < 0){
t[i] = 'L';
}
else if (t[i] == 'L' && x < 0){
t[i] = 'R';
}
else if (t[i] == 'U' && y < 0){
t[i] = 'D';
}
else if (t[i] == 'D' && y < 0){
t[i] = 'U';
}
}
return t;
}
int main(void){
ll sx, sy, tx, ty;
cin >> sx >> sy >> tx >> ty;
tx -= sx;
ty -= sy;
sx = tx;
sy = ty;
tx = abs(tx);
ty = abs(ty);
string t = "";
// 1周目
for (ll i = 0; i < ty; i++){
t += "U";
}
for (ll i = 0; i < tx; i++){
t += "R";
}
for (ll i = 0; i < ty; i++){
t += "D";
}
for (ll i = 0; i < tx; i++){
t += "L";
}
// 1周目
t += "L";
for (ll i = 0; i < ty + 1; i++){
t += "U";
}
for (ll i = 0; i < tx + 1; i++){
t += "R";
}
t += "D";
t += "R";
for (ll i = 0; i < ty + 1; i++){
t += "D";
}
for (ll i = 0; i < tx + 1; i++){
t += "L";
}
t += "U";
cout << transform(t, sx, sy) << endl;
for (ll i = 0; i < ty; i++){
t += "D";
}
for (ll i = 0; i < tx; i++){
t += "L";
}
return 0;
}
| 1 |
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <stack>
#include <queue>
#include <cctype>
#include <complex>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <functional>
#include <cassert>
#include <iomanip>
using namespace std;
#define pb push_back
typedef long long ll;
typedef complex<int> P;
typedef pair<int, int> Pii;
struct st{
string name;
double a;
st(){}
st(string n, double a) : name(n), a(a) {}
bool operator< (const st &s)const{
return (this->a == s.a) ? this->name < s.name : this->a > s.a;
}
};
bool solve(int n){
vector<st> vst;
for(int i=0;i<n;i++){
string l;
int p, a, b, c, d, e, f, s, m;
cin>> l>> p>> a>> b>> c>> d>> e>> f>> s>> m;
int t, money;
t = a + b + c + (d + e) * m;
money = m * f * s - p;
st tmp(l, (double)money/t);
vst.pb(tmp);
}
sort(vst.begin(),vst.end());
for(int i=0;i<vst.size();i++){
cout<< vst[i].name<< endl;
}
cout<< "#"<< endl;
return true;
}
int main(){
cout.setf(ios::fixed);
cout.precision(10);
int n;
while(cin>>n, n){
solve(n);
}
return 0;
}
| #include<iostream>
#include<cmath>
using namespace std;
int main()
{
int n, a, b;
bool p[10000] = {false};
for( int i = 2; i < 10000; i++ )
{
bool judge = true;
for( int j = 2; j <= sqrt(i); j++ )
if( i % j == 0 )
judge = false;
if( judge == true )
p[i] = true;
}
while( cin >> n )
{
if( n == 0 )
break;
for( int i = 2; i <= n - 2; i++ )
{
if( p[i] == true && p[i+2] == true )
{
a = i;
b = i + 2;
}
}
cout << a << " " << b << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define pb push_back
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ll long long
using namespace std;
const ll P = 1000000007;
const long long INF = 1LL << 60;
int gcd(int a, int b) { return b != 0 ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
vector<char> Alphabet = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};
vector<char> alphabet = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
int main()
{
cout << fixed << setprecision(10);
int N,K;
cin >> N >> K;
vector<int> A(N);
bool ok = false;
int M = 0;
int g = 0;
rep(i,N)
{
cin >> A[i];
if(A[i]==K)
{
ok = true;
}
M = max(M,A[i]);
if(i==0) g = A[0];
g = gcd(A[i],g);
}
if(g==1)
{
ok = true;
}
else
{
if(gcd(g,K)!=g)
{
ok = false;
}
else
{
ok = true;
}
}
if(M<K)
{
ok = false;
}
if(ok)
{
cout << "POSSIBLE" << endl;
}
else cout << "IMPOSSIBLE" << endl;
return 0;
}
| //Author: AnandRaj anand873
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vpii;
typedef pair<ll,ll> pll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<pll> vpll;
#define fastio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define test() int t;cin>>t;while(t--)
#define all(v) v.begin(),v.end()
#define prin(V) for(auto v:V) cout<<v<<" ";cout<<endl
#define take(V,f,n) for(int in=f;in<f+n;in++) cin>>V[in]
#define what(x) cerr<<#x<<" = "<<x<<endl
#define KStest() int t,t1;cin>>t;t1=t;while(t--)
#define KScout cout<<"Case #"<<t1-t<<": "
const int MOD = 998244353,MAX = 1e6+5;
/////////////////FastExp///////////////////
ll powN(ll a,ll p)
{
if(p==0) return 1;
ll z=powN(a,p/2);
z=(z*z)%MOD;
if(p%2) z=(z*a)%MOD;
return z;
}
/////////////////FastExp///////////////////
//////////////////Sieve////////////////////
vector<bool> is_prime(MAX, true);
vector<int> MinDiv(MAX);
void Sieve()
{
is_prime[0] = is_prime[1] = false;
int i,j;
for (i = 2; i*i <= MAX; i++)
{
if (is_prime[i])
{
MinDiv[i]=i;
for (j = i * i; j <= MAX; j += i)
{
is_prime[j] = false;
MinDiv[j]=i;
}
}
}
for(int i=2;i<=MAX;i++) if(is_prime[i]) MinDiv[i]=i;
}
//////////////////Sieve////////////////////
int main()
{
int n,k;
cin>>n>>k;
vi A(n);
take(A,0,n);
sort(all(A));
int gcd = 0;
for(int i=0;i<n;i++) gcd = __gcd(gcd,A[i]);
bool can=false;
for(int i=n-1;i>=0;i--)
{
if(A[i]>=k&&(A[i]-k)%gcd==0) can=true;
}
if(can) cout<<"POSSIBLE"<<endl;
else cout<<"IMPOSSIBLE"<<endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, M;
cin >> A >> B >> M;
vector<int> a(A);
for (int i = 0; i < A; i++) cin >> a.at(i);
vector<int> b(B);
for (int i = 0; i < B; i++) cin >> b.at(i);
int ans = *min_element(a.begin(), a.end()) + *min_element(b.begin(), b.end());
for (int i = 0; i < M; i++) {
int x, y, c;
cin >> x >> y >> c;
ans = min(ans, a.at(x - 1) + b.at(y - 1) - c);
}
cout << ans << "\n";
} | #include <iostream>
#include <algorithm>
using namespace std;
int main() {
string str;
int q;
cin >> str >> q;
for (int i = 0; i < q; i++) {
string inst;
unsigned int a,b;
cin >> inst >> a >> b;
if (inst == "print") {
cout << str.substr(a,b-a+1) << endl;
} else if (inst == "reverse") {
string target = str.substr(a,b-a+1);
reverse(target.begin(), target.end());
str = str.substr(0,a) + target + str.substr(b+1);
} else if (inst == "replace") {
string rep;
cin >> rep;
str = str.substr(0,a) + rep + str.substr(b+1);
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
typedef long long ll;
#define fr(i,a,b) for(ll i=a; i<b; i++)
#define rf(i,a,b) for(ll i=a; i>=b; i--)
typedef std::vector<long long > vi ;
#define F first
#define S second
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define mod 1000000007
#define PB push_back
#define MP make_pair
#define PI 3.14159265358979323846
#define all(a) a.begin(),a.end()
#define mx(a) *max_element(all(a))
#define mn(a) *min_element(all(a))
#define endl '\n'
#define show(a) for(auto el:a)cout<<el<<" "
const ll INF=LLONG_MAX/2;
const ll N=2e5+1;
#define yesno(f) yes(f);no(f);
#define yes(f) if(f)cout<<"YES\n";
#define no(f) if(!f)cout<<"NO\n";
using namespace std;
ll pow1(ll n,ll p)
{
if(p==0) return 1;
ll x=pow1(n, p/2);
x=(x*x);
if(p%2==0)
return x;
else
return (x*n);
}
int main()
{
fast;
ll t=1;
//std::cin >> t;
while(t--)
{
ll n,w,x=0,sum=0,a,b,c;
std::cin >> a>>b>>c;
if(a==b&&b!=c)
{
cout<<"Yes\n";
}
else if(a==c&&a!=b)
{
cout<<"Yes\n";
}
else if(b==c&&a!=b)
{
cout<<"Yes\n";
}
else
cout<<"No\n";
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
#define all(v) v.begin(), v.end()
const ll mod=1000000007;
ll countBits(ll in){
int res=0;
for(;in>0;in>>=1){
if((in&0x01)!=0){
res++;
}
}
return res;
}
template<typename T>
void show2dVector(vector<vector<T>>& v){
for(int i=0;i<v.size();i++){
int m=v[i].size();
cout<<i<<" : ";
for(int j=0;i<m;i++){
cout<<v[i][j]<<" ";
}
cout<<endl;
}
}
void bfs(const vector<vector<int>>&g, int v, vector<bool>& seen){
seen[v]=true;
cout<<v<<" ";
for(auto next: g[v]){
if(seen[next]){
continue;
}
bfs(g,next,seen);
}
}
bool dfs(vector<vector<int>> &g,int start,int goal,vector<bool>&seen){
bool res=false;
seen[start]=true;
if(start==goal){
return true;
}
for(auto next: g[start]){
if(seen[next]){
continue;
}
res=dfs(g,next,goal,seen);
if(res){
break;
}
}
return res;
}
ll gcd(ll a,ll b) {
return b? gcd(b,a%b): a;
}
ll lcm(ll a,ll b) {
return a*b/gcd(a,b);
}
bool isLowerCase(char c){
return (c>='a'&&c<='z');
}
char toLowerCase(char c){
if(isLowerCase(c)){
return c;
}else{
return c+'a'-'A';
}
}
char toUpperCase(char c){
if(isLowerCase(c)){
return c-('a'-'A');
}else{
return c;
}
}
ll powm(ll a,ll n, ll m){
ll ret=1;
while(n>0){
if(n%2==1){
ret=(ret*a)%m;
}
n>>=1;
a=(a*a)%m;
}
return ret;
}
const string yesno(bool ans){
return (ans?"Yes":"No");
}
void func(vector<int>& l, int depth, int idx){
;
}
int main() {
ll a[2],k;cin>>a[0]>>a[1]>>k;
for(int i=0;i<k;i++){
ll half=a[i%2]/2;
if(a[i%2]%2!=0){
a[i%2]--;
}
a[i%2]-=half;
a[(i+1)%2]+=half;
}
cout<<a[0]<<" "<<a[1]<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define REP(i, n) FOR(i, 0, (n))
#define FOR(i, a, b) for(int i=(a); i<(b); i++)
#define LAR(a, b) ((a)=max((a),(b)))
#define SML(a, b) ((a)=min((a),(b)))
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<pair<int, int>> vpii;
typedef pair<int, int> pii;
#define PB push_back
#define EB emplace_back
#ifdef LOCAL_DEBUG
#define DEBUG(...) printf(__VA_ARGS__)
#else
#define DEBUG(...)
#endif
#define MOD 1'000'000'007
#define N 512345
int n;
int a[N];
int b[N]={};
map<int, vector<int>> mp;
vi v;
ll dp[N][2];
ll chk(int x, int y){
v.clear();
vi u = mp[x];
REP(i, (int)u.size()-1){
v.EB(b[u[i+1]]-b[u[i]]);
}
dp[v.size()][0]=0;
dp[v.size()][1]=1;
for(int i=v.size()-1; i>=0; i--){
dp[i][0] = dp[i+1][0] + dp[i+1][1]*v[i];
dp[i][0] %= MOD;
dp[i][1] = y + dp[i+1][0] + dp[i+1][1]*(v[i]+1);
dp[i][1] %= MOD;
}
DEBUG("chk(%d)\n", x);
REP(i, (int)v.size()+1) DEBUG("%2d ", i); DEBUG("\n");
REP(i, (int)v.size()) DEBUG("%2d ", v[i]); DEBUG("\n");
REP(i, (int)v.size()+1) DEBUG("%2lld ", dp[i][0]); DEBUG("\n");
REP(i, (int)v.size()+1) DEBUG("%2lld ", dp[i][1]); DEBUG("\n");
return dp[0][1];
}
int main(){
scanf("%d", &n);
REP(i, n) scanf("%d", a+i);
FOR(i, 1, n) a[i]^=a[i-1];
REP(i, n) b[i+1]=b[i]+(a[i]==0?1:0);
REP(i, n) if(a[i]) mp[a[i]].EB(i);
REP(i, n) DEBUG("%2d ", i); DEBUG("\n");
REP(i, n) DEBUG("%2d ", a[i]); DEBUG("\n");
ll ans = 0;
if(a[n-1]){
ans+=chk(a[n-1], 0);
ans%=MOD;
}else{
for(auto p:mp){
ans+=chk(p.first, 1);
ans%=MOD;
}
ll pw = 1;
REP(i, b[n]-1) pw*=2, pw%=MOD;
ans+=pw;
ans%=MOD;
}
printf("%lld\n", ans);
}
| #include <stdio.h>
int n, m, l, g, e;
int a[15], b[15];
int x[15][15], y[15][15];
int ans;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
for (int j = 0; j < a[i]; j++) {
scanf("%d%d", x[i] + j, y[i] + j);
x[i][j]--;
}
}
m = 1;
for (int i = 0; i < n; i++) {
m *= 2;
}
for (int i = 0; i < m; i++) {
l = i;
g = 1;
e = 0;
for (int j = 0; j < n; j++) {
b[j] = l % 2;
l /= 2;
e += b[j];
}
for (int j = 0; j < n; j++) {
if (b[j]) {
for (int k = 0; k < a[j]; k++) {
if (b[x[j][k]] != y[j][k]) {
g = 0;
}
}
}
}
if (g) {
if (ans < e)ans = e;
}
}
printf("%d\n", ans);
}
| 0 |
#include<bits/stdc++.h>
#define Rint register int
using namespace std;
typedef unsigned long long LL;
const int N = 100003;
int n;
LL a[N], b[61], sum, res;
inline void insert(LL x){
for(Rint i = 60;~i;-- i)
if((x >> i) & 1)
if(!b[i]){
b[i] = x; return;
} else x ^= b[i];
}
int main(){
scanf("%d", &n);
for(Rint i = 1;i <= n;i ++) scanf("%llu", a + i), sum ^= a[i];
for(Rint i = 1;i <= n;i ++) insert(a[i] &= ~sum);
for(Rint i = 60;~i;-- i) res = max(res, res ^ b[i]);
printf("%llu\n", res * 2 + sum);
} | #include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long LL;
namespace INPUT{
const int L=1<<15;
char _buf[L],*S,*T,c;
char _gc(){
if(S==T){
T=(S=_buf)+fread(_buf,1,L,stdin);
if(S==T) return EOF;
}
return *S++;
}
void readc(char &c){
for(c=_gc();c<'a'||c>'z';c=_gc());
}
void readi(int &X){
for(c=_gc();c<'0'||c>'9';c=_gc());X=c&15;
for(c=_gc();c>='0'&&c<='9';X=X*10+(c&15),c=_gc());
}
}
#define readc INPUT::readc
#define readi INPUT::readi
const int Maxn=1E6+5;
int N;
char S[Maxn];
char T[Maxn];
int a[Maxn],b[Maxn];
int tap[Maxn];
/*int P[Maxn];
int lnk[Maxn];
int f[Maxn];
*/
bool Check(int X){
for(int i=1;i+X<=tap[N];++i)
if(a[i+X]-X<b[i]) return false;
return true;
}
int main(){
readi(N); bool flag=true;
for(int i=1;i<=N;++i) readc(S[i]);
for(int i=1;i<=N;++i) readc(T[i]);
for(int i=1;i<=N;++i) flag&=(S[i]==T[i]);
if(flag){puts("0"); return 0;}
tap[1]=1;
for(int i=2;i<=N;++i)
if(T[i]==T[i-1]) tap[i]=tap[i-1],b[tap[i]]=i;
else tap[i]=tap[i-1]+1;
/*for(int i=N,j=N;i>=1;--i){
j=min(j,i);
while(S[j]!=T[i]&&j>0) --j;
if(j==0){puts("-1"); return 0;}
lnk[j]=tap[i];
}*/
for(int i=N,j=N;i>=1;--i){
j=min(j,i);
while(S[j]!=T[i]&&j>0) --j;
if(j==0){printf("-1");return 0;}
a[tap[i]]=j;
}
int stt,mid,lst;
stt=0,lst=N+1;
while(stt+1<lst){
mid=(stt+lst)>>1;
if(Check(mid)) lst=mid;
else stt=mid;
}
cout<<lst;
return 0;
}
| 0 |
/*
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
*/
#include<bits/stdc++.h>
#define ALL(x) (x).begin(),(x).end()
#define ll long long
#define db double
#define ull unsigned long long
#define pii_ pair<int,int>
#define mp_ make_pair
#define pb push_back
#define fi first
#define se second
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define show1(a) cout<<#a<<" = "<<a<<endl
#define show2(a,b) cout<<#a<<" = "<<a<<"; "<<#b<<" = "<<b<<endl
using namespace std;
const ll INF = 1LL<<60;
const int inf = 1<<30;
const int maxn = 2e5+5;
inline void fastio() {ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);}
int A[maxn],B[maxn];
struct seg_tree{
ll tr[maxn<<2],lazy[maxn<<2];
void push_up(int id)
{
tr[id] = min(tr[id<<1], tr[id<<1|1]);
}
void push_down(int id)
{
if(lazy[id]!=0){
tr[id<<1] += lazy[id],tr[id<<1|1] += lazy[id];
lazy[id<<1] += lazy[id],lazy[id<<1|1] += lazy[id];
lazy[id] = 0;
}
}
void update(int id,int stl,int str,int l,int r,ll k)
{
if(stl==l && str==r){
tr[id] += k;
lazy[id] += k;
return ;
}
push_down(id);
int mid = (stl+str)>>1;
if(r<=mid) update(id<<1,stl,mid,l,r,k);
else if(l>mid) update(id<<1|1,mid+1,str,l,r,k);
else update(id<<1,stl,mid,l,mid,k),update(id<<1|1,mid+1,str,mid+1,r,k);
push_up(id);
}
ll query(int id,int stl,int str,int l,int r)
{
if(stl==l && str==r) return tr[id];
push_down(id);
int mid = (stl+str)>>1;
if(r<=mid) return query(id<<1,stl,mid,l,r);
else if (l>mid) return query(id<<1|1,mid+1,str,l,r);
else return min(query(id<<1,stl,mid,l,mid), query(id<<1|1,mid+1,str,mid+1,r));
}
}dp,rec;
int main()
{
fastio();
int n,m; cin>>n>>m;
rep(i,1,n) cin>>A[i]>>B[i];
rep(i,1,m) rec.update(1,1,m,i,i,-i);
rep(i,1,n){
int R = B[i] + 1;
if(R<=m){
ll mi = rec.query(1,1,m,1,B[i]);
ll now = dp.query(1,1,m,R,R);
if(now > mi + R){
dp.update(1,1,m,R,R,mi+R-now);
ll tmp = rec.query(1,1,m,R,R);
rec.update(1,1,m,R,R,mi-tmp);
}
}
dp.update(1,1,m,A[i],B[i],inf);
rec.update(1,1,m,A[i],B[i],inf);
dp.update(1,1,m,1,m,1);
rec.update(1,1,m,1,m,1);
ll ans = dp.tr[1];
if(ans >= inf) cout<<-1<<endl;
else cout<<ans<<endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
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; }
using ll = long long;
using P = pair<int, int>;
ll GCD(ll a, ll b) { return b?GCD(b, a%b):a; }
ll LCM(ll a, ll b) { return a/GCD(a, b)*b; }
int n, u, v;
vector< vector<int> > graphlist(100100, vector<int>());
vector<int> takahashi(100100, -1);
vector<int> aoki(100100, -1);
struct posdata {
int p; int dist;
};
int main() {
cin >> n >> u >> v;
u--; v--;
takahashi.at(u) = 0; aoki.at(v) = 0;
for(int i = 0; i < n-1; ++i) {
int aa, bb; cin >> aa >> bb;
aa--; bb--;
graphlist.at(aa).emplace_back(bb);
graphlist.at(bb).emplace_back(aa);
}
queue<posdata> tque;
posdata tfirst;
tfirst.p = u; tfirst.dist = 0;
tque.push(tfirst);
while(!tque.empty()) {
posdata now = tque.front();
tque.pop();
for(int i = 0; i < (int)graphlist.at(now.p).size(); ++i) {
int np = graphlist.at(now.p).at(i);
int ndist = now.dist+1;
if(takahashi.at(np) == -1) {
takahashi.at(np) = ndist;
posdata next;
next.p = np; next.dist = ndist;
tque.push(next);
}
}
}
queue<posdata> aque;
posdata afirst;
afirst.p = v; afirst.dist = 0;
aque.push(afirst);
while(!aque.empty()) {
posdata now = aque.front();
aque.pop();
for(int i = 0; i < (int)graphlist.at(now.p).size(); ++i) {
int np = graphlist.at(now.p).at(i);
int ndist = now.dist+1;
if(aoki.at(np) == -1) {
aoki.at(np) = ndist;
posdata next;
next.p = np; next.dist = ndist;
aque.push(next);
}
}
}
int amax = 0;
for(int i = 0; i < n; ++i) {
if(aoki.at(i) > takahashi.at(i)) {
chmax(amax, aoki.at(i));
}
}
cout << amax-1 << endl;
} | 0 |
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <cmath>
#include <numeric>
#include <iomanip>
#include <stack>
#include <complex>
#include <functional>
#include <tuple>
using namespace std;
#define Rep(i,a,b) for(ll i = a; i < b; ++i)
#define rep(i,b) Rep(i,0,b)
#define allof(a) (a).begin(), (a).end()
#define Yes(q) ((q) ? "Yes" : "No")
#define YES(q) ((q) ? "YES" : "NO")
#define Possible(q) ((q) ? "Possible" : "Impossible")
#define POSSIBLE(q) ((q) ? "POSSIBLE" : "IMPOSSIBLE")
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll infll = 1ll << 60ll;
constexpr ll mod = 1e9 + 7;
// 0~3までは右左下上 4~7までは斜め
constexpr int dx[] = { 1, 0, -1, 0, 1, 1, -1, -1 };
constexpr int dy[] = { 0, -1, 0, 1, 1, -1, -1, 1 };
namespace {
template<typename T> bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<typename T> bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
void Cout(long long x, const char* end = "\n") { std::cout << x << end; }
template <typename T> void Cout(const T& x, const char* end = "\n") { std::cout << x << end; }
template <typename T> void Cout(const std::vector<T>& x, const char* sep = " ", const char* end = "\n") { for (std::size_t i = 0, sz = x.size(); i < sz; ++i) { std::cout << x[i] << (i == sz - 1 ? end : sep); } }
// 標準入出力
struct inp {
std::size_t szi, szj;
inp(std::size_t _szi = 1, std::size_t _szj = 1) : szi(_szi), szj(_szj) {}
template <typename T> operator T () const { T a; std::cin >> a; return a; }
template <typename T> operator std::vector<T>() const { std::vector<T> a(szi); for (std::size_t i = 0; i < szi; ++i) std::cin >> a[i]; return a; }
template <typename T> operator std::vector<std::vector<T>>() const {
std::vector<std::vector<T>> a(szi, std::vector<T>(szj));
for (std::size_t i = 0; i < szi; ++i) for (std::size_t j = 0; j < szj; ++j) cin >> a[i][j]; return a;
}
};
inp inp1;
}
int main() {
string s = inp1;
int n = s.length();
// 文字の距離をとるだけでよい
vector<vector<int>> pos(26, vector<int>());
rep(i, n) {
pos[(s[i] - 'a')].emplace_back(i);
}
int a, b;
a = b = -1;
rep(i, 26) {
int sz = pos[i].size();
rep(j, sz - 1) {
if (pos[i][j + 1] - pos[i][j] <= 2) {
a = pos[i][j] + 1;
b = pos[i][j + 1] + 1;
i = 26;
break;
}
}
}
cout << a << " " << b << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
string s;
cin >> s;
int n = s.size();
for (int i=0; i<n-1; i++) {
if (s[i] == s[i+1]) {
cout << i+1 << ' ' << i+2 << endl;
return 0;
}
}
for (int i=0; i<n-2; i++) {
if (s[i] == s[i+2]) {
cout << i+1 << ' ' << i+3 << endl;
return 0;
}
}
cout << -1 << ' ' << -1 << endl;
return 0;
}
| 1 |
#include <stdio.h>
int main(void){
int n, a[100], i, j;
char c, s[53] = {"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"};
while(1){
scanf("%d",&n);
if(!n) break;
for(i = 0;i < n;i++)
scanf("%d",&a[i]);
getchar();
for(i = 0;(c = getchar()) != '\n';i++){
for(j = 0;j < 52;j++){
if(s[j] == c)
printf("%c",s[(52 + j - a[i % n]) % 52]);
}
}
printf("\n");
}
return 0;
} | #include<iostream>
int main(){
int e;
while(1){
std::cin >> e;
if(!e)break;
int m = 1000001;
for(int i=0;i*i*i<=e;i++){
for(int ii=0;i*i*i + ii*ii<=e;ii++){
int x = e-i*i*i-ii*ii;
int tmp = i+ii+x;
if(tmp < m) m = tmp;
}
}
std::cout << m << std::endl;
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define fast() ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define ll long long int
#define test() ll t; cin>>t; while(t--)
#define lp0(i,begin,end) for(ll i=begin;i<end;i++)
#define lp1(i,begin,end) for(ll i=begin;i<=end;i++)
#define rlp(i,begin,end) for(ll i=end;i>=begin;i--)
#define prec(n) fixed<<setprecision(n)
#define initial(a,i) memset(a,i,sizeof(a))
#define pb push_back
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define F first
#define S second
#define all(a) (a).begin(),(a).end()
#define BPC(x) __builtin_popcountll(x)
#define gcd(a,b) __gcd(a,b)
ll gcd(ll a,ll b) {if (a==0) return b;return gcd(b%a,a);}
ll power(ll x,ll n)
{
ll result = 1;
while (n)
{
if (n & 1)
result = result * x;
n = n / 2;
x = x * x;
}
return result;
}
// Solution Function
void solution(ll compte)
{
// cout<<compte<<"\n";
ll n,m;
cin>>n>>m;
ll x =10;
cout<<(m+(100*(10-min(x,n))) )<<"\n";
}
// Driver Function
int main()
{
ll compte = 1;
//test()
//{
solution(compte);
compte++;
//}
return 0;
}
| #include <bits/stdc++.h>
const int INF=1e9;
//const int MOD=1e9+7;
const int MOD=998244353;
const long long LINF=1e18;
using namespace std;
#define int long long
//template
std::vector<int> Factorial(5234567),Finverse(5234567);
int pw(int n,int k){
if(k<0)return pw(n,k+MOD-1);
int res=1;
while(k){
if(k&1)res*=n;res%=MOD;
n*=n;n%=MOD;
k>>=1;
}
return res;
}
void Cinit(){
Factorial[0]=1;
for(int i=1;i<5234567;i++)Factorial[i]=Factorial[i-1]*i%MOD;
for(int i=0;i<5234567;i++)Finverse[i]=pw(Factorial[i],MOD-2);
}
int nCk(int n,int k){
if(n<k)return 1;if(k<0)return 0;
int res=Factorial[n];
res*=Finverse[k];res%=MOD;
res*=Finverse[n-k];res%=MOD;
return res;
}
//main
signed main(){
Cinit();
int N,M;cin>>N>>M;
int ans=nCk(3*M+(N-1),N-1);//cout<<ans<<endl;
int mi=N*nCk(M-1+N-1,N-1)%MOD;
ans-=mi;
ans+=MOD;ans%=MOD;
//cout<<ans<<endl;
for(int i=M+1;i<=min(N,3*M);i++){
if((i&1)!=((3*M)&1))continue;
int p=(3*M-i)/2;
int q=nCk(p+N-1,N-1);
int s=nCk(N,i);
int a=q*s%MOD;
ans-=a;
ans+=MOD;ans%=MOD;
}
cout<<ans<<endl;
}
| 0 |
// C++ 14
#include <bits/stdc++.h>
using namespace std;
template <typename T> ostream& operator<<(ostream& os, const vector<T>& v) { os << "["; for (int i = 0; i < v.size(); ++i) { os << v[i]; if (i != v.size() - 1) os << ", "; } os << "]"; return os; }
template <typename T> void print(T v, string s = "\n") { cout << v << s; }
template <typename T> void in(T& v) { cin >> v; }
#define ll long long
#define loop(__x, __start, __end) for(int __x = __start; __x < __end; __x++)
int main() {
string s; in(s);
int n = s.size();
loop(len,2,4) {
if (len > n) break;
loop(l,0,n-len+1) {
map<char, int> M;
int max_ = 0;
loop(i,l,l+len) {
M[s[i]]++;
max_ = max(max_, M[s[i]]);
}
if (max_ > len/2) {
cout << l+1 << " " << l+len << endl;
return 0;
}
}
}
cout << "-1 -1" << endl;
return 0;
}
| #include <iostream>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <queue>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
ll pow[19];
ll dfs(int k, int i, ll dif, ll dif_org){
// if(k == 4) cout << dif << endl;
if(i < k-i+1) return dif == 0 ? 1:0;
if(i == k-i+1){
if(dif == 0){
if(k != i){
return 10;
}else{
return 9;
}
}else{
return 0;
}
}
ll d = pow[i-1]-pow[k-i];
ll r = dif%d;
ll m = dif/d;
ll sum = 0;
if(r == 0){
if(abs(m) < 10) {
if(k != i){
sum += (10-abs(m))*dfs(k, i-1, r, dif_org);
}else{
sum += (10-abs(m)-1)*dfs(k, i-1, r, dif_org);
}
}
}else{
if(abs(m) < 10) {
if(k != i){
sum += (10-abs(m))*dfs(k, i-1, r, dif_org);
}else{
sum += (10-abs(m)-1)*dfs(k, i-1, r, dif_org);
}
}
if(dif > 0){
if(abs(m)+1 < 10) {
if(k != i){
sum += (10-abs(m)-1)*dfs(k, i-1, r-d, dif_org);
}else{
sum += (10-abs(m)-2)*dfs(k, i-1, r-d, dif_org);
}
}
}else if(dif < 0){
if(abs(m)+1 < 10) {
if(k != i){
sum += (10-abs(m)-1)*dfs(k, i-1, r+d, dif_org);
}else{
sum += (10-abs(m)-2)*dfs(k, i-1, r+d, dif_org);
}
}
}
}
return sum;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout << setprecision(10) << fixed;
pow[0] = 1;
for(int i = 1; i < 19; i++) pow[i] = pow[i-1]*10;
ll D;
cin >> D;
ll ans = 0;
for(int i = 1; i <= 19; i++){
ans += dfs(i, i, D, D);
// cout << i << ' ' << ans << endl;
}
cout << ans << endl;
} | 0 |
#include <iostream>
#define rep(S, L) for (int i = S; i < L; ++i)
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int ans = 0;
if (n % k > 0) {
ans = 1;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
void solve(long long N, long long K) {
N%K==0?cout<<0<<endl:cout<<1<<endl;
}
// Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools (tips: You
// use the default template now. You can remove this line by using your custom
// template)
int main() {
long long N;
scanf("%lld", &N);
long long K;
scanf("%lld", &K);
solve(N, K);
return 0;
}
| 1 |
//----------------------------templates
#pragma GCC optimize ("Ofast")
#pragma GCC target ("tune=native")
#pragma GCC target ("avx")
//----------------------------
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define int ll
#define FOR(i,j,n) for (int i=(int)(j);i<(n);i++)
#define REP(i,n) for (int i=0;i<(int)(n);i++)
#define REPS(i,n) for (int i=1;i<=(int)(n);i++)
#define REPN(i,n) for (int i=(int)(n)-1;i>=0;i--)
#define REPNS(i,n) for (int i=(int)(n);i>0;i--)
#define I(n) scanf("%lld", &(n))
#define LL(n) scanf("%lld", &(n))
#define pb(n) push_back((n))
#define mp(i,j) make_pair((i),(j))
#define eb(i,j) emplace_back((i),(j))
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define uniq(v) v.erase( unique(v.begin(), v.end()), v.end() )
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
typedef vector<int> vi;
typedef pair<int,int> pi;
typedef vector<pi> vpi;
typedef vector<vi> vvi;
typedef vector<vpi> vvpi;
typedef vector<vvi> vvvi;
const int mod = 1000000007;
//--------------------------------------------
int n,x;
vi s,prim;
int ret;
int facto[201];
ll powll(ll base,ll power){
ll ans = 1;
while (power){
if (power&1) ans = (base*ans)%mod;
base = (base*base)%mod;
power >>= 1;
}
return ans;
}
int invs[201];
int dp[201][100010];
signed main(){
facto[0] = 1;
REPS(i,200) facto[i] = (facto[i-1] * i) % mod;
REPS(i,200) invs[i] = powll(i,mod-2);
I(n); I(x);
s.resize(n);
REP(i,n) I(s[i]);
sort(all(s), greater<int>());
dp[0][x] = 1;
REP(i,n){
REP(j,x+1){
int prob = invs[n-i];
dp[i+1][j] = (dp[i+1][j] + dp[i][j] * (1 + mod - prob)) % mod;
dp[i+1][j % s[i]] = (dp[i+1][j % s[i]] + dp[i][j] * prob) % mod;
}
}
int ret = 0;
REP(j,s[n-1]) ret = ((dp[n][j] * j) + ret) % mod;
cout << (ret * facto[n]) % mod << endl;
} | #include <bits/stdc++.h>
#define IO_OP std::ios::sync_with_stdio(0); std::cin.tie(0);
#define F first
#define S second
#define V vector
#define PB push_back
#define MP make_pair
#define EB emplace_back
#define ALL(v) (v).begin(), (v).end()
#define debug(x) cerr << #x << " is " << x << endl
using namespace std;
typedef long long ll;
typedef pair<int, int> pi;
typedef V<int> vi;
const int INF = 1e9 + 7, N = 4e5 + 7;
int a[N], b[N], ok[N], okk[N], c[N], d[N], fail[N];
int n;
void goo() {
for(int i=1,j=fail[0]=-1;i<n;i++) {
while(j >= 0 && d[j+1] != d[i])
j = fail[j];
if(d[j+1] == d[i])
j++;
fail[i] = j;
}
for(int i=0,j=-1;i<2*n;i++) {
while(j >= 0 && (j == n - 1 || d[j+1] != c[i]))
j = fail[j];
if(d[j+1] == c[i])
j++;
if(j == n - 1) okk[i-n+1] = 1;
}
}
void go(int bit) {
for(int i=0;i<2*n;i++)
c[i] = a[i] >> bit & 1;
for(int i=0;i<n;i++)
d[i] = b[i] >> bit & 1;
for(int i=0;i<n;i++) okk[i] = 0;
goo();
for(int i=0;i<n;i++)
d[i] ^= 1;
goo();
for(int i=0;i<n;i++) ok[i] &= okk[i];
}
signed main()
{
IO_OP;
cin >> n;
for(int i=0;i<n;i++) {
cin >> a[i];
a[i+n] = a[i];
ok[i] = 1;
}
for(int i=0;i<n;i++)
cin >> b[i];
for(int i=0;i<30;i++)
go(i);
for(int i=0;i<n;i++)
if(ok[i]) cout << i << " " << (a[i] ^ b[0]) << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define w cout
#define e '\n'
#define int long long
#define sz(x) (int)x.size()
template<class T> inline istream& operator>>(istream& str, vector<T> &a) { for (auto &i : a) str >> i; return str; }
int mod = 998244353;
void solve() {
int n ; cin >> n;
int v[n + 1] = {};
for(int i = 1 ; i <= n ;i ++) cin >> v[i];
int dd[n + 1][30];
memset(dd , 0, sizeof dd);
int l , q; cin >> l >> q;
for(int i = 1; i <= n ;i ++){
int can = v[i] - l;
dd[i][0] = max(1ll , (int)(lower_bound(v + 1 , v + n + 1 , can) - v));
}
for(int i = 1; i <= n ;i ++) {
for(int j = 1; j <= 17 ;j ++) {
dd[i][j] = dd[dd[i][j-1]][j-1];
}
}
while(q--) {
int a ,b ; cin >> a >> b;
if(a > b) swap(a , b);
int ans = 0;
for(int j = 17 ; j >= 0; j --) {
if(dd[b][j] > a) {
ans += pow(2 , j);
b = dd[b][j];
}
}
w << ans + 1 << e;
}
}
signed main() {
ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
int t = 1;
//~ cin >> t;
while(t--) {
solve();
}
}
| #include<bits/stdc++.h>
using namespace std;
#define int long long
#define REP(i,m,n) for(int i=(m);i<(n);i++)
#define rep(i,n) REP(i,0,n)
#define pb push_back
#define all(a) a.begin(),a.end()
#define rall(c) (c).rbegin(),(c).rend()
#define mp make_pair
#define endl '\n'
#define vec vector<ll>
#define mat vector<vector<ll> >
#define fi first
#define se second
typedef long long ll;
typedef pair<ll,ll> pll;
typedef long double ld;
const ll inf=1e9+7;
const ll mod=1e9+7;
signed main(){
ll n;cin>>n;
vector<ll>x(n);
rep(i,n)cin>>x[i];
ll l,q;cin>>l>>q;
vector<ll>nxt(n);
vector<pll>b(0);
for(int i=n-1;i>=0;i--){
if(i==n-1){
b.pb(mp(-x[i],i));
nxt[i]=i;
continue;
}
pll k=*lower_bound(all(b),mp(-x[i]-l,-1LL));
nxt[i]=k.second;
b.pb(mp(-x[i],i));
}
vector<vector<ll> >dp(n,vector<ll>(32));
rep(i,n)dp[i][0]=nxt[i];
REP(i,1,32){
rep(j,n){
dp[j][i]=dp[dp[j][i-1]][i-1];
}
}
rep(i,32){
//cout<<dp[0][i]<<endl;
}
while(q){
q--;
ll a,b;cin>>a>>b;
a--;b--;
if(a>b){
swap(a,b);
}
ll l=0,r=n;
while(r-l>1){
ll mid=(r+l)/2;
ll x=a;
rep(j,32){
if(mid&(1LL<<j)){
x=dp[x][j];
}
}
if(q==3){
//cout<<mid<<' '<<a<<' '<<b<<endl;
}
if(x>=b)r=mid;
else l=mid;
}
cout<<r<<endl;
}
} | 1 |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
using ll = long long;
const int mod = 1e9 + 7;
int main() {
int n, m; cin >> n >> m;
vector<ll>x(n), y(m); for (auto&& xx : x)cin >> xx;for (auto&& yy : y)cin >> yy;
sort(x.begin(), x.end());sort(y.begin(), y.end());
ll a = 0, b = 0;
for (int i = 0; i < n; i++)a -= x[i] * (n - 1 - i - i);
for (int i = 0; i < m; i++)b -= y[i] * (m - 1 - i - i);
cout << (a % mod) * (b % mod) % mod << endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <utility>
#include <string>
#include <algorithm>
#include <map>
#include <vector>
#include <climits>
#include <numeric>
#include<stdio.h>
#include <queue>
#include <iomanip>
#include <float.h>
#include <set>
#include<functional>
#include <stack>
#include <time.h>
#include <climits>
#include <bitset>
using namespace std;
int gcd(int a, int b) {
if (a < b) gcd(b, a);
int r;
while ((r = a%b)) {
a = b;
b = r;
}
return b;
}
long long lcm(long long a, long long b) {
return a / gcd(a, b) * b;
}
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
long long modinv(long long a, long long mod) {
long long b = mod, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t*b; swap(a, b);
u -= t*v; swap(u, v);
}
u %= mod;
if (u < 0) u += mod;
return u;
}
namespace NTT {
const int MOD = 998244353; // to be set appropriately
const long long PR = 3; // to be set appropriately
void trans(vector<long long> &v, bool inv = false) {
int n = (int)v.size();
for (int i = 0, j = 1; j < n - 1; j++) {
for (int k = n >> 1; k >(i ^= k); k >>= 1);
if (i > j) swap(v[i], v[j]);
}
for (int t = 2; t <= n; t <<= 1) {
long long bw = modpow(PR, (MOD - 1) / t, MOD);
if (inv) bw = modinv(bw, MOD);
for (int i = 0; i < n; i += t) {
long long w = 1;
for (int j = 0; j < t / 2; ++j) {
int j1 = i + j, j2 = i + j + t / 2;
long long c1 = v[j1], c2 = v[j2] * w % MOD;
v[j1] = c1 + c2;
v[j2] = c1 - c2 + MOD;
while (v[j1] >= MOD) v[j1] -= MOD;
while (v[j2] >= MOD) v[j2] -= MOD;
w = w * bw % MOD;
}
}
}
if (inv) {
long long inv_n = modinv(n, MOD);
for (int i = 0; i < n; ++i) v[i] = v[i] * inv_n % MOD;
}
}
// C is A*B
vector<long long> mult(vector<long long> A, vector<long long> B) {
int size_a = 1; while (size_a < A.size()) size_a <<= 1;
int size_b = 1; while (size_b < B.size()) size_b <<= 1;
int size_fft = max(size_a, size_b) << 1;
vector<long long> cA(size_fft, 0), cB(size_fft, 0), cC(size_fft, 0);
for (int i = 0; i < A.size(); ++i) cA[i] = A[i];
for (int i = 0; i < B.size(); ++i) cB[i] = B[i];
trans(cA); trans(cB);
for (int i = 0; i < size_fft; ++i) cC[i] = cA[i] * cB[i] % MOD;
trans(cC, true);
vector<long long> res((int)A.size() + (int)B.size() - 1);
for (int i = 0; i < res.size(); ++i) res[i] = cC[i];
return res;
}
};
template<class V, int ME> class BIT {
public:
V bit[1 << ME];
V operator()(int e) { if (e<0) return 0; V s = 0; e++; while (e) s += bit[e - 1], e -= e&-e; return s; }
void add(int e, V v) { e++; while (e <= 1 << ME) bit[e - 1] += v, e += e&-e; }
};
typedef pair<int, int>p;
vector<int>graph[100005];
int nyuuji[100005] = { 0 };
int parent[100005];
void dfs(int now) {
vector<int>child;
for (int i = 0; i < graph[now].size(); i++) {
nyuuji[graph[now][i]] -= 1;
if (nyuuji[graph[now][i]] == 0) {
child.push_back(graph[now][i]);
parent[graph[now][i]] = now;
}
}
for (int i = 0; i < child.size(); i++) {
dfs(child[i]);
}
}
int doubutu[100005];
int next( int now,int prev,int ans) {
if (doubutu[now]) {
ans = 1 - ans;
}
if (ans) {
return doubutu[prev];
}
else return 1 - doubutu[prev];
}
long long mod = 1e9 + 7;
signed main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
long long vsum = 0;
long long hsum = 0;
long long tmp1, tmp2;
cin >> tmp1;
for (int i = 2; i <= n; i++) {
cin >> tmp2;
long long nagasa = tmp2 - tmp1;
vsum += ((nagasa*(i - 1)) % mod)*(n - i + 1);
vsum %= mod;
tmp1 = tmp2;
}
cin >> tmp1;
for (int i = 2; i <= m; i++) {
cin >> tmp2;
long long nagasa = tmp2 - tmp1;
hsum += ((nagasa*(i - 1)) % mod)*(m - i + 1);
hsum %= mod;
tmp1 = tmp2;
}
cout << (hsum*vsum) % mod;
} | 1 |
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cstdlib>
#include <cstdio>
using namespace std;
int main()
{
string s;
int q;
cin >> s >> q;
cin.ignore();
string buf;
while (q)
{
getline(cin, buf);
//cout << "DEBUG:" << buf << endl;
if (buf.find("replace ") != string::npos)
{
char cmd[10] = {0};
int a1, a2;
char a3[1001] = {0};
sscanf(buf.c_str(), "%s %d %d %s", cmd, &a1, &a2, a3);
s.replace(a1, (a2+1)-a1, string(a3));
//cout << "DEBUG:replaced:" << s << endl;
}
else if (buf.find("reverse ") != string::npos)
{
char cmd[10] = {0};
int a1, a2;
sscanf(buf.c_str(), "%s %d %d", cmd, &a1, &a2);
string sub = s.substr(a1, (a2+1)-a1);
//cout << "DEBUG:sub( ):" << sub << endl;
reverse(sub.begin(), sub.end());
//cout << "DEBUG:sub(r):" << sub << endl;
size_t subsize = sub.size();
for (int i = a1, j = 0; i < a1 + subsize; i++, j++) {
s[i] = sub[j];
}
//cout << "DEBUG:reversed:" << s << endl;
}
else if (buf.find("print ") != string::npos)
{
char cmd[10] = {0};
int a1, a2;
sscanf(buf.c_str(), "%s %d %d", cmd, &a1, &a2);
cout << s.substr(a1, (a2+1)-a1) << endl;
}
q--;
}
return 0;
} | #include <iostream>
#include <string>
using namespace std;
string reverse_partial(string str, int s, int e) {
string top = s != 0 ? str.substr(0, s - 1) : "";
string head = str.substr(s, e - s + 1);
string tail = str.substr(e + 1, str.size());
string reverse = "";
for (int i=head.size()-1; i >= 0; i--) {
reverse += head[i];
}
return (top + reverse + tail);
}
int main () {
string str;
cin >> str;
int q;
cin >> q;
for (int i=0; i<q; i++) {
string order, p;
int a, b;
cin >> order >> a >> b;
if (order == "print") {
cout << str.substr(a, b - a + 1) << "\n";
}
else if (order == "replace") {
cin >> p;
str = str.replace(a, b - a + 1, p);
}
else if (order == "reverse") {
string sub = str.substr(a, b - a + 1);
for (int i=0; i < sub.size(); i++) {
str[i + a] = sub[sub.size() - i - 1];
}
}
}
return 0;
} | 1 |
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <vector>
#define rep(i, f, n) for (int i = (f); i < (int)(n); i++)
#define repe(i, f, n) for (int i = (f); i <= (int)(n); i++)
using namespace std;
using ll = long long;
using GraphI = vector<vector<int>>;
using GraphC = vector<vector<char>>;
using pint = pair<int, int>;
const int INF = 1001001001;
int main() {
string S;
cin >> S;
int ans = INF;
rep(i, 0, S.size() - 2) {
int x = stoi(S.substr(i, 3));
ans = min(ans, abs(753 - x));
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
int INF = 1e9+7;
signed main() {
int N;
cin >> N;
vector<int>cnt(N+1,1);
for(int i = 2; i <= N; i++) {
int X = i;
for(int j = 2; j*j <= i; j++) {
int Y = j;
if(X%Y == 0) {
while(X%Y == 0) {
cnt[Y]++;
X/=Y;
}
}
}
if(X != 1) {
cnt[X]++;
}
}
int ans = 1;
for(int i = 2; i <= N; i++) {
ans*=cnt[i];
ans = ans%INF;
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A,B;
string S;
cin >> A >> B >> S;
for(int i=0;i<S.size();++i){
if(i == A){
if(S.at(i) == '-'){
continue;
}else{
cout << "No" << endl;
return 0;
}
}else{
if(S.at(i) == '-'){
cout << "No" << endl;
return 0;
}
}
}
cout << "Yes" << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int A,B;
cin >> A >> B;
for(int i=0;i<A+B+1;i++){
char a;
cin >> a;
if((i==A&&a!='-')||(i!=A&&a=='-')){
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
} | 1 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <cmath>
#include <map>
#define reps(i,s,n) for(int (i) = (s); (i) < (n); (i)++)
#define rep(i,n) reps(i,0,n)
using namespace std;
using ll = long long;
int dp[3][100010];
int main(){
rep(i,3){
rep(j,100010){
dp[i][j] = 0;
}
}
int n;
int tmp ;
ll ans = 1;
ll mod = 1e9+7;
cin >> n;
vector<int> vec(n);
rep(j,n){
cin >> tmp;
vec[j] = tmp;
rep(i,3){
dp[i][j+1] = dp[i][j];
}
rep(i,3){
if(dp[i][j+1] == tmp) {
dp[i][j+1] = tmp+1;
break;
}
}
}
rep(j,n){
ll cnt = 0;
rep(i, 3){
if(dp[i][j] == vec[j]){
cnt++;
}
}
ans = (ans*cnt) % mod;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1001001001;
const ll mod = 1000000007;
const int MAX = 1000100;
int main(){
int n; cin >> n;
vector<ll> a(n);
for(int i = 0; i < n; i++){
cin >> a[i];
}
ll ans = 1;
vector<ll> num(n);
for(int i = 0; i < n; i++){
if(a[i] == 0){
ans *= 3 - num[0];
num[0]++;
}
else{
ans *= num[a[i] - 1] - num[a[i]];
num[a[i]]++;
}
ans %= mod;
}
cout << ans << endl;
} | 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
int n;
cin >> n;
vector<int> x(n), y(n);
rep(i, n) cin >> x[i] >> y[i];
vector<int> perm(n);
rep(i, n) perm[i] = i;
double sum_d = 0;
int k = 0;
do {
++k;
rep(i, n-1) sum_d += sqrt(pow(x[perm[i+1]] - x[perm[i]], 2) + pow(y[perm[i+1]] - y[perm[i]], 2));
} while (next_permutation(perm.begin(), perm.end()));
double ave_d = sum_d / k;
printf("%.7f\n", ave_d);
return 0;
} | #include <iostream>
#include <cstdio>
#include <climits>
#include <cmath>
#include <algorithm>
#include <utility>
#include <vector>
#include <string>
#define MAX 200000
#define INFTY 1<<30
using namespace std;
typedef long long llong;
template <typename T>
class Array
{
private:
llong merge(int l, int m, int r)
{
llong cnt = 0;
int n1 = m - l;
int n2 = r - m;
vector<T> L, R;
L.resize(n1+1);
R.resize(n2+1);
for(int i = 0; i < n1; i++) L[i] = A[l+i];
for(int i = 0; i < n2; i++) R[i] = A[m+i];
L[n1] = INFTY;
R[n2] = INFTY;
int a = 0;
int b = 0;
for(int i = l; i < r; i++)
{
if(L[a] <= R[b])
{
A[i] = L[a];
a++;
}
else
{
A[i] = R[b];
b++;
cnt += n1 - a; // mid + a - b - 1
}
}
//cerr << cnt << endl;
return cnt;
}
int partition(int p, int r)
{
T x = A[r];
int i = p-1;
T tmp;
for(int j = p; j < r; j++)
{
if(A[j] <= x)
{
i++;
tmp = A[i];
A[i] = A[j];
A[j] = tmp;
}
}
tmp = A[i+1];
A[i+1] = A[r];
A[r] = tmp;
return i+1;
}
public:
Array();
Array(vector<T> &arr){A = arr;}
vector<T> A;
T operator [] (int x)
{
return A[x];
}
void dispArr()
{
for(int i = 0; i < A.size()-1 ; i++) cout << A[i] << " ";
cout << A[A.size()-1] << endl;
}
void swap(int i, int j)
{
T tmp = A[i];
A[i] = A[j];
A[j] = tmp;
}
/*
l : ?????????index
r : (?????????index + 1) or (?????° + ?????????index)
*/
llong mergeSort(int l, int r)
{
llong v1, v2, v3;
if(l + 1 < r){
int m = (l + r) / 2;
v1 = mergeSort(l, m);
v2 = mergeSort(m, r);
v3 = merge(l, m ,r);
return v1 + v2 + v3;
}
else return 0;
}
/*
l : ?????????index
r : ?????????index
*/
void quicksort(int p, int r)
{
if(p < r)
{
int q = partition(p,r);
quicksort(p, q-1);
quicksort(q+1, r);
}
}
};
int main()
{
int n; cin >> n;
vector<int> v;
v.resize(n);
for(int i = 0; i < n; i++) cin >> v[i];
Array<int> T(v);
cout << T.mergeSort(0, n) << endl;
//T.dispArr();
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
const int MOD = 1000000007;
int main()
{
int h, w, a, b;
cin >> h >> w >> a >> b;
rep(i, b)
{
rep(j, a) cout << 0;
for (int j = a; j < w; j++)
cout << 1;
cout << endl;
}
for (int i = b; i < h; i++)
{
rep(j, a) cout << 1;
for (int j = a; j < w; j++)
cout << 0;
cout << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main(void){
/*
int a, b;
cin >> a >> b ;
//*/
//*
vector<int> vec(3);
cin >> vec.at(0) >> vec.at(1) >> vec.at(2) ;
sort(vec.begin(), vec.end());
//*/
/*
if( a < 6 ){
cout << 0 << endl;
} else if (a < 13){
cout << b / 2 << endl;
} else {
cout << b << endl;
}
//*/
cout << vec.at(0) + vec.at(1) << endl;
return 0;
}
| 0 |
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
using ll = int64_t;
#define rep(i, j, n) for (int i = j; i < (int)n; ++i)
constexpr ll INFL = 0x3f3f3f3f3f3f3f3fLL;
int main() {
ll n;
cin >> n;
ll ans = INFL;
auto d = [](ll x) {
ll res = 0;
while (x) {
res++;
x /= 10;
}
return res;
};
for (ll i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ll a = d(i);
ll b = d(n / i);
ll f = max(a, b);
ans = min(ans, f);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
#ifdef LOCAL
freopen("inp.txt", "r", stdin );
freopen("ans.txt", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
if(s=="SUN") cout << 7 << '\n';
if(s=="MON") cout << 6 << '\n';
if(s=="TUE") cout << 5 << '\n';
if(s=="WED") cout << 4 << '\n';
if(s=="THU") cout << 3 << '\n';
if(s=="FRI") cout << 2 << '\n';
if(s=="SAT") cout << 1 << '\n';
}
| 0 |
#include <bits/stdc++.h>
int main() {
unsigned int firstNumber;
unsigned int lastNumber;
std::cin >> firstNumber >> lastNumber;
unsigned int numOfPalindrome = 0U;
for(unsigned int i = firstNumber; i <= lastNumber; ++i) {
std::string forwardNumber = std::to_string(i);
std::string reverseNumber = forwardNumber;
std::reverse(reverseNumber.begin(), reverseNumber.end());
if(forwardNumber == reverseNumber) {
++numOfPalindrome;
}
}
std::cout << numOfPalindrome << std::endl;
} | #include <map>
#include <set>
#include <ctime>
#include <queue>
#include <stack>
#include <cmath>
#include <vector>
#include <bitset>
#include <cstdio>
#include <cctype>
#include <string>
#include <numeric>
#include <cstring>
#include <cassert>
#include <climits>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std ;
#define rep(i, a, b) for (register int i = (a); i <= (b); ++i)
#define per(i, a, b) for (register int i = (a); i >= (b); --i)
#define loop(it, v) for (auto it = v.begin(); it != v.end(); it++)
#define cont(i, x) for (register int i = head[x]; i; i = edge[i].nex)
#define clr(a) memset(a, 0, sizeof(a))
#define ass(a, cnt) memset(a, cnt, sizeof(a))
#define cop(a, b) memcpy(a, b, sizeof(a))
#define lowbit(x) (x & -x)
#define all(x) x.begin(), x.end()
#define SC(t, x) static_cast <t> (x)
#define ub upper_bound
#define lb lower_bound
#define pqueue priority_queue
#define mp make_pair
#define pb push_back
#define pof pop_front
#define pob pop_back
#define fi first
#define se second
#define y1 y1_
#define Pi acos(-1.0)
#define iv inline void
#define enter putchar('\n')
#define siz(x) ((int)x.size())
#define file(x) freopen(x".in", "r", stdin),freopen(x".out", "w", stdout)
typedef double db ;
typedef long long ll ;
typedef unsigned long long ull ;
typedef pair <int, int> pii ;
typedef vector <int> vi ;
typedef vector <pii> vii ;
typedef queue <int> qi ;
typedef queue <pii> qii ;
typedef set <int> si ;
typedef map <int, int> mii ;
typedef map <string, int> msi ;
const int maxn = 1e6 + 100 ;
const int inf = 0x3f3f3f3f ;
const int iinf = 1 << 30 ;
const ll linf = 2e18 ;
const ll mod = 1e9 + 7 ;
const double eps = 1e-5 ;
ll n, s;
ll x[maxn], p[maxn];
ll ans[maxn], tim;
signed main()
{
scanf("%lld %lld", &n, &s);
rep(i, 1, n) scanf("%lld %lld", &x[i], &p[i]);
ll l = 1, r = n;
rep(i, 1, n)
{
if(x[r] < s) ans[i] = x[l], p[r] += p[l ++];
else if(x[l] > s) ans[i] = x[r], p[l] += p[r --];
else
{
if(p[l] < p[r]) ans[i] = x[l], p[r] += p[l ++];
else ans[i] = x[r], p[l] += p[r --];
}
}
per(i, n, 1) tim += abs(s - ans[i]), s = ans[i];
printf("%lld\n", tim);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int s,i,a,b,c;
while(cin>>s,s){
while(s--){
cin>>a>>b>>c;
if(a==100||b==100||c==100||b+c>179||a+b+c>239)cout<<'A'<<endl;
else if(a+b+c>209||(a+b+c>149&&(a>79||c>79)))cout<<'B'<<endl;
else cout<<'C'<<endl;
}}
} | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5+5;
void solve() {
int res = N*100;
int n; cin >> n;
vector<int> X(n), Y(n);
string d(n,'?');
for (int i = 0; i < n; i++) {
cin >> X[i] >> Y[i] >> d[i];
}
auto rotate = [&](){
for (int i = 0; i < n; i++) {
if (d[i] == 'R') d[i] = 'U';
else if (d[i] == 'U') d[i] = 'L';
else if (d[i] == 'L') d[i] = 'D';
else d[i] = 'R';
swap(X[i], Y[i]);
X[i] = N - X[i];
}
};
// -> <-
auto ck0 = [&](){
vector<vector<int>> evs(N+1);
for (int i = 0; i < n; i++) {
if (d[i]=='L' || d[i]=='R') {
evs[Y[i]].push_back(i);
}
}
for (auto& a: evs) {
sort(a.begin(), a.end(), [&](auto& u, auto& v){
return X[u] < X[v];
});
int n = a.size();
for (int i = 1; i < n; i++) {
if (d[a[i-1]] == 'R' && d[a[i]] == 'L') {
res = min(res, (X[a[i]] - X[a[i-1]]) * 5);
}
}
}
};
// ->
// ^
auto ck1 = [&](){
vector<vector<int>> evs(N*2);
for (int i = 0; i < n; i++) {
if (d[i] == 'R' || d[i] == 'U') {
evs[X[i]+Y[i]].push_back(i);
}
}
for (auto& a: evs) {
sort(a.begin(), a.end(), [&](auto& u, auto& v){
return X[u] < X[v];
});
int n = a.size();
for (int i = 1; i < n; i++) {
if (d[a[i-1]] == 'R' && d[a[i]] == 'U') {
res = min(res, (X[a[i]] - X[a[i-1]]) * 10);
}
}
}
};
for (int _ = 0; _ < 4; _++) {
ck0();ck1();rotate();
}
if (res == N*100) cout << "SAFE";
else cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
typedef pair<P,ll> PLL;
typedef pair<P,P> PP;
typedef vector<ll> VECLL;
typedef vector<P> VECP;
typedef priority_queue<P,VECP,greater<P> > PQP;
typedef priority_queue<ll, VECLL, greater<ll> > PQll;
#define rep(i,a,n) for(ll i = a;i < n;i++)
#define rrep(i,a,n) for(ll i = n; i >= a;i--)
#define index_check(i,n) if(i > n-1 || i < 0) continue;
#define LINF (ll)1e18
#define INF (int)1e9
#define fs first
#define sc second
#include <bits/stdc++.h>
#define rep(i,a,n) for(ll i = a;i < n;i++)
typedef long long ll;
using namespace std;
int main(){
ll n,k;
cin >> n >> k;
ll a[n] = {};
rep(i,0,n) cin >> a[i];
ll ans = 0;
rep(i,0,n-1){
if(a[i] + a[i+1] > k){
if(a[i] >= k){
ans += a[i+1] + a[i] - k;
a[i] = k;
a[i+1] = 0;
}
else{
ans += a[i]+a[i+1]-k;
a[i+1] -= a[i]+a[i+1]-k;
}
}
}
cout << ans << endl;
}
| #include <iostream>
#include <string>
#include <algorithm>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <cmath>
#include <stdio.h>
#include <queue>
#include <deque>
#include <cstdio>
#include <set>
#include <map>
#include <bitset>
#include <stack>
#include <cctype>
using namespace std;
set<pair<long long, long long>> st;
long long sum = 0;
int main() {
long long n, m;
cin >> n >> m;
long long ans = 0;
st.insert(make_pair(0, 1));
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
sum = (sum + a) % m;
pair<long long, long long> pa;
if (st.lower_bound(make_pair(sum, 0)) != st.end()) {
pa = *st.lower_bound(make_pair(sum, 0));
if (sum == pa.first) {
ans += pa.second;
st.erase(*st.lower_bound(make_pair(sum, 0)));
st.insert(make_pair(sum, pa.second + 1));
}
else {
st.insert(make_pair(sum, 1));
}
}
else {
st.insert(make_pair(sum, 1));
}
}
cout << ans << endl;
return 0;
} | 0 |
#include<iostream>
#include<algorithm>
#include<math.h>
#include<string>
#include<tuple>
#include<vector>
#include<cstdlib>
#include<cstdint>
#include<stdio.h>
#include<cmath>
#include<limits>
#include<iomanip>
#include<ctime>
#include<climits>
#include<random>
#include<queue>
#include<map>
using namespace std;
template <class T> using V = vector<T>;
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
const long long INF = 1LL << 60;
const double pi=acos(-1);
using ll = long long;
using db = long double;
using st = string;
using ch = char;
using vll = V<ll>;
using vpll =V<pair<ll,ll>>;
using vst = V<st>;
using vdb = V<db>;
using vch = V<ch>;
using graph = V<V<int>>;
using pq = priority_queue<ll>;
#define FOR(i,a,b) for(ll i=(a);i<(b);i++)
#define bgn begin()
#define en end()
#define SORT(a) sort((a).bgn,(a).en)
#define REV(a) reverse((a).bgn,(a).en)
#define fi first
#define se second
#define sz size()
#define gcd(a,b) __gcd(a,b)
#define pb(a) push_back(a);
#define ALL(a) (a).begin(),(a).end()
ll Sum(ll n) {
ll m=0;
while(n){
m+=n%10;
n/=10;
}
return m;
}
const int MAX = 510000;
// change
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
void Comuse() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
#define comuse Comuse()
ll combi(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll perm(int n,int k){
if(n < k) return 0;
if(n < 0 || k < 0) return 0;
return fac[n] * (finv[k] % MOD) % MOD;
}
ll modpow(ll a,ll n,ll mod){
ll ans=1;
while(n>0){
if(n&1){
ans=ans*a%mod;
}
a=a*a%mod;
n>>=1;
}
return ans;
}
ll modinv(ll a, ll mod) {
return modpow(a, mod - 2, mod);
}
ll modcombi(int n,int k,int mod){
ll ans=1;
for(ll i=n;i>n-k;i--){
ans*=i;
ans%=mod;
}
for(ll i=1;i<=k;i++){
ans*=modinv(i,mod);
ans%=mod;
}
return ans;
}
ll lcm(ll a,ll b){
ll n;
n=a/gcd(a,b)*b;
return n;
}
vll div(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);
}
vector<bool> isprime(MAX+100,true);
void primeuse(){
isprime[0]=false;
isprime[1]=false;
for(int i=2;i<MAX+50;i++){
int up=sqrt(i)+1;
for(int j=2;j<up;j++){
if(i%j==0){
isprime[i]=false;
}
}
}
}
void bf(ll n,string s){
for(ll i=0;i<n;i++){
cout<<s;
}
cout<<"\n";
}
void Solve();
const int MAX_N = 131072;
//segment tree
int NN;
int seg[MAX_N*2-1];
void seguse(){
for(int i=0;i<2*NN-1;i++){
seg[i]=INT_MAX;
}
}
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<setprecision(20)<<fixed;
Solve();
}
/****************************************\
| Thank you for viewing my code:) |
| Written by RedSpica a.k.a. RanseMirage |
| Twitter:@asakaakasaka |
\****************************************/
//segtreeの葉の先頭の添え字はN-1
void Solve(){
string s;
cin>>s;
ll n=s.size();
FOR(i,0,n-1){
if(s[i]==s[i+1]){
cout<<i+1<<" "<<i+2<<"\n";
return;
}
}
FOR(i,0,n-2){
if(s[i]==s[i+2]){
cout<<i+1<<" "<<i+3<<"\n";
return;
}
}
cout<<"-1 -1\n";
} | #include<iostream>
#include<algorithm>
#include<string>
using namespace std;
int main(){
string s;cin>>s;
string a[7]={"MON","TUE","WED","THU","FRI","SAT","SUN"};
for(int i=0;i<7;i++){
if( s!="SUN" && a[i]==s){
cout<<(6-i);
}
else if(s=="SUN"){
cout<<7;
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
//#include <boost/multiprecision/cpp_int.hpp>
//using multiInt = boost::multiprecision::cpp_int;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_temp>
using smaller_queue = priority_queue<Q_temp, vector<Q_temp>, greater<Q_temp>>;
const ll MOD = (ll)(1e9 + 7);
const int INF = (int)1e9;
const ll LINF = (ll)4e18;
const double PI = acos(-1.0);
#define REP(i, m, n) for (ll i = m; i < (ll)(n); ++i)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
#define MT make_tuple
#define YES(n) cout << ((n) ? "YES" : "NO") << endl
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl
#define Possible(n) cout << ((n) ? "Possible" : "Impossible") << endl
#define possible(n) cout << ((n) ? "possible" : "impossible") << endl
#define Yay(n) cout << ((n) ? "Yay!" : ":(") << endl
#define all(v) v.begin(), v.end()
#define NP(v) next_permutation(all(v))
#define dbg(x) cerr << #x << ":" << x << endl;
vector<int> Dx = {0, 0, -1, 1, -1, 1, -1, 1, 0};
vector<int> Dy = {1, -1, 0, 0, -1, -1, 1, 1, 0};
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(50) << setiosflags(ios::fixed);
int n, m;
cin >> n >> m;
int a[100010], b[100010];
vector<int> E[100010];
int in_cnt[100010] = {};
rep(i, n + m - 1)
{
cin >> a[i] >> b[i];
E[a[i]].push_back(b[i]);
in_cnt[b[i]]++;
}
int root;
for (int i = 1; i <= n; ++i)
{
if (in_cnt[i] == 0)
{
root = i;
break;
}
}
queue<int> que;
int d[100010];
int check_cnt[100010] = {};
d[root] = 0;
que.push(root);
while (!que.empty())
{
int q = que.front();
que.pop();
for (auto to : E[q])
{
d[to] = d[q] + 1;
check_cnt[to]++;
if (check_cnt[to] == in_cnt[to])
que.push(to);
}
}
int par[100010];
for (int i = 1; i <= n; ++i)
par[i] = -1;
par[root] = 0;
que.push(root);
while (!que.empty())
{
int q = que.front();
que.pop();
for (auto to : E[q])
{
if (par[to] != -1)
continue;
if (d[to] == d[q] + 1)
{
par[to] = q;
que.push(to);
}
}
}
for (int i = 1; i <= n; ++i)
cout << par[i] << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<(n); i++)
#define rrep(i,n) for(int i=(n)-1; i>=0; i--)
#define FOR(i,a,b) for(int i=(a); i<(b); i++)
#define RFOR(i,a,b) for(int i=(b-1); i>=(a); i--)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
#define UNIQUE(v) v.erase( unique(v.begin(), v.end()), v.end() );
#define pb push_back
using ll = long long;
using D = double;
using LD = long double;
using P = pair<int, int>;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int main(){
int h,w; cin >> h >> w;
vector<int> a(h), b(h);
rep(i,h) {
cin >> a[i] >> b[i];
a[i]--;
}
map<int, int> mp;
multiset<int> cand;
rep(i,w) mp[i] = i;
rep(i,w) cand.insert(0);
rep(i,h){
int l = a[i], r = b[i];
auto it = mp.lower_bound(l);
int rb = -1;
while(it != mp.end() && it -> first <= r){
chmax(rb, it -> second);
cand.erase(cand.find(it -> first - it -> second));
mp.erase(it++);
}
if(rb != -1 && r < w){
cand.insert(r - rb);
mp[r] = rb;
}
int ans = -1;
if(cand.size()) ans = *cand.begin() + i+1;
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#include<cstdlib>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
typedef long long ll;
int main(){
int n;
cin >> n;
string s,t;
cin >> s >> t;
rep(i,n){
int same=n-i;
bool check=true;
rep(j,same){
if(s.at(n-same+j)!=t.at(j)){check=false; break;}
}
if(check){cout<<n*2-same; return 0;}
}
cout << n*2;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ldouble = long double;
const ll inf = 1ll << 60;
const ll mod = (ll)1e9 + 7;
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define print(s) cout << s;
#define println(s) cout << s << endl;
#define printd(s) cout << fixed << setprecision(10) << s << endl;
string res;
int main()
{
ll a, b;
string s;
cin >> a >> b >> s;
res = "Yes";
for (int i = 0; i < s.length(); i++)
{
if (i == a)
{
if (s[i] != '-')
{
res = "No";
}
}
else
{
if (!('0' <= s[i] && s[i] <= '9'))
{
res = "No";
}
}
}
println(res);
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int m,n_min,n_max,gap,temp=0;
while(1){
cin >> m >> n_min >> n_max;
if(m==0 && n_min==0 && n_max==0){break;}
int P[m+1];
P[0]=-1;
for(int i=1;i<=m;i++){
cin >> P[i];
}
gap=0;
for(int i=n_min;i<=n_max;i++){
if(P[i]-P[i+1]>=gap){
gap=P[i]-P[i+1];
temp=i;
}
}
cout << temp << endl;
}
} | #include <string>
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int N, Q; string S;
cin >> N >> S >> Q;
vector<int> dsum(N + 1), msum(N + 1);
for (int i = 0; i < N; ++i) {
dsum[i + 1] = dsum[i] + (S[i] == 'D' ? 1 : 0);
msum[i + 1] = msum[i] + (S[i] == 'M' ? 1 : 0);
}
for (int i = 0; i < Q; ++i) {
int K;
cin >> K;
long long cur = 0, ans = 0;
for (int i = 0; i < N; ++i) {
if (S[i] == 'C') {
ans += cur;
}
if (S[i] == 'M') {
cur += dsum[i] - dsum[max(i - K + 1, 0)];
}
if (i >= K - 1 && S[i - K + 1] == 'D') {
cur -= msum[i + 1] - msum[i - K + 2];
}
}
cout << ans << '\n';
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define INF 1e9
using namespace std;
#define REPR(i,n) for(int i=(n); i >= 0; --i)
#define FOR(i, m, n) for(int i = (m); i < (n); ++i)
#define REP(i, n) for(int i=0, i##_len=(n); i<i##_len; ++i)
#define ALL(a) (a).begin(),(a).end()
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return true; } return false; }
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
int gcd(int a,int b){return b?gcd(b,a%b):a;}
typedef long long ll;
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
int main() {
int N;
cin >> N;
vector<double> a(N);
REP(i,N) cin >> a[i];
double av = accumulate(ALL(a),double(0))/N;
int ans = 0;
double shortest = INF;
REP(i,N) {
if (chmin(shortest,abs(av-a[i]))) {
ans = i;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
int main(){
int N;
cin >> N;
int sum = 0;
double ave = 0;
double mini = 100;
double aa = 0;
int ans = 0;
vector<int> a(N);
for(int i = 0;i < N;i++){
cin >> a.at(i);
sum += a.at(i);
}
ave = (double)sum/(double)N;
/*cout << ave << endl;*/
for(int i = 0;i < N;i++){
aa = abs(ave - a.at(i));
if(mini > aa){
mini = aa;
ans = i;
}
}
cout << ans << endl;
}
| 1 |
#include <cstdio>
#include <bitset>
#include <cmath>
#include <complex>
#include <vector>
#include <algorithm>
#include <stack>
#include <iostream>
#include <sstream>
#define EPS 1e-6
using namespace std;
typedef complex<double> coor;
double cross(coor a, coor b)
{
return a.real() * b.imag() - a.imag() * b.real();
}
double dot(coor a, coor b)
{
return a.real() * b.real() + a.imag() * b.imag();
}
int main()
{
string str;
while (getline(cin, str)) {
istringstream is(str);
string token;
int n;
while (is >> token) {
for (int i = 0; i < 26; i++) {
string tmp;
for (int j = 0; j < token.size(); j++) {
tmp += (token[j] - 'a' + i) % 26 + 'a';
}
//cout << "i = " << i << "tmp = " << tmp << endl;
if (tmp == "the" || tmp == "this" || tmp == "that") {
n = i;
goto next;
}
}
}
next:
//printf("n = %d\n", n);
for (int i = 0; i < str.size(); i++) {
printf("%c", ('a' <= str[i] && str[i] <= 'z') ?(str[i] - 'a' + n) % 26 + 'a' : str[i]);
}
printf("\n");
}
} | #include <iostream>
#include <cctype>
#include <string>
using namespace std;
string tar[] = { "the", "this", "that" };
int main()
{
string in;
while (getline(cin, in))
{
string ans;
for (int i=0; i<26; i++)
{
ans = in;
for (int k=0; k<ans.size(); k++)
{
if (islower(ans[k]))
{
int r = i - ('z' - ans[k]);
if (r > 0)
ans[k] = (char) ((int) 'a' + r - 1);
else
ans[k] = (char) ((int) ans[k] + i);
}
}
if ( ans.find(tar[0], 0) != string::npos
|| ans.find(tar[1], 0) != string::npos
|| ans.find(tar[2], 0) != string::npos)
break;
}
cout << ans << endl;
}
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define Abigail inline void
typedef long long LL;
const int N=15,INF=(1<<30)-1;
int n,m,e[N+9][N+9],sum;
int a[(1<<N)+9];
void Get_a(){
for (int g=1;g<1<<n;++g)
for (int i=0;i<n;++i){
if (g>>i&1^1) continue;
for (int j=i+1;j<n;++j)
if (g>>j&1) a[g]+=e[i][j];
}
}
int b[N+9][(1<<N)+9];
void Get_b(){
for (int g=1;g<1<<n;++g)
for (int i=0;i<n;++i){
if (g>>i&1) continue;
b[i][g]=a[g];
for (int j=0;j<n;++j)
if (g>>j&1) b[i][g]+=e[i][j];
}
}
int dp[N+9][(1<<N)+9];
void Get_dp(){
for (int i=0;i<n;++i)
for (int g=0;g<1<<n;++g) dp[i][g]=-INF;
dp[0][1]=0;
for (int g1=1;g1<1<<n;++g1)
for (int i=0;i<n;++i){
if (dp[i][g1]==-INF) continue;
int t=~g1&(1<<n)-1;
for (int g2=t;g2;g2=g2-1&t)
dp[i][g1|g2]=max(dp[i][g1|g2],dp[i][g1]+b[i][g2]);
for (int j=0;j<n;++j)
if (g1>>j&1^1&&e[i][j]){
dp[j][g1|1<<j]=max(dp[j][g1|1<<j],dp[i][g1]+e[i][j]);
}
}
}
Abigail into(){
scanf("%d%d",&n,&m);
for (int i=1;i<=m;++i){
int x,y,v;
scanf("%d%d%d",&x,&y,&v);--x;--y;
e[x][y]=e[y][x]=v;
sum+=v;
}
}
Abigail work(){
Get_a();
Get_b();
Get_dp();
}
Abigail outo(){
printf("%d\n",sum-dp[n-1][(1<<n)-1]);
}
int main(){
into();
work();
outo();
return 0;
} | #include<bits/stdc++.h>
using namespace std;
inline int read()
{
char ch=getchar(); int f=1,x=0;
while (ch<'0' || ch>'9') { if (ch=='-') f=-1; ch=getchar(); }
while (ch>='0' && ch<='9') { x=x*10+ch-'0'; ch=getchar(); }
return f*x;
}
int n,m,a,b,c,sum,dis[17][17],v[1<<15],f[1<<15][17];
signed main()
{
n=read(); m=read();
const int N=1<<n;
for (int i=1;i<=m;i++)
{
a=read(); b=read();
sum+=dis[a][b]=dis[b][a]=read();
}
for (int i=1;i<N;i++)
{
for (int j=0;j<n;j++)
{
if (!(i>>j&1)) continue;
for (int k=0;k<j;k++)
{
if (!(i>>k&1)) continue;
v[i]+=dis[j+1][k+1];
}
}
}
memset(f,-1,sizeof(f));
f[1][1]=0;
for (int i=1;i<N;i++)
{
for (int j=0;j<n;j++)
{
if (!(i>>j&1) || !~f[i][j+1]) continue;
for (int k=0;k<n;k++)
{
if (i>>k&1 || !dis[j+1][k+1]) continue;
f[i|(1<<k)][k+1]=max(f[i|(1<<k)][k+1],f[i][j+1]+dis[j+1][k+1]);
}
int tot=((N-1)^i)|(1<<j);
for (int k=tot;k;k=(k-1)&tot)
{
if (!(k>>j&1)) continue;
f[i|k][j+1]=max(f[i|k][j+1],f[i][j+1]+v[k]);
}
}
}
return !printf("%d\n",sum-f[N-1][n]);
} | 1 |
#include <stdio.h>
int main(){
int H, W, N, res;
scanf("%d", &H);
scanf("%d", &W);
scanf("%d", &N);
if(H>W){
res = N/H;
N%H > 0? res+=1 : res=res;
}
else{
res = N/W;
N%W > 0? res+=1 : res=res;
}
printf("%d\n", res);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int INF = 1001001001;
int main(){
ll n, x; cin >> n >> x;
vector<ll> a(n);
for(int i = 0; i < n; i++) cin >> a[i];
ll ans = 0;
for(int i = 0; i < n-1; i++){
if(a[i] > x){
ll tmp = a[i] - x;
ans += tmp + a[i+1];
a[i+1] = 0;
}
else{
if(a[i+1] + a[i] <= x) continue;
else{
ll tmp = a[i+1] + a[i] - x;
ans += tmp;
a[i+1] -= tmp;
if(i + 1 == n - 1 && a[i+1] > x) ans += a[i+1] - x;
}
}
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
#define all(a) (a).begin(), (a).end()
int main()
{
string s;
cin >> s;
int ans = 0;
bool ok = true;
rep(i, 3)
{
if (s[i] == 'R')
{
if (ok)
{
ans++;
}
ok = true;
}
else
{
if (ans > 0)
{
ok = false;
}
}
}
cout << ans << '\n';
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define reps(i,a,b) for(int i=(a);i<(b);i++)
#define pb push_back
#define eb emplace_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
using vint=vector<int>;
using pint=pair<int,int>;
using vpint=vector<pint>;
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
template<class A,class B>
ostream& operator<<(ostream& ost,const pair<A,B>&p){
ost<<"{"<<p.first<<","<<p.second<<"}";
return ost;
}
template<class T>
ostream& operator<<(ostream& ost,const vector<T>&v){
ost<<"{";
for(int i=0;i<v.size();i++){
if(i)ost<<",";
ost<<v[i];
}
ost<<"}";
return ost;
}
signed main(){
int n;
cin>>n;
cout<<180*(n-2)<<endl;
return 0;
} | 0 |
#include<iostream>
#include<cctype>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<cctype>
#include<cstring>
#include<utility>
const int inf=0x7fffffff;
typedef long long int ll;
using namespace std;
const int N=100+5;
char s[100+10];
char ans[][10]={
"No\n",
"Yes\n"
};
struct DICE{
int u,s,e,w,n,d;
DICE (int u=0,int s=0,int e=0,int w=0,int n=0,int d=0):u(u),s(s),e(e),w(w),n(n),d(d){}
DICE fW(){
DICE tmp;
tmp.s=this->s;
tmp.n=this->n;
tmp.e=this->d;
tmp.w=this->u;
tmp.u=this->e;
tmp.d=this->w;
return tmp;
}
DICE fS(){
DICE tmp;
tmp.s=this->u;
tmp.n=this->d;
tmp.e=this->e;
tmp.w=this->w;
tmp.d=this->s;
tmp.u=this->n;
return tmp;
}
DICE fE(){
DICE tmp;
tmp.s=this->s;
tmp.n=this->n;
tmp.e=this->u;
tmp.w=this->d;
tmp.d=this->e;
tmp.u=this->w;
return tmp;
}
DICE fN(){
DICE tmp;
tmp.s=this->d;
tmp.n=this->u;
tmp.e=this->e;
tmp.w=this->w;
tmp.d=this->n;
tmp.u=this->s;
return tmp;
}
int right(int t,int f){
if(t==this->u)
{
if(f==this->s)return this->e;
else if(f==this->e)return this->n;
else if(f==this->n)return this->w;
else if(f==this->w)return this->s;
else return -1;
}
else if(t==this->s){
DICE tmp=(*this).fN();
return tmp.right(t,f);
}
else if(t==this->e){
DICE tmp=(*this).fW();
return tmp.right(t,f);
}
else if(t==this->n){
DICE tmp=(*this).fS();
return tmp.right(t,f);
}
else if(t==this->w){
DICE tmp=(*this).fE();
return tmp.right(t,f);
}
else if(t==this->d){
DICE tmp=(*this).fE().fE();
return tmp.right(t,f);
}
else return -1;
}
};
DICE A[N];
bool check(DICE x,DICE y){
int ax[]={
x.s,x.e,x.n,x.w
};
int ay[]={
y.s,y.e,y.n,y.w
};
if(x.u==y.u){
if(x.d==y.d){
int cnt=0;
while(cnt<=4){
while(ax[cnt]!=ay[0]&&cnt<=4)
cnt++;
int i=0;
while(ax[(i+cnt)%4]==ay[i]&&i<=4)
i++;
if(i==4)return 1;
cnt++;
}
}
}
return 0;
}
bool sovle(DICE x,DICE y){
if(check(x,y))return 1;
if(check(x.fE(),y))return 1;
if(check(x.fW(),y))return 1;
if(check(x.fN(),y))return 1;
if(check(x.fS(),y))return 1;
if(check(x.fS().fS(),y))return 1;
return 0;
}
int main()
{
//#ifdef DEBUG
// freopen("in", "r", stdin);
//// freopen("out", "w", stdout);
//#endif
int n;scanf("%d", &n);
int t=0;
int a[6];
bool flag=1;
for(int i=0;i<6;i++){
scanf("%d", &a[i]);
}
A[0]=DICE(a[0],a[1],a[2],a[3],a[4],a[5]);
t++;
while(t<n){
for(int i=0;i<6;i++){
scanf("%d", &a[i]);
}
A[t]=DICE (a[0],a[1],a[2],a[3],a[4],a[5]);
for(int i=0;i<t;i++)
{
if(sovle(A[i],A[t])){flag=0;
// cout<<i<<' '<<t<<endl;
}
}
t++;
}
printf("%s", ans[flag]);
// printf("%s", ans[solve(dice,dice2)]);
// DICE I
// scanf("%s", s);
// int len=strlen(s);
// for(int i=0;i<len;i++){
// switch(s[i]){
// case'S':dice=dice.fS();break;
// case'E':dice=dice.fE();break;
// case'W':dice=dice.fW();break;
// case'N':dice=dice.fN();break;
// }
// }
// printf("%d\n", dice.u);
//
return 0;
}
//aoj1_11_a.cc
//AC | #include<string>
#include<iostream>
using namespace std;
class Dice{
int dn[6];
int ori[6];
int up, front;
string qu;
public:
Dice(int d1, int d2, int d3, int d4, int d5, int d6){
dn[0] = d1;
dn[1] = d2;
dn[2] = d3;
dn[3] = d4;
dn[4] = d5;
dn[5] = d6;
ori[0] = d1;
ori[1] = d2;
ori[2] = d3;
ori[3] = d4;
ori[4] = d5;
ori[5] = d6;
}
void Result(string m){
int w;
qu = m;
for (int i = 0; i < 6; i++){
dn[i] = ori[i];
}
for (int i = 0; i < qu.size(); i++){
switch (qu[i]){
case 'E':
w = dn[0];
dn[0] = dn[3];
dn[3] = dn[5];
dn[5] = dn[2];
dn[2] = w;
break;
case 'N':
w = dn[5];
dn[5] = dn[4];
dn[4] = dn[0];
dn[0] = dn[1];
dn[1] = w;
break;
case 'S':
w = dn[0];
dn[0] = dn[4];
dn[4] = dn[5];
dn[5] = dn[1];
dn[1] = w;
break;
case 'W':
w = dn[0];
dn[0] = dn[2];
dn[2] = dn[5];
dn[5] = dn[3];
dn[3] = w;
break;
}
}
}
int get0(){
return dn[0];
}
int get1(){
return dn[1];
}
int get2(){
return dn[2];
}
int get3(){
return dn[3];
}
int get4(){
return dn[4];
}
int get5(){
return dn[5];
}
};
int main()
{
int n;
int count = 0;
int ndice[100][6];
string flag = "Yes";
string quu[23] = { "WSE", "ESW", "WSSE", "SWW", "EN", "WN", "N", "SW", "W", "SSW",
"NW", "SE", "E", "SSE", "NE", "S", "WS", "ES", "WWS", "WW", "SWS", "SES", "SS" };
cin >> n;
for (int i = 0; i < n; i++){ // n個のサイコロの入力
for (int j = 0; j < 6; j++){
cin >> ndice[i][j];
}
}
for (int i = 0; i < n; i++){ // サイコロを比べる
for (int j = i + 1; j < n; j++){ // Dice a()にサイコロを登録し、順次比較していく
Dice a(ndice[j][0], ndice[j][1], ndice[j][2],
ndice[j][3], ndice[j][4], ndice[j][5]);
for (int k = 0; k < 6; k++){ // 転がすこともなく同じサイコロかどうか
if (ndice[i][k] == ndice[j][k]){
count = count + 1;
}
}
if (count == 6){ // 6面全てが一致すれば、同じサイコロ
flag = "No";
}
count = 0;
for (int l = 0; l < 23; l++){ // サイコロが取り得る全ての可能性(面の上下左右)を比較していく
a.Result(quu[l]);
ndice[j][0] = a.get0();
ndice[j][1] = a.get1();
ndice[j][2] = a.get2();
ndice[j][3] = a.get3();
ndice[j][4] = a.get4();
ndice[j][5] = a.get5();
for (int k = 0; k < 6; k++){ // 6面全てが一致すれば、同じサイコロ
if (ndice[i][k] == ndice[j][k]){
count = count + 1;
}
}
if (count == 6){
flag = "No";
}
count = 0;
}
}
}
cout << flag << endl;
return 0;
}
| 1 |
#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#define re(c, b) for(ll c=0;c<b;c++)
using namespace std;
int main() {
int h, w;scanf("%d %d", &h, &w);
vector<string> s(h);
for(int i=0;i<h;i++) std::cin >> s[i];
vector<set<int>> spl(w);
for(int i=w-1;i>=1;i--){
int mode = (s[0][i]==s[0][i-1]);
for(int j=1;j<h;j++){
if(mode==(s[j][i]==s[j][i-1])) continue;
mode = (s[j][i]==s[j][i-1]);
spl[i].insert(j-1);
}
}
vector<int> las(h, -1);
int ans = 0;
for(int j=w-1;j>=0;j--){
int tmp = h;
map<int, int> L;
map<int, int> rev; // 長さ、個数
L.emplace(0, h);
rev.emplace(h, 1);
for(int i=1;i+j<w;i++){
for(auto t:spl[i+j]){
auto itr = --L.upper_bound(t);
int x_len = t - (*itr).first + 1;
int y_len = (*itr).first + (*itr).second - 1 - t;
auto x = rev.find((*itr).second);
if((*x).second==1) rev.erase(x);
else (*x).second--;
(*itr).second = x_len;
L.emplace(t+1, y_len);
x = rev.find(x_len);
if(x==rev.end()) rev.emplace(x_len, 1);
else (*x).second++;
x = rev.find(y_len);
if(x==rev.end()) rev.emplace(y_len, 1);
else (*x).second++;
//rev.insert(x_len);
//rev.insert(y_len);
}
auto itr = (--rev.end());
tmp = max((*itr).first*(i+1), tmp);
}
ans = max(ans, tmp);
for(auto i:spl[j]){
if(las[i]!=-1) spl[las[i]].erase(i);
las[i] = j;
}
}
std::cout << ans << '\n';
return 0;
}
| #include<bits/stdc++.h>
#define ll int
#define ld long double
#define pb push_back
#define mp make_pair
#define F first
#define S second
using namespace :: std;
const ll maxn=2010;
char jad[maxn][maxn];
ll ava[maxn];
ll l[maxn];
ll r[maxn];
ll finds(ll n){
stack<ll> stk;
for(ll i=0;i<n;i++){
while(!stk.empty() && ava[stk.top()]>=ava[i]){
stk.pop();
}
if(stk.empty()){
l[i]=-1;
}else{
l[i]=stk.top();
}
stk.push(i);
}
while(!stk.empty()){
stk.pop();
}
for(ll i=n-1;i>=0;i--){
while(!stk.empty() && ava[stk.top()]>=ava[i]){
stk.pop();
}
if(stk.empty()){
r[i]=n;
}else{
r[i]=stk.top();
}
stk.push(i);
}
ll ans=0;
for(ll i=0;i<n;i++){
ans=max(ans,(ava[i]+1)*(r[i]-l[i]));
}
return ans;
}
bool good(ll i,ll j){
int t=0;
if(jad[i][j]=='#'){
t^=1;
}
if(jad[i+1][j]=='#'){
t^=1;
}
if(jad[i][j+1]=='#'){
t^=1;
}
if(jad[i+1][j+1]=='#'){
t^=1;
}
if(t&1){
return 0;
}
return 1;
}
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll w,h;
cin>>w>>h;
for(ll i=0;i<w;i++){
for(ll j=0;j<h;j++){
cin>>jad[i][j];
}
}
ll ans=w;
for(ll i=0;i<w-1;i++){
for(ll j=0;j<h-1;j++){
if(good(i,j)){
ava[j]++;
}else{
ava[j]=0;
}
}
ans=max(ans,finds(h-1));
}
cout<<ans;
}
| 1 |
Subsets and Splits