code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <iostream>
using namespace std;
typedef long long ll;
const ll mod = 998244353;
int n;
int a[305];
ll dp[305][90005];
ll dp2[305][90005];
ll p(ll a, ll x) {
ll res = 1;
while(x > 0) {
if(x & 1) res = res * a % mod;
a = a * a % mod;
x >>= 1;
}
return res;
}
int main() {
cin >> n;
int sum = 0;
int maxa = 0;
for(int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
maxa = max(maxa,a[i]);
}
dp[0][0] = 1;
for(int i = 0; i < n; i++) {
for(int j = 0; j <= i * maxa; j++) {
if(dp[i][j] == 0) continue;
dp[i+1][j] = (dp[i+1][j] + dp[i][j] * 2) % mod;
dp[i+1][j+a[i]] = (dp[i+1][j+a[i]] + dp[i][j]) % mod;
}
}
dp2[0][0] = 1;
for(int i = 0; i < n; i++) {
for(int j = 0; j <= i * maxa; j++) {
if(dp2[i][j] == 0) continue;
dp2[i+1][j] = (dp2[i+1][j] + dp2[i][j]) % mod;
dp2[i+1][j+a[i]] = (dp2[i+1][j+a[i]] + dp2[i][j]) % mod;
}
}
ll ans = p(3,n);
for(int i = 0; i <= n * maxa; i++) {
if(i >= sum - i) {
ans = (ans + mod - dp[n][i] * 3 % mod) % mod;
}
if(i == sum - i) {
ans = (ans + dp2[n][i] * 3 % mod) % mod;
}
}
if(ans < 0 ) cout << ans + mod << endl;
else
cout << ans << endl;
}
| #include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <string>
#include <vector>
#include <random>
#include <bitset>
#include <queue>
#include <cmath>
#include <stack>
#include <set>
#include <map>
typedef long long ll;
using namespace std;
const ll MOD = 998244353;
void add(ll& a, ll b) { a = (a+b) % MOD; }
void mul(ll& a, ll b) { a = (a*b) % MOD; }
int main() {
int N, A[300];
cin >> N;
int sm = 0;
for (int i = 0; i < N; i++) {
cin >> A[i];
sm += A[i];
}
const int MX = 300 * 300;
static ll dp[301][MX + 301], sub[301][MX + 301];
dp[0][0] = 1;
sub[0][0] = 1;
for (int i = 0; i < N; i++) {
for (int j = 0; j <= MX; j++) {
add(dp[i + 1][j + A[i]], dp[i][j]);
add(dp[i + 1][j], 2 * dp[i][j]);
add(sub[i + 1][j + A[i]], sub[i][j]);
add(sub[i + 1][j], sub[i][j]);
}
}
ll ng = 0;
for (int j = (sm + 1) / 2; j <= MX; j++) add(ng, dp[N][j]);
if (sm % 2 == 0) add(ng, MOD - sub[N][sm / 2]);
mul(ng, 3);
ll ans = 1;
for (int i = 0; i < N; i++) mul(ans, 3);
add(ans, MOD - ng);
cout << ans << endl;
return 0;
} | 1 |
#include<iostream>
#include<algorithm>
#include<string>
#include<vector>
using namespace std;
int main()
{
//ใณใณใในใ
int W[10], K[10];
for (int i = 0; i < 10; i++) {
cin >> W[i];
}
for (int i = 0; i < 10; i++) {
cin >> K[i];
}
sort(W, W + 10);
reverse(W, W + 10);
sort(K, K + 10);
reverse(K, K + 10);
cout << W[0] + W[1] + W[2] << " " << K[0] + K[1] + K[2] << endl;
//ใใคใณใใซใผใ
/*
int N, M;
cin >> N >> M;
int a;
int A[5000];
int b = 0;
int x = 0;
for (int i = 0; i < M; i++) {
cin >> a;
if (a < N) {
A[x]=a;
x++;
}
else
{
b++;
}
cin >> a;
}
int sum = 0;
if (b < M - 1) {
sort(A, A+x);
reverse(A, A+x);
for (int i = 0; i < M - 1 - b; i++) {
sum += N - A[i];
}
}
cout << sum << endl;
*/
//ๅ่จๆ้
/*
int sum=0, n;
for (int i = 0; i < 4; i++) {
cin >> n;
sum += n;
}
cout << sum / 60 << endl;
cout << sum % 60 << endl;
//ๅนณๅ็น
/*
int P[5];
int sum=0;
for (int i = 0; i < 5; i++) {
cin >> P[i];
if (P[i] < 40) P[i] = 40;
sum += P[i];
}
cout << sum / 5 << endl;
*/
//ๆ็ฅจ
/*
int N, M;
cin >> N >> M;
int A[1000], vote[1000];
for (int i = 0; i < N; i++) {
cin >> A[i];
vote[i] = 0;
}
int b;
for (int i = 0; i < M; i++) {
cin >> b;
for (int j = 0; j < N; j++) {
if (A[j] <= b) {
vote[j]++;
break;
}
}
}
int temps = 0, ans;
for (int i = 0; i < N; i++) {
if (vote[i] > temps) {
temps = vote[i];
ans = i;
}
}
cout << ans + 1 << endl;
*/
//2.ใใใใ
/*
int n;
cin >> n;
int A, _A = 1;
int k = 0;
int A_count[100];
A_count[0] = 1;
for (int i = 0; i < n; i++)
{
cin >> A;
if (A == 1)
{
if (A == _A)
{
A_count[k]++;
}
else
{
k++;
A_count[k] = 2;
}
}
_A = A;
}
sort(A_count, A_count + k + 1);
cout << A_count[k] << endl;
*/
//ใฟใคใ ใซใผใ
/*
int t[2][3];
int x[3][3];
for (int n=0; n < 3; n++)
{
for (int i=0; i < 2; i++)
for (int k=0; k < 3; k++)
cin >> t[i][k];
for (int m = 2; m >= 0; m--)
{
x[n][m] = t[1][m] - t[0][m];
if (t[0][m] > t[1][m])
{
x[n][m] += 60;
t[1][m - 1]--;
}
}
}
for (int n= 0; n < 3; n++)
{
cout << x[n][0] << ' ' << x[n][1] <<' '<< x[n][2] << endl;
}
*/
return 0;
}
| #include<iostream>
#include<vector>
#include<algorithm>
#include<functional>
using namespace std;
int main() {
vector<int> W, K;
int dommy;
for (int i = 0; i < 10; ++i) {
cin >> dommy;
W.push_back(dommy);
}
sort(W.begin(), W.end(), greater<int>());
for (int i = 0; i < 10; ++i) {
cin >> dommy;
K.push_back(dommy);
}
sort(K.begin(), K.end(), greater<int>());
int Wpoint = 0, Kpoint = 0;
for (int i = 0; i < 3; ++i) {
Wpoint += W[i];
}
for (int i = 0; i < 3; ++i) {
Kpoint += K[i];
}
cout << Wpoint << ' ' << Kpoint << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
cin>>a;
if(a.at(0)=='7'||a.at(1)=='7'||a.at(2)=='7'){
cout<<"Yes";
}else{
cout<<"No";
}
} | #include<bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
string S;
cin >> S;
vector<int> v={0};
for (int i = 0; i < (int)S.size(); i++) {
if (S[i] == 'S') {
v.push_back(0);
} else {
v[(int)v.size()-1]++;
}
}
cout << *max_element(v.begin(), v.end()) << endl;
return 0;
} | 0 |
/**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author champon
*/
#include <iostream>
#include <fstream>
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define inf 9e18
#define ceill(a, b) (a+b-1)/b
#define ok cout << "ok" << endl;
#define sp << " " <<
ll mod = 1e9+7;
void ans(bool b, ostream& out=cout){ out << (b ? "Yes" : "No") << endl; }
void ans2(bool b, ostream& out=cout){ out << (b ? "YES" : "NO") << endl; }
template<typename T> inline bool chmax(T &a, T b){ if(a<b){a=b; return true;} return false; }
template<typename T> inline bool chmin(T &a, T b){ if(b<a){a=b; return true;} return false; }
template<typename A, size_t N, typename T> void Fill(A (&array)[N], const T &val){fill((T*)array, (T*)(array+N), val);}
int dx[] = {1, 0, -1, 0, 1, -1, 1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, -1, 1};
#ifndef INCLUDE_DEBUG_HPP
#define INCLUDE_DEBUG_HPP
class debug
{
public:
template<typename T> void vdeb(T vec);
template<typename T1, typename T2> void adeb(T1 *arr, T2 n);
template<typename T> void mdeb(T mp);
};
#endif //INCLUDE_DEBUG_HPP
template<typename T> void debug::vdeb(T vec)
{
cout << "#vector set debug" << endl;
for(auto vv : vec) cout << vv << " ";
cout << endl;
}
template<typename T1, typename T2> void debug::adeb(T1 *arr, T2 n)
{
cout << "#adebug" << endl;
for(int i=0; i<=n; i++) cout << arr[i] << " ";
cout << endl;
}
template<typename T> void debug::mdeb(T mp)
{
cout << "#map pair debug" << endl;
for(auto const& m : mp) cout << m.first sp m.second << endl;
}
debug dbg;
class BAcrostic {
public:
void solve(std::istream& in, std::ostream& out)
{
string s;
int w;
in >> s >> w;
string res = "";
for(int i=0; i<s.length(); i++){
if(i%w == 0) res += s[i];
}
out << res << endl;
}
};
int main() {
BAcrostic solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define repex(i, a, b, c) for(int i = a; i < b; i += c)
#define repx(i, a, b) repex(i, a, b, 1)
#define rep(i, n) repx(i, 0, n)
#define repr(i, a, b) for(int i = a; i >= b; i--)
#define pb push_back
int main(){
// 1. ๅ
ฅๅๆ
ๅ ฑ.
char c[2020];
int w;
scanf("%s %d", c, &w);
// 2. ๆๅญใ้ฃ็ต.
string ans = "";
int l = strlen(c);
rep(i, l) if(i % w == 0) ans.pb(c[i]);
// 3. ๅบๅ.
printf("%s\n", ans.c_str());
return 0;
} | 1 |
#include<iostream>
#include<string>
using namespace std;
int main()
{
int n;
cin>>n;
while(n){
string action;
int base=0,outCount=0,point=0;
while(outCount!=3){
cin>>action;
if(action=="OUT"){
outCount++;
}
else if(action=="HIT"){
base++;
if(base==4){
point++;
base--;
}
}
else if(action=="HOMERUN"){
point += base+1;
base=0;
}
}
cout<<point<<endl;
n--;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(ll i=0;i<n;++i)
#define RREP(i,n) for(ll i=n-1;i>=0;--i)
#define FOR(i,m,n) for(ll i=m;i<n;++i)
#define RFOR(i,m,n) for(ll i=n-1;i>=m;--i)
#define ALL(v) (v).begin(),v).end()
#define PB(a) push_back(a)
#define MOD 1000000007
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> VI;
typedef vector<VI> VVI;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const int INF = numeric_limits<int>::max() / 2;
const int NEG_INF = numeric_limits<int>::min() / 2;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;cin>>n;
for(int i=0;i<n;i++){
int f=0,s=0,t=0,out=0,point=0;
string st;
while(cin>>st){
if(st=="HIT"){
if(t) point++;
if(s) t=1;
if(f) s=1;
f=1;
}
else if(st=="HOMERUN"){
point+=(f+s+t+1);
f=0;s=0;t=0;
}
else{
out++;
if(out==3){
cout<<point<<endl;
break;
}
}
}
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
typedef long double ld;
const int inf=1e9+7;
const ll longinf=1LL<<60;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
#define F first
#define S second
constexpr char ln = '\n';
const int mx=100010;
const ll mod=1e9+7;
int main(){
int n,t;
cin >> n >> t;
vector<P> a(n);
rep(i,n){
cin >> a[i].F >> a[i].S;
}
sort(a.begin(),a.end());
vector<vector<ll>> dp(3010, vector<ll>(6010,0));
rep(i,n)rep(j,6005){
dp[i+1][j] = dp[i][j];
if(j-a[i].F>=0 && j-a[i].F<t){
dp[i+1][j] = max(dp[i+1][j], dp[i][j-a[i].F] + a[i].S);
}
}
ll ans = 0;
rep(i,6005){
ans = max(ans, dp[n][i]);
}
cout << ans << ln;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
ios::sync_with_stdio(false);
cin.tie();
int n, m;
cin>>n>>m;
if(n == 0 || m == 0){
cout<<"0 0";
return 0;
}
bool accepted[n];
unordered_map<int, int> ma;
for(int i = 0; i < n; i++){
accepted[i] = false;
}
for(int i = 0; i < m; i++){
int p; string s;
cin>>p>>s;
p-=1;
if(s == "AC"){
accepted[p] = true;
}else{
if(!accepted[p]){
if(ma.find(p) == ma.end()){
ma[p] = 1;
}else
{
ma[p]++;
}
}
}
}
int correct = 0, penalties = 0;
for(int i = 0; i < n; i++){
if(accepted[i]){
correct++;
penalties += ma[i];
}
}
cout<<correct<<" "<<penalties;
return 0;
} | 0 |
#include <stdio.h>
#include<bits/stdc++.h>
using namespace std;
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
#define mx 1000008
#define pii pair<int,int>
#define pi acos(-1.0)
#define pb push_back
#define ss second
#define ff first
typedef long long int ll;
///adjacent move
int fx[4]={0,+1,0,-1};
int fy[4]={+1,0,-1,0};
///knight
ll prime[mx];
void seive()
{
for(int i=2;i<mx;i+=2) prime[i]=2;
for(int i=3;i<mx;i+=2) prime[i]=i;
ll sq=sqrt(mx);
for(int i=3;i<=sq;i+=2){
if(prime[i]==i){
for(int j=i*i;j<mx;j+=i){
if(prime[j]==j) prime[j]=i;
}
}
}
}
int a[1000004];
ll f[2000004];
ll po[2000004];
int main()
{
//seive();
int t=1;
//cin>>t;
int c=0;
vector<ll>vec;
for(int i=2;i<mx;i++){
if(prime[i]==i){
vec.push_back(i);
}
}
while(t--){
ll n,m;
cin>>n;
ll a[n*2+7];
for(int i=1;i<=2*n;i++) cin>>a[i];
ll sum=0;
sort(a+1,a+2*n+1);
for(int i=1;i<=2*n;i++){
if(i&1) sum+=a[i];
}
cout<<sum<<endl;
}
}
| /*MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWO:,'..'xXWWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMO. .:kOo.,kNMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMO. .lNWWo..lXMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
MNOxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxMMMMWKxoloxKWNc .:xxd; ,dxxxkXMXkxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxMM
MKc''''''''''''''''. ..'''''. .''''. .''MMMWx..,:. .xXo''. .''. ..'';kMk;'''''. .'.''. .''''''. ..''. .''MM
MWNXNNNNNNNNNNNNNNNO' ;KNNNNNKo. cKNNNd. lXNMMMK; ,0Wx. :NWXXl .dNNO' ;KNNNWMWNNNNNXc .kNNNNx. cXNNNNNO' ;KNN0; 'ONNMM
MMMMMMMMMMMMMMMMMWM0' :NMMMMWMX: .OMWWx. oWMMMMWx. ';. .dNMWWo .xMM0' :NWWMMMMMMMMWWl .OMMMWk. lWWMMWM0' ;XMMX: ,KMMMM
MMMMMMWMWkccccccccc;. :NMWNNNKd. :XMMWx. oWMMMWKo. .',. .,ldx; .dMM0' :NMMMMMMMNNWMWl .OMMMWk. lWMMMMM0' ;XMMX: ,0MMMM
MMWXKNWMWxcc,. .;cc;. :XMk,''..'lKWMMWx. oWMNx:. .lONNKxl. .xMM0' :NMMMMMM0:,oKO' ,KMMMMk. lWWNkoc,. .;::;. ,KMMMM
MMXc.lXMMWWWNd..xWM0' :NM0; ;kXWMMMWNl oWMK:.;xXWWMWXx:. ,c' .dMM0' :NMMMMMMKc. ...;kWMMMMk. lWWc .:;. .clc:. ,KMMMM
MWWx. lXMWMMMK, lWM0' :NMMNx'.,ldxxoc' oWMWNKNWWWN0o' .:kNWo .dMM0' :NMMMMMMMNO; ,OWWWMMMk. lWM' lXx. lNMMX: ,KMMMM
MMMWk'.,xKNX0c..kWM0' :NMMMMNkl;,'',:l: oWMMMMMWMWO' 'l0WMWWo .xMM0' :NMMMMMMMMMNd. .oXWMMMk. lWMd.....;0WMMX: ,KMMMM
MMMMWKo'...'..:kWMM0' :NMMMMMMMWWNNWWWx. oWMMMMMMMMWOxXWMWMWWo .xMM0' :NMMMMMMMMMMMKl. ,kNMMk. lWMWKkxx0NMWMMX: ,KMMMM
MMMMMMMN0kxk0XNWMMWKl;xNMMMMMMMMMMMMWM0c;kWMMMMMMMMMMMWWMMMMWk;:OMMXl,dNMMMMMMMMMMMMWO; .dNM0c;kWWMMMMMMMMMMMNd,oXMMMM
MMMMMMMMWWMWMMMMMMMMMWWMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMWWMMWWMMWMMMMMMMMMMMMMMNkxKWMMWWMMMMMMMMMMMMMMWMMWMMMMM
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM*/
// Author: Udit "luctivud" Gupta @ (https://www.linkedin.com/in/udit-gupta-1b7863135/) //
#include <bits/stdc++.h>
#pragma GCC optimize "trapv"
using namespace std;
typedef long long int lld;
typedef unsigned long long int llu;
#define TESTCASES() cin >> (T3X0); T353 = T3X0; while(T3X0--)
#define _input(V3C) for(auto &V3C_I7 : (V3C)) cin >> (V3C_I7)
#define mems(A77AY, V4LU) memset((A77AY), (V4LU), sizeof((A77AY)))
#define CH3K(I7, E4, S7) (((S7)<0) ? (I7)>(E4) : (I7)<(E4))
#define for4(I7,S4,E4,S7) for(auto I7=(S4); CH3K(I7,E4,S7); (I7)+=(S7))
void solveEachTest(lld T35TC453N = 1) {
int n; cin >> n;
int k; cin >> k;
vector<bool> arr(10, false);
for4(i, 0, k, 1) {
int temp; cin >> temp;
arr[temp] = true;
}
while (true) {
int temp = n;
bool ok = true;
while (temp) {
if (arr[temp % 10]) {ok = false; break;}
temp /= 10;
}
if (ok) {
break;
}
n++;
}
cout << n;
return;
}
signed main() {
ios_base::sync_with_stdio(false); cin.tie(0);
lld T3X0 = 0, T353 = 1;
// TESTCASES()
solveEachTest(T353 - T3X0);
return 0;
}
// Random Thought : null | 0 |
// #pragma GCC target("avx") // CPU ๅฆ็ไธฆๅๅ
// #pragma GCC optimize("O3") // CPU ๅฆ็ไธฆๅๅ
// #pragma GCC optimize("unroll-loops") // ๆกไปถๅฆ็ใฎๅผใณๅบใใๆธใใ
// #define BEGIN_STACK_EXTEND(size) void * stack_extend_memory_ = malloc(size);void * stack_extend_origin_memory_;char * stack_extend_dummy_memory_ = (char*)alloca((1+(int)(((long long)stack_extend_memory_)&127))*16);*stack_extend_dummy_memory_ = 0;asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp":"=b"(stack_extend_origin_memory_):"a"((char*)stack_extend_memory_+(size)-1024));
// #define END_STACK_EXTEND asm volatile("mov %%rax, %%rsp"::"a"(stack_extend_origin_memory_));free(stack_extend_memory_);
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<deque>
#include<stack>
#include<string>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#include<stdlib.h>
#include<cassert>
#include<time.h>
#include<bitset>
#include<numeric>
#include<unordered_set>
#include<unordered_map>
#include<complex>
using namespace std;
const long long mod=998244353;
const long long inf=mod*mod;
const long long d2=(mod+1)/2;
const long double EPS=1e-9;
const long double INF=1e+10;
const long double PI=acos(-1.0);
const int C_SIZE = 3100000;
const int UF_SIZE = 3100000;
namespace{
long long fact[C_SIZE];
long long finv[C_SIZE];
long long inv[C_SIZE];
long long Comb(int a,int b){
if(a<b||b<0)return 0;
return fact[a]*finv[b]%mod*finv[a-b]%mod;
}
void init_C(int n){
fact[0]=finv[0]=inv[1]=1;
for(int i=2;i<n;i++){
inv[i]=(mod-(mod/i)*inv[mod%i]%mod)%mod;
}
for(int i=1;i<n;i++){
fact[i]=fact[i-1]*i%mod;
finv[i]=finv[i-1]*inv[i]%mod;
}
}
long long pw(long long a,long long b){
if(a<0LL)return 0;
if(b<0LL)return 0;
long long ret=1;
while(b){
if(b%2)ret=ret*a%mod;
a=a*a%mod;
b/=2;
}
return ret;
}
long long pw_mod(long long a,long long b,long long M){
if(a<0LL)return 0;
if(b<0LL)return 0;
long long ret=1;
while(b){
if(b%2)ret=ret*a%M;
a=a*a%M;
b/=2;
}
return ret;
}
int pw_mod_int(int a,int b,int M){
if(a<0)return 0;
if(b<0)return 0;
int ret=1;
while(b){
if(b%2)ret=(long long)ret*a%M;
a=(long long)a*a%M;
b/=2;
}
return ret;
}
int ABS(int a){return max(a,-a);}
long long ABS(long long a){return max(a,-a);}
double ABS(double a){return max(a,-a);}
int sig(double r) { return (r < -EPS) ? -1 : (r > +EPS) ? +1 : 0; }
int UF[UF_SIZE];
void init_UF(int n){
for(int i=0;i<n;i++)UF[i]=-1;
}
int FIND(int a){
if(UF[a]<0)return a;
return UF[a]=FIND(UF[a]);
}
void UNION(int a,int b){
a=FIND(a);b=FIND(b);if(a==b)return;
if(UF[a]>UF[b])swap(a,b);
UF[a]+=UF[b];UF[b]=a;
}
}
// ใใใใ็ทจ้ใใ
int main(){
int a,b;scanf("%d%d",&a,&b);
if(a>b)swap(a,b);
init_C(1100000);
long long ret=0;
long long cur=Comb(a+b-1,b-1);
long long S=0;
for(int i=1;i<=a+b;i++){
S=(S+cur)%mod;
ret=(ret+S*inv[i])%mod;
if(i%2){
if(a-(i+1)/2>=0)cur=(cur+mod-Comb(a-(i+1)/2+b-(i+1)/2,a-(i+1)/2)*Comb((i+1)/2+(i+1)/2-2,(i+1)/2-1)%mod)%mod;
}else{
cur=(cur+Comb(a-i/2+b-i/2-1,a-i/2)*Comb(i/2+i/2-1,i/2))%mod;
}
// printf("%d: %lld %lld %lld\n",i,S,ret,cur);
}
// printf("%lld\n",ret*12%mod);
cur=Comb(a+b-1,a-1);
S=0;
for(int i=1;i<=a+b;i++){
S=(S+cur)%mod;
ret=(ret+S*inv[i])%mod;
if(i%2){
if(b-(i+1)/2>=0)cur=(cur+mod-Comb(a-(i+1)/2+b-(i+1)/2,b-(i+1)/2)*Comb((i+1)/2+(i+1)/2-2,(i+1)/2-1)%mod)%mod;
}else{
cur=(cur+Comb(b-i/2+a-i/2-1,b-i/2)*Comb(i/2+i/2-1,i/2))%mod;
}
}
ret=ret*fact[a]%mod*fact[b]%mod*finv[a+b]%mod;
printf("%lld\n",ret);
} | #include <iostream>
#include <utility>
#include <map>
#include <vector>
#include <algorithm>
#include <queue>
#include <math.h>
#include <stack>
#include <set>
#include <deque>
#include <cmath>
using namespace std;
typedef long long ll;
ll mod = 1e9+7;
#define rep(i,n) for(int i = 0; i < (n); ++i)
int main(){
ll n;
ll m;
cin >> n >> m;
vector<ll> a(n);
rep(i, n) cin >> a[i];
vector<ll> sum(n+1);
sum[0] = 0;
map<ll, ll> mp;
mp[0] = 1;
rep(i, n) {
sum[i+1] = (sum[i]+a[i]) % m;
++mp[sum[i+1]];
}
ll ans = 0;
for ( auto p : mp ) {
ans += p.second * (p.second - 1 ) / 2;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <iostream>
#include <algorithm>
#include <vector>
int main(){
int n,m;
while(std::cin >> n >> m){
if(n == 0 && m == 0) return 0;
std::vector<int> a(n);
for(int i = 0; i < n; ++i){
std::cin >> a[i];
}
std::sort(a.begin(), a.end(), std::greater<int>());//้้
int cost = 0;
for(int i = 0; i < n; ++i){
if((i+1) % m != 0) cost += a[i];//mใฎๅๆฐ็ช็ฎใซ้ซใ้่ใ็กๆใซใใ
}
std::cout << cost << std::endl;
}
}
| #include<iostream>
#include<string>
#include<vector>
#include<algorithm>
int main() {
int n, k;
std::cin >> n >> k;
std::vector<int> a(n);
for (int i = 0; i < n; i++)
{
std::cin >> a[i];
}
std::sort(a.begin(), a.end(), std::greater<int>());
int ans = 0;
for (int i = 0; i < k; i++)
{
ans += a[i];
}
std::cout << ans << "\n";
} | 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 = (int)(n - 1); i >= 0; i--)
#define all(x) (x).begin(), (x).end()
#define sz(x) int(x.size())
#define get_unique(x) x.erase(unique(all(x)), x.end());
typedef long long ll;
typedef complex<double> Complex;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
const ll LINF = 1e18;
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;
}
template <class T>
vector<T> make_vec(size_t a) {
return vector<T>(a);
}
template <class T, class... Ts>
auto make_vec(size_t a, Ts... ts) {
return vector<decltype(make_vec<T>(ts...))>(a, make_vec<T>(ts...));
}
bool dfs(int now, int pre, vector<int> &d, vector<vector<int>> &g) {
if (now) d[now] = d[pre] + 1;
bool ret = false;
for (int nxt : g[now]) {
if (d[nxt] != -1) {
if (d[nxt] % 2 != d[now] % 2)
continue;
else
return true;
}
ret |= dfs(nxt, now, d, g);
}
return ret;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> g(n);
rep(i, m) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_back(b);
g[b].push_back(a);
}
vector<int> d(n, -1);
d[0] = 0;
if (dfs(0, -1, d, g)) {
cout << (ll)n * (n - 1) / 2 - (ll)m << endl;
return 0;
}
ll odd = 0, even = 0;
rep(i, n) {
(d[i] % 2 == 0 ? even : odd)++;
}
cout << odd * even - (ll)m << endl;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using PII = pair<int, int>;
using VI = vector<int>;
const int N = 1e5 + 10;
VI adj[N];
int col[N];
bool bip = true;
int f[3];
void dfs(int u, int c) {
if (col[u] != 0) {
if (c != col[u]) bip = false;
return;
}
col[u] = c;
f[c]++;
for (int v: adj[u]) {
dfs(v, 3 - c);
}
}
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
int n; cin >> n;
int m; cin >> m;
for (int i = 0; i < m; i++) {
int u, v; cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 1);
ll ans = 0;
if (!bip) {
ans = (n * 1ll * (n - 1)) / 2 - m;
} else {
ans = f[1] * 1ll * f[2] - m;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int main() {
int x, y;
cin >> x >> y;
vector<int> m(206, 0);
m[0] = 300000;
m[1] = 200000;
m[2] = 100000;
cout << m[x - 1] + m[y - 1] + (x == 1 && y == 1 ? 400000 : 0) << endl;
return 0;
} | #define _GLIBCXX_DEBUG
#include<bits/stdc++.h>
using namespace std;
typedef long long int lli;
typedef unsigned long long int ulli;
#define vec(s) vector<s>
#define vvec(s) vector<vector<s>>
typedef vector<lli> vi;
typedef vector<vi> vvi;
typedef pair<lli,lli> pii;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define Yes(x) cout<<(x?"Yes":"No")<<endl;
#define YES(x) cout<<(x?"YES":"NO")<<endl;
#define out(s) cout<<s<<endl;
#define pb(s) push_back(s);
#define sp " "
#define INF 10000000000
#define LINF 9000000000000000000
#define all(s) s.begin(),s.end()
void vout(vi v){
for(lli i=0;i<v.size();i++)
cout<<v.at(i)<<endl;
}
int main(){
lli x;
lli y;
cin>>x>>y;
lli ans=0;
lli pre=400000-x*100000;
if(pre>0){
ans+=pre;
}
pre=400000-y*100000;
if(pre>0){
ans+=pre;
}
if(y==1&&x==1){
ans+=400000;
}
out(ans);
} | 1 |
/********************************************************
**โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ**
**โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ**
**โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ**
**โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ**
**โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ**
**โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ**
*********************************************************/
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define forn(i,n) for(int i=0;i<n;++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(),v.rend();
#define isSubstring(s1,s2) s1.find(s2) != std::string::npos
#define pb push_back
#define pf push_front
#define mp make_pair
#define fr first
#define sc second
#define vpi <vector<pair<int,int>>
#define vi vector<int>
#define sz(a) (int)a.size()
#define endl "\n"
#define nl cout<<"\n";
#define fastio ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define MN INT_MIN
#define MX INT_MAX
bool isPrime(ll n){if(n<2)return false;for(ll x = 2;x*x <=n;x++){if(n%x == 0)return false;}return true;}
bool isPerfectSquare(long double x){long double sr=sqrt(x);return((sr-floor(sr))==0);}
int gcd(int a, int b){if(a==0)return b;if(b==0) return a;if(a==b)return a;if(a>b)return gcd(a-b,b);return gcd(a,b-a);}
int32_t main()
{
map<string,int> m;
m["SUN"] = 7;
m["MON"] = 6;
m["TUE"] = 5;
m["WED"] = 4;
m["THU"] = 3;
m["FRI"] = 2;
m["SAT"] = 1;
string s;
cin >> s;
cout << m[s] << endl;
}
| #include "bits/stdc++.h"
using namespace std;
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef long long ll;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(a) (a).begin(),(a).end()
#define pb push_back
int main(){
int n;
cin>>n;
rep(loop,n){
int rui[5]={};
string s;
int o=0;
int p=0;
while(cin>>s){
if(s=="HIT"){
if(rui[3]==1)p++;
rui[3]=rui[2];
rui[2]=rui[1];
rui[1]=1;
}
if(s=="OUT"){
o++;
if(o>=3)break;
}
if(s=="HOMERUN"){
p+=1+rui[3]+rui[2]+rui[1];
rui[3]=0;
rui[2]=0;
rui[1]=0;
}
}
cout<<p<<endl;
}
} | 0 |
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
template <class Type> Type GCD(Type a, Type b)
{
if (a % b == 0) { return b; }
if (b % a == 0) { return a; }
if (a > b) { return GCD(b, a % b); }
if (a < b) { return GCD(a, b % a); }
return (Type)(-1);
}
template <class Type> Type GCD(vector<Type> v)
{
Type ret = v[0];
for (int i = 1; i < v.size(); i++)
{
ret = GCD(ret, v[i]);
}
return ret;
}
template <class Type> vector<Type> Divisors(Type n)
{
vector<int> c;
for (Type i = 1; i * i <= n; i++)
{
if (n % i == 0) { c.push_back(i); if (i * i != n) { c.push_back(n / i); } }
}
sort(c.begin(), c.end());
return c;
}
int main()
{
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++)
{
cin >> v[i];
}
vector<int> c = Divisors(GCD(v));
for (int i = 0; i < c.size(); i++)
{
cout << c[i] << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(int)(n); i++)
#define REP(i,m,n) for(ll i=(ll)(m);i<(ll)(n);i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
ll n; cin >> n;
vector<ll> t(5);
rep(i,5) cin >> t[i];
ll bn = *min_element(t.begin(),t.end());
ll ans = 5;
if (n>bn) {
ans = n/bn + 4;
if (n > (n/bn) * bn) ans++;
}
cout << ans << endl;
return 0;
} | 0 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <math.h>
#include <cmath>
#include <ctime>
#include <stdlib.h>
using namespace std;
#define int long long
#define endl "\n"
#define all(v) v.begin(),v.end()
#define fir first
#define sec second
#define m_p make_pair
#define m_t make_tuple
#define rep(i,n) for(int i=0; i<(int) (n); i++)
typedef pair<int, int> P;
const double pai = 3.1415926535897;
const int mod = 1000000007;
const int INF = 1000000021;
const int MAX = 510000;
const int MOD = 1000000007;
long long fac[MAX], finv[MAX], inv[MAX];
//xๆชๆบใฎ่ฆ็ด ๆฐใ่ฟใไบๅๆข็ดข้ขๆฐ
int b_s(vector<int>& vec, int xx) {
return lower_bound(all(vec), xx) - vec.begin();
}
template<typename T>void vecout(vector<T>& vec) { for (T t : vec) cout << t << " "; cout << endl; }
template<typename TT>void vecin(vector<TT>& vec) {
for (int i = 0; i < vec.size(); i++) {
cin >> vec[i];
}
}
// ใใผใใซใไฝใๅๅฆ็
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
//nๅใ1ๅไปฅไธใฎx็ตใฎใฐใซใผใใซๅใใ้่ค็ตใฟๅใใใฏcom(n-1,x-1)
long long COM(int n, int k) {
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
long long modpow(int a, int n) {
int res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
bool chmax(int& xx, int yy) {
if (xx < yy) {
xx = yy;
return true;
}
return false;
}
bool chmin(int& xx, int yy) {
if (xx > yy) {
xx = yy;
return true;
}
return false;
}
int gcd(int xx, int yy) {
int p = xx;
int q = yy;
if (q > p)swap(p, q);
while (p % q != 0) {
p %= q;
swap(p, q);
}
return q;
}
int lcm(int xx, int yy) {
return xx * yy / gcd(xx, yy);
}
bool prime(int xx) {
if (xx <= 1) {
return 0;
}
for (int i = 2; i * i <= xx; i++) {
if (xx % i == 0) {
return 0;
}
}
return 1;
}
signed main() {
int n, y,a,b,c;
cin >> n >> y;
for (int i = 0; i <= y / 10000; i++) {
for (int j = 0; j <= (y - i * 10000) / 5000; j++) {
int a = (y - i * 10000 - j * 5000) / 1000;
if (a + i + j == n) {
cout << i << " " << j << " " << a << endl;
return 0;
}
}
}
cout << "-1 -1 -1" << endl;
} | #pragma GCC target ("avx2")
#pragma GCC optimize ("unroll-loops")
#pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include <unordered_set>
#include <unordered_map>
#include <random>
using namespace std;
typedef long long ll;
const ll MOD = 1'000'000'007LL; /*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)++)
const int dx[4]={ 1,0,-1,0 };
const int dy[4]={ 0,1,0,-1 };
template<typename T>
T power(T x, long long n){
if(n == 0) return 1;
if(n == 1) return x;
T tmp = power(x, n/2);
if(n%2 == 0) return tmp * tmp;
else return tmp * tmp * x;
}
ll N, M, D;
double ans = 0;
double f(double N, double D){
if(D == 0) return N;
else return (N-D)*2;
}
signed main(){
cin >> N >> M >> D;
ans = (double)(M-1)*f(N,D)/N/N;
cout << fixed << setprecision(16) << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
bool ok = false;
char c;
for (c = 'a' ; c <= 'z'; c++ ) {
ok = false;
for (int i = 0; i < S.size(); i++) {
if(S.at(i) == c){
ok = true;
break;
}
}
if(ok == false){
break;
}
}
if(ok == false){
cout << c << endl;
}else {
cout << "None" << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main(void){
vector<int>X(26,0);
string S;cin>>S;
for(long long i=0;i<S.size();i++){
X[(int)S[i]-97]++;
}
for(long long i=0;i<26;i++){
if(X[i]==0){
int ans=i+97;
cout<<(char)ans<<endl;
return 0;
}
}
cout<<"None"<<endl;
return 0;
} | 1 |
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <stack>
#include <queue>
#include <map>
#include <algorithm>
#include <iomanip>
#include <math.h>
#include <string.h>
#include <cstdio>
#include <tuple>
#include <numeric>
using namespace std; using ll = long long; using ld = long double; using pll = pair<ll, ll>;
using vl = vector<ll>; using vll = vector<vl>; using vpll = vector<pll>;
using vs = vector<string>; using tll = tuple<ll, ll, ll>; using vtll = vector<tll>;
const ld PI = 3.1415926535897932;
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#define rep1(n) for(ll i=0;i<n;++i)
#define rep2(i,n) for(ll i=0;i<n;++i)
#define rep3(i,a,b) for(ll i=a;i<b;++i)
#define rep4(i,a,b,c) for(ll i=a;i<b;i+=c)
#define rep(...) overload4(__VA_ARGS__,rep4,rep3,rep2,rep1)(__VA_ARGS__)
#define mp make_pair
#define mt make_tuple
void in() {}
void debug_out() { cerr << endl; }
template<typename Head, typename... Tail>
void debug_out(Head h, Tail... t) {
cerr << " " << h;
if (sizeof...(t) > 0) cerr << " :";
debug_out(t...);
}
template <typename T>
ostream& operator<<(ostream& os, vector<T> vec) {
for (size_t i = 0; i < vec.size(); i++)os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
ll ctoi(char c) {
switch (c) {
case '0': return 0; case '1': return 1; case '2': return 2;
case '3': return 3; case '4': return 4; case '5': return 5;
case '6': return 6; case '7': return 7; case '8': return 8;
case '9': return 9; default: return 0;
}
}
bool pairCompare(const pll firstElof, pll secondElof)
{
return firstElof.first > secondElof.first;
}
//**Snippetใชในใ**//
//rep, vin, all, iteLoop, bitSearch, bitList, nod//
//gcdlcm, isPrime, eratos, primeFactorize, Npow, combination, divisor, modinv, digitDP//
//dfs, bfs, dijkstra, WarshallFloyd, BellmanFord, UnionFind, Kruskal ,RMQ, LCA//
ll i, j, k, l; ll N, M, K, H, W, L, X, Y, Z, R, Q;
ll MOD = 1000000007; ll INF = 1LL << 60; ll ans = 0; ll z = 0, o = 1;
vl flag; vll path; vll D;
//***********//
ll binarySearch(vl V, ll key) {
ll left = -1; //ใindex = 0ใใๆกไปถใๆบใใใใจใใใใฎใงใๅๆๅคใฏ -1
ll right = V.size(); // ใindex = a.size()-1ใใๆกไปถใๆบใใใชใใใจใใใใฎใงใๅๆๅคใฏ V.size()
while (right - left > 1) {
ll mid = left + (right - left) / 2;
if (V[mid] >= key) right = mid;
else left = mid;
}
/* left ใฏๆกไปถใๆบใใใชใๆๅคงใฎๅคใright ใฏๆกไปถใๆบใใๆๅฐใฎๅคใซใชใฃใฆใใ */
return right;
}
int main() {
ll V, P;
cin >> N >> M >> V >> P;
vl A(N);
for (i = 0; i < N; i++) {
cin >> A[i];
}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
ll left = -1;
ll right = N;
while(right-left>1) {
ll mid = left + (right - left) / 2;
ll valid = 1;
if (mid < P) valid = 1;
else {
if (A[mid] + M >= A[P - 1]) {
ll pre = M * P;
for (j = P-1; j < N; j++) {
if (j == mid) continue;
pre += min(M, A[mid] + M - A[j]);
}
if (pre >= M * V) valid = 1;
else valid = 0;
}
else {
valid = 0;
}
}
if (valid) left = mid;
else right = mid;
}
cout << left + 1;
} |
#include <bits/stdc++.h>
using namespace std;
/* g++ -g -fsanitize=address -lasan -std=c++11 -Dfoo_ */
/* freopen("input.txt", "rt", stdin); */
/* freopen("output.txt", "wt", stdout); */
#define ALL(c) (c).begin(), (c).end()
#define ALLR(c) (c).rbegin(), (c).rend()
#define FOR(i,a,b) for (int i=(a); i < (b); ++i)
#define FORR(i,a,b) for (int i=(a); i > (b); --i)
#define FOR_ALL(i,c) for (__typeof((c).begin()) i=(c).begin(); \
i != (c).end(); ++i)
#define FOR_ALLR(i,c) for (__typeof((c).rbegin()) i=(c).rbegin(); \
i != (c).rend(); ++i)
#define SZ(array) (sizeof(array)/sizeof(array[0]))
#define lc(x) (x<<1) /* 2*x */
#define rc(x) (x<<1 | 1) /* 2*x+1 */
#define lowbit(x) (x & (-x)) /* 0b10100 -> 0b100 */
typedef long long LL;
typedef map<int,int> MII;
typedef pair<int,int> PII;
typedef set<int> SI;
typedef vector<bool> VB;
typedef vector<double> VD;
typedef vector<int> VI;
typedef vector<string> VS;
/* check if a key is in container C */
template <class C>
inline bool in_(const typename C::key_type& k, const C& A)
{ return A.find(k) != A.end(); }
inline bool in_(const string& s, const string& S)
{ return S.find(s) != string::npos; }
int n,m,v,p;
vector<LL> A;
bool P(const int i, int v)
{
if (n-i <= p)
return true;
/* everyone pick i */
const LL x = A[i]+m;
/*
* We need i to be in the top p, so everyone can pick any of the
* top p-1 w/o effecting i.
*/
int j = n - min(p,v);
if (x < A[n-p])
return false;
v -= n-(j+1)+1; /* the top ones can't effect i */
v -= i; /* anyone before i can't catch i */
if (v > 0) {
/*
* m people, each select v number of problems. We need to
* distribute the selection in a box such that max in the
* box not exceed x.
*/
while (A[j] > x)
j--;
const int y = j-i; /* box width */
LL vol = x*y; /* box volume */
FOR(k,i+1,j+1)
vol -= A[k];
return vol >= 1LL * v*m;
}
return true;
}
int main()
{
#ifdef foo_
freopen("foo", "rt", stdin);
#endif
ios::sync_with_stdio(false);
while (cin >> n >> m >> v >> p) {
A.resize(n);
FOR(i,0,n)
cin >> A[i];
sort(ALL(A));
int lo = 0, hi = n-1;
while (lo < hi) {
const int mid = (lo+hi)/2;
if (P(mid,v))
hi = mid;
else
lo = mid+1;
}
cout << n-lo << endl;
}
return 0;
}
| 1 |
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int A, B, C, D;
int main(int argc, char* argv[]) {
cin >> A >> B >> C >> D;
int L = A + B;
int R = C + D;
if (L > R)
cout << "Left" << endl;
else if (L == R)
cout << "Balanced" << endl;
else
cout << "Right" << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
const int Inf = 10000 * 100000 + 100;
int main(){
int V,E,R;
cin >> V >> E >> R;
vector<int> s(E),t(E),d(E);
for(int i = 0; i < E; i++)
cin >> s[i] >> t[i] >> d[i];
vector<int> cost(V, Inf);
cost[R] = 0;
for(int p = 0; p < V; p++){
bool update = false;
for(int i = 0; i < E; i++){
int ns = s[i], nt = t[i], nd = d[i];
if(cost[ns] < Inf && cost[ns] + nd < cost[nt]){
update = true;
cost[nt] = cost[ns] + nd;
}
}
if(!update) break;
}
for(int i = 0; i < V; i++){
if(cost[i] == Inf)
cout << "INF";
else
cout << cost[i];
cout << endl;
}
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
//read_kaisetsu
int main() {
string s;cin>>s;
ll n = s.size();
ll ans = n*(n-1)/2 + 1;
ll a[27];rep(i,27)a[i]=0;
// memset(a,0,sizeof(a));
rep(i,n){
ll tmp = s[i]-'a';
// cout<<tmp<<endl;
++a[tmp];
}
rep(i,27)if(a[i]>=2)ans-=a[i]*(a[i]-1)/2;
cout<<ans<<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=1;i<(n);++i)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int inf = 0x7ffffff;
const int mod = 1000000007;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int ans = n / 3;
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define vec(x) vector<x>
#define pb push_back
#define pii pair<ll,ll>
#define vi vector<ll>
#define vii vector<pair<ll,ll>>
#define matrix(x) vector<vector<x>>
#define all(v) v.begin(),v.end()
#define mem(a,b) memset(a, b, sizeof a)
#define ff first
#define ss second
#define mp make_pair
const int INF = 1e9;
const int MOD = 1e9 + 7;
int main()
{
ll t;
cin>>t;
ll a[t];
for(ll i=0;i<t;i++)
{
cin>>a[i];
}
sort(a,a+t);
ll x=a[t-1];
ll cont=0;
ll s=0;
ll res=1;
for(ll i=t-1;i>=0;i--)
{
if(x==a[i])
{
cont++;
}
else
{
cont=1;
x=a[i];
}
if(cont==2)
{
s=s+1;
cont=0;
res=res*x;
x=a[i-1];
}
if(s==2)
break;
}
if(s>=2)
cout<<res<<endl;
else
cout<<0<<endl;
}
| #include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#include <cmath>
#include <bitset>
#include <iomanip>
#include <stack>
#include <list>
#include <map>
#include <unordered_map>
#include <chrono>
#include <numeric>
using namespace std;
using ll = long long;
const ll INF = (ll)1e18+1;
const ll DIV = 1000000007;
//#define TEST
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
#ifdef TEST
chrono::system_clock::time_point start, end;
start = chrono::system_clock::now();
#endif
long N;
cin >> N;
map<long, long> A;
for(size_t i=0;i<N; i++)
{
long a;
cin >> a;
A[a]++;
}
ll max_area = 0;
ll first_edge=0,second_edge =0;
for(auto a:A)
{
if(a.second >=2)
{
if(first_edge == 0) first_edge = a.first;
if(a.second >= 4)
{
first_edge = a.first;
second_edge = a.first;
}else
{
first_edge = second_edge;
second_edge = a.first;
}
}
if(first_edge != 0 && second_edge != 0) max_area = max(max_area, first_edge * second_edge);
}
cout << max_area << endl;
#ifdef TEST
end = chrono::system_clock::now();
cerr << static_cast<double>(chrono::duration_cast<chrono::microseconds>(end - start).count() / 1000.0) << "[ms]" << endl;
#endif
return 0;
} | 1 |
#include<iostream>
using namespace std;
#include<vector>
#include<functional>
template<typename T>
struct lazysegtree{
function<T(T,T)>calcfn,lazycalcfn;
function<T(T,T,unsigned int)>updatefn;
int n;
T defvalue,lazydefvalue;
vector<T>dat,lazy;
vector<bool>lazyflag;
lazysegtree(int n_=0,T defvalue_=0,
function<T(T,T)>calcfn_=[](T a,T b){return a+b;},
function<T(T,T)>lazycalcfn_=[](T a,T b){return a+b;},
function<T(T,T,unsigned int)>updatefn_=[](T a,T b,unsigned int width){return a+b*width;},
T lazydefvalue_=0
):defvalue(defvalue_),lazydefvalue(lazydefvalue_),
calcfn(calcfn_),lazycalcfn(lazycalcfn_),updatefn(updatefn_)
{
n=1;
while(n<n_)n<<=1;
dat.assign(2*n-1,defvalue);
lazy.assign(2*n-1,lazydefvalue);
lazyflag.assign(2*n-1,false);
}
void copy(vector<T>v)
{
for(int i=0;i<v.size();i++)dat[i+n-1]=v[i];
for(int i=n-2;i>=0;i--)dat[i]=calcfn(dat[2*i+1],dat[2*i+2]);
}
void eval(int i,int l,int r)
{
if(lazyflag[i])
{
dat[i]=updatefn(dat[i],lazy[i],r-l);
if(r-l>1)
{
lazy[2*i+1]=lazycalcfn(lazy[2*i+1],lazy[i]);
lazy[2*i+2]=lazycalcfn(lazy[2*i+2],lazy[i]);
lazyflag[2*i+1]=lazyflag[2*i+2]=true;
}
lazy[i]=lazydefvalue;
lazyflag[i]=false;
}
}
void update(int a,int b,T x,int k=0,int l=0,int r=-1)
{
if(r<0)r=n;
eval(k,l,r);
if(b<=l||r<=a)return;
else if(a<=l&&r<=b)
{
lazy[k]=lazycalcfn(lazy[k],x);
lazyflag[k]=true;
eval(k,l,r);
}
else
{
update(a,b,x,2*k+1,l,(l+r)/2);
update(a,b,x,2*k+2,(l+r)/2,r);
dat[k]=calcfn(dat[2*k+1],dat[2*k+2]);
}
}
T query(int a,int b,int k=0,int l=0,int r=-1)
{
if(r<0)r=n;
eval(k,l,r);
if(b<=l||r<=a)return defvalue;
else if(a<=l&&r<=b)return dat[k];
else return calcfn(
query(a,b,2*k+1,l,(l+r)/2),
query(a,b,2*k+2,(l+r)/2,r)
);
}
};
main()
{
int n,q;cin>>n>>q;
lazysegtree<int>S(n,2147483647,[](int a,int b){return a==2147483647?b:a;},[](int a,int b){return b;},[](int a,int b,unsigned int c){return b;});
for(int i=0;i<q;i++)
{
int c;cin>>c;
if(c)
{
int s;cin>>s;
cout<<S.query(s,s+1)<<endl;
}
else
{
int s,t,x;cin>>s>>t>>x;
S.update(s,t+1,x);
}
}
}
| #include <bits/stdc++.h>
using namespace std;
const int MAXN = 1400010;
inline int read()
{
int a = 0, f = 1; char c = getchar();
while(c > '9' || c < '0') { if(c == '-') f = -1; c = getchar(); }
while(c >= '0' && c <= '9') { a = a * 10 + c - '0'; c = getchar(); }
return a * f;
}
int n, m;
int a[MAXN], pre[MAXN], Ans[MAXN];
struct node
{
int l, r, id;
}ask[MAXN];
inline bool cmp(const node &a, const node &b)
{
return a.r < b.r;
}
int c[MAXN];
inline int lowbit(int x)
{
return x & (-x);
}
inline void add(int x, int dt)
{
while(x <= 1000000)
{
c[x] += dt;
x += lowbit(x);
}
}
inline int sum(int x)
{
int ans = 0;
while(x)
{
ans += c[x];
x -= lowbit(x);
}
return ans;
}
int main()
{
n = read(); m = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= m; i++) ask[i].l = read(), ask[i].r = read(), ask[i].id = i;
sort(ask + 1, ask + m + 1, cmp);
int nr = 0;
for (int i = 1; i <= m; i++)
{
while(nr < ask[i].r)
{
nr++;
if(pre[a[nr]]) add(pre[a[nr]], -1);
pre[a[nr]] = nr;
add(nr, 1);
}
Ans[ask[i].id] = sum(nr) - sum(ask[i].l - 1);
}
for (int i = 1; i <= m; i++)
printf("%d\n", Ans[i]);
return 0;
} | 0 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <cmath>
#include <map>
#include <iomanip>
#define intt long long
int main() {
intt N; std::cin >> N;
std::map<std::string, int> MAP;
std::vector<std::string> s(N);
for (auto& r : s) {
std::cin >> r;
++MAP[r];
}
intt M; std::cin >> M;
std::vector<std::string> t(M);
for (auto& r : t) {
std::cin >> r;
--MAP[r];
}
int max = -201;
for (auto& r : MAP)
max = std::max(max, r.second);
std::cout << std::max(max, 0) << std::endl;
}
| #include <stdio.h>
#define _USE_MATH_DEFINES
#include <math.h>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int n;
scanf("%d", &n);
vector<int> via(n),vib(n);
for(int i = 0; i < n; i++){
scanf("%d", &via[i]);
}
for(int i = 0; i < n; i++){
scanf("%d", &vib[n-i-1]);
}
int k = -1;
int kCount = 0;
for(int i = 0; i < n; i++){
if(via[i] == vib[i]){
k = via[i];
kCount++;
}
}
if(kCount > 0){
int iaNotEqual_k, ibNotEqual_k, iabEqual_k;
for(int i = 0; i < n; i++){
if(via[i] == k){
iaNotEqual_k = i;
break;
}
}
for(int i = 0; i < n; i++){
if(vib[i] == k){
ibNotEqual_k = i;
break;
}
}
for(int i = n - 1; i >= 0; i--){
if(via[i] == vib[i]){
iabEqual_k = i;
iabEqual_k++;
break;
}
}
int iRev = min(iaNotEqual_k + ibNotEqual_k, iabEqual_k);
reverse(vib.begin(), vib.begin()+iRev);
reverse(vib.begin()+iRev, vib.end());
}
for(int i = 0; i < n; i++){
if(via[i] == vib[i]){
printf("No");
return 0;
}
}
printf("Yes\n");
for(int i = 0; i < n; i++){
printf("%d ", vib[i]);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n, m; cin >> n >> m;
vector<int> xt(n+1); cin >> xt[0];
vector<int> yt(m+1); cin >> yt[0];
for (int i=1; i<n+1; i++) cin >> xt.at(i);
for (int i=1; i<m+1; i++) cin >> yt.at(i);
sort(xt.begin(), xt.end());
sort(yt.begin(), yt.end());
if (xt[n] >= yt[0]) {
cout << "War" << endl;
} else {
cout << "No War" << endl;
}
return 0;
} | #include<iostream>
#include<string>
#include<stdio.h>
#include <algorithm>
#include <set>
#include<math.h>
#include<vector>
using namespace std;
int main(){
int N,M,X,Y;cin >> N >> M >> X >> Y;
int x[100]={};
int y[100]={};
int flag = 1;
for(int i = 0;i < N;i++)cin >> x[i];
for(int i = 0;i < M;i++)cin >> y[i];
for(int i = X+1;i <= Y;i++){
flag = 1;
for(int j=0;j < N;j++){
if(x[j] >= i){
flag = 0;
continue;
}
}
if(flag==0)continue;
for(int j = 0;j < M;j++){
if(y[j] < i){
flag = 0;
continue;
}
}
if(flag == 1)break;
}
if(flag == 1)cout << "No War" << endl;
else cout << "War" << endl;
} | 1 |
#include <iostream>
#include <utility>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
#define gcu getchar_unlocked
#define pcu putchar_unlocked
#define _il inline
#define _in _il int in
#define _sc _il bool scan
_in(int c){int n=0;bool m=false;if(c=='-')m=true,c=gcu();
do{n=10*n+(c-'0'),c=gcu();}while(c>='0');return m?-n:n;} //&&c<='9'
_in() {return in(gcu());}
_sc(int &n){int c=gcu();return c==EOF?false:(n=in(c),true);}
_sc(char &c){c=gcu();gcu();return c!=EOF;}
//_sc(string &s){int c;s="";
// for(;;){c=gcu();if(c=='\n'||c==' ')return true;else if(c==EOF)return false;s+=c;}}
template <typename H,typename... T> _sc(H &h, T&&... t){return scan(h)&&scan(t...);}
#define _vo _il void out
#define _vl _il void outl
template <typename T>
_vo(T n){static char buf[20];char *p=buf;
if(n<0)pcu('-'),n*=-1;if(!n)*p++='0';else while(n)*p++=n%10+'0',n/=10;
while (p!=buf)pcu(*--p);}
_vo(const char *s){while(*s)pcu(*s++);}
_vo(char c){pcu(c);}
//_vo(string &s){for (char c: s) pcu(c);}
template <typename H,typename... T> _vo(H&& h, T&&... t){out(h);out(move(t)...);}
//template <typename T> _vo(vector<T> &v){for(T &x:v)out(&x == &v[0]?"":" "),out(x);out('\n');}
_vl(){out('\n');}
template <typename... T> _vl(T&&... t){out(move(t)...);outl();}
template<int N>
struct sieve {
bool s[N];
constexpr sieve() : s() {
for (int i = 0; i < N; i++)
s[i] = true;
for (int i = 4; i < N; i += 2)
s[i] = false;
for (int i = 9; i < N; i += 6)
s[i] = false;
for (int i = 6, e = sqrt(N); i <= e; i += 6) {
for (int j : {i - 1, i + 1})
if (s[j])
for (int k = j * j; k < N; k += j)
s[k] = false;
}
}
};
template<int N>
struct twin {
int t[N/10], l;
constexpr twin() : t(), l(1) {
sieve<N> s;
t[0] = 5;
for (int i = 0; i < N; i++)
if (s.s[i - 2] && s.s[i])
t[l++] = i;
}
};
int main() {
enum {N = 10001};
twin<N> t;
for (int n; (n = in());) {
auto r = upper_bound(t.t, t.t + t.l, n) - 1;
outl(*r - 2, ' ', *r);
}
}
| #include <stdio.h>
int isprime(int n) {
int i;
for(i = 2; i * i <= n; i++) {
if(n % i == 0) return 0;
}
return 1;
}
int main(){
int i, n, max;
while(1){
scanf("%d", &n);
if(n == 0) break;
for(i = n;i > 0;i--){
if(isprime(i) == 1 && isprime(i - 2) == 1){
max = i;
break;
}
}
printf("%d %d\n", max - 2, max);
}
return 0;
} | 1 |
#include<cstdio>
#include<set>
#include<stack>
#include<queue>
int main()
{
int d,f,s;
scanf("%d %d %d",&d,&f,&s);
if(d<=f*s){printf("Yes");}
else{printf("No");}
} | // #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
// #include <atcoder/all>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(a) (a).begin(), (a).end()
using namespace std;
// using namespace atcoder;
using ll = long long;
using P = pair<int, int>;
const int mod = 1e9 + 7;
// --------------------------------------------------------------------------------
void solve()
{
int a, b;
cin >> a >> b;
for (int i = 0;; i++)
{
if (b == 1)
{
cout << 0 << endl;
break;
}
if (b <= a * (i + 1) - i)
{
cout << i + 1 << endl;
break;
}
}
}
// --------------------------------------------------------------------------------
int main()
{
// srand((unsigned)time(NULL));
// int bt = clock();
solve();
// double et = 1.0 * (clock() - bt) / CLOCKS_PER_SEC;
// printf("Execution Time: %.4lf sec\n", et);
return 0;
} | 0 |
#include<iostream>
#include<sstream>
#include<algorithm>
#include<climits>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<ctime>
#include<cfloat>
#include<functional>
#include<map>
#include<string>
#include<cstring>
#include<vector>
#include<queue>
#include<stack>
#include<deque>
#include<set>
#include<bitset>
#include<list>
#include<numeric>
#include<complex>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> i_i;
typedef pair<long long, int> ll_i;
typedef pair<double, int> d_i;
typedef pair<long long, long long> ll_ll;
typedef pair<double, double> d_d;
typedef vector<int> Vint;
#define PI 3.141592653589793238462643383279
#define mod 1000000007LL
#define rep(i, n) for(i = 0;i < n;++i)
#define rep1(i, n) for(i = 1;i < n;++i)
#define rep2d(i, j, n) for(i = 0;i < n;++i)for(j = i + 1;j < n;++j)
#define per(i, n) for(i = n - 1;i > -1;--i)
#define int(x) int x; scanf("%d",&x)
#define int2(x, y) int x, y; scanf("%d%d",&x, &y)
#define int3(x, y, z) int x, y, z; scanf("%d%d%d",&x, &y, &z)
#define int4(v, x, y, z) int v, x, y, z; scanf("%d%d%d%d", &v, &x, &y, &z)
#define int5(v, w, x, y, z) int v, w, x, y, z; scanf("%d%d%d%d%d", &v, &w, &x, &y, &z)
#define scn(n, a) rep(i, n)cin >> a[i]
#define sc2n(n, a, b) rep(i, n)cin >> a[i] >> b[i]
#define pri(x) cout << x << "\n"
#define pri2(x, y) cout << x << " " << y << "\n"
#define pri3(x, y, z) cout << x << " " << y << " " << z << "\n"
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(),(a).end()
#define endl "\n"
#define kabe puts("---------------------------")
#define kara puts("")
#define debug(x) cout << " --- " << x << "\n"
#define debug2(x, y) cout << " --- " << x << " " << y << "\n"
#define debug3(x, y, z) cout << " --- " << x << " " << y << " " << z << "\n"
#define X first
#define Y second
#define eps 0.0001
#define prid(x) printf("%.15lf\n", x)
signed main(void){
int i, j, k;
for(int testcase = 0;testcase >= 0;testcase++){
int3(m, nin, nax); if(!(m|nax|nin))break;
int p[m]; scn(m, p);
int res = 0, resi;
nin--; nax--;
for(i = nin;i <= nax;++i){
if(res <= p[i] - p[i + 1]){ res = p[i] - p[i + 1]; resi = i + 1; }
}
pri(resi);
//*/
//*/ break;
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int m, nmin, nmax;
while (cin >> m >> nmin >> nmax, m | nmin | nmax) {
vector<int> P(m);
for (int i = 0; i < m; i++) {
cin >> P[i];
}
int cost = 0, ans = 0;
for (int i = 0; i < m; i++) {
if (i + 1 < nmin || i + 1 > nmax) continue;
if (i + 1 >= m) continue;
if (P[i] - P[i + 1] >= cost) {
cost = P[i] - P[i + 1];
ans = i + 1;
}
}
cout << ans << endl;
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=3e5+5;
const ll mod=1e9+7;
ll power(ll a,ll b){return b?power(a*a%mod,b/2)*(b%2?a:1)%mod:1;}
ll n,ans=0,mx=0,a[N],num[100]={0},cnt[100]={0};
void split(ll x){
ll p=0;
while(x){
if(x%2) cnt[p]++;
p++;
x/=2;
}
mx=max(mx,p);
}
int main(){
cin>>n;
for(int i=1;i<=n;i++) cin>>a[i],split(a[i]);
for(int i=1;i<=n;i++){
for(ll j=0;j<mx;j++){
if(a[i]&(1LL<<j)) num[j]+=n-cnt[j];
else num[j]+=cnt[j];
}
}
for(ll i=0;i<100;i++){
num[i+1]+=num[i]/2;
if(num[i]%2) ans=(ans+power(2,i))%mod;
}
cout<<ans*power(2,mod-2)%mod;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
void solve();
clock_t start_time;
double get_current_time() {
return (double)(clock() - start_time) / CLOCKS_PER_SEC;
}
int main() {
// freopen("input.txt", "r", stdin);
// freopen();
ios_base::sync_with_stdio(false);
solve();
}
/* ========== actual code starts here ========== */
#define fi first
#define re return
#define se second
#define in insert
#define pb push_back
#define eb emplace_back
#define y1 y123123123123
#define all(x) x.begin(), x.end()
#define hash hash123s
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repx(i, x, n) for (int i = x; i < (n); i++)
#define repd(i, n, d) for (int i = 0; i < (n); i += d)
#define rrep(i, n) for (int i = (n) - 1; i >= 0; i--)
#define rrepd(i, n, d) for (int i = (n) - 1; i >= 0; i -= d)
#ifdef artem
#define debug(x) x
#define eprintf(...) fprintf(stderr, __VA_ARGS__);fflush(stderr);
#else
#define debug(x)
#endif
const int limit = 100500;
const int k = 18;
const int inf = 10050000;
int n, l;
int x[ limit ];
int dp[ limit ][ k + 1 ];
void precalc() {
int j = 0;
for(int i = 0; i < n; i++) {
while(j < n && x[ j ] - x[ i ] <= l) {
++j;
}
dp[ i ][ 0 ] = j - 1;
}
dp[ n - 1 ][ 0 ] = n - 1;
for(int i = n - 1; i >= 0; i--) {
for(int j = 1; j <= k; j++) {
dp[ i ][ j ] = dp[ dp[ i ][ j - 1 ] ][ j - 1 ];
}
}
// for(int i = 0; i <= k; i++) {
// for(int j = 0; j < n; j++) {
// cout << dp[ j ][ i ] << ' ';
// }
// cout << endl;
// }
}
int calc(int l, int r) {
int ans = 0;
for(int j = k; j >= 0; j--) {
if(dp[ l ][ j ] < r) {
l = dp[ l ][ j ];
ans += (1 << j);
}
}
re ans + 1;
}
void solve() {
cin >> n;
rep(i, n) {
cin >> x[ i ];
}
cin >> l;
precalc();
int q;
cin >> q;
while(q--) {
int l, r;
cin >> l >> r, --l, --r;
if(l > r) swap(l, r);
cout << calc(l, r) << '\n';
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll solve() {
ll N, M, Q;
cin >> N >> M >> Q;
vector<string> S(N);
for ( int i = 0; i < N; i++ ) {
cin >> S[i];
}
vector<int> X1(Q), Y1(Q), X2(Q), Y2(Q);
for ( int i = 0; i < Q; i++ ) {
cin >> X1[i] >> Y1[i] >> X2[i] >> Y2[i];
X1[i]--, Y1[i]--, X2[i]--, Y2[i]--;
}
vector<vector<ll>> c(N+1, vector<ll>(M+1));
for ( int n = 0; n < N; n++ ) {
for ( int m = 0; m < M; m++ ) {
if ( S[n][m] == '1' ) c[n+1][m+1] = 1;
}
}
for ( int n = 0; n <= N; n++ ) {
for ( int m = 0; m < M; m++ ) {
c[n][m+1] += c[n][m];
}
}
for ( int n = 0; n < N; n++ ) {
for ( int m = 0; m <= M; m++ ) {
c[n+1][m] += c[n][m];
}
}
vector<vector<ll>> a(2*N, vector<ll>(2*M));
for ( int n = 0; n < N; n++ ) {
for ( int m = 0; m < M-1; m++ ) {
if ( S[n][m] == '1' && S[n][m+1] == '1' ) a[2*n+1][2*m+2] = 1;
}
}
for ( int n = 0; n < N-1; n++ ) {
for ( int m = 0; m < M; m++ ) {
if ( S[n][m] == '1' && S[n+1][m] == '1' ) a[2*n+2][2*m+1] = 1;
}
}
for ( int n = 0; n < 2*N; n++ ) {
for ( int m = 0; m < 2*M-1; m++ ) {
a[n][m+1] += a[n][m];
}
}
for ( int n = 0; n < 2*N-1; n++ ) {
for ( int m = 0; m < 2*M; m++ ) {
a[n+1][m] += a[n][m];
}
}
for ( int q = 0; q < Q; q++ ) {
ll x1 = 2*X1[q], y1 = 2*Y1[q];
ll x2 = 2*X2[q]+1, y2 =2*Y2[q]+1;
ll j = a[x2][y2] - a[x2][y1] - a[x1][y2] + a[x1][y1];
ll b = c[X2[q]+1][Y2[q]+1] - c[X2[q]+1][Y1[q]] - c[X1[q]][Y2[q]+1] + c[X1[q]][Y1[q]];
cout << b - j << "\n";
}
return 0;
}
int main() {
solve();
return 0;
} | #include<iostream>
#include<cstdio>
#include<queue>
#include<vector>
#include<algorithm>
#define F first
#define S second
using namespace std;
typedef pair<int,int> P;
int w,h,sx,sy,gx,gy,fc;
int imap[110][110];
const int dx[4] = {0,1,0,-1};
const int dy[4] = {1,0,-1,0};
bool found;
void Init(){
for(int i=0;i<110;i++){
for(int j=0;j<110;j++){
imap[i][j] = -1;
}
}
}
void display(){
for(int i=0;i<=h;i++){
for(int j=0;j<=w;j++){
printf("%3d ",imap[i][j]);
}
cout << endl;
}
}
void draw(int c,int d,int x,int y){
int limy,limx;
limy = d==1?4:2;
limx = d==1?2:4;
for(int i=0;i<limy && i<=h;i++){
for(int j=0;j<limx && j<=w;j++){
imap[y+i][x+j] = c;
}
}
}
void rec(int px,int py){
if(px == gx && py == gy){
found = true;
return;
}
for(int i=0;i<4;i++){
int nx = px+dx[i], ny = py+dy[i];
if(!found && 0<=nx && nx <=w && 0<=ny && ny<=h && imap[ny][nx] == fc){
imap[ny][nx] = -1;
rec(nx,ny);
}
}
}
bool isMaze(){
rec(sx,sy);
if(found)return true;
return false;
}
int main(){
int n,c,d,x,y;
while(cin >> w >> h && w && h){
found = false;
cin >> sx >> sy;
cin >> gx >> gy;
cin >> n;
Init();
for(int i=0;i<n;i++){
cin >> c >> d >> x >> y;
draw(c,d,x,y);
}
fc = imap[sy][sx];
if(fc == -1)cout << "NG" << endl;
else{
if(isMaze())cout << "OK" << endl;
else cout << "NG" << endl;
}
}
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <utility>
#include <queue>
#include <string>
#include <set>
#include <bitset>
#include <unordered_map>
#include <cmath>
#include <functional>
#include <map>
#include <cstdlib>
using namespace std;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template <class T>
using Vvec = vector<vector<T> >;
template <class T>
void debug(T& v)
{
for(auto& x: v) cout << x << " ";
cout << endl;
}
int main()
{
const ll push = 0;
const ll pop = 1;
const ll get = 2;
struct Data{
ll key, qid, val;
Data(): key(0), qid(0), val(0){}
Data(ll k, ll q, ll v): key(k), qid(q), val(v){}
bool operator<(const Data& e) const{
if(key == e.key){
if(qid == e.qid) return val < e.val;
return qid < e.qid;
}
return key < e.key;
}
};
int N, Q;
cin >> N >> Q;
vector<ll> S(N), T(N), X(N), D(Q), ans(Q);
for(int i=0; i<N; i++) cin >> S[i] >> T[i] >> X[i];
for(auto& x: D) cin >> x;
multimap<ll, Pll> mp;
vector<Data> ds(2*N+Q);
for(int i=0; i<N; i++){
ds[2*i] = Data(S[i]-X[i], push, X[i]);
ds[2*i+1] = Data(T[i]-X[i], pop, X[i]);
}
for(int i=0; i<Q; i++) ds[2*N+i] = Data(D[i], get, i);
sort(ds.begin(), ds.end());
multiset<ll> Xs;
for(auto& d: ds){
ll qid = d.qid;
ll val = d.val;
// cout << d.key << " " << qid << " " << val << "\n";
if(qid == push) Xs.insert(val);
else if(qid == pop){
auto itr = Xs.find(val);
Xs.erase(itr);
}else{
if(Xs.empty()) ans[val] = -1;
else ans[val] = *Xs.begin();
}
}
for(auto& x: ans) cout << x << "\n";
} | #include <cstdio>
#include <algorithm>
#include <vector>
#include <set>
using namespace std;
using Weight=long long;
static const Weight INF=1LL<<57;
struct Edge {
size_t src, dst;
Weight weight;
Edge() {}
Edge(size_t src, size_t dst, Weight weight=1):
src(src), dst(dst), weight(weight)
{}
};
bool operator<(const Edge &e, const Edge &f) {
if (e.weight != f.weight) {
return e.weight > f.weight;
} else {
return e.src!=f.src? e.src<f.src : e.dst<f.dst;
}
}
using Edges=vector<Edge>;
using Vertex=vector<Edge>;
using Graph=vector<Vertex>;
void join(Graph &g, size_t s, size_t d, Weight w=1) {
// non-directed
g[s].push_back(Edge(s, d, w));
g[d].push_back(Edge(d, s, w));
}
void connect(Graph &g, size_t s, size_t d, Weight w=1) {
// directed
g[s].push_back(Edge(s, d, w));
}
void visit(
const Graph &g, size_t v, size_t u, set<size_t> &artpoint,
vector<size_t> &num, vector<size_t> &low, int &time
) {
low[v] = num[v] = ++time;
for (const Edge &e: g[v]) {
size_t w=e.dst;
if (!num[w]) {
visit(g, w, v, artpoint, num, low, time);
low[v] = min(low[v], low[w]);
if (num[v]==1? num[w]!=2 : low[w]>=num[v])
artpoint.insert(v);
} else {
low[v] = min(low[v], num[w]);
}
}
}
set<size_t> get_artpoint(const Graph &g) {
const size_t V=g.size();
vector<size_t> low(V), num(V);
set<size_t> artpoint;
for (size_t u=0; u<V; ++u) if (!num[u]) {
int time=0;
visit(g, u, -1, artpoint, num, low, time);
}
return artpoint;
}
int main() {
size_t V, E;
scanf("%zu %zu", &V, &E);
Graph g(V);
for (size_t i=0; i<E; ++i) {
size_t s, t;
scanf("%zu %zu", &s, &t);
join(g, s, t);
}
set<size_t> artpoint=get_artpoint(g);
for (size_t v: artpoint)
printf("%zu\n", v);
return 0;
} | 0 |
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math")
#include <bits/stdc++.h>
using namespace std;
template<class t> inline t read(t &x){
char c=getchar();bool f=0;x=0;
while(!isdigit(c)) f|=c=='-',c=getchar();
while(isdigit(c)) x=(x<<1)+(x<<3)+(c^48),c=getchar();
if(f) x=-x;return x;
}
template<class t,class ...A> inline void read(t &x,A &...a){
read(x);read(a...);
}
template<class t> inline void write(t x){
if(x<0) putchar('-'),write(-x);
else{if(x>9) write(x/10);putchar('0'+x%10);}
}
int n,m,a,b;
signed main(){
read(n,m,a,b);
for(int i=1;i<=n;i++,puts("")) for(int j=1;j<=m;j++) write((i<=b&&j<=a)||(i>b&&j>a));
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(a) (a).begin(),(a).end()
#define VI vector<int>
#define MOD 1000000007
using ll = long long int;
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; }
const ll INF=(ll)1e19;
//const int INF=(1<<30);
//const int INF=(1<<29);
int main(){
int h,w,a,b;
cin >> h >> w >> a >> b;
REP(i,h)REP(j,w){
if((i < b && j < a) || (i >= b && j >= a)){
cout << 0;
}else{
cout << 1;
}
if(j==w-1)cout<<endl;
}
}
| 1 |
#include <bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,b,a) for(int i=b;i>=a;i--)
#define fori(a) for(auto i : a )
#define all(a) begin(a), end(a)
#define set(a,b) memset(a,b,sizeof(a))
#define sz(a) a.size()
#define pi 3.14159
#define ll long long
#define ull unsigned long long
#define pb push_back
#define PF push_front //deque
#define mp make_pair
#define pq priority_queue
#define mod 1000000007
#define f first
#define s second
#define pii pair< int, int >
#define vi vector<int>
#define vpii vector<pii>
#define debug(v) for(auto i:v) cout<<i<<" ";
#define tc int t; cin >> t; while(t--)
using namespace std;
string repeat(string s, int n) {
string s1 = "";
for (int i=0; i<n;i++)
s1+=s;
return s1;
}
string getString(char x) {
string s(1, x);
return s;
}
void optimizeIO(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int gcd(int a, int b){
if (a == 0) return b;
return gcd(b % a, a);
}
void solve(){
int x,y;
cin>>x>>y;
if(x<=8 && y<=8) cout<<"Yay!\n";
else cout<<":(\n";
}
int main(){
optimizeIO();
// tc
{ solve();
}
}
| #include<bits/stdc++.h>
using namespace std;
int main(){
int a, b;
string s;
cin >> a >> b;
cin >> s;
vector<char> num{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
if(s.at(a) == '-'){
vector<bool> judge2 (s.size(), false);
judge2.at(a) = true;
for(int i = 0;i < s.size();i++){
for(int j = 0;j < num.size();j++){
if(i == a)continue;
else if(s.at(i) == num.at(j))judge2.at(i) = true;
}
}
bool judge = true;
for(int i = 0;i < judge2.size();i++){
if(!judge2.at(i))judge = false;
}
if(judge)cout << "Yes" << endl;
else cout << "No" << endl;
}
else cout << "No" << endl;
} | 0 |
#include<bits/stdc++.h>
const int N=1005,mo=1e9+7;
int n,m,a[N],b[N],i,j,k,ans=1,p,q;
int main(){
scanf("%d%d",&n,&m);
for(i=1;i<=n;++i)scanf("%d",a+i);std::sort(a+1,a+n+1);
for(i=1;i<n;++i)if(a[i]==a[i+1])return puts("0"),0;
for(i=1;i<=m;++i)scanf("%d",b+i);std::sort(b+1,b+m+1);
for(i=1;i<m;++i)if(b[i]==b[i+1])return puts("0"),0;
for(i=n+1,j=m+1,k=n*m;k;--k){
for(;a[i-1]>=k;--i);for(;b[j-1]>=k;--j);
if(a[i]==k && b[j]==k)continue;
if(a[i]==k)ans=1ll*ans*(m-j+1)%mo;else if(b[j]==k)ans=1ll*ans*(n-i+1)%mo;
else p=n*m-k+1,q=(n-i+1)*(m-j+1),ans=p<=q?1ll*ans*(q-p+1)%mo:0;
}
printf("%d\n",ans);
return 0;
} | #include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 3000;
const int P = 1e9 + 7;
int n, k;
int fac[N * N], inv[N * N], f[N][N];
int power(int a,int b) {
int res = 1;
while (b > 0) {
if (b & 1) res = res * a % P;
a = a * a % P, b >>= 1;
}
return res;
}
int C(int n,int m) {
int A = fac[n];
int B = inv[n-m] * inv[m] % P;
return A * B % P;
}
signed main(void)
{
cin >> n >> k;
fac[0] = 1;
for (int i=1;i<=2100 * 2100;++i)
fac[i] = fac[i-1] * i % P;
f[0][0] = 1;
int MAXN = 2000 * 2000;
inv[MAXN] = power(fac[MAXN], P - 2);
for (int i=MAXN - 1;i>=0;--i)
inv[i] = inv[i+1] * (i + 1) % P;
for (int i=1;i<=n;++i)
for (int j=0;j<=i;++j) {
f[i][j] = f[i-1][j];
if (j == 0) continue;
f[i][j] += f[i][j-1] * (n-j+1) % P * C(n*k-i-(j-1)*(k-1)-1,k-2) % P;
f[i][j] %= P;
}
cout << f[n][n] + (k == 1) << endl;
return 0;
} | 0 |
#include <iostream>
#include <cstdio>
#include <cassert>
#include <cstring>
#include <vector>
#include <valarray>
#include <array>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <algorithm>
#include <cmath>
#include <complex>
#include <random>
using namespace std;
using ll = long long;
using ull = unsigned long long;
constexpr int TEN(int n) {return (n==0)?1:10*TEN(n-1);}
int main() {
ll fib[31];
fib[1] = 1;
fib[2] = 2;
fib[3] = 4;
for (int i = 4; i <= 30; i++) {
fib[i] = fib[i-1]+fib[i-2]+fib[i-3];
}
while (true) {
int t; cin >> t;
if (!t) break;
cout << ((fib[t]+9)/10+364)/365 << endl;
}
return 0;
} | #include <iostream>
#include <memory.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
const int sz = 100000;
bool prime[sz];
int main(){
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = false;
for(int i = 2; i * i < sz; i++){
if(prime[i]){
for(int j = 2; i * j < sz; j++){
prime[i*j] = false;
}
}
}
int n;
while(cin >> n && n){
for(int i = n; i >= 2; i--){
if(prime[i] && prime[i-2]){
cout << i - 2 << " " << i << endl;
break;
}
}
}
return 0;
} | 0 |
#include"bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using pi = pair<int, int>;
const ll INF = 1LL << 60;
int main() {
ll n,a,mins = INF;
cin >> n;
rep(i, 5) {
cin >> a;
mins = min(mins, a);
}
cout << fixed << setprecision(0)<< ceil((double)n / mins) + 4 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int64_t N;
cin >> N;
int64_t minimum;
for(int i = 0; i < 5; i++) {
if(i == 0) {
cin >> minimum;
}
else {
int64_t a;
cin >> a;
minimum = min(minimum, a);
}
}
cout << (N - 1) / minimum + 5 << endl;
} | 1 |
#include <cassert>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <limits.h>
#include <map>
#include <queue>
#include <set>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
const int MAX_N = 200000;
struct Node {
int idx;
int skipCnt;
int takeCnt;
ll sum;
Node(int idx = -1, int skipCnt = -1, int takeCnt = -1, ll sum = -1) {
this->idx = idx;
this->skipCnt = skipCnt;
this->takeCnt = takeCnt;
this->sum = sum;
}
bool operator>(const Node &n) const {
return idx > n.idx;
}
};
int main() {
int N;
cin >> N;
ll dp[N][3];
int takeLimit = N / 2;
int skipLimit = (N % 2 == 0) ? 1 : 2;
vector<ll> A;
ll a;
for (int i = 0; i < N; ++i) {
cin >> a;
A.push_back(a);
for (int s = 0; s < 3; ++s) {
dp[i][s] = LLONG_MIN;
}
}
priority_queue <Node, vector<Node>, greater<Node>> pque;
pque.push(Node(0, 0, 0, 0));
ll ans = LLONG_MIN;
while (!pque.empty()) {
Node node = pque.top();
pque.pop();
// fprintf(stderr, "[%d, skipCnt: %d, takeCnt: %d, %lld]\n", node.idx, node.skipCnt, node.takeCnt, node.sum);
if (node.takeCnt == takeLimit) {
ans = max(ans, node.sum);
continue;
}
if (node.sum <= dp[node.idx][node.skipCnt]) continue;
dp[node.idx][node.skipCnt] = max(dp[node.idx][node.skipCnt], node.sum);
if (node.skipCnt == skipLimit) {
int nextIdx = node.idx + 2;
ll sum = node.sum + A[node.idx];
pque.push(Node(nextIdx, node.skipCnt, node.takeCnt + 1, sum));
} else {
// skip taking number
pque.push(Node(node.idx + 1, node.skipCnt + 1, node.takeCnt, node.sum));
// no skip
pque.push(Node(node.idx + 2, node.skipCnt, node.takeCnt + 1, node.sum + A[node.idx]));
}
}
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <algorithm>
using namespace std;
long long N, A[1 << 18];
long long dp[1 << 18][2][20];
int main() {
cin >> N;
for (int i = 1; i <= N; i++) cin >> A[i];
for (int i = 0; i <= N; i++) {
for (int j = 0; j < 20; j++) {
dp[i][0][j] = -(1LL << 60);
dp[i][1][j] = -(1LL << 60);
}
}
dp[0][0][10] = 0;
for (int i = 1; i <= N; i++) {
for (int j = 6; j <= 14; j++) {
if (dp[i - 1][0][j] != (1LL << 60)) {
dp[i][1][j + 1] = max(dp[i][1][j + 1], dp[i - 1][0][j] + A[i]);
dp[i][0][j - 1] = max(dp[i][0][j - 1], dp[i - 1][0][j]);
}
if (dp[i - 1][1][j] != (1LL << 60)) {
dp[i][0][j - 1] = max(dp[i][0][j - 1], dp[i - 1][1][j]);
}
}
}
long long V = 10LL + (N / 2) - (N - (N / 2));
long long T1 = dp[N][0][V];
long long T2 = dp[N][1][V];
cout << max(T1, T2) << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
#define rep(i, a) for (int i = (int)0; i < (int)a; ++i)
#define rrep(i, a) for (int i = (int)a - 1; i >= 0; --i)
#define REP(i, a, b) for (int i = (int)a; i < (int)b; ++i)
#define RREP(i, a, b) for (int i = (int)a - 1; i >= b; --i)
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define popcount __builtin_popcount
using ll = long long;
constexpr ll mod = 1e9 + 7;
constexpr ll INF = 1LL << 60;
template <class T>
inline bool chmin(T &a, T b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T &a, T b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
ll gcd(ll n, ll m)
{
ll tmp;
while (m != 0)
{
tmp = n % m;
n = m;
m = tmp;
}
return n;
}
ll lcm(ll n, ll m)
{
return abs(n) / gcd(n, m) * abs(m); //gl=xy
}
using namespace std;
using P=pair<ll,pair<ll,ll>>;
void solve(){
ll n;
cin>>n;
vector<P>p(n);
rep(i,n){
cin>>p[i].second.first>>p[i].second.second;
p[i].first=p[i].second.second-p[i].second.first;
}
sort(all(p));
ll ans=0;
vector<ll>val(n+1),rval(n+1);
ll left=0,right=1e9;
rep(i,n){
chmax(left,p[i].second.first);
chmin(right,p[i].second.second);
val[i+1]=right-left+1;
}
left=0,right=1e9;
for(int i=n-1;i>=0;--i){
chmax(left,p[i].second.first);
chmin(right,p[i].second.second);
rval[i]=right-left+1;
}
REP(i,1,n){
//cout<<val[i]<<" "<<rval[i]<<"\n";
chmax(ans,max(val[i],0LL)+max(rval[i],0LL));
}
rep(i,n)p[i].first=0;
sort(all(p));
left=0,right=1e9;
rep(i,n){
chmax(left,p[i].second.first);
chmin(right,p[i].second.second);
val[i+1]=right-left+1;
}
left=0,right=1e9;
for(int i=n-1;i>=0;--i){
chmax(left,p[i].second.first);
chmin(right,p[i].second.second);
rval[i]=right-left+1;
}
REP(i,1,n){
//cout<<val[i]<<" "<<rval[i]<<"\n";
chmax(ans,max(val[i],0LL)+max(rval[i],0LL));
}
cout<<ans<<"\n";
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
solve();
return 0;
}
| //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using namespace std;
using ll = int64_t;
using ld = long double;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<int>;
using vvi = vector<vi>;
template<class T> using PQ = priority_queue<T>;
template<class T> using PQG = priority_queue<T, vector<T>, greater<T> >;
const int INF = 100010001;
const ll LINF = (ll)INF*INF*10;
template<typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) {return a < b && (a = b, true);}
template<typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) {return a > b && (a = b, true);}
template<typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) { return is >> p.first >> p.second;}
template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) { return os << p.first << ' ' << p.second;}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<P> lr(n);
rep(i, n) cin >> lr[i];
sort(all(lr));
int ans = 0;
vi mil(n+1, INT_MAX), mir(n+1, INT_MAX);
rep(i, n) {
mil[i+1] = min(mil[i], lr[i].second);
mir[n-1-i] = min(mir[n-i], lr[n-1-i].second);
}
int min = INT_MAX;
rep(i, n-1) {
chmin(min, lr[i].second);
if(min < lr[i].first) break;
chmax(ans, min-lr[i].first + mir[i+1]-lr[n-1].first + 2);
}
rep(i, n) {
chmax(ans, lr[i].second - lr[i].first + 1 + (mil[n] >= lr[n-1].first?mil[n]-lr[n-1].first+1:0));
}
cout << ans << endl;
} | 1 |
#include <string>
#include <queue>
#include <stack>
#include <vector>
#include <sstream>
#include <algorithm>
#include <deque>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <list>
#include <cstdio>
#include <iostream>
#include <cmath>
#include <climits>
#include <bitset>
#include <functional>
#include <numeric>
#include <ctime>
#include <cassert>
#include <cstring>
#include <fstream>
#include <iomanip>
using namespace std;
#define FOR(i, a, b) for(int (i)=(a);(i)<(b);(i)++)
#define IFOR(i, a, b) for(int (i)=(a);(i)<=(b);(i)++)
#define RFOR(i, a, b) for(int (i)=(a);(i)>=(b);(i)--)
#define REP(i, n) FOR((i), 0, (n))
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template<class T>
void print_container(T &container, string delim=" ") {
bool first = true;
for(auto &t: container){
if(!first){
cout << delim;
}
first = false;
cout << t;
}
cout << endl;
}
int main() {
int n;
cin >> n;
vector<ll> a(n);
REP(i, n)
cin >> a[i];
vector<ll> dp(n+1);
dp[0] = 0;
dp[1] = 0;
ll accum = a[0];
IFOR(i, 2, n){
if(i % 2 == 0){
dp[i] = max(dp[i-2] + a[i-1], accum);
}
else{
accum += a[i-1];
dp[i] = max(dp[i-2] + a[i-1], dp[i-1]);
}
}
cout << dp[n] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
typedef pair<int, int> pii;
typedef long long ll;
const int MAXN = 2e5 + 5;
const ll INF = 5e16;
int n;
int a[MAXN];
ll brute(int i, int qtt) {
if (i > n) {
if (qtt == n/2) return 0;
else return -INF;
}
return max(a[i] + brute(i+2, qtt+1), brute(i+1, qtt));
}
ll memo[MAXN][5];
ll solve(int i, int duplo) {
if (i > n) return duplo * -INF;
ll& ret = memo[i][duplo];
if (ret != -INF) return ret;
ret = max(ret, a[i] + solve(i+2, duplo));
if (duplo) ret = max(ret, solve(i+1, duplo-1));
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
if (n <= 10) printf("%lld\n", brute(1, 0));
else {
for (int i = 1; i <= n; i++) for (int j = 0; j <= 4; j++)
memo[i][j] = -INF;
ll ans = -INF;
if (n%2 == 0) {
ans = solve(1, 1);
ans = max(ans, solve(2, 0));
} else {
ans = solve(1, 2);
ans = max(ans, solve(2, 1));
}
printf("%lld\n", ans);
}
} | 1 |
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <utility>
#include <tuple>
#include <algorithm>
#include <numeric>
#include <cstdio>
#include <cmath>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
const int MOD = 1e9+7;
int main() {
int n;
string s;
cin >> n >> s;
int lnum = 0;
ll ans = 1;
rep(i, n*2) {
if (s[i]=='B' ^ lnum%2)
lnum++; //ไฟ็ใซใใ(=ๅบ้ใฎๅทฆ็ซฏใจใใฆไฝฟใ)
else {
(ans *= lnum) %= MOD;
lnum--; //ไฟ็ใไธใคๆถ่ฒปใใ
}
}
if (lnum)
cout << 0 << endl;
else {
for (int i=1; i<=n; i++)
(ans *= i) %= MOD;
cout << ans << endl;
}
return 0;
} | /*
[jsc2019-qual] C - Cell Inversion
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> pii;
typedef pair<ll, int> pli;
typedef pair<ll, ll> pll;
#define ALL(c) (c).begin(), (c).end()
const int MAX_N = 1e5;
const int MOD = 1e9 + 7;
class gf {
public:
int n;
gf() : n(0) {}
gf(int n) : n(n % MOD) {}
gf operator+(gf x) { return gf((n + x.n) % MOD); }
gf operator-(gf x) { return gf((n - x.n + MOD) % MOD); }
gf operator*(gf x) { return gf((1LL * n * x.n) % MOD); }
gf& operator+=(gf x) { return *this = (*this + x); }
gf& operator-=(gf x) { return *this = (*this - x); }
gf& operator*=(gf x) { return *this = (*this * x); }
};
int N;
string S;
int cnt[2 * MAX_N];
ll solve() {
if (S[0] == 'W' || S[2 * N - 1] == 'W') {
return 0;
}
cnt[0] = 1;
for (int i = 1; i < 2 * N; i++) {
cnt[i] = (S[i - 1] == S[i]) ? (1 - cnt[i - 1]) : cnt[i - 1];
}
for (int i = 1; i < 2 * N; i++) {
cnt[i] += cnt[i - 1];
}
if (cnt[2 * N - 1] != N) {
return 0;
}
gf ans = 1;
for (int i = 1; i < 2 * N; i++) {
if (cnt[i - 1] == cnt[i]) {
// R
int p = 2 * cnt[i - 1] - i;
if (p <= 0) {
return 0;
}
ans *= p;
}
}
for (int i = 1; i <= N; i++) {
ans *= i;
}
return ans.n;
}
int main() {
cin >> N;
cin >> S;
cout << solve() << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep2(i, x, n) for(int i = x; i <= n; i++)
#define rep3(i, x, n) for(int i = x; i >= n; i--)
#define elif else if
#define sp(x) fixed << setprecision(x)
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define sz(x) (int)x.size()
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const ll MOD = 1e9+7;
//const ll MOD = 998244353;
const int inf = (1<<30)-1;
const ll INF = (1LL<<60)-1;
const ld EPS = 1e-10;
template<typename T> bool chmax(T &x, const T &y) {return (x < y)? (x = y, true) : false;};
template<typename T> bool chmin(T &x, const T &y) {return (x > y)? (x = y, true) : false;};
void print(ll x){
cout << x << ".00000000000000" << endl;
}
int main(){
int N;
cin >> N;
ll x[N];
rep(i, N) cin >> x[i];
ll d[N-1];
rep(i, N-1) d[i] = x[i+1]-x[i];
int M; ll K;
cin >> M >> K;
int dp[60][N-1];
rep(i, N-1) dp[0][i] = i;
rep(i, M){
int a;
cin >> a;
swap(dp[0][a-2], dp[0][a-1]);
}
rep2(i, 1, 59){
rep(j, N-1) dp[i][j] = dp[i-1][dp[i-1][j]];
}
ll ans = x[0];
print(ans);
rep(i, N-1){
int now = i;
rep(j, 60){
if(K&(1LL<<j)) now = dp[j][now];
}
print(ans += d[now]);
}
} | #include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
const ll mod=1000000007;
const ll INF=1e15;
#define REP(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)
vec chikan(vec X, vec M){
vec ret(M.size());
for(int i=0;i<M.size();i++) {
ret.at(i)=M.at(X.at(i));
}
return ret;
}
vec bekic(vec X, ll n){
vec ret(X.size());
rep(i,X.size()) ret.at(i)=i;
while(n>0){
if(n%2) ret=chikan(ret,X);
X=chikan(X,X);
n/=2;
}
return ret;
}
int main(){
ll N; cin>>N;
vec x(N);
rep(i,N) cin>>x.at(i);
ll M,K; cin>>M>>K;
vec a(M);
rep(i,M) cin>>a.at(i);
rep(i,M) a.at(i)--;
vec d(N);
REP(i,1,N) d.at(i)=x.at(i)-x.at(i-1);
vec P(N);
rep(i,N) P.at(i)=i;
rep(i,M) swap(P.at(a.at(i)),P.at(a.at(i)+1));
P=bekic(P,K);
d=chikan(P,d);
d.at(0)=x.at(0);
rep(i,N-1) d.at(i+1)+=d.at(i);
rep(i,N) cout<<d.at(i)<<endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define fore(i,x,n) for(int i=x;i<n;i++)
#define all(a) a.begin(),a.end()
#define pb push_back
#define ordenar(a) sort(all(a))
typedef long long ll;
typedef vector<int> vi;
int a[5], k;
int main(){
IOS
fore(i,0,5) cin>>a[i];
cin>>k;
fore(i,0,4){
fore(j,i+1,5){
if(a[j]-a[i] > k) {
cout<<":(";
return 0;
}
}
}
cout<<"Yay!";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int a;
int b;
int c;
int d;
int e;
int k;
cin >>a;
cin >>b;
cin >>c;
cin >>d;
cin >>e;
cin >>k;
if(e - a <= k)cout << "Yay!" <<endl;
else cout << ":(" <<endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, j, k) for(int i = j; i < k; ++i)
#define rep(i, j) FOR(i, 0, j)
#define repr(i, j) for(int i = j; i >= 0; --i)
#define INF (1 << 30)
#define MOD 1e9 + 7
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
int main() {
int a[5];
while(scanf("%d,%d,%d,%d,%d", &a[0], &a[1], &a[2], &a[3], &a[4]) != EOF) {
bool three = false, four = false, straight = false, full = false;
int pair = 0, count = 1;
sort(a, a + 5);
rep(i, 4) {
if(a[i] == a[i+1]) ++count;
else count = 1;
if(count == 4) four = true;
if(count == 3) three = true;
else if(count == 2) ++pair;
}
rep(i, 4) {
if(a[0] == 1 && a[1] == 10 && a[2] == 11 && a[3] == 12 && a[4] == 13) {
straight = true;
break;
}
if(a[i] != a[i + 1] - 1) {
straight = false;
break;
}
else straight = true;
}
if(three && pair == 2) full = true;
if(four) cout << "four card" << endl;
else if(full) cout << "full house" << endl;
else if(straight) cout << "straight" << endl;
else if(three) cout << "three card" << endl;
else if(pair == 2) cout << "two pair" << endl;
else if(pair == 1) cout << "one pair" << endl;
else cout << "null" << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for(int i = (int)(n); i > 0; i--)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define resort(v) sort((v).rbegin(), (v).rend())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
using ll = long long;
using P = pair<int, int>;
/* ----------------ใใไฝฟใๆฐๅญใ้
ๅ----------------- */
int dx[] = {1,0,-1,0};
int dy[] = {0,1,0,-1};
constexpr ll mod = 1e9+7;
constexpr ll inf = LLONG_MAX;
constexpr long double eps = DBL_EPSILON;
constexpr long double pi = 3.141592653589793238462643383279;
/* ----------------------end----------------------- */
/* --------------------ใฉใคใใฉใช-------------------- */
ll fact(int i) { //้ไน
if (i == 0) return 1;
return (fact(i - 1)) * i;
}
ll gcd(ll a, ll b) { //ๆๅคงๅ
ฌ็ดๆฐ
if(b == 0) return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { //ๆๅฐๅ
ฌๅๆฐ
return a * b / gcd(a, b);
}
int keta(ll n) { //ๆกๆฐใๆฑใใ
if(n == 0) return 1;
int count = 0;
while(n != 0) {
n /= 10;
count++;
}
return count;
}
ll ketasum(ll n) { //ๅๆกใฎๅ
ll sum = 0;
while(n != 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
/* ----------------------end----------------------- */
int main() {
int a,b,c,d;
cin >> a >> b >> c >> d;
int p = a+b,q=c+d;
if(p>q) cout << "Left" << endl;
else if(p<q) cout << "Right" << endl;
else cout << "Balanced" << endl;
return 0;
} | 0 |
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <iostream> // cout, endl, cin
#include <iomanip>
#include <string> // string, to_string, stoi
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <utility> // pair, make_pair
#include <tuple> // tuple, make_tuple
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <math.h>
using namespace std;
int main() {
vector<long long> num(3);
long long K;
for (int i = 0; i < 3; i++) {
cin >> num.at(i);
}
sort(num.begin(), num.end());
cin >> K;
for (int i = 0; i < K; i++) {
num.back() *= 2;
}
long long ans;
ans = num.at(0) + num.at(1) + num.at(2);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, c, k;
cin >> a >> b >> c >> k;
long long ans = a + b + c;
a = max(a, max(b, c));
ans -= a;
for(int i = 0; i < k; i++) a *= 2;
cout << ans + a << endl;
} | 1 |
#include <iostream>
using namespace std;
int main()
{
int n, m, q, x, y;
cin >> n >> m >> q;
int count[501][501] = {0};
for(int i = 0; i < m; i++)
{
cin >> x >> y;
count[x][y]++;
}
for(int i =0; i <= n; i++)
{
for(int j = 1; j <= n; j++)
{
count[i][j] += count[i][j - 1];
}
}
for(int i = 0; i <= n; i++)
{
for(int j = n - 1; j >= 0; j--)
{
count[j][i] += count[j + 1][i];
}
}
for(int i = 0; i < q; i++)
{
cin >> x >> y;
cout << count[x][y] << endl;
}
return 0;
}
| #include <bits/stdc++.h>
// #undef DEBUG // Uncomment this line to forcefully disable debug print.
#if DEBUG
template <typename T>
void debug(const T& value) {
std::cerr << value;
}
template <typename T, typename... Ts>
void debug(const T& value, const Ts&... args) {
std::cerr << value << ", ";
debug(args...);
}
#define dbg(...) \
do { \
cerr << #__VA_ARGS__ << ": "; \
debug(__VA_ARGS__); \
cerr << " (L" << __LINE__ << ")\n"; \
} while (0)
#else
#define dbg(...)
#endif
void read_from_cin() {}
template <typename T, typename... Ts>
void read_from_cin(T& value, Ts&... args) {
std::cin >> value;
read_from_cin(args...);
}
#define in(type, ...) \
type __VA_ARGS__; \
read_from_cin(__VA_ARGS__);
template <typename T>
void write_to_cout(const T& value) {
std::cout << value << '\n';
}
template <typename T, typename... Ts>
void write_to_cout(const T& value, const Ts&... args) {
std::cout << value << ' ';
write_to_cout(args...);
}
#define out(...) write_to_cout(__VA_ARGS__);
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
using ll = long long;
template <typename T>
using V = std::vector<T>;
template <typename T>
using VV = V<V<T>>;
using namespace std;
template <typename T>
class BIT {
public:
BIT(int n) : v_(n) {}
T Sum(int i) const {
T ret = 0;
while (i >= 0) {
ret += v_[i];
i = (i & (i + 1)) - 1;
}
return ret;
}
T Get(int i) const { return Sum(i) - Sum(i - 1); }
void Add(int i, T v) {
while (i < v_.size()) {
v_[i] += v;
i |= i + 1;
}
}
private:
std::vector<T> v_;
};
using P = pair<int, int>;
struct Query {
int i, l, r;
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
in(int, N, M, Q);
V<P> trains;
rep(i, M) {
in(int, L, R);
trains.push_back({L - 1, R - 1});
}
sort(all(trains), [](const P& a, const P& b) { return a.second < b.second; });
V<Query> queries;
rep(i, Q) {
in(int, p, q);
queries.push_back({i, p - 1, q - 1});
}
sort(all(queries), [](const Query& a, const Query& b) { return a.r < b.r; });
V<int> ans(Q);
BIT<int> bit(N);
auto ti = trains.begin();
auto qi = queries.begin();
rep(r, N) {
for (; ti != trains.end() && ti->second <= r; ++ti) {
bit.Add(ti->first, 1);
}
for (; qi != queries.end() && qi->r <= r; ++qi) {
ans[qi->i] = bit.Sum(qi->r) - bit.Sum(qi->l - 1);
}
}
rep(i, Q) out(ans[i]);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;
#define ALL(a) begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define FF first
#define SS second
template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
return is >> p.FF >> p.SS;
}
template<class S, class T>
ostream& operator<<(ostream& os, const pair<S,T>& p){
return os << p.FF << " " << p.SS;
}
template<class T>
void maxi(T& x, T y){
if(x < y) x = y;
}
template<class T>
void mini(T& x, T y){
if(x > y) x = y;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const LL MOD = 1e9+7;
struct Edge{
int to, cost;
Edge(int t, int c = 0): to(t), cost(c)
{}
bool operator>(const Edge& rhs) const{
return cost > rhs.cost;
}
bool operator<(const Edge& rhs) const{
return cost < rhs.cost;
}
};
using Graph = vector< vector<Edge> >;
void add_edge(Graph& graph, int u, int v, int cost = 0){
graph[u].push_back(Edge(v,cost));
graph[v].push_back(Edge(u,cost));
}
void lowlink(int u, int p, int& num, const Graph& G, VI& ord, VI& low,
VI& art, vector<pair<int,int>>& brd){
ord[u] = low[u] = num++;
int chd_num = 0, chd_low_mx = -1;
for(unsigned int i=0;i<G[u].size();++i){
auto& e = G[u][i];
int to = e.to;
if(to == p) continue;
if(ord[to] < 0){
lowlink(to, u, num, G, ord, low, art, brd);
low[u] = min(low[u], low[to]);
if(ord[u] < low[to]){
brd.push_back(MP(u, i));
}
++chd_num;
chd_low_mx = max(chd_low_mx, low[to]);
}
else{
low[u] = min(low[u], ord[to]);
}
}
if(p == -1){
if(chd_num > 1)
art.push_back(u);
}
else{
if(ord[u] <= chd_low_mx)
art.push_back(u);
}
}
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
int V, E;
cin >> V >> E;
Graph G(V);
REP(i,E){
int u, v;
cin >> u >> v;
add_edge(G, u, v);
}
int num = 0;
VI ord(V, -1);
VI low(V, -1);
vector<PII> brd;
VI art;
lowlink(0, -1, num, G, ord, low, art, brd);
SORT(art);
for(int v: art) cout << v << endl;
return 0;
}
| #include<iostream>
#include<list>
#include<queue>
#include<set>
#include<algorithm>
#include<stdio.h>
using namespace std;
int n, m;
struct Node {
//int id;
list<int> next;
};
Node graph[100005];
int prenum[100005];
int parent[100005];
int lowest[100005];
set<int> answer;
int rootCount;
void dfs(int curNodeId,int step) {
int low = prenum[curNodeId];
list<int>::iterator it = graph[curNodeId].next.begin();
list<int>::iterator end = graph[curNodeId].next.end();
for (it; it != end; it++) {
int id = *it;
if (prenum[id] == 0) {
parent[id] = curNodeId;
prenum[id] = step + 1;
dfs(id, step + 1);
low = min(low, lowest[id]);
if (step == 1) {
rootCount++;
}
}
else {
low = min(low, prenum[id]);
}
}
lowest[curNodeId] = low;
}
void findArticulationPoint() {
if (rootCount >= 2) {
answer.insert(0);
}
int p;
for (int i = 1; i < n; i++) {
p = parent[i];
if (p == 0) {
continue;
}
if (prenum[p] <= lowest[i]) {
answer.insert(p);
}
}
vector<int> ans;
for (set<int>::iterator it = answer.begin(); it != answer.end(); it++) {
ans.push_back(*it);
}
sort(ans.begin(), ans.end());
for (vector<int>::iterator it = ans.begin(); it != ans.end(); it++) {
printf("%d\n", *it);
}
}
int main() {
scanf("%d %d", &n,&m);
int a, b;
for (int i = 0; i < m; i++) {
scanf("%d %d", &a,&b);
graph[a].next.push_back(b);
graph[b].next.push_back(a);
}
prenum[0] = 1;
dfs(0,1);
findArticulationPoint();
/*for (int i = 0; i < n; i++) {
cout << i << " " << prenum[i] << " " << parent[i] << " " << lowest[i] << endl;
}*/
}
| 1 |
#define _USE_MATH_DEFINES
#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cmath>
#include <bitset>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef tuple<ll, ll, ll> tl3;
const int BIG_NUM = 1e9;
const ll INF = 1000000000000000000;
const ll MOD = 1e9 + 7;
//const ll MOD = 998244353;
const int MAX = 18;
int main() {
int n;
cin >> n;
ll ans = 0;
vector<vector<ll>> c(MAX + 1, vector<ll>(MAX + 1));
for (int i = 0; i < n; i++) {
string s;
cin >> s;
ll a = 0;
bool isD = false;
int cnt = 0;
for (int i = 0; i < s.length(); i++) {
if (isD) {
cnt++;
}
if (s[i] == '.') {
isD = true;
continue;
}
a = a * 10 + s[i] - '0';
}
while (cnt < 9) {
a *= 10;
cnt++;
}
//cout << a << endl;
int cnt2 = 0;
int cnt5 = 0;
while (a % 2 == 0) {
cnt2++;
a /= 2;
}
cnt2 = min(cnt2, MAX);
while (a % 5 == 0) {
cnt5++;
a /= 5;
}
cnt5 = min(cnt5, MAX);
for (int i = 0; i <= MAX; i++) {
if (i + cnt2 < MAX) {
continue;
}
for (int j = 0; j <= MAX; j++) {
if (j + cnt5 < MAX) {
continue;
}
ans += c[i][j];
}
}
c[cnt2][cnt5]++;
}
cout << ans << endl;
/*
cout.fill(' ');
cout << " ";
for (int i = 0; i <= MAX; i++) {
cout << setw(2) << i << " ";
}
cout << endl;
for (int i = 0; i <= MAX; i++) {
cout << setw(2) << i << " ";
for (int j = 0; j <= MAX; j++) {
cout << setw(2) << c[i][j] << " ";
}
cout << setw(2) << endl;
}
*/
} | #include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
using namespace std;
void read(int &x){
x=0; char c=getchar(); int p=1;
for (;c<48;c=getchar())if (c=='-')p=-1;
for (;c>47;c=getchar())x=(x<<1)+(x<<3)+(c^48);
x*=p;
}
void read(ll &x){
x=0; char c=getchar(); int p=1;
for (;c<48;c=getchar())if (c=='-')p=-1;
for (;c>47;c=getchar())x=(x<<1)+(x<<3)+(c^48);
x*=p;
}
void Min(int &x,int y){
if (x>y)x=y;
}
void Min(ll &x,ll y){
if (x>y)x=y;
}
void Max(int &x,int y){
if (x<y)x=y;
}
void Max(ll &x,ll y){
if (x<y)x=y;
}
#define bas 50
ll cnt[105][105];
char s[50];
int main(){
// freopen("1.in","r",stdin);
int n,i,j,k,l;
ll x,res=0;
read(n);
/*
cnt2[i]+cnt2[j]>=0
cnt5[i]+cnt5[j]>=0
*/
int m,ct2,ct5;
for (i=1;i<=n;i++){
scanf("%s",s);
m=strlen(s);
x=0; ct2=ct5=0;
for (j=0;j<m;j++){
if (s[j]!='.'){
x=(x<<1)+(x<<3)+(s[j]^48);
}
else{
ct2-=m-j-1;
ct5-=m-j-1;
}
}
for (;x&&x%2==0;)x/=2,ct2++;
for (;x&&x%5==0;)x/=5,ct5++;
cnt[bas+ct2][bas+ct5]++;
if (ct2>=0&&ct5>=0)res--;
// printf("%d %d\n",ct2,ct5);
}
for (i=-50;i<=50;i++){
for (j=-50;j<=50;j++)if (cnt[i+bas][j+bas]){
for (k=-i;k<=50;k++){
for (l=-j;l<=50;l++){
res+=cnt[i+bas][j+bas]*cnt[k+bas][l+bas];
}
}
}
}
printf("%lld\n",res/2);
return 0;
} | 1 |
#include <iostream>
using namespace std;
int main(){
while(1){
int E;
cin >> E;
if(E==0) break;
int x=0,y=0,z=0;
int m = 1000000;
for(z=0;z*z*z<=E;z++){
for(y=0;(z*z*z)+(y*y)<=E;y++){
x=E-(z*z*z)-(y*y);
if(x+y+z<m){
m=x+y+z;
//cout << x << y << z << endl;
}
}
}
cout << m << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
const int N = 510;
int p[10010];
vector<int> primes;
int a[N * 2], b[N * 2];
void init() {
for (int i = 2; i < 10000; i++) {
if (!p[i]) {
for (int j = i + i; j < 10000; j += i) {
p[j] = 1;
}
primes.push_back(i);
}
}
}
long long res[N][N];
set<long long> has;
long long lcm(long long a, long long b) {
long long c = __gcd(a, b);
return (a / c) * b;
}
int main() {
init();
int n;
scanf("%d", &n);
int cnt = 0;
for (int i = 0; i < n; i++) {
a[i] = primes[cnt++];
}
for (int i = 0; i < n; i++) {
b[i] = primes[cnt++];
}
memset(res, -1, sizeof res);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if ((i + j) % 2 == 0) {
int aa = i + j >> 1;
int bb = (i - j + n) >> 1;
res[i][j] = 1ll * a[aa] * b[bb];
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if ((i + j) % 2 == 0) {
continue;
}
long long foo = 1ll;
if (i > 0) {
foo = lcm(foo, res[i - 1][j]);
}
if (i + 1 < n) {
foo = lcm(foo, res[i + 1][j]);
}
if (j > 0) {
foo = lcm(foo, res[i][j - 1]);
}
if (j + 1 < n) {
foo = lcm(foo, res[i][j + 1]);
}
int it = 1;
while (has.count(foo * it)) {
it++;
}
has.insert(foo * it);
res[i][j] = foo * it + 1;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
printf("%lld ", res[i][j]);
}
printf("\n");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); ++i)
#define MOD 1e9+7;
using namespace std;
using ll = long long;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i,n) cin >> a[i];
if (n == 1) {
cout << 1;
return 0;
}
sort(a.begin(), a.end());
int ans = 0;
rep(i,n - 1) {
if (a[i] != a[i + 1]) ans++;
else i++;
if (i == n - 2) ans++;
}
cout << ans;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repI(i, d, n) for (int i = (d); i < (n); ++i)
#define reps1(i, n) for (int i = 1; i < (n); ++i)
using namespace std;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
using ll = long long;
using P = pair<int, int>;
using Pl = pair<ll, ll>;
using M = map<int, int>;
using Ml = map<ll, ll>;
ll const INF = 1ll<<61;
double pi = 3.141592653589793238;
int main() {
string a, b, c;
cin >> a >> b >> c;
queue<char> qa, qb, qc;
for(char ch: a) qa.push(ch);
for(char ch: b) qb.push(ch);
for(char ch: c) qc.push(ch);
char next = 'a';
while(true) {
if (next == 'a') {
if (qa.empty()) {
cout << 'A' << endl;
return 0;
}
next = qa.front();
qa.pop();
}
if (next == 'b') {
if (qb.empty()) {
cout << 'B' << endl;
return 0;
}
next = qb.front();
qb.pop();
}
if (next == 'c') {
if (qc.empty()) {
cout << 'C' << endl;
return 0;
}
next = qc.front();
qc.pop();
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,n)for(long long i=0;i<(n);i++)
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int INF=1e9;
const int MOD=1e9+7;
const double pi=acos(-1);
int main(){
int n;
cin >> n;
ll s[200010];
s[0]=0;
rep(i,n){
ll a;
cin >> a;
s[i+1]=s[i]+a;
}
ll ans=1e18;
for(int i=2;i<n-1;i++){
ll *l,*r;
ll gap;
l=lower_bound(s+1,s+i+1,s[i]/2+1);
r=lower_bound(s+i+1,s+n+1,(s[n]+s[i])/2+1);
rep(j,2){
rep(k,2){
gap=max({*l,s[i]-*l,*r-s[i],s[n]-*r})-min({*l,s[i]-*l,*r-s[i],s[n]-*r});
ans=min(ans,gap);
l--;
}
l+=2;
r--;
}
}
cout << ans << endl;
}
| #include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <random>
#include <iomanip>
#include <functional>
#include <cassert>
using namespace std;
typedef long long ll;
int gcd(int a, int b) {
return (b == 0 ? a : gcd(b, a % b));
}
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
#ifdef LOCAL
freopen("input.txt", "r", stdin);
#endif
int n;
cin >> n;
vector <int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
function <int(vector <int>)> get = [&] (vector <int> v) {
ll sum = 0;
for (int i = 0; i < n; ++i) sum += v[i] - 1;
if (sum % 2 == 1) return 0;
int cnt = 0;
for (int i = 0; i < n; ++i) {
if (v[i] % 2 == 1) {
if (v[i] == 1) {
cnt += 2;
} else {
++cnt;
}
}
}
if (cnt != 1) {
return 1;
} else {
int g = 0;
for (int i = 0; i < n; ++i) {
if (v[i] % 2 == 1) {
--v[i];
}
g = gcd(g, v[i]);
}
for (int i = 0; i < n; ++i) v[i] /= g;
return 1 ^ get(v);
}
};
if (get(a) == 0) {
cout << "First\n";
} else {
cout << "Second\n";
}
}
| 0 |
#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#define NIL -1
#define MAX 610005
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
using namespace std;
int n;
int root;
int *p = new int[MAX]; // p---| Unit
int *left2 = new int[MAX]; // left2 --|--------> T
int *right2 = new int[MAX]; //right2---|
int *key = new int[MAX]; // key----|
void Init(){
rep(i,MAX){
p[i]=left2[i]=right2[i]=key[i]=NIL;
}
}
int TREE_MINIMUM(int x){
while(left2[x] != NIL){
x = left2[x];
}
return x;
}
int TREE_SUCCESSOR(int x){
if(right2[x] != NIL)return TREE_MINIMUM(right2[x]);
int y = p[x];
while(y != NIL && x == right2[y]){
x = y;
y = p[y];
}
return y;
}
void TREE_DELETE(int z){
int y,x;
if(left2[z] == NIL || right2[z] == NIL)y = z;
else y = TREE_SUCCESSOR(z);
if(left2[y] != NIL)x = left2[y];
else x = right2[y];
if(x != NIL)p[x]=p[y];
if(p[y] == NIL)root = x;
else if(y == left2[p[y]])left2[p[y]] = x;
else right2[p[y]] = x;
if(y != z)key[z] = key[y];
}
bool SEARCH(int x,int k){
if(k == key[x])return true;
if(x == NIL)return false;
if(k < key[x])return SEARCH(left2[x],k);
else return SEARCH(right2[x],k);
}
void TREE_INSERT(int z){
int y = NIL;
int x = root;
while(x != NIL){
y = x;
if(key[z] < key[x]){
x = left2[x];
}
else x = right2[x];
}
p[z]=y;
if(y == NIL){
root = z;
}
else if(key[z] < key[y]){
left2[y] = z;
}else{
right2[y] = z;
}
}
int IndexSearch(int x){
for(int i=0;i<MAX;i++){
if(key[i] == x)return i;
}
return -1;
}
void InorderTreeWalk(int x){
if(x != NIL){
InorderTreeWalk(left2[x]);
printf(" %d",key[x]);
InorderTreeWalk(right2[x]);
}
}
void PreorderTreeWalk(int x){
if(x != NIL){
printf(" %d",key[x]);
PreorderTreeWalk(left2[x]);
PreorderTreeWalk(right2[x]);
}
}
int main(){
int val;
string op;
long long zr;
scanf("%d",&n);
Init();
root = -1;
zr=0;
while(n-- > 0){
cin >> op;
if(op == "insert"){
scanf("%d",&val);
key[zr]=val;
TREE_INSERT(zr);
zr++;
}else if(op == "print"){
InorderTreeWalk(root);
printf("\n");
PreorderTreeWalk(root);
printf("\n");
}
else if(op == "find"){
scanf("%d",&val);
if(SEARCH(root,val)){
printf("yes\n");
}else{
printf("no\n");
}
}
else if(op == "delete"){
scanf("%d",&val);
int inthis = IndexSearch(val);
if(inthis != -1){
TREE_DELETE(inthis);
}
}
}
delete [] p;
delete [] left2;
delete [] right2;
delete [] key;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define int ll
#define pb push_back
#define setbits(x) __builtin_popcountll(x)
#define endl "\n"
typedef long long ll;
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin>>n;
int arr[n][n];
for(int i=0;i<n;i++)
{
for(int j=0;j<n-1;j++)
{
cin>>arr[i][j];
arr[i][j]-=1;
}
}
int dp[n+1]={};
int ans=0;
while(1)
{int jarorat[n]={};
int vis[n]={};
for(int j=0;j<n;j++)
{
int x=dp[j];
if(x!=n-1)
jarorat[j]=(arr[j][x]);
else
vis[j]=1;
}
int cnt=0;
for(int j=0;j<n;j++)
{
if(jarorat[jarorat[j]]==j&&vis[j]==0&&vis[jarorat[jarorat[j]]]==0)
{
dp[j]++;
dp[jarorat[j]]++;
vis[j]=1;
vis[jarorat[j]]=1;
cnt++;
}
}
if(cnt==0)
break;
ans++;
}
for(int i=0;i<n;i++)
{
if(dp[i]!=n-1)
{
cout<<-1<<endl;
return 0;
}
}
cout<<ans<<endl;
return 0;
}
| 0 |
// https://agc026.contest.atcoder.jp/tasks/agc026_c
#include <bits/stdc++.h>
using namespace std;
template<class C>constexpr int sz(const C&c){return int(c.size());}
using ll=long long;constexpr const char nl='\n',sp=' ';
seed_seq seq {
uint64_t(chrono::duration_cast<chrono::nanoseconds>(
chrono::steady_clock::now().time_since_epoch()).count()
),
uint64_t(__builtin_ia32_rdtsc()),
uint64_t(uintptr_t(make_unique<char>().get()))
};
mt19937 rng(seq); mt19937_64 rng64(seq);
const size_t RANDOM = uniform_int_distribution<size_t>(
0, numeric_limits<size_t>::max())(rng64);
struct rand_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15; x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb; return x ^ (x >> 31);
}
template <class T> size_t operator () (const T &x) const {
return splitmix64(hash<T>()(x) + RANDOM);
}
template <class T1, class T2>
size_t operator () (const pair<T1, T2> &p) const {
return 31 * operator ()(p.first) + operator ()(p.second);
}
};
template <class K, class H = rand_hash, class ...Ts>
using uset = unordered_set<K, H, Ts ...>;
template <class K, class V, class H = rand_hash, class ...Ts>
using umap = unordered_map<K, V, H, Ts ...>;
int N;
string S;
umap<pair<string, string>, ll> M;
int main() {
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
// freopen("err.txt", "w", stderr);
ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
cin >> N >> S;
for (int i = 0; i < (1 << N); i++) {
string red, blue;
for (int j = 0; j < N; j++) {
if ((i >> j) & 1) red.push_back(S[j]);
else blue.push_back(S[j]);
}
reverse(blue.begin(), blue.end());
M[make_pair(red, blue)]++;
}
ll cnt = 0;
for (int i = 0; i < (1 << N); i++) {
string red, blue;
for (int j = 0; j < N; j++) {
if ((i >> j) & 1) red.push_back(S[N + j]);
else blue.push_back(S[N + j]);
}
reverse(blue.begin(), blue.end());
cnt += M[make_pair(blue, red)];
}
cout << cnt << nl;
return 0;
}
| #include<bits/stdc++.h>
#define ll long long
using namespace std;
ll n,i,j,mx,t,x,ans,f[19][19],a[19],b[19];
char s[101];
int main(){
scanf("%lld",&n);
scanf("%s",s+1);
mx=1ll<<n;mx--;
for(t=0;t<=mx;t++){
a[0]=b[0]=0;
for(i=n*2;i>n;i--){
x=n*2-i;
if(t&(1ll<<x))a[++a[0]]=s[i]-'a';
else b[++b[0]]=s[i]-'a';
}
memset(f,0,sizeof(f));
f[0][0]=1;
for(i=1;i<=n;i++){
for(j=0;j<=min(a[0],i-1);j++){
if(i-1-j>b[0])continue;
if(j<a[0]&&s[i]-'a'==a[j+1])f[i][j+1]+=f[i-1][j];
if(i-j<=b[0]&&s[i]-'a'==b[i-j])f[i][j]+=f[i-1][j];
}
}
ans+=f[n][a[0]];
}
printf("%lld",ans);
} | 1 |
#include <bits/stdc++.h>
using namespace std;
string query(int n) {
cout << n << '\n' << flush;
string s; cin >> s;
if (s == "Vacant") exit(0);
return s;
}
int main() {
int n; cin >> n;
int l = 0;
int r = n - 1;
string L = query(l);
string R = query(r);
while (true) {
int m = (l + r) / 2;
string M = query(m);
if (L == M && m % 2) r = m;
if (L == M && !(m % 2)) l = m;
if (L != M && m % 2) l = m;
if (L != M && !(m % 2)) r = m;
}
return 0;
} | #include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define mp make_pair
using namespace std;
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
int t=1;
//cin>>t;
while(t--)
{
string s;
cin>>s;
int l,r;
string t;
if(s.size()<2)
{
cout<<"-1 -1";
return 0;
}
if(s.size()==2)
{
if(s[0]==s[1])
{
cout<<"1 2";
return 0;
}
else
{
cout<<"-1 -1";
return 0;
}
}
for(int i=0;i<s.size()-2;++i)
{
t = s.substr(i,3);
sort(t.begin(),t.end());
if(t[0]==t[1] || t[1]==t[2])
{
cout<<i+1<<" "<<i+3;
return 0;
}
//cout<<t<<"\n";
}
cout<<"-1 -1";
}
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,n)for(long long i=0;i<(long long)(n);++i)
#define all(a) a.begin(), a.end()
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
const ll MOD=1e9+7;
const ll INF=1e18;
const double pi=acos(-1);
int dx[8] = {1,0,-1,0,1,1,-1,-1};
int dy[8] = {0,1,0,-1,-1,1,1,-1};
const int MAX=510000;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int a,b,c,d;
cin >> a >> b >> c>> d;
b+=60*a;
d+=60*c;
int k;
cin >> k;
if(d-b>=k)cout << d-b-k << endl;
else cout << 0 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define rep(i, n) repl(i, 0, n)
#define fi first
#define se second
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
using ll = long long;
const ll MOD = 1000000007;
const int inf = 1e9 + 10;
const ll INF = 4e18 + 10;
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
int a, b, c, d, k;
cin >> a >> b >> c >> d >> k;
cout << c * 60 + d - a * 60 - b - k << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int,int> pii;
#define REP(i,n) for(ll i=0;i<n;++i)
#define REPR(i,n) for(ll i=1;i<n;++i)
#define FOR(i,a,b) for(ll i=a;i<b;++i)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define DEBUG_VEC(v) cout<<#v<<":";REP(i,v.size())cout<<" "<<v[i];cout<<endl
#define ALL(a) (a).begin(),(a).end()
#define MOD (ll)(1e9+7)
#define ADD(a,b) a=((a)+(b))%MOD
#define FIX(a) ((a)%MOD+MOD)%MOD
#define INF 1000000000
typedef long double Real;
#define EPS 1e-11
#define EQ(x) (-EPS<x && x<EPS)
typedef complex<Real> P;
Real dot(P a,P b){return real(conj(a)*b);}
Real cross(P a,P b){return imag(conj(a)*b);}
char s[10];
bool eq(int a,int b,int c,char o){
return (s[a]==o && s[b]==o && s[c]==o);
}
int mp[12][12];
void dfs(int x,int y,int k){
if(x<0 || x>=12 || y<0 || y>=12)return;
if(mp[x][y]!=-1)return;
mp[x][y] = k;
int d[5]={0,1,0,-1,0};
REP(i,4)dfs(x+d[i],y+d[i+1],k);
}
int main(){
ll n;
while(~scanf("%lld",&n)){
REP(i,12){
mp[0][i]=-(n&1);
n/=10;
}
REPR(i,12){
scanf("%lld",&n);
REP(j,12){
mp[i][j]=-(n&1);
n/=10;
}
}
int k = 1;
int cnt = 0;
REP(i,12)REP(j,12){
if(mp[i][j]==-1){
++cnt;
dfs(i,j,k++);
}
}
cout<<cnt<<endl;
}
return 0;
} | #include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <stack>
#include <queue>
#include <set>
#include <bitset>
#include <map>
#include <unordered_map>
#include <ctime>
#include <list>
#include <numeric>
#include <utility>
#include <ctime>
#define INF 1000000000
#define LINF 9000000000000000000
#define mod 1000000007
#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 REP(i,a,b) for(int i=(a);i<int(b);i++)
#define all(x) (x).begin(),x.end()
#define pb push_back
#define mp make_pair
#define MOD(x) (x%(mod))
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef pair<int,int> pi;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
int ddx[8]={-1,-1,0,1,1,1,0,-1};
int ddy[8]={0,1,1,1,0,-1,-1,-1};
bool debug=false;
/*---------------------------------------------------*/
char island[13][13];
void bfs(int x,int y){
island[y][x]='0';
queue<pi> que;
que.push(mp(x,y));
while(que.size()){
pi d=que.front();que.pop();
rep(i,4){
int xx=d.first+dx[i],yy=d.second+dy[i];
if(0<=xx&&xx<=12&&0<=yy&&yy<=12&&island[yy][xx]=='1'){
que.push(mp(xx,yy));
island[yy][xx]='0';
}
}
}
}
int solve(){
int ret=0;
rep(i,12){
rep(j,12){
if(island[i][j]=='1'){
ret++;
bfs(j, i);
}
}
}
return ret;
}
int main(){
char a;
while(cin>>a){
island[0][0]=a;
// cout<<"in"<<endl;
rep(i,12){
rep(j,12){
if(i==0&&j==0)continue;
// cout<<i<<" "<<j<<endl;
cin>>island[i][j];
}
}
cout<<solve()<<endl;
}
}
| 1 |
#include <bits/stdc++.h>
#define ri register
#define int long long
using namespace std;
inline int read()
{
int s=0, w=1; ri char ch=getchar();
while(ch<'0'||ch>'9') { if(ch=='-') w=-1; ch=getchar(); }
while(ch>='0'&&ch<='9') s=(s<<3)+(s<<1)+(ch^48), ch=getchar();
return s*w;
}
int s[10];
inline bool Check(int x)
{
int cnt=0;
while(x) s[++cnt]=x%10, x/=10;
if(s[1]==s[5]&&s[2]==s[4]) return 1;
return 0;
}
signed main()
{
int a,b;
a=read();
b=read();
int res=0;
for(ri int i=a;i<=b;i++) if(Check(i)) res++;
printf("%lld\n",res);
return 0;
} |
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<math.h>
using namespace std;
int main()
{
int b,c,d,e,f,g,h,i,j,k,l,m,t;
long long a;
cin>>a;
string s;
while(a--)
{
s+=('a'+a%26);
a=a/26;
}
reverse(s.begin(),s.end());
cout<<s;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll MOD = 1000000007;
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define REP2(i, x, n) for (ll i = x; i < (n); i++)
const long long INF = numeric_limits<long long>::max();
template <class T>
inline bool chmin(T &a, T b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T &a, T b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
string func(ll N, ll Y)
{
for (ll i = 0; i <= N; ++i)
{
ll iAmount = 10000 * i;
for (ll j = 0; j <= (N-i); ++j)
{
ll jAmount = 5000 * j;
ll k = N - (i + j);
if ( k < 0 ) continue;
if (iAmount + jAmount + 1000 * k == Y)
{
#ifdef SOURCE_TEST
cout << N << " " << Y << endl;
cout << i + j + k << endl;
cout << i * 10000 + j * 5000 + k * 1000 << endl;
#endif
return to_string(i) + " " + to_string(j) + " " + to_string(k);
}
}
}
return "-1 -1 -1";
}
int main()
{
ll N, Y;
cin >> N >> Y;
cout << func(N, Y) << endl;
return 0;
} | #include <iostream> // cout, endl, cin
#include <string> // string, to_string, stoi
#include <vector> // vector
#include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <utility> // pair, make_pair
#include <tuple> // tuple, make_tuple
#include <cstdint> // int64_t, int*_t
#include <cstdio> // printf
#include <map> // map
#include <queue> // queue, priority_queue
#include <set> // set
#include <stack> // stack
#include <deque> // deque
#include <unordered_map> // unordered_map
#include <unordered_set> // unordered_set
#include <bitset> // bitset
#include <cctype> // isupper, islower, isdigit, toupper, tolower
#include <memory> // unique_ptr, shared_ptr, weak_ptr
#include <cstring>
#include <cmath>
using namespace std;
using ll = long long int;
using vi = vector<int>;
using vvi = vector<vi>;
#define _LIBCPP_DEBUG 0
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define all(v) v.begin(), v.end()
int main() {
int N, Y; cin >> N >> Y;
for (int x=0; x<=N; x++) {
for (int y=0; x+y<=N; y++) {
int z = N - x - y;
if (Y == 10000*x + 5000*y + 1000*z) {
cout << x << " " << y << " " << z << endl;
return 0;
}
}
}
cout << "-1 -1 -1" << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n; cin >> n;
string s; cin >> s;
if(s.length() <= n) cout << s << endl;
else{
for(int i = 0; i < n; i++) cout << s[i];
cout << "..." << endl;
}
} | #include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
#define initdp(a, b) for (int i = 0; i <= a; i++) for (int j = 0; j <= b; j++) dp[i][j] = -1;
#define pb push_back
#define mpr make_pair
#define pii pair<int, int>
#define ll long long
#define pll pair<ll, ll>
#define all(arr) arr.begin(), arr.end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repd(i, n) for (int i = n - 1; i >= 0; i--)
#define fo(i, l, r) for (int i = l; i <= r; i++)
#define INF 1000000001
#define inf1 1000000000000000001
#define mod 1000000007
#define pie 3.14159265358979323846264338327950L
#define N 1000005
#define mid(l, r) l + (r - l) / 2
#define vec vector<int>
#define vecl vector<ll>
#define umap unordered_map<ll,ll>
#define yes cout << "YES" << endl;
#define no cout << "NO" << endl;
#define endl "\n"
using namespace std;
ll gcd(ll a, ll b) {
if(b==0)
return a;
return gcd(b, a%b);
}
void solve(){
int n,M;
cin>>n>>M;
int a,b;
if(M%2==0){
a=M/2;
b=M/2;
}else{
a=M/2;
b=M-a;
}
for(int i=1;i<=a;++i){
cout<<i<<" "<<2*a+2-i<<endl;
}
for(int i=1;i<=b;++i){
cout<<i+2*a+1<<" "<<M*2+2-i<<endl;
}
}
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout<<fixed<<setprecision(20);
int t = 1;
// cin >> t;
while (t--)
{
solve();
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
using ll = long long;
using P = pair<ll,ll>;
using graph = vector<vector<int>>;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll INF = 1LL<<60;
const ll mod = 1000000007LL;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
struct BIT{
int N;
int bit[1000010];
void add(int a,int w){
for(int x = a; x < N; x+=(x&-x)) bit[x]+=w;
}
int sum(int a){
int ret = 0;
for ( int x = a; x > 0;x-=(x&-x)) ret += bit[x];
return ret;
}
};
int main() {
ll N;
string S;
cin>>N>>S;
int Q;
cin>>Q;
vector<int> D,M,C;
vector<vector<ll>> cnt(N+1,vector<ll>(3,0));
rep(i,N){
if(S[i]=='D') {
D.push_back(i);
cnt[i+1][0]++;
}
if(S[i]=='M') {
M.push_back(i);
cnt[i+1][1]++;
}
if(S[i]=='C') {
C.push_back(i);
cnt[i+1][2]++;
}
}
rep(i,N){
rep(j,3){
cnt[i+1][j]+=cnt[i][j];
}
}
vector<ll> DMcnt(N+1,0);
rep(i,N){
if(S[i]=='M') DMcnt[i+1]+=cnt[i+1][0];
}
rep(i,N) DMcnt[i+1]+=DMcnt[i];
rep(i,Q){
int k;
cin>>k;
ll ans = 0;
for(auto x:C){
ll p = DMcnt[x+1]-DMcnt[max(0,x-k+1)]-cnt[max(0,x-k+1)][0]*(cnt[x+1][1]-cnt[max(0,x-k+1)][1]);
ans += p;
}
cout<<ans<<endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double Double;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
// chmax, chmin
template<class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template<class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
void solve(long long N, std::string S, long long Q, std::vector<long long> k) {
auto solve = [&](long long K) {
long long sum = 0;
long long ans = 0;
deque<pair<char, int>> Q;
int dC = 0;
int mC = 0;
for (int i = 0; i < S.size(); i++) {
while (Q.size() && i - K >= Q.front().second) {
if (Q.front().first == 'D') {
sum -= mC;
dC--;
} else {
mC--;
}
Q.pop_front();
}
if (S[i] == 'D') {
Q.push_back({'D', i});
dC++;
} else if (S[i] == 'M') {
Q.push_back({'M', i});
mC++;
sum += dC;
} else if (S[i] == 'C') {
ans += sum;
}
}
return ans;
};
for (auto kv : k) {
cout << solve(kv) << endl;
}
}
int main() {
long long N;
scanf("%lld", &N);
std::string S;
std::cin >> S;
long long Q;
scanf("%lld", &Q);
std::vector<long long> k(Q - 1 - 0 + 1);
for (int i = 0; i < Q - 1 - 0 + 1; i++) {
scanf("%lld", &k[i]);
}
solve(N, S, Q, std::move(k));
return 0;
}
| 1 |
#include<iostream>
#include <algorithm>
using namespace std;
int main(){
int n,a,b,c,d;
cin >> n;
int A[1000];
int B[1000];
for (int i=0; i<n; i++){
A[i] = 0;
B[i] = 0;
}
for(int i=0; i<n*(n-1)/2; i++){
cin >> a >> b >> c >> d;
if( c > d ){
A[a-1] += 3;
B[a-1] += 3;
}
else if( c < d ){
A[b-1] += 3;
B[b-1] += 3;
}
else{
A[a-1] ++;
A[b-1] ++;
B[a-1] ++;
B[b-1] ++;
}
}
sort(A,A+1000);
reverse(A,A+1000);
int x = 0;
for(int i=0; i<n; i++){
for(int j=0; j<n; j++){
x++;
if(B[i] == A[j]){
cout << x << endl;
x = 0;
break;
}
}
}
return 0;
}
| #include<stdio.h>
#include<iostream>
using namespace std;
int main(void){
int n,a[4],t[100],i,c,j;
cin>>n;
for(i=0;i!=n;i++){
t[i]=0;
}
for(i=0;i!=n*(n-1)/2;i++){
for(j=0;j!=4;j++)
cin>>a[j];
if(a[2]<a[3])
t[a[1]-1]+=3;
else if(a[2]>a[3])
t[a[0]-1]+=3;
else{
t[a[0]-1]++;
t[a[1]-1]++;
}
}
for(i=0;i!=n;i++){
c=1;
for(j=0;j!=n;j++){
if(t[i]<t[j])
c++;
}
cout<<c<<endl;
}
} | 1 |
#include <iostream>
#include <vector>
#include <string>
using namespace std;
int main(){
string S; cin >> S;
const int N = S.size();
int K; cin >> K;
int res = 0;
vector<vector<vector<int>>> dp(K+1, vector<vector<int>>(N, vector<int>(N, 0)));
for(int d=N-1;d>=0;d--){
for(int i=0;i+d<N;i++){
int j = i+d;
for(int k=0;k<=K;k++){
if(k < K && S[i] != S[j]){
res = max(res, dp[k][i][j] + 2);
if(i+1 < N && j > 0){
dp[k+1][i+1][j-1] = max(dp[k+1][i+1][j-1], dp[k][i][j] + 2);
}
}
if(S[i] == S[j]){
res = max(res, dp[k][i][j] + (i==j ? 1 : 2));
if(i+1 < N && j > 0){
dp[k][i+1][j-1] = max(dp[k][i+1][j-1], dp[k][i][j] + (i==j ? 1 : 2));
}
}
if(i+1 < N) dp[k][i+1][j] = max(dp[k][i+1][j], dp[k][i][j]);
if(j > 0) dp[k][i][j-1] = max(dp[k][i][j-1], dp[k][i][j]);
}
}
}
cout << res << endl;
} | #include <cstdio>
using namespace std;
int main() {
int a, b;
scanf("%d %d", &a, &b);
int c = 0;
for(int i = a; i <= b; i++) {
int p = i % 10, q = i / 10000 % 10;
int r = i / 10 % 10, s = i / 1000 % 10;
if(p == q && r == s)
c++;
}
printf("%d\n", c);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, y;
cin >> n >> m >> x >> y;
int xmax = x;
int ymin = y;
int a, b;
for (int i = 0; i < n; i++) {
cin >> a;
xmax = max(a, xmax);
}
for (int i = 0; i < m; i++) {
cin >> b;
ymin = min(b, ymin);
}
if (xmax < ymin) {
cout << "No War" << endl;
}
else {
cout << "War" << endl;
}
}
| #include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <deque>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <iomanip>
#include <bitset>
#include <set>
#include <map>
#include <stdio.h>
#include <numeric>
#include <cstring>
#define rep(i,n) for (int i = 0; i < (n); i++)
#define rep1(i,n) for (int i = 1; i < (n); i++)
#define FOR(i,a,b) for (int i=(a); i < (b); i++)
#define MOD 1000000007 //10^9+7
#define ALL(a) (a).begin(),(a).end()
using namespace std;
using ll = long long;
using PII = pair<int, int>;
using PLL = pair<long long, long long>;
const int INF = numeric_limits<int>::max();
const ll INFL = numeric_limits<ll>::max();
constexpr ll TEN(int n) { return (n==0) ? 1 : 10*TEN(n-1); }
const double PI = acos(-1);
// ่ฒ ใฎๆฐใซใๅฏพๅฟใใ % ๆผ็ฎ
long long mod(long long val, long long m) {
long long res = val % m;
if (res < 0) res += m;
return res;
}
//greatest common divisor
long long gcd(ll a, ll b)
{
if (a % b == 0) {
return b;
} else {
return gcd(b, a % b);
}
}
//least common multiple
long long lcm(ll a, ll b)
{
return a / gcd(a, b) * b ;
}
ll factorial(ll n) {
ll res = 1;
for (ll i = 1; i <= n; i++) {
res *= i;
}
return res;
}
bool fn_is_prime(ll n) {
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return n != 1;
}
bool isOK(int index, int key, vector<ll>& a) {
if (a[index] >= key) return true;
else return false;
}
int binary_search(int key, vector<ll>& a) {
int ng = -1;
int ok = a.size();
while (abs(ok - ng) > 1) {
int mid = (ok + ng) / 2;
if (isOK(mid, key, a)) ok = mid;
else ng = mid;
}
return ok;
}
struct UnionFind {
vector<int> r;
UnionFind(int N) {
r = vector<int>(N, -1);
}
int root(int x) {
if (r[x] < 0) return x;
return r[x] = root(r[x]);
}
bool unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (r[x] > r[y]) swap(x, y);
r[x] += r[y];
r[y] = x;
return true;
}
int size(int x) {
return -r[root(x)];
}
bool same(int x, int y) {
return root(x) == root(y);
}
};
//็ด ๅ ๆฐๅ่งฃ
vector<pair<long long, long long> > prime_factorize(long long N) {
vector<pair<long long, long long> > res;
for (long long a = 2; a * a <= N; ++a) {
if (N % a != 0) continue;
long long ex = 0;
while (N % a == 0) {
++ex;
N /= a;
}
res.push_back({a, ex});
}
if (N != 1) res.push_back({N, 1});
return res;
}
//const auto &pf = prime_factorize(i);
//for (auto p : pf) cout << p.first << " " << p.second;
long long pow(long long x, long long n) {
long long ret = 1;
while (n > 0) {
if (n & 1) ret = ret * x % MOD; // n ใฎๆไธไฝbitใ 1 ใชใใฐ x^(2^i) ใใใใ
x = x * x % MOD;
n >>= 1; // n ใ1bit ๅทฆใซใใใ
}
return ret;
}
int main()
{
int n, m; cin >> n >> m;
vector<int> x(n+1), y(m+1);
cin >> x[0] >> y[0];
for (int i = 1; i<= n; i++)
cin >> x[i];
for (int i = 1; i<= m; i++)
cin >> y[i];
sort(ALL(x));
sort(ALL(y));
if (x[n] < y[0])
cout << "No War" << endl;
else
cout <<"War" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define int long long
typedef long long ll;
using namespace std;
const ll MAXN = 200000;
ll N, K, ans=1000000000000, tmp=-1;
vector<ll> A, B;
signed main(){
cin >> N >> K;
for(int i=0;i<N;i++) {
ll a;
cin >> a;
if(a<0) A.push_back(a);
else B.push_back(a);
}
reverse(A.begin(), A.end());
ll As = (ll)A.size();
ll Bs = (ll)B.size();
for(int i=0;i<min(K, As);i++) {
if(Bs-1>=K-i-2&&K-i-2>=0) {
ans = min(ans, 2*min(abs(A[i]), abs(B[K-i-2])) + max(abs(A[i]), abs(B[K-i-2])));
}
}
if(As>=K) ans = min(ans, abs(A[K-1]));
for(int i=0;i<min(K, Bs);i++) {
if(As-1>=K-i-2&&K-i-2>=0) {
ans = min(ans, 2*min(abs(B[i]), abs(A[K-i-2])) + max(abs(B[i]), abs(A[K-i-2])));
}
}
if((ll)B.size()>=K) ans = min(ans, abs(B[K-1]));
/*
if(K>tmp+1) {
for(int i=0;i<=tmp;i++) {
if(K+i-1<=N-1) ans = min(ans, 2*min(abs(A[i]), abs(A[K+i-1])) + max(abs(A[i]), abs(A[K+i-1])));
}
}
if(K>N-tmp-1) {
for(int i=tmp+1;i<N;i++) {
if(i+1-K>=0) ans = min(ans, 2*min(abs(A[i]), abs(A[i+1-K])) + max(abs(A[i]), abs(A[i+1-K])));
}
}
*/
cout << ans << endl;
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
#define FORR(i,b,e) for(int i=(b);i<(int)(e);++i)
#define FOR(i,e) FORR(i,0,e)
#define dump(var) cerr << #var ": " << var << "\n"
#define dumpc(con) for(auto& e: con) cerr << e << " "; cerr<<"\n"
typedef long long ll;
typedef unsigned long long ull;
const double EPS = 1e-6;
const int d4[] = {0, -1, 0, 1, 0};
using namespace std;
struct UnionFind {
vector<int> v;
int groups;
UnionFind() {}
UnionFind(int n): groups(n) {
v.resize(n+1);
FORR(i, 1, n+1) v[i] = i;
}
int find(int p) {
if (v[p] == p) return p;
return v[p] = find(v[p]);
}
int merge(int p, int q) {
p = find(p);
q = find(q);
if (p != q) {
v[q] = p;
groups--;
}
return groups;
}
};
struct Edge {
int s, t, w;
bool operator<(const Edge &o) const {
return w < o.w;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int V, E;
cin >> V >> E;
vector<Edge> edge(E);
FOR(i, E) {
auto &e = edge[i];
cin >> e.s >> e.t >> e.w;
}
sort(edge.begin(), edge.end());
UnionFind uf(V);
int weight = 0;
for (auto &e: edge) {
if (uf.find(e.s) != uf.find(e.t)) {
weight += e.w;
uf.merge(e.s, e.t);
if (uf.groups == 1) break;
}
}
cout << weight << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
long long N;
long long A[200005];
int main(){
cin >> N;
for(long long i = 0; i < N; i++) {
cin >> A[i];
}
set<long long> aset;
for(long long i = 0; i < N; i++) {
if(aset.count(A[i]) != 0) {
cout << "NO" << endl;
return 0;
}
aset.insert(A[i]);
}
cout << "YES" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
string s; cin >> s;
string c = "abcdefghijklmnopqrstuvwxyz";
bool find_flag = false;
for (int i=0; i<26; i++) {
bool target = false;
for (int j=0; j<s.length(); j++) {
if (c[i] == s[j]) target = true;
}
if (!target) {
cout << c[i] << endl;
find_flag = true;
break;
}
}
if (!find_flag) cout << "None" << endl;
return 0;
} | 0 |
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
#include <atcoder/all>
#include <bits/stdc++.h>
using namespace std;
using namespace atcoder;
int main(){
int n,q;
cin>>n>>q;
ll c,x,y;
fenwick_tree<ll> fw(n);
rep(i,n){
cin>>x;
fw.add(i,x);
}
rep(i,q){
cin>>c>>x>>y;
if(c==0) fw.add(x,y);
else cout<<fw.sum(x,y)<<endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
struct BIT {
int n; vector<LL> bit;
void init(int _n) { n = _n; bit.assign(n + 1, 0); }
void m(int x, LL d) {
while (x <= n)
bit[x] += d, x += x & (-x);
}
LL q(int x) {
LL ret = 0;
while (x > 0)
ret += bit[x], x -= x & (-x);
return ret;
}
} solver;
int main() {
ios_base::sync_with_stdio(false); cin.tie(0);
int n, q; cin >> n >> q;
solver.init(n);
for (int i = 0 ; i < n ; i++) {
LL v; cin >> v;
solver.m(i + 1, v);
}
while (q--) {
int t; cin >> t;
if (t == 0) {
int x; LL v; cin >> x >> v;
solver.m(x + 1, v);
} else {
int l, r; cin >> l >> r;
cout << solver.q(r) - solver.q(l) << '\n';
}
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#include <math.h>
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 int64_t INF = 1LL << 60;
int main() {
int N;
cin>>N;
string s;
string t;
cin>>s>>t;
string d;
if(s==t){cout<<s.size()<<endl;return 0;}
else{
int ans=s.size()+t.size();
for(int i=0;i<N;i++){
if(s.substr(i)==t.substr(0,N-i)){
d=s.substr(0,i)+t;
int a=d.size();
ans=min(ans,a);
}
}
cout<<ans<<endl;return 0;
}
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--)
using namespace std;
#define INF ((1<<30)-1)
#define LINF (1LL<<60)
#define EPS (1e-10)
typedef long long ll;
typedef pair<ll, ll> P;
const int MOD = 1000000007;
const int MOD2 = 998244353;
// ref : https://atcoder.jp/contests/abc167/submissions/13086967
int main(){
int n;
cin >> n;
vector<P> pos, neg;
rep(i, n){
string s;
cin >> s;
int tmp = 0, mn = 0;
for(char c : s){
if (c == '(') tmp++;
else tmp--;
mn = min(mn, tmp);
}
if (tmp >= 0) pos.push_back({mn, tmp});
else neg.push_back({mn, tmp});
}
sort(pos.rbegin(), pos.rend());
int tot = 0;
for (auto p : pos){
if (tot + p.first < 0) {
cout << "No" << endl;
return 0;
}
tot += p.second;
}
sort(neg.begin(), neg.end(), [](auto a, auto b){ return a.second - a.first > b.second - b.first; } ); // sum - mnใๅคงใใ้ ใซใฝใผใใใ
for(auto& p : neg){
if(tot + p.first < 0){
cout << "No" << endl;
return 0;
}
tot += p.second;
}
if(tot != 0){
cout << "No" << endl;
return 0;
}
cout << "Yes" << endl;
return 0;
}
| 0 |
#include<cstdio>
#include<vector>
using namespace std;
int n,m;
vector<int> tomo[1001];
int ss[1001];
void saiki(int s,int dps){
ss[s]=1;
if(dps==2){
return;
}
for(int i=0;i<tomo[s].size();i++){
saiki(tomo[s][i],dps+1);
}
}
int main(){
while(1){
scanf("%d%d",&n,&m);
if(n==0&&m==0){
break;
}
for(int i=0;i<1001;i++){
ss[i]=0;
tomo[i].clear();
}
for(int i=0;i<m;i++){
int a,b;
scanf("%d%d",&a,&b);
tomo[a].push_back(b);
tomo[b].push_back(a);
}
saiki(1,0);
int cont=0;
for(int i=2;i<=n;i++){
cont+=ss[i];
}
printf("%d\n",cont);
}
} | #include <bits/stdc++.h>
using namespace std;
#define LIMIT 100001
int N, Q, K;
vector<map<long long, long long>> nodeDis(LIMIT);
vector<long long> kToNode(LIMIT);
vector<bool> check(LIMIT);
vector<unordered_set<int>> vg(LIMIT);
void makeDistance(int k, long long dis){
check[k] = true;
kToNode[k] = dis;
for(auto x: vg[k]){
if(check[x]){
continue;
}
makeDistance(x, dis + nodeDis[k].at(x));
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << setprecision(20) << fixed;
cin >> N;
for(int i = 0; i < N-1; i++){
long long a, b, c;
cin >> a >> b >> c;
a--;
b--;
nodeDis[a][b] = c;
nodeDis[b][a] = c;
vg[a].insert(b);
vg[b].insert(a);
}
cin >> Q >> K;
K--;
makeDistance(K, 0);
/*
for(int i = 0; i < N; i++){
cout << i << " " << kToNode[i] <<endl;
}
//*/
for(int i = 0; i < Q; i++){
int a, b;
cin >> a >> b;
a--;
b--;
cout << kToNode[a] + kToNode[b] <<endl;
}
}
| 0 |
#include<iostream>
#include<queue>
#include<vector>
using namespace std;
long long int gcd(long long int a, long long int b);
//int a[200000];
vector<int> graph[100000];
int flag[100000];
int main() {
//F
int n;
cin >> n;
int u, v;
cin >> u >> v;
int a, b;
int i;
for (i = 0; i < n - 1; i++) {
cin >> a >> b;
graph[a - 1].push_back(b - 1);
graph[b - 1].push_back(a - 1);
}
u = u - 1;
v = v - 1;
queue<int> que;
que.push(u);
for (i = 0; i < n; i++) {
flag[i] = -1;
}
flag[u] = 0;
while (que.size()) {
a = que.front(); que.pop();
for (i = 0; i < graph[a].size(); i++) {
if (flag[graph[a][i]] == -1) {
que.push(graph[a][i]);
flag[graph[a][i]] = flag[a] + 1;
}
}
}
vector<int> path;
path.push_back(v);
a = v;
while (flag[a] != 0) {
for (i = 0; i < graph[a].size(); i++) {
if (flag[graph[a][i]] == flag[a] - 1) {
a = graph[a][i];
path.push_back(a);
break;
}
}
}
//cout << flag[v] << endl;
//vใใuใฎใในใใงใใ๏ผ
//if (flag[v] == 1) {
// cout << 0 << endl;
// return 0;
//}
int counter = 0;
counter = counter + (int)((path.size() - 2) / 2);
//cout << counter << endl;
v = path[((path.size() - 2) / 2)];
u = path[((path.size() - 2) / 2)+ 1 + (path.size() % 2)];
int w = path[((path.size() - 2) / 2) + 1];
//for (i = 0; i < path.size(); i++)cout << path[i] << ' ';
//cout << endl;
//cout << path.size() << 'u' << u << 'v' << v << endl;
for (i = 0; i < n; i++) {
flag[i] = -1;
}
flag[u] = 0;
int maxflag = 0;
que.push(u);
while (que.size()) {
a = que.front(); que.pop();
for (i = 0; i < graph[a].size(); i++) {
if ((flag[graph[a][i]] == -1) && (graph[a][i]!=v) && (graph[a][i] != w)) {
que.push(graph[a][i]);
flag[graph[a][i]] = flag[a] + 1;
if (maxflag < flag[a] + 1) {
maxflag = flag[a] + 1;
//cout << maxflag << endl;
}
}
}
}
//cout << counter << ' ' << maxflag << ' ' << path.size() << endl;
//for (i = 0; i < 9; i++)cout << flag[i] << ' ';
//cout << endl;
counter = counter + maxflag + (path.size() % 2);
cout << counter << endl;
return 0;
//E
/*long long int N;
cin >> N;
long long int counter = 0;
if (N % 2 == 1) {
cout << 0 << endl;
return 0;
}
else {
if (N == 0) {
cout << 0 << endl;
return 0;
}
else {
N = N - (N % 10);
N = N / 10;
counter = counter + N;
while (N > 0) {
N = N - (N % 5);
N = N / 5;
counter = counter + N;
}
cout << counter << endl;
return 0;
}
}
*/
//D
/*int n;
cin >> n;
int i;
for (i = 0; i < n; i++) {
cin >> a[i];
}
int counter = 0;
int seek = 1;
for (i = 0; i < n; i++) {
if (a[i] == seek) {
counter++;
seek++;
}
}
if (counter == 0) {
cout << -1 << endl;
return 0;
}
cout << n - counter << endl;
return 0;*/
//C
/*long long int A, B;
cin >> A >> B;
cout << A * B / gcd(A, B) << endl;
return 0;*/
//B
/*int n;
cin >> n;
string s, t;
cin >> s >> t;
int i;
for (i = 0; i < n; i++) {
cout << s[i];
cout << t[i];
}
cout << endl;
return 0;*/
}
long long int gcd(long long int a,long long int b) {
if (a == 0) {
return b;
}
else if (b == 0) {
return a;
}
else {
return gcd(b, a%b);
}
} | #include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int dis[2][N];
vector<int> g[N];
void bfs(int be, int id) {
queue<int> q;
q.push(be);
dis[id][be] = 1;
while (!q.empty()) {
int u = q.front();
q.pop();
for (auto v : g[u]) {
if (!dis[id][v]) {
dis[id][v] = dis[id][u] + 1;
q.push(v);
}
}
}
}
int main() {
int n, x, y, u, v, res = 0;
cin >> n >> x >> y;
for (int i = 1; i < n; i++) {
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
bfs(x, 0);
bfs(y, 1);
for (int i = 1; i <= n; i++) {
if (dis[0][i] < dis[1][i]) res = max(res, dis[1][i] - 2);
}
cout << res << endl;
return 0;
}
| 1 |
#include<stdio.h>
#include<iostream>
#include<vector>
#include<math.h>
#include<queue>
#include<map>
#include<algorithm>
#include<string.h>
#include<functional>
#include<limits.h>
#include<stdlib.h>
#include<cmath>
#include<cstring>
#include<set>
#include<climits>
using namespace std;
#define intmax INT_MAX
#define lmax LONG_MAX
#define uintmax UINT_MAX
#define ulmax ULONG_MAX
#define llmax LLONG_MAX
#define ll long long
#define rep(i,a,N) for((i)=(a);(i)<(N);(i)++)
#define rrp(i,N,a) for((i)=(N)-1;(i)>=(a);(i)--)
#define llfor ll i,j
#define sc(a) cin>>a
#define pr(a) cout<<a<<endl
#define pY puts("YES")
#define pN puts("NO")
#define py puts("Yes")
#define pn puts("No")
#define pnn printf("\n")
#define all(a) a.begin(),a.end()
#define push(a,b) (a).push_back(b)
#define llvec vector<vector<ll>>
#define charvec vector<vector<char>>
#define size(a,b) (a,vector<ll>(b))
#define llpvec vector<pair<ll,ll>>
/*pi*/double pi=acos(-1);
/*็นฐใไธใ้ค็ฎ*/ll cei(ll x,ll y){ll ans=x/y;if(x%y!=0)ans++;return ans;}
/*ๆๅคงๅ
ฌ็ดๆฐ*/ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
/*ๆๅฐๅ
ฌๅๆฐ*/ll lcm(ll x,ll y){return x/gcd(x,y)*y;}
/*nไน*/ll llpow(ll x,ll n){ll i,ans=1;rep(i,0,n)ans*=x;return ans;}
/*้ไน*/ll fact(ll x){ll i,ans=1;rep(i,0,x)ans*=(x-i);return ans;}
/*nCr*/ll ncr(ll n,ll r){return fact(n)/fact(r)/fact(n-r);}
/*nPr*/ll npr(ll n,ll r){return fact(n)/fact(n-r);}
/*primejudge*/bool prime(ll a){if(a<=1)return false;ll i;for(i=2;i*i<=a;i++){if(a%i==0)return false;}return true;}
/*Fibonacciๆฐๅ*/ll fib(ll x){ll i,fibo[x+10];fibo[0]=1;fibo[1]=1;fibo[2]=1;rep(i,3,x+1)fibo[i]=fibo[i-1]+fibo[i-2];return fibo[x];}
/*ๆกๆฐ*/ll dig(ll n){ll d=0,i=0;while(n/10>0){i++;d++;}return d;}
llfor;ll ans=0;////////////////////////////////////////////////////////////
int main(){
ll n;
sc(n);
ll a[n+10];
ll mn;
ll sm=0;
ll cnt=0;
rep(i,0,n){
sc(a[i]);
sm+=abs(a[i]);
if(a[i]<0)cnt++;
if(i==0)mn=abs(a[i]);
else mn=min(mn,abs(a[i]));
//cout<<sm<<" "<<mn<<endl;
}
//่ฒ ใฎ่ฆ็ด ใๅถๆฐๅใ ใจๅ
จใฆใ+ใซใงใใ
ans=0;
rep(i,0,n-1){
if(cnt%2==0){
pr(sm);return 0;
}
}
pr(sm-mn*2);
return 0;} | #include <iostream>
#include <array>
#include <algorithm>
#include <vector>
#include <bitset>
#include <set>
#include <unordered_set>
#include <cmath>
#include <complex>
#include <deque>
#include <iterator>
#include <numeric>
#include <map>
#include <unordered_map>
#include <queue>
#include <stack>
#include <string>
#include <tuple>
#include <utility>
#include <limits>
#include <iomanip>
#include <functional>
#include <cassert>
using namespace std;
using ll=long long;
template<class T> using V = vector<T>;
template<class T, class U> using P = pair<T, U>;
using vll = V<ll>;
using vvll = V<vll>;
#define ALL(v) v.begin(),v.end()
template < class T > inline bool chmax(T& a, T b) {if (a < b) { a=b; return true; } return false; }
template < class T > inline bool chmin(T& a, T b) {if (a > b) { a=b; return true; } return false; }
#define DEBUG_VLL(vec) for(int sz=0;sz<int(vec.size());sz++) std::cerr<<vec[sz]<<(sz==vec.size()-1?'\n':' ');
const long long MOD = 1000000007;
const long long HIGHINF = (long long)1e18;
const int INF = (int)1e9;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n; cin >> n;
vll a(n);
for (int i = 0; i < n; i++) cin >> a[i];
vll dp1(n + 1, -HIGHINF), dp2(n + 1, -HIGHINF);
dp1[0] = 0;
for (int i = 0; i < n; i++) {
chmax(dp1[i + 1], max(dp1[i] + a[i], dp2[i] - a[i]));
chmax(dp2[i + 1], max(dp1[i] - a[i], dp2[i] + a[i]));
}
// DEBUG_VLL(dp1)
// DEBUG_VLL(dp2)
cout << dp1.back() << '\n';
return 0;
}
| 1 |
#include<iostream>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<vector>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<time.h>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
const double PI=acos(-1);
const double EPS=1e-10;
const int inf=1e8;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
vector<vector<char> >tmp;
vector<vector<int> >scr;
int main(){
int n,m;
while(cin>>n>>m,n||m){
vector<int>d(m);
vector<vi >cost(m,vector<int>(m));
vector<vi >tim(m,vector<int>(m));
vector<bool>used(m);
rep(i,m)rep(j,m){cost[i][j]=inf;tim[i][j]=inf;}
rep(i,n){
int a,b,c,d;
cin>>a>>b>>c>>d;
a--;b--;
cost[a][b]=cost[b][a]=c;
tim[a][b]=tim[b][a]=d;
}
cin>>n;
rep(i,n){
int a,b,c;
cin>>a>>b>>c;
a--;b--;
rep(j,m)d[j]=inf;
rep(j,m)used[j]=false;
if(c){
d[a]=0;
while(1){
int v=-1;
rep(j,m)if(!used[j]&&(v==-1||d[v]>d[j]))v=j;
if(v==-1)break;
used[v]=true;
rep(j,m)d[j]=min(d[j],d[v]+tim[v][j]);
}
}else{
d[a]=0;
while(1){
int v=-1;
rep(j,m)if(!used[j]&&(v==-1||d[v]>d[j]))v=j;
if(v==-1)break;
used[v]=true;
rep(j,m)d[j]=min(d[j],d[v]+cost[v][j]);
}
}
cout<<d[b]<<endl;
}
}
} | #define NODE 0
#define WEIGHT 1
#define COST_IDX 0
#define TIME_IDX 1
#define P_IDX 0
#define Q_IDX 1
#define R_IDX 2
#include <iostream>
#include <cstring>
using namespace std;
int n, m, k;
int weights[101][101][2];
int min_w[101][101][2];
int requests[200][3];
struct heap_queue {
int arr[101];
int *cmp_val;
int lookup[101];
int size=0;
};
void heap_push(int elm, heap_queue &q) {
q.arr[q.size] = elm;
int above, i = q.size++;
while (i && q.cmp_val[q.arr[(above=(i-1)>>1)]] > q.cmp_val[elm]) {
q.arr[i] = q.arr[above];
q.lookup[q.arr[i]] = i;
i = above;
}
q.arr[i] = elm;
q.lookup[elm] = i;
}
int heap_pop(heap_queue &q) {
int popped = q.arr[0];
int elm = q.arr[--q.size];
int below, i = 0;
while ((below=(i<<1)+1) < q.size) {
if (below+1 < q.size && q.cmp_val[q.arr[below+1]] < q.cmp_val[q.arr[below]])
below++;
if (q.cmp_val[q.arr[below]] >= q.cmp_val[elm])
break;
q.arr[i] = q.arr[below];
q.lookup[q.arr[i]] = i;
i = below;
}
q.arr[i] = elm;
q.lookup[elm] = i;
return popped;
}
void change_val(int elm, heap_queue &q) {
int above, i = q.lookup[elm];
while (i && q.cmp_val[q.arr[(above=(i-1)>>1)]] > q.cmp_val[elm]) {
q.arr[i] = q.arr[above];
q.lookup[q.arr[i]] = i;
i = above;
}
q.arr[i] = elm;
q.lookup[elm] = i;
}
bool read_input() {
cin >> n >> m;
if (n*m == 0)
return false;
memset(weights, 0, sizeof(int)*101*101*2);
memset(min_w, 0, sizeof(int)*101*101*2);
for (int i = 0; i < n; i++) {
int a, b, c, t;
cin >> a >> b >> c >> t;
weights[a][b][COST_IDX] = weights[b][a][COST_IDX] = c;
weights[a][b][TIME_IDX] = weights[b][a][TIME_IDX] = t;
}
cin >> k;
for (int i = 0; i < k; i++) {
cin >> requests[i][P_IDX] >> requests[i][Q_IDX] >> requests[i][R_IDX];
}
return true;
}
int resolve_request(int i_th) {
int p, q, r;
p = requests[i_th][P_IDX];
q = requests[i_th][Q_IDX];
r = requests[i_th][R_IDX];
if (min_w[p][q][r])
return min_w[p][q][r];
int weight_sum_map[101];
memset(weight_sum_map, -1, sizeof(int)*101);
/* starting node has weight_sum of 0 */
weight_sum_map[p] = 0;
int in_queue[101] = {};
heap_queue heap_q;
heap_q.cmp_val = weight_sum_map;
heap_push(p, heap_q);
in_queue[p] = 1;
while (heap_q.size) {
int current_node = heap_pop(heap_q);
in_queue[current_node] = 0;
int weight_sum = weight_sum_map[current_node];
min_w[p][current_node][r] = weight_sum;
if (current_node == q)
break;
for (int i = 1; i < 101; i++) {
if (!weights[current_node][i][r])
continue;
int adj_node = i;
int w = weights[current_node][adj_node][r];
int new_weight_sum = weight_sum + w;
if (weight_sum_map[adj_node] == -1 || new_weight_sum < weight_sum_map[adj_node]) {
weight_sum_map[adj_node] = new_weight_sum;
if (!in_queue[adj_node]) {
heap_push(adj_node, heap_q);
in_queue[adj_node] = 1;
} else {
change_val(adj_node, heap_q);
}
}
}
}
return weight_sum_map[q];
}
void solve() {
//cout << endl;
for (int i = 0; i < k; i++)
cout << resolve_request(i) << endl;
}
int main() {
cin.tie(0); ios::sync_with_stdio(false);
while(read_input()) {
solve();
}
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
#include <vector>
typedef int TInt;
typedef std::vector<TInt> TList;
TList Input()
{
int Count;
std::cin >> Count;
TList List(Count);
for(int i = 0; i < Count; ++i){
std::cin >> List[i];
}
return List;
}
int insertionSort(TList& A, int g)
{
int cnt = 0;
for(int i = g; i < A.size(); ++i){
TInt v = A[i];
int j = i - g;
while(j >= 0 && A[j] > v){
A[j+g] = A[j];
j = j - g;
cnt++;
}
A[j+g] = v;
}
return cnt;
}
void Reverse(TList& List)
{
TList R;
for(TList::reverse_iterator It = List.rbegin();
It != List.rend();
++It)
{
R.push_back(*It);
}
std::swap(R, List);
}
TList GetG(int Max)
{
TList G;
int h = 1;
while(h <= Max){
G.push_back(h);
h = 3 * h + 1;
}
// Reverse(G);
std::reverse(G.begin(), G.end());
return G;
}
int shellSort(TList& A, const TList& G)
{
int cnt = 0;
for(TList::const_iterator It = G.begin();
It != G.end();
++It){
cnt += insertionSort(A, *It);
}
return cnt;
}
void OutputLine(const TList& List)
{
TList::const_iterator It = List.begin();
std::cout << *(It++);
for(; It != List.end(); ++It){
std::cout << " " << *It;
}
std::cout << std::endl;
}
void Output(const TList& List)
{
TList::const_iterator It = List.begin();
// std::cout << *(It++);
for(; It != List.end(); ++It){
std::cout << *It << std::endl;
}
}
int main()
{
std::cin.tie(0);
std::ios::sync_with_stdio(false);
TList A = Input();
TList G = GetG(A.size());
int cnt = shellSort(A, G);
std::cout << G.size() << std::endl;
OutputLine(G);
std::cout << cnt << std::endl;
Output(A);
return 0;
} | #include <algorithm>
#include <cmath>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#include <cassert>
#include <functional>
using namespace std;
#define LOG(...) printf(__VA_ARGS__)
//#define LOG(...)
#define FOR(i,a,b) for(int i=(int)(a);i<(int)(b);++i)
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define RSORT(c) sort((c).rbegin(),(c).rend())
#define CLR(a) memset((a), 0 ,sizeof(a))
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int dx[] = { -1, 0, 1, 0 }; const int dy[] = { 0, 1, 0, -1 };
int main() {
int n;
while (cin >> n, n){
vector<pair<double, string>> veg(n);
REP(i, n){
double a, b, c, d, e, f, g, h, m;
cin >> veg[i].second;
cin >> a >> b >> c >> d >> e >> f >> g >> h >> m;
veg[i].first = -(m*h*g-a)/((b+c+d)+(e+f)*m);
}
SORT(veg);
REP(i, n){
cout << veg[i].second << endl;
}
cout << '#' << endl;
}
} | 0 |
// A - 01 Matrix
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
// const int INF = 2147483647;
// const ll INF = 9223372036854775807;
// const ll MOD = 1e9 + 7;
int grid[1000][1000];
int main() {
int H, W, A, B;
cin >> H >> W >> A >> B;
for (int i=0; i<H; i++) {
for (int j=0; j<W; j++) {
if ((i < B && j < A) || (i >= B && j >= A)) {
grid[i][j] = 0;
} else {
grid[i][j] = 1;
}
}
}
for (int i=0; i<H; i++) {
for (int j=0; j<W; j++) {
cout << grid[i][j];
}
cout << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main(void){
int n,i,a[100];
cin >> n;
for(i=0;i<n;i++){
cin >> a[i];
}
for(i=n-1;i>=0;i--){
cout << a[i];
if(i!=0) cout << " ";
else cout << endl;
}
}
| 0 |
#include "bits//stdc++.h"
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
const ll MOD = 1e9 + 7;
#define rep(i,n) for (int i = 0; i < (n); i++)
#define ALL(v) v.begin(), v.end()
int a[100000];
vector<int> G[100000];
int in[100000];
int N, K;
int ans;
int solve(int v) {
if (G[v].size() == 0) return 0;
int ma = 0;
for (int to : G[v]) {
int t = solve(to) + 1;
if (t == K && v > 0) {
t = 0;
ans++;
}
ma = max(ma, t);
}
return ma;
}
int main() {
cin >> N >> K;
rep(i, N) {
cin >> a[i];
a[i]--;
}
if (a[0] != 0) ans++;
for (int i = 1; i < N; i++) {
G[a[i]].push_back(i);
}
solve(0);
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0;i < n;i++)
#define REPR(i, n) for(int i = n;i >= 0;i--)
#define FOR(i, m, n) for(int i = m;i < n;i++)
#define fi first
#define se second
#define mp make_pair
#define itrfor(itr,A) for(auto itr = A.begin(); itr !=A.end();itr++)
template <class T> using reversed_priority_queue = priority_queue<T, vector<T>, greater<T> >;
typedef long long llong;
char moji[26]={'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'};
char moji2[26]={'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'};
char moji3[10]={'0','1','2','3','4','5','6','7','8','9'};
#define Sort(a) sort(a.begin(),a.end());
#define Reverse(a) reverse(a.begin(),a.end());
#define print(a) cout << a << endl;
#define MOD llong(1e9+7)
#define MAX int(2 * 1e5 +5)
#define debug(x) cout << #x << " = " << (x) << endl;
#define pi acos(-1.0)
#define int llong
#define INF llong(1e17)
template<class T> bool chmax(T &a, T b) {if(a<b){a=b; return 1;} return 0;}
template<class T> bool chmin(T &a, T b) {if(a>b){a=b; return 1;} return 0;}
bool Add(int &a,int b){a = (a + b) % MOD;}
void myprint(int* A,int A_num){
REP(i,A_num) cout << A[i] << " ";
cout << endl;
}
const int x_max = 100004;
const int n_max = 205;
signed main(){
int n,x;
cin >> n >> x;
int A[n];
REP(i,n) cin >> A[i];
sort(A,A+n);
int dp[2][x_max];
REP(j,x_max) dp[0][j] = j % A[0];
FOR(i,1,n){
REP(j,x_max){
dp[i%2][j] = 0;
Add(dp[i%2][j],dp[(i-1)%2][j % A[i]]);
Add(dp[i%2][j],i * dp[(i-1)%2][j]);
}
}
cout << dp[(n-1)%2][x] << endl;
} | 0 |
#include <iostream>
#include <fstream>
#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <functional>
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
using namespace std;
#define ll long long int
#define rep(i,n) for( int i = 0; i < n; i++ )
#define rrep(i,n) for( int i = n; i >= 0; i-- )
#define REP(i,s,t) for( int i = s; i <= t; i++ )
#define RREP(i,s,t) for( int i = s; i >= t; i-- )
#define dump(x) cerr << #x << " = " << (x) << endl;
#define INF 2000000000
#define mod 1000000007
#define INF2 1000000000000000000
typedef pair<int, int> P;
typedef pair<P, P> PP;
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int H, W;
cin >> H >> W;
int a[510][510];
rep(i, H) {
rep(j, W) {
cin >> a[i][j];
}
}
vector<PP> v;
rep(i, H) {
rep(j, W - 1) {
if(a[i][j] % 2 == 1) {
a[i][j]--;
a[i][j + 1]++;
v.push_back({{i, j}, {i, j + 1}});
}
}
}
rep(i, H - 1) {
if(a[i][W - 1] % 2 == 1) {
a[i][W - 1]--;
a[i + 1][W - 1]++;
v.push_back({{i, W - 1}, {i + 1, W - 1}});
}
}
cout << v.size() << endl;
for(auto& e: v) {
cout << e.first.first + 1 << " ";
cout << e.first.second + 1 << " ";
cout << e.second.first + 1 << " ";
cout << e.second.second + 1<< endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int k, t;
cin >> k >> t;
vector<int>a(t);
for (int i = 0; i < t; i++)cin >> a.at(i);
sort(a.begin(), a.end());
reverse(a.begin(), a.end());
if (a.at(0) <= ceil((double)k / 2))cout << 0 << endl;
else {
if (k % 2 == 0)cout << 1 + 2 * (a.at(0) - ceil((double) k/2 ) - 1) << endl;
else cout << 2 * (a.at(0) - ceil((double)k / 2)) << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1000000007;
const double PI = acos(-1);
int main()
{
string s;
cin >> s;
cout << s.substr(0, s.size() - 8) << endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
for (int i = 0; i < str.size() - 8; i++) {
cout << str[i];
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
int ans = 7;
string w[] = { "SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN" };
for (unsigned int i = 0; i < 7; i++) {
if(s == w[i]) {
ans -= i;
}
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string arr[7] = {"SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"};
string s;
cin>>s;
int x = find(arr,arr+7,s)-arr;
cout<<7-x<<endl;
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int main(){
int a,b,k,i;
cin>>a>>b>>k;
for(i=0;i<k;i++){
if(i&1){
a+=(b>>=1);
}else{
b+=(a>>=1);
}
}
cout<<a<<" "<<b;
return 0;
} | #include "bits/stdc++.h"
#define MOD 1000000007
#define rep(i, n) for(ll i=0; i < (n); i++)
#define rrep(i, n) for(ll i=(n)-1; i >=0; i--)
#define ALL(v) v.begin(),v.end()
#define rALL(v) v.rbegin(),v.rend()
#define FOR(i, j, k) for(ll i=j;i<k;i++)
#define debug_print(var) cerr << #var << "=" << var <<endl;
#define DUMP(i, v)for(ll i=0;i<v.size();i++)cerr<<v[i]<<" "
#define fi first
#define se second
using namespace std;
typedef long long int ll;
typedef vector<ll> llvec;
typedef vector<double> dvec;
typedef pair<ll, ll> P;
typedef long double ld;
struct edge{ll x, c;};
ll mod(ll a, ll mod){
ll res = a%mod;
if(res<0)res=res + mod;
return res;
}
ll modpow(ll a, ll n, ll mod){
ll res=1;
while(n>0){
if(n&1) res=res*a%mod;
a=a*a%mod;
n>>=1;
}
return res;
}
ll modinv(ll a, ll mod){
ll b=mod, u=1, v=0;
while(b){
ll t=a/b;
a-=t*b; swap(a, b);
u-=t*v; swap(u, v);
}
u%=mod;
if(u<0)u+=mod;
return u;
}
ll gcd(ll a, ll b){
ll r = a%b;
if(r==0) return b;
else return gcd(b, a%b);
}
bool is_prime(ll n){
ll i = 2;
if(n==1)return false;
if(n==2)return true;
bool res = true;
while(i*i <n){
if(n%i==0){
res = false;
}
i = i+1;
}
//if(i==1)res = false;
if(n%i==0)res=false;
return res;
}
struct UnionFind{
ll N;
llvec p;
llvec cnt;
UnionFind(ll n){
N = n;
p=llvec(N);
cnt=llvec(N, 0);
rep(i, N){
p[i] = i;
cnt[i] = 1;
}
}
void con(ll a, ll b){
P at = root(a);
P bt = root(b);
if(at.second!=bt.second){
if(at.first>bt.first){
swap(at, bt);
swap(a, b);
}
p[at.second] = bt.second;
cnt[bt.second]+=cnt[at.second];
p[a]=bt.second;
}
}
P root(ll a){
ll atmp = a;
ll c=0;
while(atmp!=p[atmp]){
atmp = p[atmp];
c++;
}
p[a] = atmp;
return {c, atmp};
}
bool is_con(ll a, ll b){
P at=root(a);
P bt=root(b);
return at.second == bt.second;
}
};
struct dijkstra{
ll N;
llvec d;
vector<vector<edge>> e;
dijkstra(ll n){
N = n;
//d = llvec(N, 1e18);
e = vector<vector<edge>>(N);
}
void add_edge(ll from, ll to, ll cost){
e[from].push_back({to, cost});
}
void run(ll start){
priority_queue<P, vector<P>, greater<P>> que;
que.push({0, start});
d = llvec(N, 1e18);
d[start]=0;
while(!que.empty()){
P q = que.top();que.pop();
ll dc = q.first;
ll x = q.second;
if(dc>d[x]){
continue;
}else{
for(auto ip: e[x]){
if(d[ip.x]<=d[x]+ip.c){
continue;
}else{
d[ip.x]= d[x]+ip.c;
que.push({d[ip.x], ip.x});
}
}
}
}
}
};
/**************************************
** A main function starts from here **
***************************************/
int main(){
ll a, b;
cin >> a >> b;
ll k;
cin >> k;
for(ll i=0;i<k;i++){
if(a%2==1)a-=1;
b += a/2;
a/=2;
i++;
if(i==k)break;
if(b%2==1)b-=1;
a += b/2;
b/=2;
}
cout << a << " " << b << endl;
return 0;
}
| 1 |
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
#define MOD 1000000007LL
using namespace std;
typedef int_fast64_t ll;
template<int N, typename T, T M>
struct ModFact {
T fact[N+1];
constexpr ModFact() : fact() {
fact[0] = 1;
for (int i=0; i<N; ++i)
fact[i+1] = (fact[i]*(i+1))%M;
}
};
ModFact<100000, ll, MOD> fact;
ll N, M, ans = 1, cnt = 1;
constexpr ll th = 1LL<<45;
char S[200000];
int main() {
scanf("%lld\n", &N);
M = N << 1;
fread_unlocked(S, 1, M, stdin);
if(S[0] == 'B' && S[M-1] == 'B') {
bool f = false;
for(size_t i = 0; i < M-1;) {
if(S[i++] == S[i]) f ^= true;
if(f) {
ans *= (cnt << 1) - i;
if(ans > th) ans %= MOD;
}
else if(++cnt > N) break;
}
if(cnt != N) ans = 0;
else ans = ((ans % MOD) * fact.fact[N]) % MOD;
} else ans = 0;
printf("%lld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
string res = "AC";
int C_cnt = 0;
if (s.at(0) == 'A') {
for (int i = 1; i < s.size(); i++) {
if (s.at(i) == 'C') {
if (2 <= i && i <= (s.size()-2)) {
C_cnt++;
} else {
res = "WA";
}
} else {
if (!('a' <= s.at(i) && s.at(i) <= 'z')) res = "WA";
}
}
if (C_cnt != 1) res = "WA";
} else {
res = "WA";
}
cout << res << endl;
return 0;
}
| 0 |
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
char s[200005];
int n,cnt[26];
ll ans=0;
int main()
{
scanf("%s",s+1);
n=strlen(s+1);
for(int i=1;i<=n;i++)cnt[s[i]-'a']++;
ans=1;
for(int i=0;i<26;i++)for(int j=i+1;j<26;j++)ans+=1ll*cnt[i]*cnt[j];
printf("%lld\n",ans);
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i=0; i<(n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int main(){
string s;
cin>>s;
int n=s.size();
ll ans=1;
map<char,int>mp;
rep(i,n){
mp[s[i]]++;
ans+=i+1-mp[s[i]];
}
cout<<ans<<endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vec = vector<ll>;
using mat = vector<vec>;
using pll = pair<ll,ll>;
#define INF (1LL << 60)
#define MOD 1000000007
#define PI 3.14159265358979323846
#define REP(i,m,n) for(ll (i)=(m),(i_len)=(n);(i)<(i_len);++(i))
#define FORR(i,v) for(auto (i):v)
#define ALL(x) (x).begin(), (x).end()
#define PR(x) cout << (x) << endl
#define PS(x) cout << (x) << " "
#define SZ(x) ((ll)(x).size())
#define MAX(a,b) (((a)>(b))?(a):(b))
#define MIN(a,b) (((a)<(b))?(a):(b))
#define REV(x) reverse(ALL((x)))
#define ASC(x) sort(ALL((x)))
#define DESC(x) ASC((x)); REV((x))
#define pb push_back
#define eb emplace_back
int main()
{
string S;
cin >> S;
ll mn = INF;
REP(i,0,SZ(S)-2) {
ll N = 100*(S[i]-'0') + 10*(S[i+1]-'0') + (S[i+2]-'0');
mn = MIN(mn,abs(N-753));
}
PR(mn);
return 0;
}
/*
*/ | #include<bits/stdc++.h>
using namespace std;
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i: x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#define fo(i, n) for(int i=0; i<n; i++)
#define Fo(i, k, n) for(int i=k; i<n; i++)
#define w(x) int x; cin>>x; while(x--)
#define watch(x) cout << (#x) << " is " << (x) << "\n"
#define watch2(x,y) cout <<(#x)<<" is "<<(x)<<" and "<<(#y)<<" is "<<(y)<<"\n"
#define watch3(x,y,z) cout <<(#x)<<" is "<<(x)<<" and "<<(#y)<<" is "<<(y)<<" and "<<(#z)<<" is "<<(z)<<"\n"
#define watch4(x,y,z,q) cout <<(#x)<<" is "<<(x)<<" and "<<(#y)<<" is "<<(y)<<" and "<<(#z)<<" is "<<(z)<<" and "<<(#q)<<" is "<<(q)<<"\n"
#define MOD 1000000007
#define INF 1000000007;
#define F first
#define S second
#define pb(x) push_back(x);
#define ll long long
#define all(c) (c).begin(),(c).end()
#define endl "\n"
typedef vector<int> vl;
typedef vector< vl > vvl;
typedef pair< int, int> pll;
typedef map< int, int> mll;
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
void c_p_c()
{
#ifndef ONLINE_JUDGE
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
void parray(int a[],int n){
for(int i=0;i<n;i++){
cout<<a[i]<<" ";
}
cout<<endl;
}
int main() {
int i,n,m,k,c=0,sum=0;
c_p_c();
// cout<<c<<endl;
string s;
cin>>s;
n = (int)s.size();
int ans =753;
int mini=INF;
for (int i = 0,j=2; i <=n-3; i++)
{
/* code */
// j++;
string str=s.substr(i,3);
// watch(str-"0");
int x = stoi(str);
// debug(x);
mini=min(mini,abs(ans-x));
}
cout<<mini<<endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int M = 1e9+7 ;
const ll INF = 1e18 ;
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int N;
cin >> N;
vector<vector<int>> A(N, vector<int>(2));
for (int i = 0; i < N; ++i) {
cin >> A[i][0] >> A[i][1];
}
auto comp = [&](vector<int>& a, vector<int>& b) {
return a[0] + a[1] < b[0] + b[1];
};
sort(A.begin(), A.end(), comp);
vector<vector<ll>> dp (N+1 , vector<ll> (N+1, INF));
for(int i = 0 ; i <= N; ++i){
dp[i][0] = 0 ;
}
for(int i = 1 ; i <= N; ++i){
for(int j = 1 ; j <= i ; ++j ){
dp[i][j] = dp[i-1][j];
if (A[i-1][0] >= dp[i-1][j-1]){
dp[i][j] = min(dp[i][j] , dp[i-1][j-1] + A[i-1][1]);
}
}
}
for(int j = N ; j >= 0; --j){
if (dp[N][j] != INF){
cout << j << "\n";
break;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define ull unsigned long long
#define ld long double
#define vi vector<int>
#define vll vector<ll>
#define vc vector<char>
#define vs vector<string>
#define vpii vector<pii>
#define vpll vector<pll>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define repr(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rep1r(i, n) for (int i = ((int)(n)); i >= 1; i--)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define RSORT(x) sort(rall(x));
#define pb push_back
#define mp make_pair
#define INF (1e9)
#define PI (acos(-1))
#define EPS (1e-7)
ull gcd(ull a, ull b) { return b ? gcd(b, a % b) : a; }
ull lcm(ull a, ull b) { return a / gcd(a, b) * b; }
int main(){
int h, w, a, b;
cin >> h >> w >> a >> b;
vs s(b*2+1);
rep(i, b*2+1) rep(j, a*2+1) {
s[i].pb(((i+j)%2)+'0');
}
rep(i, b*2+1) for (int j=a*2+1; j<w; ++j) s[i].pb(s[i].back());
for (int j=b*2+1; j<h; ++j) {
s.pb(s.back());
}
if (w<=a*2) rep(i, h) s[i].pop_back();
rep(i, h) cout << s[i] << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define pi 3.14159
using namespace std;
int main()
{
int p,q,r,a,b;
cin>>p>>q>>r;
a=min(p+q,q+r);
b=min(a,p+r);
cout<<b<<endl;
return 0;
}
| #include<iostream>
#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include<algorithm>
using namespace std;
int n,x[1000010],p;
char s[1000010],t[1000010];
int main()
{
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
int i,j,k,l;
scanf("%d%s%s",&n,&s,&t);
for(i=n-1,j=n,k=0,l=0;i>=0;i--)
{
if(j>i && t[i]!=s[i])
j=i;
if(j<=i && t[i]!=s[j])
{
for(;j>=0 && t[i]!=s[j];j--);
if(j<0)
{
printf("-1\n");
return 0;
}
k++;
l++;
x[j+l]++;
p=max(p,k);
}
k-=x[i+l];
x[i+l]=0;
}
printf("%d\n",p);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define pp pair<int,int>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define ll long long
#define all(a) (a).begin(),(a).end()
ll MOD=1000000007;
ll mod=998244353;
int inf=1000001000;
ll INF=10000000000000000;
ll extgcd(ll a, ll b, ll& x, ll& y) {
ll d = a;
if(b != 0) {
d = extgcd(b, a % b, y, x);
y -= (a / b) * x;
}else {
x = 1;
y = 0;
}
return d;
}
unordered_map<ll, ll> memo;
ll inv(ll a) {
if(memo.find(a) != memo.end()) return memo[a];
ll x, y;
extgcd(a, MOD, x, y);
return memo[a] = (x + MOD) % MOD;
}
int main(){
ll n,a,b,c,d;
cin >> n >> a >> b >> c >> d;
ll f[1001];
f[0]=1;
rep(i,n) f[i+1]=f[i]*(i+1)%MOD;
vector<vector<ll>> s(n+1,vector<ll>(n+1,0));
rep(i,n+1) s.at(0).at(i)=1;
for (ll i=a;i<=b;i++){
rep(k,n+1){
s.at(k).at(i)=s.at(k).at(i-1);
ll in=1;
ll invf=inv(f[i]);
rep(j,c) in=in*invf%MOD;
for (int j=c;j<=min(d,k/i);j++){
ll tmp=f[n-k+i*j]*inv(f[n-k])%MOD;
tmp=tmp*in%MOD;
in=in*invf%MOD;
tmp=tmp*inv(f[j])%MOD;
(s.at(k).at(i)+=s.at(k-i*j).at(i-1)*tmp%MOD)%=MOD;
}
}
}
cout << s.at(n).at(b)%MOD << endl;
}
| #include <bits/stdc++.h>
using namespace std;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
using ll = long long;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll mod = 1000000007LL;
ll dp[110][10];
bool memo[110][10];
vector<ll> a;
ll W;
ll f(ll i, ll j){
if(memo[i][j]) return dp[i][j];
memo[i][j]=true;
dp[i][j]=0LL;
if(j>=2) dp[i][j]+=(f(i-1,j-1)*(a[j-2]*a[W-j]))%mod;
dp[i][j]+=(f(i-1,j)*(a[j-1]*a[W-j]))%mod;
if(j<=W-1) dp[i][j]+=(f(i-1,j+1)*(a[j-1]*a[W-j-1]))%mod;
dp[i][j]%=mod;
return dp[i][j];
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
ll H,K;
cin>>H>>W>>K;
a.assign(W+1,1LL);
for(ll i = 2LL;i <= W;i++){
a[i]=a[i-1LL]+a[i-2LL];
}
memo[0][1]=true;
dp[0][1]=1LL;
for(int i = 2;i <=W;i++){
memo[0][i]=true;
dp[0][i]=0LL;
}
cout<<f(H,K)<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
#define rep(i,m,n) for(int i=m;i<n;i++)
ll mod=1e9+7;
int main(){
int n,k;
cin>>n>>k;
if(n%k==0) cout<<0<<endl;
else cout<<1<<endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define m0(x) memset(x, 0, sizeof(x))
#define all(x) x.begin(), x.end()
#define rep(i, n) for(int i = 0; i < (n); i++)
#define asort(x) sort(all(x));
#define dsort(x, t) sort(x.beggin(), x.end(), greater<t>());
#define dump(x) cout << #x << " = " << (x) << endl
#define vuniq(v) v.erase(unique(v.begin(), v.end()), v.end());
#define minse(m, s) m.insert(make_pair(s, 1));
#define mfin(m, s) m.find(s) != m.end()
#define YES(n) cout << ((n) ? "YES" : "NO" ) << endl
#define Yes(n) cout << ((n) ? "Yes" : "No" ) << endl
const int INF = 1e9;
const ll LINF = 1e18;
const int mod = 1e9+7;
int main(){
int k, x;
cin >> k >> x;
for (int i = x - k + 1; i < x + k; i++) {
cout << (i == x - k + 1 ? "": " ") << i;
}
cout << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int main() {
int N; cin >> N;
vector<int> A(N), B(N);
vector<int> C(N);
ll totalB = 0;
rep(i, N){
cin >> A[i] >> B[i];
C[i] = A[i] + B[i];
totalB += B[i];
}
sort(C.begin(), C.end());
int n = (N+1) / 2;
ll totalA = 0;
rep(i, n){
totalA += C[N-1-i*2];
}
cout << totalA - totalB << endl;
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#define INF 99999999
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
long long ans = 0;
cin >> n;
vector <vector<int>> v(n, vector<int>(3));
int a, b, c;
for (vector<int>& tmp : v) {
cin >> a >> b;
c = a+b;
tmp[0] = c; tmp[1] = a; tmp[2] = b;
ans -= b;
}
/*
for(vector<int> tmp : v) {
cout << tmp[0] << " " << tmp[1] << " " << tmp[2] << endl;
}
*/
sort(v.begin(), v.end(), greater<>());
for(int i = 0; i < n; i += 2) {
ans += v[i][0];
}
cout << ans << endl;
return 0;
}
| 1 |
#include <iostream>
#include <cstdio>
using namespace std;
#define N 50
int main(){
while(1){
int n,m;
int ca[N];
cin >> n >> m;
if(!n&&!m) break;
fill(ca,ca+n,0);
int wan = m;
int k = 0;
while(1){
while(wan){
ca[k]++;
k++;
k = k%n;
wan--;
}
if((k==0&&ca[n-1]==m)||(ca[k-1]==m)){
break;
}else{
wan = ca[k];
ca[k] = 0;
k++;
k = k%n;
}
}
if(!k){
cout << n-1 << endl;
}else{
cout << k-1 << endl;
}
}
return 0;
} | #include<iostream>
#include<stdio.h>
#include<cmath>
#include<vector>
using namespace std;
#define loop(i,a,b) for(int i=a,i<b;i++)
#define rep(i,a) loop(i,0,a)
int main(){
int n,p;
while(cin>>n>>p,n||p){
int wan=p;
vector<int>in(n);
int to=0;
while(1){
if(wan){
wan--;
in[to]++;
}else{
wan+=in[to];
in[to]=0;
}
if(in[to]==p)break;
to++;
if(to==n)to=0;
}
cout<<to<<endl;
}
} | 1 |
#include<iostream>
#include<cmath>
using namespace std;
int main(){
int n,k,c[10],l[10],e[10000],d,a,b;
while(true){
cin>>n;
cin>>k;
if(n==0 && k==0){
break;
}
for(int i=0;i<n;i++){
cin>>c[i];
if(c[i]>=10){
l[i]=100;
}
else{
l[i]=10;
}
}
d=0;
if(k==2){
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
b=0;
if(i!=j){
a=c[i]*l[j]+c[j];
for(int k=0;k<d;k++){
if(a==e[k]){
goto Exit1;
}
}
e[d]=a;
d++;
Exit1:
a=0;
}
}
}
}
if(k==3){
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
for(int m=0;m<n;m++){
b=0;
if(i!=j && (j!=m && m!=i)){
a=c[i]*(l[j]*l[m])+c[j]*l[m]+c[m];
for(int k=0;k<d;k++){
if(a==e[k]){
goto Exit2;
}
}
e[d]=a;
d++;
Exit2:
a=0;
}
}
}
}
}
if(k==4){
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
for(int m=0;m<n;m++){
for(int o=0;o<n;o++){
b=0;
if(((i!=j && o!=i) && (j!=m && m!=i)) && (o!=j && o!=m)){
a=c[i]*(l[j]*l[m]*l[o])+c[j]*(l[m]*l[o])+c[m]*l[o]+c[o];
for(int k=0;k<d;k++){
if(a==e[k]){
goto Exit3;
}
}
e[d]=a;
d++;
Exit3:
a=0;
}
}
}
}
}
}
std::cout<<d<<endl;
}
return 0;
} | #include<bits/stdc++.h>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
typedef long long ll;
int n,k,d[10];
int sum(int a,int b,int c=0,int d=0){
int x=a*(b>=10?100:10)+b;
if(k==2)return x;
x=x*(c>=10?100:10)+c;
if(k==3)return x;
return x=x*(d>=10?100:10)+d;
}
int main(){
while(scanf("%d%d",&n,&k),n){
for(int i=0;i<n;i++)scanf("%d",&d[i]);
sort(d,d+n);
vector<int> data;
for(int i=n-1;i>=0;i--){
for(int j=n-1;j>=0;j--){
if(i==j)continue;
if(k==2){
data.push_back(sum(d[i],d[j]));
continue;
}
for(int r=n-1;r>=0;r--){
if(i==r||j==r)continue;
if(k==3){
data.push_back(sum(d[i],d[j],d[r]));
continue;
}
for(int z=n-1;z>=0;z--){
if(i==z||j==z||r==z)continue;
data.push_back(sum(d[i],d[j],d[r],d[z]));
}
}
}
}
sort(data.begin(),data.end());
data.erase(unique(data.begin(),data.end()),data.end());
printf("%ld\n",data.size());
}
} | 1 |
#include <iostream>
using namespace std;
int main() {
int m,min,max,ten[200],gap=10001,sa;
cin>>m>>min>>max;
while(1){
if(m==0 && min==0 && max==0){
break;
}
for(int i=1;i<=m;i++){
cin>>ten[i];
}
for(int i=min;i<=max;i++){
if(gap>=ten[i+1]-ten[i]){
gap=ten[i+1]-ten[i];
sa=i;
}
}
cout<<sa<<endl;
gap=10001;
sa=0;
cin>>m>>min>>max;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std ;
#define pb(n) push_back(n)
#define fi first
#define se second
#define all(r) (r).begin(),(r).end()
#define vmax(ary) *max_element(all(ary))
#define vmin(ary) *min_element(all(ary))
#define debug(x) cout<<#x<<": "<<x<<endl
#define fcout(n) cout<<fixed<<setprecision((n))
#define scout(n) cout<<setw(n)
#define vary(type,name,size,init) vector< type> name(size,init)
#define vvl(v,w,h,init) vector<vector<ll>> v(w,vector<ll>(h,init))
#define mp(a,b) make_pair(a,b)
#define rep(i,n) for(int i = 0; i < (int)(n);++i)
#define REP(i,a,b) for(int i = (a);i < (int)(b);++i)
#define repi(it,array) for(auto it = array.begin(),end = array.end(); it != end;++it)
#define repa(n,array) for(auto &n :(array))
using ll = long long;
using pii = pair<int,int> ;
using pll = pair<ll,ll> ;
const int mod = 1000000007;
constexpr int inf = ((1<<30)-1)*2+1 ;
constexpr double PI = acos(-1.0) ;
double eps = 1e-10 ;
const int dy[] = {-1,0,1,0,1,-1,1,-1};
const int dx[] = {0,-1,0,1,1,-1,-1,1};
inline bool value(int x,int y,int w,int h){
return (x >= 0 && x < w && y >= 0 && y < h);
}
template<typename T>
void Unique(vector<T> &v){
sort(all(v));
v.erase(unique(all(v)),v.end());
}
template<typename T,typename U>
ll FindErase(T &v,U tar){
ll cnt = 0;
for(auto it = v.begin(); it != v.end();){
if(*it == tar){
it = v.erase(it);
++cnt;
}
else{
++it;
}
}
return cnt;
}
template<typename T>
bool SuffixErase(T &v,size_t suf){
if(suf > v.size()) return false;
for(auto it = v.begin(); it != v.end();){
if(distance(v.begin(),it) == suf){
v.erase(it);
return true;
}
else{
++it;
}
}
return false;
}
template<typename T>
T ston(string& str, T n){
istringstream sin(str) ;
T num ;
sin >> num ;
return num ;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll m,n1,n2;
while(cin >> m >> n1 >> n2 && m+n1+n2){
vector<ll> v(m);
rep(i,m){
cin >> v[i];
}
sort(all(v));
ll gapM = -1,ans = 0;
REP(i,n1,n2+1){
if(gapM <= v[m-i] - v[m-i-1]){
gapM = v[m-i] - v[m-i-1];
ans = i;
}
}
cout << ans << endl;
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
typedef pair<ll,ll> pll;
const ll mod=1e9+7;
//const ll mod=998244353;
const ll inf=5e18;
int main() {
ll a,b,c,d;
cin >> a >> b >> c >> d;
cout << min(a,b)+min(c,d) << endl;
} | #include<iostream>
using namespace std;
int main(){
int a,b,c,d,e,f,m,n;
cin >> a >> b >> c >> d >> e >> f;
if(a<b && a<c && a<d) m=b+c+d;
if(b<a && b<c && b<d) m=a+c+d;
if(c<a && c<b && c<d) m=a+b+d;
if(d<a && d<b && d<c) m=a+b+c;
if(e<f){
n=f;
}else{
n=e;
}
cout << m+n << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
void insertion_sort(vector<int>& A, int n, int g, int& cnt)
{
for (int i = g; i < n; ++i) {
int key = A[i];
int j = i - g;
while (j >= 0 && A[j] > key) {
A[j + g] = A[j];
j -= g;
++cnt;
}
A[j + g] = key;
}
}
void shell_sort(vector<int>& A, int n, int& cnt)
{
vector<int> G;
int h = 1;
G.push_back(h);
int upper = n / 2;
// if (n >= 1000) { upper = n / 9; }
// else if (n >= 100) { upper = n / 7; }
for (int i = 3 * h + 1; i < upper; i = 3 * i + 1) {
G.push_back(i);
}
reverse(G.begin(), G.end());
int m = G.size();
fprintf(stdout, "%d\n", m);
for (int i = 0; i < m; ++i) {
if (i) { fprintf(stdout, " "); }
fprintf(stdout, "%d", G[i]);
}
fprintf(stdout, "\n");
for (int i = 0; i < m; ++i) {
insertion_sort(A, n, G[i], cnt);
}
}
int main()
{
int n = 0;
fscanf(stdin, "%d", &n);
vector<int> A(n);
for (int i = 0; i < n; ++i) {
fscanf(stdin, "%d", &A[i]);
}
int cnt = 0;
shell_sort(A, n, cnt);
fprintf(stdout, "%d\n", cnt);
for (int i = 0; i < n; ++i) {
fprintf(stdout, "%d\n", A[i]);
}
return 0;
} | #include <iostream>
#include <vector>
template<typename T>
void print_ary(std::vector<T> ary, char delim = '\n') {
for(int i = 0; i < ary.size()-1; i++) {
std::cout << ary[i] << delim;
}
std::cout << ary[ary.size()-1];
}
template<typename T>
void insertion_sort(std::vector<T>&& ary) {
for (int i = 1; i < ary.size(); i++) {
int target = ary[i];
int j = i - 1;
while(j >= 0 && ary[j] > target) {
ary[j+1] = ary[j];
j--;
}
ary[j+1] = target;
print_ary(ary, ' ');
std::cout << std::endl;
}
}
template<typename T>
void bubble_sort(std::vector<T> && ary) {
int n = ary.size();
bool flag = true;
int counter = 0;
while (flag) {
flag = false;
for (int j = n - 1; j > 0; j--) {
if (ary[j] < ary[j - 1]) {
std::swap(ary[j], ary[j - 1]);
flag = true;
counter++;
}
}
}
print_ary(ary, ' ');
std::cout << std::endl << counter << std::endl;;
}
template<typename T>
void selection_sort(std::vector<T>&& ary){
int counter = 0;
for (int i = 0; i < ary.size(); i++) {
int min_index = i;
for(int j = i + 1; j < ary.size(); j++) {
if (ary[min_index] > ary[j]) {
min_index = j;
}
}
if(i != min_index) {
std::swap(ary[i], ary[min_index]);
counter++;
}
}
print_ary(ary, ' ');
std::cout << std::endl << counter << std::endl;;
}
template<typename T>
void insertion_sort(std::vector<T>&& ary, int g, int& cnt) {
int n = ary.size();
for (int i = g; i < n; i++) {
int target = ary[i];
int j = i - g;
while(j >= 0 && ary[j] > target) {
ary[j + g] = ary[j];
cnt++;
j -= g;
}
ary[j + g] = target;
}
}
template<typename T>
void shell_sort(std::vector<T>&& ary){
int cnt = 0;
std::vector<int> G;
for(int h = 1; ; ){
if(h > ary.size())
break;
G.push_back(h);
h = 3 * h + 1;
}
std::cout << G.size() << std::endl;
for(int i = G.size() - 1; i >= 0; i--) {
insertion_sort(std::move(ary), G[i], cnt);
std::cout << G[i];
if (i != 0) {
std::cout << " ";
}else{
std::cout << std::endl;
}
}
std::cout << cnt << std::endl;
print_ary(ary);
}
int main(int argc, char const* argv[])
{
int n;
std::cin >> n;
std::vector<int> ary(n);
for (auto &i: ary) {
std::cin >> i;
}
shell_sort(std::move(ary));
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
const ll MOD = 1000000007;
const ld PI = acos(-1);
const ld EPS = 0.0000000001;
#define REP(i, n) for(ll i=0; i<(ll)(n); i++)
#define REPD(i, n) for(ll i=n-1; 0<=i; i--)
#define FOR(i, a, b) for(ll i=a; i<(ll)(b); i++)
#define FORD(i, a, b) for(ll i=a; (ll)(b)<=i; i--)
#define ALL(x) x.begin(), x.end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
int main(){
int n; cin >> n;
map<int, int> a;
a[0] = 3;
ll res=1;
REP(i, n){
int x; cin >> x;
res *= a[x];
res %= MOD;
a[x] -= 1;
a[x+1] += 1;
}
cout << res << endl;
} | #include <bits/stdc++.h>
using namespace std;
struct Fast {Fast(){std::cin.tie(0);ios::sync_with_stdio(false);}} fast;
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vector<int> > vii;
typedef queue<int> qi;
typedef stack<int> si;
typedef deque<int> dqi;
#define reps(i, a, b) for (int i = a; i < b; ++i)
#define rep(i, n) reps(i, 0, n)
#define REPS(i, a, b) reps(i, a, b)
#define REP(i, n) rep(i, n)
#define deps(i, a, b) for (int i = a; i >= b; --i)
#define dep(i, n) deps(i, n, 0)
#define DEPS(i, a, b) deps(i, a, b)
#define DEP(i, n) dep(i, n)
#define pf push_front
#define pb push_back
#define mp make_pair
#define fst first
#define FST fst
#define sec second
#define SEC sec
#define sz(obj) ((int)(obj).size())
#define all(v) (v).begin(), (v).end()
#define ALL(v) all(v)
const int INF = 999999999;
const int MOD = 1e9 + 7;
const int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
inline bool inside(int y, int x, int H, int W) {return y >= 0 && x >= 0 && y < H && x < W;}
inline int in() {int x; std::cin >> x; return x;}
template <typename T>
void print(std::vector<T>& v, char c = ' ') {
REP(i, v.size()) {
if (i != 0) std::cout << c;
std::cout << v[i];
}
std::cout << endl;
}
template <typename T> void print(T x) { std::cout << x << '\n'; }
signed main()
{
vi v(4);
rep(i, 4) v[i] = in();
sort(all(v));
print(v[1] + v[2] + v[3] + max(in(), in()));
return (0);
} | 0 |
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <fstream>
#include <string>
#include <math.h>
#include <cstdlib>
#include <istream>
#include <sstream>
#include <cctype>
#include <iomanip>
//cout << fixed << setprecision(20) << *** << endl;
#define rep(i,N) for(int i=0;i<(int)N;++i)
typedef long long ll;
using namespace std;
int main()
{
ll A,B,M,t;
vector<ll>AA,BB,ANS;
cin>>A>>B>>M;
rep(i,A){
cin>>t;
AA.push_back(t);
}
rep(i,B){
cin>>t;
BB.push_back(t);
}
rep(i,M){
ll x,y,z,zz;
cin>>x>>y>>z;
zz=AA[x-1]+BB[y-1]-z;
ANS.push_back(zz);
}
sort(AA.begin(),AA.end());
sort(BB.begin(),BB.end());
ANS.push_back(AA[0]+BB[0]);
sort(ANS.begin(),ANS.end());
cout<<ANS[0]<<endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, M;
cin >> A >> B >> M;
vector<int>a(A);
vector<int>b(B);
vector<vector<int>>xyc(3, vector<int>(M));
for(int i=0; i<A; i++)cin >> a.at(i);
for(int i=0; i<B; i++)cin >> b.at(i);
for(int i=0; i<M; i++){
for(int j=0; j<3; j++){
cin >> xyc.at(j).at(i);
}
}
int mina = a.at(0);
int minb = b.at(0);
for(int i=0; i<A; i++){
if(mina > a.at(i))mina = a.at(i);
}
for(int i=0; i<B; i++){
if(minb > b.at(i))minb = b.at(i);
}
int ans = mina + minb;
for(int i=0; i<M; i++){
int waribiki = a.at(xyc.at(0).at(i)-1) + b.at(xyc.at(1).at(i)-1) - xyc.at(2).at(i);
if(ans > waribiki)ans = waribiki;
}
cout << ans << endl;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int N = 2e5 + 5;
const int mod = 1e9 + 7;
vector < ll > fact(N);
ll pwr(ll a, ll b){
ll res = 1;
while(b > 0){
if(b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
ll inv(ll a){
return pwr(a, mod - 2);
}
ll comb(int n, int r){
return (((fact[n] * inv(fact[n - r]) % mod) * inv(fact[r])) % mod);
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
fact[0] = 1;
for(int i = 1; i < N; i++) fact[i] = (i * fact[i - 1]) % mod;
int n, m;
cin >> n >> m;
ll ans = 1;
for(int i = 2; i <= sqrt(m); i++){
if(m % i == 0){
int cnt = 0;
while(m % i == 0){
cnt++;
m /= i;
}
ans = (ans * comb(n + cnt - 1, n - 1)) % mod;
}
}
if(m > 1){
ans = (ans * n) % mod;
}
cout << ans << '\n';
}
| #define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef double db;
typedef vector<ll> VLL;
typedef vector<VLL> VVLL;
typedef pair<ll,ll> PLL;
#define REP(x,l,u) for(ll x = l; x < u; x++)
#define RREP(x,l,u) for(ll x = l; x >= u; x--)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define mst(x,v) memset(x, v, sizeof(x))
#define sz(x) (ll)x.size()
string to_string(string s) {return s;}
string to_string(char c) {string s = string(1, c);return s;}
template <typename A, typename B> string to_string(pair<A,B> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <typename A> string to_string(vector<A> v) { string s = "("; int first = 1; for (A a : v) { if (!first) { s += ", "; } first = 0; s += to_string(a); } s += ")"; return s; }
template <typename A> string to_string(set<A> v) { string s = "("; int first = 1; for (A a : v) { if (!first) { s += ", "; } first = 0; s += to_string(a); } s += ")"; return s; }
void debug_out() {cerr << endl;}
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) { cerr << " " << to_string(H); debug_out(T...); }
void in() {}
template <typename A> void in(A & x) { cin >> x; }
template <typename A, typename B> void in(pair<A,B> & x) { in(x.first); in(x.second); }
template <typename A> void in(vector<A> & x) { REP(i,0,(ll)x.size()) in(x[i]); }
template <typename Head, typename... Tail> void in(Head & H, Tail & ... T) {in(H); in(T...); }
#ifndef ONLINE_JUDGE
#define debug(...) do { cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__); } while (false)
#else
#define debug(...) do { } while (false)
#endif
const ll inf = (ll)1e18 + 5;
const ll mod = 1e9+7;
ll nax = 1005;
VLL p(nax*nax, 1);
VLL P;
void init() {
p[0] = 0;
p[1] = 0;
for (ll x = 2; x < nax*nax; x++) {
if (p[x] == 0) {
continue;
}
P.push_back(x);
for (ll f = x; x * f < nax * nax; f++) {
p[x*f] = 0;
}
}
}
map<ll,ll> pf(ll x) {
map<ll,ll> f;
REP(i,0,sz(P)) {
if (P[i] * P[i] > x) break;
while (x % P[i] == 0) {
f[P[i]]++;
x /= P[i];
}
}
if (x > 1) f[x]++;
return f;
}
VLL F(100500, -1);
VLL INVF(100500, -1);
ll pow(ll a, ll b) {
if (b == 0) return 1;
ll h = pow(a, b/2);
ll ans = b % 2 ? h * h % mod * a : h * h;
ans %= mod;
return ans;
}
ll f(ll x) {
if (F[x] != -1) return F[x];
if (x == 0) return 1;
F[x] = f(x-1) * x % mod;
return F[x];
}
ll invf(ll x) {
if (INVF[x] != -1) return INVF[x];
INVF[x] = pow(f(x), mod-2);
return INVF[x];
}
ll ncr(ll n, ll r) {
// n! / r! / (n-r)!
ll ans = f(n);
ans *= invf(r);
ans %= mod;
ans *= invf(n-r);
ans %= mod;
return ans;
}
void solve() {
ll n, m;
in(n, m);
map<ll,ll> factors = pf(m);
REP(i,0,n) f(i); // ease on the recursion
ll ans = 1;
for (PLL a : factors) {
ans *= ncr(a.second + n - 1, a.second) % mod;
ans %= mod;
}
cout << ans << endl;
}
signed main() {
init();
ll t = 1;
REP(i,0,t) solve();
return 0;
} | 1 |
#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
constexpr char ln = '\n';
constexpr long long MOD = 998244353;
constexpr long long INF = 1000000009LL;
#define all(x) (x).begin(),(x).end()
#define rep(i,n) for(int i=0;i<(n);i++)
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main() {
string a, b, c; cin >> a >> b >> c;
if(a.back()==b[0] && b.back()==c[0]){
cout << "YES" << ln;
}else cout << "NO" << ln;
}
| #include<stdio.h>
int main(){
char a[150];
int x=1;
scanf("%[^\n]", a);
for (int i=0 ; a[i]!='\0' ; i++){
if (a[i]==' '){
if (a[i-1]==a[i+1]){
continue;
} else{
x=0;
break;
}
}
}
printf("%s\n", x==1 ? "YES" : "NO");
return 0;
} | 1 |
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
#include <queue>
#include <algorithm>
#include <bits/stdc++.h>
#include <cmath>
#include <limits>
using namespace std;
int main(int argc, char* argv[]){
cin.tie(0);
ios::sync_with_stdio(false);
int A, B, C, D;
int L, R;
cin >> A >> B >> C >> D;
L = A + B;
R = C + D;
if(L > R){
printf("Left\n");
}
else if(L == R){
printf("Balanced\n");
}
else{
printf("Right\n");
}
return 0;
}
| #include <bits/stdc++.h>
#define fastIO (cin.tie(0), cout.tie(0), ios::sync_with_stdio(false))
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define precise(i) fixed << setprecision(i)
using lint = long;
using llint = long long;
using namespace std;
int main() {
fastIO;
string sa, sb, sc;
cin >> sa >> sb >> sc;
size_t a = 0, b = 0, c = 0;
char turn = sa[a++];
while (true) {
if (turn == 'a') {
if (sa.size() == a) {
cout << "A\n";
return 0;
}
turn = sa[a++];
} else if (turn == 'b') {
if (sb.size() == b) {
cout << "B\n";
return 0;
}
turn = sb[b++];
} else if (turn == 'c') {
if (sc.size() == c) {
cout << "C\n";
return 0;
}
turn = sc[c++];
}
}
}
| 0 |
#include <iostream>
#include <vector>
int main() {
int A, B, M; std::cin >> A >> B >> M;
std::vector<int> a(A);
int ma = 0;
for (int i = 0; i < A; i++) {
std::cin >> a[i];
if (i == 0) {
ma = a[0];
} else {
ma = std::min(ma, a[i]);
}
}
std::vector<int> b(B);
int mb = 0;
for (int i = 0; i < B; i++) {
std::cin >> b[i];
if (i == 0) {
mb = b[0];
} else {
mb = std::min(mb, b[i]);
}
}
int m = ma + mb;
for (int i = 0; i < M; i++) {
int x, y, c; std::cin >> x >> y >> c;
x--; y--;
m = std::min(m, a[x] + b[y] - c);
}
std::cout << m << std::endl;
return 0;
} | #include <iostream>
#include <array>
#include <string>
using namespace std;
enum dir_t {NORTH, EAST, WEST, SOUTH};
enum face_t {TOP, BOTTOM, FRONT, BACK, LEFT, RIGHT};
class Dice {
public:
Dice(int32_t top, int32_t bottom, int32_t front, int32_t back, int32_t left, int32_t right) {
val[TOP] = top;
val[BOTTOM] = bottom;
val[FRONT] = front;
val[BACK] = back;
val[LEFT] = left;
val[RIGHT] = right;
}
int32_t operator[](face_t f) {
return val[f];
}
void roll(dir_t dir) {
switch (dir) {
case NORTH: inner_roll(TOP, FRONT, BOTTOM, BACK); break;
case EAST: inner_roll(TOP, LEFT, BOTTOM, RIGHT); break;
case WEST: inner_roll(TOP, RIGHT, BOTTOM, LEFT); break;
case SOUTH: inner_roll(TOP, BACK, BOTTOM, FRONT); break;
}
}
private:
array<int32_t, 6> val;
void inner_roll(face_t f1, face_t f2, face_t f3, face_t f4) {
int32_t temp;
temp = val[f1];
val[f1] = val[f2];
val[f2] = val[f3];
val[f3] = val[f4];
val[f4] = temp;
return;
}
};
int main() {
int32_t top, bottom, front, back, left, right;
string op;
cin >> top >> front >> right >> left >> back >> bottom >> op;
Dice d(top, bottom, front, back, left, right);
for (uint8_t dir : op) {
switch (dir) {
case 'N': d.roll(NORTH); break;
case 'E': d.roll(EAST); break;
case 'W': d.roll(WEST); break;
case 'S': d.roll(SOUTH); break;
}
}
cout << d[TOP] << endl;
return 0;
} | 0 |
#include <iostream>
using namespace std;
int main()
{
int n;
cin >> n;
int x = 0;
while (n > 2)
{
x++;
n = n - 3;
}
cout << x << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using Graph = vector<vector<int>>;
using ll = long long;
using P = pair<int, int>;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define all(v) v.begin(), v.end()
#define sz(x) ((int) x.size())
#define pb push_back
#define mp make_pair
#define F first
#define S second
typedef vector<ll> vi;
const int MOD = 1000000007;
template<class T> void print(const T& t){ cout << t << endl; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main(){
ll n;
cin >> n;
print(n / 3);
} | 1 |
// 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); }
template<typename V> constexpr typename V::value_type sum(const V &v) { return accumulate(all(v), 0); }
void solve();
main { solve(); return 0; }
// clang-format on
constexpr int zeller(int y, int m, const int &d) {
if (m == 1 || m == 2) y--, m += 12;
int k = y % 100, j = y / 100;
return (d + 13 * (m + 1) / 5 + k + k / 4 + j / 4 + 5 * j + 6) % 7;
}
void solve() {
int m, d;
string t[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};
while (cin >> m >> d, m) cout << t[zeller(2004, m, d)] << endl;
} | #include<iostream>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<vector>
#include<cmath>
#include<cstdio>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define it ::iterator
#define all(in) in.begin(),in.end()
const double PI=acos(-1);
const double ESP=1e-10;
using namespace std;
int main(){
int m,d;
while(cin>>m>>d,m+d){
int day = 0;
m--;
// 2 , 4 , 6 , 9 . 11
int month[12] = {31,29,31,30,31,30,
31,31,30,31,30,31};
rep(i,m){
day+=month[i];
}
day=(day + d + 7 - 1)%7;
switch(day){
case 0:
cout<<"Thursday"<<endl;
break;
case 1:
cout<<"Friday"<<endl;
break;
case 2:
cout<<"Saturday"<<endl;
break;
case 3:
cout<<"Sunday"<<endl;
break;
case 4:
cout<<"Monday"<<endl;
break;
case 5:
cout<<"Tuesday"<<endl;
break;
case 6:
cout<<"Wednesday"<<endl;
break;
}
}
} | 1 |
#include <bits/stdc++.h>
#define rep(i,x,n) for(int i=x; i<(int)(n); i++)
#define rep_eq(i,x,n) for(int i=x; i<=(int)(n); i++)
using namespace std;
int main() {
vector<int> a(3);
rep(i,0,3) cin >>a[i];
sort(a.begin(),a.end());
int K; cin >>K;
a[2]*=pow(2,K);
cout <<accumulate(a.begin(),a.end(),0) <<endl;
return 0;
}
| #include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
int n, a = 0, b = 0, c;
cin >> a >> b >> c;
cin >> n;
cout << (a + b + c) - max(max(a, b), c) + (max(max(a, b), c) << n);
}
| 1 |
///Bismillahir Rahmanir Rahim
#include "bits/stdc++.h"
#define ll long long
#define int ll
#define fi first
#define si second
#define mp make_pair
#define pb push_back
#define pi pair<ll,ll>
#define clr(x) memset(x,0,sizeof(x));
#define f(i,l,r) for(int i=l;i<=r;i++)
#define rf(i,r,l) for(int i=r;i>=l;i--)
#define done(i) cout<<"done = "<<i<<endl;
#define show(x,y) cout<<x<<" : ";for(auto z:y)cout<<z<<" ";cout<<endl;
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
const ll inf=1e18;
const int mod=1e9+7;
const int M=3005;
int n,t;
int dp[M][M];
int a[M],b[M];
vector<pi>vec;
int solve(int pos,int tym)
{
if(pos>n)return 0;
if(tym>=t)return 0;
int &ret=dp[pos][tym];
if(ret!=(-1))return ret;
ret=solve(pos+1,tym);
ret=max(ret,solve(pos+1,tym+a[pos])+b[pos]);
return ret;
}
main()
{
fast
memset(dp,-1,sizeof dp);
cin>>n>>t;
f(i,1,n)
{
cin>>a[i]>>b[i];
vec.pb(mp(a[i],-b[i]));
}
sort(vec.begin(),vec.end());
f(i,0,n-1)
{
a[i+1]=vec[i].fi;
b[i+1]=-vec[i].si;
}
int ses=solve(1,0);
cout<<ses<<endl;
return 0;
}
| #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;
#define SIZE 1005
ll N,M;
int min_dist[SIZE],pre_node[SIZE];
vector<int> G[SIZE];
vector<int> bfs(int start){
vector<int> ret(N+1);
for(int i = 0; i < N; i++){
min_dist[i] = BIG_NUM;
pre_node[i] = -1;
}
min_dist[start] = 0;
queue<int> Q;
Q.push(start);
while(!Q.empty()){
int node_id = Q.front();
Q.pop();
for(int i = 0; i < G[node_id].size(); i++){
int next = G[node_id][i];
if(min_dist[next] != BIG_NUM)continue;
min_dist[next] = min_dist[node_id]+1;
pre_node[next] = node_id;
Q.push(next);
}
}
int minimum = BIG_NUM,last_node = -1;
for(int i = 0; i < N; i++){
if(i == start)continue;
for(int k = 0; k < G[i].size(); k++){
if(G[i][k] == start){
if(minimum > min_dist[i]){
minimum = min_dist[i];
last_node = i;
}
}
}
}
if(last_node == -1)return ret;
int tmp = last_node;
ret.clear();
while(tmp != -1){
ret.push_back(tmp);
tmp = pre_node[tmp];
}
return ret;
}
int main(){
scanf("%lld %lld",&N,&M);
int from,to;
for(ll i = 0; i < M; i++){
scanf("%d %d",&from,&to);
from--;
to--;
G[from].push_back(to);
}
vector<int> ans(N+1);
for(ll start = 0; start < N; start++){
vector<int> work = bfs(start);
if(work.size() < ans.size()){
ans = work;
}
}
if(ans.size() == N+1){
printf("-1\n");
return 0;
}else{
printf("%lld\n",ans.size());
for(int i = 0; i < ans.size(); i++){
printf("%d\n",ans[i]+1);
}
}
return 0;
}
| 0 |
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cassert>
#include <iostream>
#include <iomanip>
#include <string>
#include <stack>
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <numeric>
#include <bitset>
#define all(c) c.begin(), c.end()
#define rall(c) c.rbegin(), c.rend()
#define debug(x) cerr << #x << ": " << x << endl
using namespace std;
typedef long long ll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pii;
const ll MOD = 1000000007;
int main() {
ll h, w, a;
cin >> h >> w;
vector<Pii> nums(h*w+1, {-1, -1});
bool ok = true;
for(int i=0;i<h;++i) {
cin >> a;
if(nums[a].first != -1) ok = false;
nums[a].first = i;
}
for(int i=0;i<w;++i) {
cin >> a;
if(nums[a].second != -1) ok = false;
nums[a].second = i;
}
if(!ok) {
cout << 0 << endl;
return 0;
}
int used_line[h], used_row[w];
ll line_cnt = 0, row_cnt = 0;
fill(used_line, used_line+h, 0);
fill(used_row, used_row+w, 0);
ll ans = 1LL;
for(ll i=h*w;i>=1;--i) {
// cerr << i << ": " << nums[i].first << ", " << nums[i].second << "\t";
if(nums[i].first != -1) {
++used_line[nums[i].first];
if(used_line[nums[i].first] == 1) {
++line_cnt;
}
}
if(nums[i].second != -1) {
++used_row[nums[i].second];
if(used_row[nums[i].second] == 1) {
++row_cnt;
}
}
if(nums[i].first == -1 && nums[i].second == -1) {
ans *= ((row_cnt*line_cnt) - (h*w - i));
} else if(nums[i].first == -1) {
ans *= line_cnt;
} else if(nums[i].second == -1) {
ans *= row_cnt;
}
ans %= MOD;
if(ans <= 0) {
ans = 0;
break;
}
}
cout << ans << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define LL long long
#define DD double
#define Pb push_back
#define Bp pop_back
#define Pf push_front
#define Fp pop_front
#define Ub upper_bound
#define Lb lower_bound
#define In insert
#define All(x) x.begin(), x.end()
#define mem(a, b) memset(a, b, sizeof(a))
#define fast ios_base::sync_with_stdio(0);cin.tie(0)
#define X first
#define Y second
#define mx1 10
#define mx2 110
#define mx3 1010
#define mx4 10010
#define mx5 100010
#define mx6 1000010
typedef vector<LL> Vl;
typedef vector<DD> Vd;
typedef vector<bool> Vb;
typedef vector<Vl> VVl;
typedef pair<LL, LL> Pll;
typedef pair<DD, DD> Pdd;
typedef vector<Pll> Vpl;
typedef vector<Pdd> Vpd;
typedef queue<LL> Ql;
typedef stack<LL> Sl;
typedef deque<LL> Dl;
LL _set(LL N, LL pos) {return N = N | (1 << pos);}
LL _reset(LL N, LL pos) {return N = N & ~(1 << pos);}
bool _check(LL N, LL pos) {return (bool)(N & (1 << pos));}
bool _upper(char a) {return a >= 'A' && a <= 'Z';}
bool _lower(char a) {return a >= 'a' && a <= 'z';}
bool _digit(char a) {return a >= '0' && a <= '9';}
LL dx[] = {1, -1, 0, 0, -1, -1, 1, 1};
LL dy[] = {0, 0, 1, -1, -1, 1, -1, 1};
///**************************DONE****************************///
int main()
{
int n, k;
cin >> n >> k;
vector<int> a, b;
for(int i = 0; i < n; i++){
int x;
cin >> x;
if(x < 0)
b.Pb(-x);
else
a.Pb(x);
}
reverse(All(b));
int la = a.size(), lb = b.size();
int ans = INT_MAX;
for(int i = 0; i < la; i++){
int x = i + 1;
if(x > k)
break;
if(k - x > lb)
continue;
if(k == x){
ans = min(ans, a[i]);
break;
}
x = k - x - 1;
ans = min(ans, 2 * a[i] + b[x]);
}
for(int i = 0; i < lb; i++){
int x = i + 1;
if(x > k)
break;
if(k - x > la)
continue;
if(k == x){
ans = min(ans, b[i]);
break;
}
x = k - x - 1;
ans = min(ans, 2 * b[i] + a[x]);
}
cout << ans << '\n';
return 0;
}
| 0 |
#include <bits/stdc++.h>
#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 PB push_back
#define INF INT_MAX/3
#define ALL(a) (a).begin(),(a).end()
#define CLR(a) memset(a,0,sizeof(a))
typedef long long int ll;
using namespace std;
int dp[41];
int main(){
memset(dp,0,sizeof(dp));
dp[0] = 1;
for(int j=0;j<30;j++){
for(int i=1;i<=3;i++){
dp[i+j] += dp[j];
}
}
while(true){
int n;
cin >> n;
if(n == 0) break;
int fact = dp[n]/10 + ((dp[n]%365==0) ? 0 : 1) ;
cout << fact/365 + ((fact%365==0) ? 0 : 1) << endl;
}
return 0;
} | #define _USE_MATH_DEFINES
#include "bits/stdc++.h"
#define EPS 1e-10
using namespace std;
typedef long long llong;
int main() {
int n;
while (cin >> n, n) {
for (int i = 0; i < n; i++) {
int m, e, j;
cin >> m >> e >> j;
if (m == 100 || e == 100 || j == 100 || (m + e) / 2 >= 90 || (m + e + j) / 3 >= 80)cout << 'A' << endl;
else if ((m + e + j) / 3 >= 70 || ((m + e + j) / 3 >= 50) && ((m >= 80) || (e >= 80)))cout << 'B' << endl;
else cout << 'C' << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#include <string>
#include <vector>
#include <algorithm>
#include <math.h>
#include <iostream>
#include <numeric>
#define rep(i,n) for (int i = 0;i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define chmax(x,y) x = max(x,y)
int INF = 1e9;
int main(){
int n,K;cin >> n >> K;
vector<int> num;
rep(i,10) num.push_back(i);
rep(i,K) {
int a;cin >> a;
rep(j,num.size()){
if(num[j]==a) num.erase(num.begin()+j);
}
}
//rep(i,num.size()) cout << num[i]<< endl;
int ans = 100000;
for(int a:num)for(int b:num)for(int c:num)for(int d:num)for(int e:num){
int temp = 10000*a+1000*b+100*c+10*d+e;
int temp2 = 1000*b+100*c+10*d+e;
int temp3 = 100*c+10*d+e;
int temp4 = 10*d+e;
int temp5 = e;
if(temp >= n) ans = min(ans,temp);
if(temp2 >= n) ans = min(ans,temp2);
if(temp3 >= n) ans = min(ans,temp3);
if(temp4 >= n) ans = min(ans,temp4);
if(temp5 >= n) ans = min(ans,temp5);
}
cout << ans << endl;
}
| #include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int num[10];
bool is_OK(int X){
while(X > 0){
int n = X % 10;
if(num[n]){
return false;
}
X /= 10;
}
return true;
}
int main(void){
int N,K;
cin >> N >> K;
int D[K];
for(int i=0;i<K;i++){
cin >> D[i];
}
for(int i=0;i<K;i++){
num[D[i]]++;
}
int ans;
for(int i=N;;i++){
if(is_OK(i)){
cout << i << endl;
return 0;
}
}
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.