code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define rep(i,N) for(int i = 0; i < (N); i++)
#define erep(i,N) for(int i = N - 1; i >= 0; i--)
const ll INF = 1000000000;
//const ll MOD = 1000000007;
const ld PI = (acos(-1));
using Graph = vector<vector<int>>;
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;}
typedef pair<int, int> P;
typedef pair<ll,ll> PLL;
double rad(double a) {return a * 180 / PI;}
struct UnionFind {
vector<int> par; // par[i]:iの親の番号 (例) par[3] = 2 : 3の親が2
UnionFind(int N) : par(N) { //最初は全てが根であるとして初期化
for(int i = 0; i < N; i++) par[i] = i;
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (par[x] == x) return x;
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); //xの根をrx
int ry = root(y); //yの根をry
if (rx == ry) return; //xとyの根が同じ(=同じ木にある)時はそのまま
par[rx] = ry; //xとyの根が同じでない(=同じ木にない)時：xの根rxをyの根ryにつける
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
};
//dpTable
int dp[100050];
int main(){
ll N;
cin >> N;
int sqrtN = sqrt(N);
int A,B;
for (int i = sqrtN; i >= 1; i--) {
if (N % i == 0) {
A = i;
B = N / i;
break;
}
}
int cntA = 0,cntB = 0;
while (A != 0) {
A /= 10;
cntA++;
}
while (B != 0) {
B /= 10;
cntB++;
}
cout << max(cntA,cntB) << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);++i)
using namespace std;
using ll = long long;
int main(){
// 制約見て！！！デカかったらlong longにすること！
string s;
cin >> s;
int m = 753;
rep(i,s.size()-2){
string sub = s.substr(i,3);
int x = stoi(sub);
m = std::min(m,abs(x-753));
}
cout << m <<endl;
} | 0 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<map>
#include<set>
#include<queue>
#include<cstdio>
#include<climits>
#include<cmath>
#include<cstring>
#include<string>
#include<sstream>
#include<numeric>
#include<cassert>
#define f first
#define s second
#define mp make_pair
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define rep(i,s,n) for(int i=(s); i<(int)(n); i++)
#define FOR(i,c) for(__typeof((c).begin()) i=(c).begin(); i!=(c).end(); i++)
#define ALL(c) (c).begin(), (c).end()
#define IN(x,s,g) ((x) >= (s) && (x) < (g))
#define ISIN(x,y,w,h) (IN((x),0,(w)) && IN((y),0,(h)))
#define print(x) printf("%d\n",x)
using namespace std;
typedef unsigned int uint;
typedef long long ll;
const int _dx[] = {0,1,0,-1};
const int _dy[] = {-1,0,1,0};
int getInt(){
int ret = 0,c;
c = getchar();
while(!isdigit(c)) c = getchar();
while(isdigit(c)){
ret *= 10;
ret += c - '0';
c = getchar();
}
return ret;
}
int main(){
int n, m;
while((n = getInt()) + (m = getInt())){
vector<int> v(n);
int ans = 0;
REP(i,n) v[i] = getInt();
sort(v.rbegin(), v.rend());
REP(i,n) if(i % m != (m - 1))
ans += v[i];
print(ans);
}
return 0;
} |
#include <iostream>
#include <set>
int main(){
while (true) {
int n; // I will buy n vegetables.
int m; // One bag contains m vegetables.
std::cin >> n >> m;
std::cin.ignore();
if ( n==0 && m==0 ) {
return 0;
}
// input vegetable's cost.
std::multiset<int, std::greater<int> > buy;
int in;
for (int i=0; i < n ; ++i) {
std::cin >> in;
buy.insert(in);
}
int cost = 0; // How much must I pay?
int x = 1; // This is the 'x'th vegetable in the bag.
while ( ! buy.empty() ) {
// the first item in 'buy' is the most expensive.
std::set<int>::iterator it = buy.begin();
// the 'm'th item in the bag is free!
if ( x > m-1 ) {
x = 1;
}else{
cost += *it;
++x;
}
buy.erase(it);
}
// output
std::cout << cost << std::endl;
}
return 0;
} | 1 |
//Boxes and Candies
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
#define rep(i,x,y) for(ll i=x;i<y;i++)
#define nvarep(n,a) ll n;cin>>n;vector<ll>a(n);rep(i,0,n)cin>>a[i]
#define vecrep(n,a,type) vector<type>a(n);rep(i,0,n)cin>>a[i]
#define YN(flag) (flag?"Yes":"No")
#define lcm(a,b) (a/__gcd(a, b)*b)
#define range(a) (a).begin(),(a).end()
#define pb push_back
#define mp make_pair
#define nnn "\n"
#define spa " "
using P = pair<ll,ll>;
using graph = vector<vector<ll>>;
const int inf = 2147483647;//2*10^9
const ll INF = 9223372036854775807;//9*10^18
signed main (){
int n,x,ans=0;cin>>n>>x;
vecrep(n,a,int);
int t=a[0];
rep(i,1,n){
t+=a[i];
if(t>x){
int s=t-x;
if(s>a[i]){
s-=a[i];
t-=a[i];
ans+=a[i];
a[i]=0;
a[i-1]-=s;
}else{
a[i]-=s;
}
ans+=s;
t-=s;
}
t-=a[i-1];
}
cout<<ans<<nnn;
return 0;
} | #include <iostream>
#include<vector>
#include<algorithm>
#include<map>
#include<iomanip>
#include<set>
#include<queue>
#include<deque>
#include<iomanip>
#include<sstream>
#include<cmath>
#include<tuple>
#include<bitset>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define req(i,n) for(int i = 1;i <= n; i++)
#define rrep(i,n) for(int i = n -1;i >= 0;i--)
#define ALL(obj) begin(obj), end(obj)
typedef long long int ll;
typedef long double ld;
const ll INF = (1LL << 62);
ll n,k, m, t; string s;
const ld PI = acos(-1);
template<typename A, size_t N, typename T>
void Fill(A(&array)[N], const T & val) {
std::fill((T*)array, (T*)(array + N), val);
}bool visit[410][410],b[410][410]; vector<vector<char>> c;
ll cc[2],ans = 0;
int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };
void dfs(int x,int y) {
cc[b[y][x]]++;
rep(i, 4) {
int nx = x + dx[i], ny = y + dy[i];
if (nx < 0 || ny < 0 || nx >= m || ny >= n) continue;
if (visit[ny][nx] || b[ny][nx] == b[y][x])continue;
visit[ny][nx] = 1;
dfs(nx, ny);
}
}
int main() {
cin >> n >> m; vector<vector<char>> c(n, vector<char>(m));
Fill(visit, 0);
rep(i, n) {
rep(j, m) {
cin >> c[i][j];
b[i][j] = (c[i][j] == '#');
}
}
rep(i, n) {
rep(j, m) {
if (visit[i][j]) continue;
visit[i][j] = 1;
cc[0] = 0; cc[1] = 0;
dfs(j, i);
ans += cc[0] * cc[1];
}
}cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
#define M_PI 3.14159265358979323846 // pi
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<ll> VI;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> t3;
typedef tuple<ll, ll, ll, ll> t4;
typedef tuple<ll, ll, ll, ll, ll> t5;
#define rep(a,n) for(ll a = 0;a < n;a++)
#define repi(a,b,n) for(ll a = b;a < n;a++)
using namespace std;
static const ll INF = 1e15;
template<typename T>
static inline void chmin(T& ref, const T value) {
if (ref > value) ref = value;
}
template<typename T>
static inline void chmax(T& ref, const T value) {
if (ref < value) ref = value;
}
constexpr ll mod = 1000000007;
class modint {
static constexpr std::int_fast64_t Modulus = 1e9 + 7;
using u64 = std::int_fast64_t;
public:
u64 a;
constexpr modint(const u64 x = 0) noexcept : a(x% Modulus) {}
constexpr u64& value() noexcept { return a; }
constexpr const u64& value() const noexcept { return a; }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint& operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint& operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint& operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
};
int main() {
int n;
cin >> n;
vector<int> vs(n);
rep(i, n) {
cin >> vs[i];
}
vector<int> colors(3, 0);
modint all = 1;
rep(i, n) {
int same = 0;
rep(j, 3) {
if (colors[j] == vs[i]) same++;
}
all *= same;
rep(j, 3) {
if (colors[j] == vs[i]) {
colors[j]++;
break;
}
}
}
cout << all.a << endl;
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define ll long long
#define INF 1000000000000000000
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
ll MOD = pow(10, 9) + 7;
vector<ll> A(N);
rep(i, N) {
cin >> A[i];
A[i]++;
}
vector<ll> dp(N, 0);
ll ans = 1;
dp[0] = 3;
for (int i = 0; i < N; i++) {
if (dp[A[i] - 1] == 0) {
cout << 0 << endl;
return 0;
}
ans *= dp[A[i] - 1];
ans %= MOD;
dp[A[i] - 1]--;
dp[A[i]]++;
}
cout << ans << endl;
}
| 1 |
#include <iostream>
#include <tuple>
#include <vector>
int main()
{
int h, w; std::cin >> h >> w;
std::vector<std::vector<int>> a(h, std::vector<int>(w, 0));
std::vector<std::tuple<int, int, int, int>> t;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
std::cin >> a[i][j];
a[i][j] %= 2;
}
}
for (int i = 0; i < h; i++) {
for (int j = 0; j < w-1; j++) {
if (a[i][j] == 1) {
t.push_back(std::make_tuple(i+1, j+1, i+1, j+2));
a[i][j+1] = (a[i][j+1] + 1) % 2;
a[i][j] = 0;
}
}
}
for (int i = 0; i < h-1; i++) {
if (a[i][w-1] == 1) {
t.push_back(std::make_tuple(i+1, w, i+2, w));
a[i+1][w-1] = (a[i+1][w-1] + 1) % 2;
a[i][w-1] = 0;
}
}
std::cout << t.size() << std::endl;
for (const auto& tt: t) {
std::cout
<< std::get<0>(tt) << " "
<< std::get<1>(tt) << " "
<< std::get<2>(tt) << " "
<< std::get<3>(tt) << std::endl;
}
return 0;
}
| #include<bits/stdc++.h>
#define fo(i,a,b)for(int i=a,_e=b;i<=_e;++i)
#define ll long long
using namespace std;
const int N=505,M=10000;
int n,p[M+5],p2[M+5],mu[M+5],ps;
ll a[N][N],h[N],l[N];
bool b[M+5];
ll gcd(ll x,ll y){
for(;y;y%=x)swap(x,y);
return x;
}
ll lcm(ll x,ll y){return x/gcd(x,y)*y;}
int main(){
n=500;
fo(i,2,M){
if(!b[i])p[++ps]=i,mu[i]=1;
for(int j=1,u;(u=i*p[j])<=M;++j){
b[u]=1;
if(i%p[j]==0)break;
mu[u]=mu[i];
}
}
ps=0;
for(int i=2;i<=n+n;i+=2){
++ps;
fo(j,max(1,i-n),min(n,i-1)){
int k=i-j;
a[j][k]=p[ps];
}
}
for(int i=n-2;i>=2-n;i-=2){
++ps;
fo(j,max(i+1,1),min(n,n+i)){
int k=j-i;
a[j][k]*=p[ps];
}
}
fo(i,1,n)fo(j,1,n)if(i+j&1){
a[i][j]=1;
if(i>1)a[i][j]=lcm(a[i][j],a[i-1][j]);
if(i<n)a[i][j]=lcm(a[i][j],a[i+1][j]);
if(j>1)a[i][j]=lcm(a[i][j],a[i][j-1]);
if(j<n)a[i][j]=lcm(a[i][j],a[i][j+1]);
++a[i][j];
}
cin>>n;
fo(i,1,n){
fo(j,1,n)printf("%lld ",a[i][j]);
printf("\n");
}
} | 0 |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;
#define llong long long
int n,m;
int pos[200200];
int nxt[200200];
llong K;
bool vis[200200];
int sta[200200],top;
double ans[100100];
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;++i) scanf("%d",&pos[i]),nxt[i]=i;
for(int i=n;i;--i)pos[i]-=pos[i-1];
scanf("%d%lld",&m,&K);
int xx;
for(int i=1;i<=m;++i)
scanf("%d",&xx),swap(nxt[xx],nxt[xx+1]);
for(int i=1;i<=n;++i)
if(!vis[i])
{
xx=i; top=0;
while(!vis[xx]) vis[xx]=1,sta[top++]=xx,xx=nxt[xx];
for(int j=0;j<top;++j)
ans[sta[j]]=pos[sta[(K+j)%top]];
}
for(int i=1;i<=n;++i)
{
ans[i]+=ans[i-1];
printf("%.1lf ",ans[i]);
}
puts("");
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define rep2(i,n) for (int i = 1; i < (n); ++i)
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<int> a(N);
rep(i,N) cin >> a[i];
double s = 0;
rep(i,N) {
s += a[i];
}
s /= N;
double min = 10000;
int min_num = 10000;
for(int i = N-1; i >= 0; i--) {
if (abs(s-a[i]) <= min){
min = abs(s-a[i]);
min_num = i;
}
}
cout << min_num << endl;
return 0;
}
| 0 |
// https://atcoder.jp/contests/nomura2020/tasks/nomura2020_a
#include<iostream>
#include<vector>//可変長配列
#include<algorithm>//sort,二分探索,など
#include<map>//map(辞書)
using namespace std;
int main(void){
int h1, m1, h2, m2, k;
cin >> h1 >> m1 >> h2 >> m2 >> k;
int wake = h1 * 60 + m1;
int sleep = h2 * 60 + m2;
int diff = sleep - wake - k;
cout << diff << endl;
return 0;
} | #define TEMPLATE_USED
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll,ll> pl;
typedef vector<pl> vp;
const ll INF=1001001001;
const ll LINF=1001001001001001001;
const ll D4[]={0,1,0,-1,0};
const ll D8[]={0,1,1,0,-1,-1,1,-1,0};
#define _overload3(_1,_2,_3,name,...) name
#define _rep2(i,n) for(ll i=0;i<(n);++i)
#define _rep3(i,a,b) for(ll i=(ll)(a);i<(ll)(b);++i)
#define rep(...) _overload3(__VA_ARGS__,_rep3,_rep2)(__VA_ARGS__)
#define _repe2(i,n) for(ll i=0;i<=(ll)(n);++i)
#define _repe3(i,a,b) for(ll i=(ll)(a);i<=(ll)(b);++i)
#define repe(...) _overload3(__VA_ARGS__,_repe3,_repe2)(__VA_ARGS__)
#define _rrep2(i,n) for(ll i=(ll)(n)-1;i>=0;i--)
#define _rrep3(i,a,b) for(ll i=(ll)(b)-1;i>=(ll)(a);i--)
#define rrep(...) _overload3(__VA_ARGS__,_rrep3,_rrep2)(__VA_ARGS__)
#define _rrepe2(i,n) for(ll i=(ll)(n);i>=0;i--)
#define _rrepe3(i,a,b) for(ll i=(ll)(b);i>=(ll)(a);i--)
#define rrepe(...) _overload3(__VA_ARGS__,_rrepe3,_rrepe2)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
template<class T>
bool chmax(T &a,const T &b){if(a<b){a=b;return 1;}return 0;}
template<class T>
bool chmin(T &a,const T &b){if(b<a){a=b;return 1;}return 0;}
template<class T>
using pq=priority_queue<T,vector<T>,greater<T>>;
vl H;
vl M;
ll K;
void solve();
int main(){
cin.tie(0);
ios::sync_with_stdio(0);
H = vl(2);
M = vl(2);
for(int i = 0; i < 2; ++i){
cin >> H[i];
cin >> M[i];
}
cin >> K;
solve();
}
// 0 < H_1, H_2 < 23
// 0 < M_1, M_2 < 59
// H_1 時 M_1 分は H_2 時 M_2 分より前の時刻である
// K > 1
// 高橋君が起きている時間の長さは K 分以上である
// 入力は全て整数である
// vl H, vl M, ll K
// 答えを整数として出力せよ。
void solve(){
ll t=H[1]*60+M[1]-(H[0]*60+M[0]);
cout<<t-K<<endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N; string s, a, b, A, B;
void change(int i){
int j=(N+i-1)%N, k=(i+1)%N;
A[i]=(A[i]=='S')?'W':'S'; a[i]=(a[i]=='o')?'x':'o';
a[j]=(a[j]=='o')?'x':'o'; a[k]=(a[k]=='o')?'x':'o';
B[i]=(B[i]=='S')?'W':'S'; b[i]=(b[i]=='o')?'x':'o';
b[j]=(b[j]=='o')?'x':'o'; b[k]=(b[k]=='o')?'x':'o';
}
void flipA(int c){ for(int i=c+2; i<c+N; i+=3){change(i%N);} }
void flipB(int c){ for(int i=c+1; i<c+N; i+=3){change(i%N);} }
int main(){
cin >> N >> s;
a=string(N,'o'); b=string(N,'x');
A=string(N,'S'); B=string(N,'W');
for(int i=0; i<N-2; i++){ if(a[i]!=s[i]){change(i+1);} }
if(a[N-2]==s[N-2]&&a[N-1]==s[N-1]){ cout << A << "\n"; }
else if(N%3==0){ cout << -1 << "\n"; }
else if(N%3==1){
if(a[N-2]==s[N-2]){ flipA(N-1); cout << B << "\n"; }
else if(a[N-1]==s[N-1]){ flipA(N-2); cout << B << "\n"; }
else{ flipA(N-2); flipA(N-1); cout << A << "\n"; }
}
else{
if(a[N-2]==s[N-2]){ flipB(N-1); cout << B << "\n"; }
else if(a[N-1]==s[N-1]){ flipB(N-2); cout << B << "\n"; }
else{ flipB(N-2); flipB(N-1); cout << A << "\n"; }
}
} | #include <bits/stdc++.h>
using namespace std;
const int N=1e5+10;
char s[N],a[N];
bool ok(char s[],char a[],int n)
{
for (int i=1;i<n-1;i++) {
if (a[i]=='S'&&s[i]=='o' || a[i]=='W'&&s[i]=='x') {
a[i+1]=a[i-1];
} else {
a[i+1]=(a[i-1]=='W')?'S':'W';
}
}
if (a[n-1]=='S'&&s[n-1]=='o' || a[n-1]=='W'&&s[n-1]=='x') {
if (a[n-2]!=a[0]) return false;
} else {
if (a[n-2]==a[0]) return false;
}
if (a[0]=='S'&&s[0]=='o' || a[0]=='W'&&s[0]=='x') {
if (a[n-1]!=a[1]) return false;
} else {
if (a[n-1]==a[1]) return false;
}
return true;
}
int main()
{
int n;
scanf("%d",&n);
scanf("%s",s);
bool good=false;
for (int i=0;i<2;i++) {
for (int j=0;j<2;j++) {
a[0]=i?'S':'W';
a[1]=j?'S':'W';
if (ok(s,a,n)) {
puts(a);
good=true;
break;
}
}
if (good) break;
}
if (!good) {
puts("-1");
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, v;
cin >> n;
int* ohash = (int*) calloc(100000, sizeof(int));
int* ehash = (int*) calloc(100000, sizeof(int));
for (int i = 0; i < n/2; i++) {
cin >> v;
ohash[v - 1]++;
cin >> v;
ehash[v - 1]++;
}
int omax = 0, emax = 0;
for (int i = 0; i < 100000; i++) {
if (ohash[i] > ohash[omax]) omax = i;
if (ehash[i] > ehash[emax]) emax = i;
}
if (omax != emax) {
cout << n - ohash[omax] - ehash[emax];
}
else {
int omax2 = 0, emax2 = 0;
for (int i = 0; i < 100000; i++) {
if (ohash[i] > ohash[omax2] && i != omax) omax2 = i;
if (ehash[i] > ehash[emax2] && i != emax) emax2 = i;
}
if (ohash[omax] == n/2 && ehash[emax] == n/2) {
cout << n/2;
}
else if (ohash[omax] == n/2) {
cout << n/2 - ehash[emax2];
}
else if (ehash[emax] == n/2) {
cout << n/2 - ohash[omax2];
}
else {
cout << min(n - ohash[omax] - ehash[emax2], n - ohash[omax2] - ehash[emax]);
}
}
free(ohash);
free(ehash);
return 0;
} | #pragma GCC optimize("Ofast")
#define _USE_MATH_DEFINES
#include "bits/stdc++.h"
using namespace std;
using u8 = uint8_t;
using u16 = uint16_t;
using u32 = uint32_t;
using u64 = uint64_t;
using i8 = int8_t;
using i16 = int16_t;
using i32 = int32_t;
using i64 = int64_t;
using vi = vector<int>;
constexpr char newl = '\n';
constexpr double eps = 1e-10;
#define FOR(i,a,b) for (int i = (a); i < (b); i++)
#define F0R(i,b) FOR(i,0,b)
#define RFO(i,a,b) for (int i = ((b)-1); i >=(a); i--)
#define RF0(i,b) RFO(i,0,b)
#define fi first
#define se second
#define show(x) cout << #x << " = " << x << '\n';
#define rng(a) a.begin(),a.end()
#define rrng(a) a.rbegin(),a.rend()
#define sz(x) (int)(x).size()
#define YesNo {cout<<"Yes";}else{cout<<"No";}
#define YESNO {cout<<"YES";}else{cout<<"NO";}
#define v(T) vector<T>
template<typename T1, typename T2> inline void chmin(T1& a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2> inline void chmax(T1& a, T2 b) { if (a < b) a = b; }
template<class T> bool lcmp(const pair<T, T>& l, const pair<T, T>& r) {
return l.first < r.first;
}
template<class T> istream& operator>>(istream& i, v(T)& v) {
F0R(j, sz(v)) i >> v[j];
return i;
}
template<class A, class B> istream& operator>>(istream& i, pair<A, B>& p) {
return i >> p.first >> p.second;
}
template<class A, class B, class C> istream& operator>>(istream& i, tuple<A, B, C>& t) {
return i >> get<0>(t) >> get<1>(t) >> get<2>(t);
}
template<class T> ostream& operator<<(ostream& o, const vector<T>& v) {
F0R(i, v.size()) {
o << v[i] << ' ';
}
o << newl;
return o;
}
template<class T1, class T2> ostream& operator<<(ostream& o, const map<T1, T2>& m) {
for (auto& p : m) {
o << p.first << ": " << p.second << newl;
}
o << newl;
return o;
}
#if 1
// INSERT ABOVE HERE
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
unordered_map<int, int> a, b;
F0R(i, n) {
int v;
cin >> v;
if (i & 1) {
++a[v];
}
else {
++b[v];
}
}
vector<pair<int,int>> c, d;
for (auto& p : a) c.emplace_back(p.second, p.first);
for (auto& p : b) d.emplace_back(p.second, p.first);
sort(rrng(c), lcmp<int>);
sort(rrng(d), lcmp<int>);
c.emplace_back(0, -1);
d.emplace_back(0, -1);
int r;
if (c[0].second != d[0].second)
r = n - c[0].first - d[0].first;
else {
r = n - max(c[0].first + d[1].first, c[1].first + d[0].first);
}
cout << r;
}
#endif
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9+7;
int main(){
int N;
cin >> N;
vector<long long> A(N);
for(int i = 0; i < N; i++)
cin >> A[i];
long long ans = 0;
long long sum = 0;
long long sum2 = 0;
for(int i = 0; i < N; i++){
sum2 = (sum2 + A[i]*A[i]) % (2*mod);
sum = (sum + A[i]) % (2*mod);
}
ans = (sum*sum - sum2) % (2*mod) / 2;
cout << ans << endl;
}
| #include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
template < typename T > using oset = tree < T, null_type, less < T >, rb_tree_tag, tree_order_statistics_node_update >;
// find_by_order(k) (k+1)th largest element
// order_of_key(k) no of elements <=k
typedef long long ll;
typedef long double ld;
#define endl '\n'
#define rep(i,n) for(ll i = 0; i < (n); ++i)
#define repA(i, a, n) for(ll i = a; i <= (n); ++i)
#define repD(i, a, n) for(ll i = a; i >= (n); --i)
#define trav(a, x) for(auto& a : x)
#define all(x) x.begin(), x.end()
#define sz(x) (ll)(x).size()
#define ff first
#define ss second
#define pb push_back
typedef vector<ll> vll;
typedef vector<pair<ll,ll>> vpl;
const ld PI = 4*atan((ld)1);
const ll INF = LLONG_MAX;
const ll mod = 1e9+7;
int main()
{
//freopen("input.txt","r",stdin);
//freopen("output.txt","w",stdout);
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
ll tt=1;
// cin >> tt;
repA(qq,1,tt){
ll n; cin >> n;
vll a(n),suf(n);
rep(i,n){
cin >> a[i];
}
suf[n-1] = a[n-1];
repD(i,n-2,0){
suf[i] = suf[i+1]+a[i];
}
ll ans =0;
rep(i,n-1){
// cout << a[i] << " " << suf[i] << endl;
ans += a[i]*(suf[i+1]%mod);
ans %=mod;
}
cout << ans << endl;
}
}
| 1 |
#include <iostream>
#include <vector>
#include <set>
using namespace std;
static const int NIL = -1;
struct Vertex {
vector<int> link;
int parent = NIL;
int ord;
int lowlink;
bool is_visit = false;
};
class ArticulationPoint {
private:
int n;
vector<Vertex> graph;
int timer = 1;
public:
ArticulationPoint() {}
ArticulationPoint(int n)
{
this->n = n;
graph.resize(n);
int edge;
cin >> edge;
int s, t;
for (int e = 0; e < edge; e++)
{
cin >> s >> t;
graph[s].link.push_back(t);
graph[t].link.push_back(s);
}
}
void dfs(int current)
{
graph[current].is_visit = true;
graph[current].ord = graph[current].lowlink = timer;
timer++;
for(int next : graph[current].link)
{
if(!graph[next].is_visit)
{
graph[next].parent = current;
dfs(next);
graph[current].lowlink = min(graph[current].lowlink, graph[next].lowlink); // 3.
}
else if(next != graph[current].parent)
{
// １回の移動で行くことのできる訪問済みの頂点は，Backedgeを除けば自分の親しかいない
// つまりこのブロックにくるのはnextがBackedgeを通った訪問済みの頂点のとき
graph[current].lowlink = min(graph[current].lowlink, graph[next].ord);
}
}
}
void articulation_point()
{
set<int> art_point;
int root = 0;
dfs(root);
int root_child_num = 0;
for(int u = 0; u < n; u++)
{
int p = graph[u].parent;
if(p == NIL) continue;
if(p == root)
{
root_child_num++;
if(root_child_num >= 2)
art_point.insert(root);
}
else if(graph[p].ord <= graph[u].lowlink)
{
art_point.insert(p);
}
}
for(int x : art_point)
cout << x << endl;
}
};
int main()
{
int n;
cin >> n;
ArticulationPoint articulationPoint(n);
articulationPoint.articulation_point();
}
| #include<bits/stdc++.h>
using namespace std;
#define INF 100010
typedef pair<int,int> P;
vector<int> G[100010];
vector<int> GG[100010];
int V,E,n;
int ord[100010];
int low[100010];
int par[100010];
int lowlink(int x,int p){
ord[x]=n++,par[x]=p;
int ans=ord[x];
for(int i=0;i<G[x].size();i++){
if(G[x][i]==p)continue;
if(ord[G[x][i]]!=INF)ans=min(ord[G[x][i]],ans);
else {
ans=min(ans,lowlink(G[x][i],x));
GG[x].push_back(G[x][i]);
}
}
return low[x]=ans;
}
int main(){
for(int i=0;i<100010;i++)
low[i]=ord[i]=INF;
cin>>V>>E;
P p[100010];
for(int i=0;i<E;i++){
int s,t;
cin>>s>>t;
G[s].push_back(t);
G[t].push_back(s);
if(s>t)swap(s,t);
p[i]=P(s,t);
}
sort(p,p+E);
lowlink(0,-1);
for(int i=0;i<V;i++){
int f=0;
if(i==0&&GG[0].size()>1)f=1;
if(i!=0)
for(int j=0;j<GG[i].size();j++){
if(GG[i][j]==par[i])continue;
if(low[GG[i][j]]>=ord[i])f=1;
//cout<<i<<" "<<G[i][j]<<" "<<low[i]<<" "<<low[G[i][j]]<<" "<<f<<endl;
}
//cout<<low[i]<<endl;
if(f)cout<<i<<endl;
}
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int main(){
unsigned long long int a,b,c,k;
cin>>a>>b>>c>>k;
unsigned long long int sum=a+b+c;
unsigned long long int term=max(a,max(b,c));
sum-=term;
while(k)
{
term*=2;
k--;
}
cout<<sum+term;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> VI;
ll mm=1000000000;ll MM=mm+7;
#define rep(i, n) for(int i=0;i<n;i++)
#define PI 3.141592653589793
int main(){
ll x;
cin >> x;
ll n=x%11;
ll m=x/11;
if(n==0)cout<< 2*m << endl;
else if(n<=6)cout << 2*m+1 << endl;
else cout << 2*m+2 << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
inline int read() {
int res=0,fh=1;
char ch=getchar();
while((ch>'9'||ch<'0')&&ch!='-')ch=getchar();
if(ch=='-')fh=-1,ch=getchar();
while(ch>='0'&&ch<='9')res=res*10+ch-'0',ch=getchar();
return fh*res;
}
const int maxn=16;
int n,m,mxs,sum[(1<<16)+12],a[maxn][maxn];
int f[(1<<maxn)][maxn];
inline int Max(int a,int b){return a>b?a:b;}
int main(){
n=read(),m=read();
mxs=(1<<n)-1;
for(int i=1;i<=m;i++){
int x=read()-1,y=read()-1,z=read();
a[x][y]=a[y][x]=z;
}
for(int i=0;i<=mxs;i++){
sum[i]=0;
for(int j=0;j<n;j++)
if((i&(1<<j)))
for(int k=j+1;k<n;k++)
if((i&(1<<k))) sum[i]+=a[j][k];
}
memset(f,-1,sizeof f);
f[1][0]=0;
for(int i=1;i<=mxs;i+=2){
for(int j=0;j<n;j++){
if(f[i][j]==-1) continue;
if(!(i&(1<<j))) continue;
for(int k=0;k<n;k++)
if(a[j][k]&&(!(i&(1<<k))))
f[i|(1<<k)][k]=Max(f[i|(1<<k)][k],f[i][j]+a[j][k]);
int c=(mxs-i)|(1<<j);
for(int k=c;k>=0;k=(k==0?-1:(k-1)&c))
f[i|k][j]=Max(f[i][j]+sum[k],f[i|k][j]);
}
}
int ans=0;
for(int i=(mxs>>1)+2;i<=mxs;i+=2)
ans=Max(ans,f[i][n-1]);
printf("%d\n",sum[mxs]-ans);
return 0;
}
| #include <stdio.h>
#include <vector>
#include <set>
#include <utility>
using namespace std;
typedef long long ll;
int main(void) {
ll i, j, k, l, n, m, a, b, now, min;
scanf("%lld%lld", &n, &m);
vector<ll> vec[n], rev[n];
ll d[n], be[n];
pair<ll, ll> p;
for(i = 0; i < m; ++i) {
scanf("%lld%lld", &a, &b);
vec[--a].push_back(--b);
rev[b].push_back(a);
}
for(i = 0; i < n; ++i) {
set< pair<ll, ll> > s;
for(j = 0; j < n; ++j) d[j] = 1e9;
d[i] = 0;
for(j = 0; j < n; ++j) s.insert(make_pair(d[j], j));
while(s.size()) {
p = *s.begin(), s.erase(s.begin());
if(p.first == 1e9) break;
for(j = 0; j < vec[p.second].size(); ++j) if(d[vec[p.second][j]] > p.first + 1) {
s.erase(make_pair(d[vec[p.second][j]], vec[p.second][j]));
d[vec[p.second][j]] = p.first + 1;
be[vec[p.second][j]] = p.second;
s.insert(make_pair(p.first + 1, vec[p.second][j]));
}
}
for(j = 0; j < rev[i].size(); ++j) if(d[rev[i][j]] != 1e9) {
vector<ll> ans;
now = rev[i][j];
while(now != i) ans.push_back(now), now = be[now];
ans.push_back(i);
min = ans.size();
ll flg[n];
for(k = 0; k < n; ++k) flg[k] = ans.size();
flg[i] = ans.size() - 1;
for(now = ans.size() - 2; now >= 0; --now) {
for(k = 0; k < vec[ans[now]].size(); ++k) if(flg[vec[ans[now]][k]] < min) min = flg[vec[ans[now]][k]];
if(min != ans.size()) break;
flg[ans[now]] = now;
}
printf("%lld\n", min - now + 1);
for(k = min; k >= now; --k) printf("%lld\n", ans[k] + 1);
return 0;
}
}
printf("-1");
return 0;
} | 0 |
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <vector>
// Acknowledgement: Special thanks to kyomukyomupurin, who developed this
// template.
template <class T, class U>
std::ostream& operator<<(std::ostream& os, const std::pair<T, U>& p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <class T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& vec) {
int n = 0;
for (auto e : vec) os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T>
std::ostream& operator<<(std::ostream& os, const std::set<T>& st) {
int n = 0;
for (auto e : st) os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T, class U>
std::ostream& operator<<(std::ostream& os, const std::map<T, U>& mp) {
int n = 0;
for (auto e : mp) os << (n++ ? ", " : "{") << e;
return os << (n ? "}" : "{}");
}
template <class T>
std::istream& operator>>(std::istream& is, std::vector<T>& vec) {
for (T& e : vec) is >> e;
return is;
}
#ifdef LOCAL
#define debug(...) \
std::cerr << "[" << #__VA_ARGS__ << "]: ", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
void debug_out() { std::cerr << '\n'; }
template <class Head, class... Tail>
void debug_out(Head&& head, Tail&&... tail) {
std::cerr << head;
if (sizeof...(Tail) != 0) std::cerr << ", ";
debug_out(std::forward<Tail>(tail)...);
}
using namespace std;
using int64 = long long;
int main() {
int K, T;
cin >> K >> T;
vector<int> a(T);
cin >> a;
auto itr = max_element(a.begin(), a.end());
int ans = *itr - (K - *itr) - 1;
cout << max(0, ans) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, K; cin >> N >> K;
vector<int> A(N);
for (int i = 0; i < N; i++) cin >> A.at(i);
for (int i = 0; i < K; i++) {
vector<int> B(N+1, 0);
for (int j = 0; j < N; j++) {
int left = max(0, j - A.at(j));
int right = min(N, j + A.at(j) + 1);
B.at(left)++; B.at(right)--;
}
for (int j = 0; j < N; j++) B.at(j+1) += B.at(j);
B.pop_back();
if (A == B) break;
A = B;
}
for (int i = 0; i < N; i++) {
if (i) cout << " ";
cout << A.at(i);
}
cout << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define _GLIBCXX_DEBUG
#define INF 1e8
typedef long long int ll;
const double PI = acos(-1);
using Graph = vector<vector<int>>;
int main() {
int n, m;
cin >> n >> m;
int s[m];
char c[m];
rep(i, m) { cin >> s[i] >> c[i]; }
for (int i = 0; i < pow(10, n); i++) {
string str = to_string(i);
bool flag = true;
rep(j, m) {
if (str[s[j] - 1] != c[j]) {
flag = false;
break;
}
}
if (flag && str.length() == n) {
cout << str << endl;
return 0;
}
}
cout << "-1" << endl;
}
| #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 n, m;
cin >> n >> m;
vi s(m), c(m);
rep(i, m) {
cin >> s[i] >> c[i];
s[i]--;
}
vi q(n, -1);
rep(i, m) {
if (q[s[i]]!=-1 && q[s[i]]!=c[i]) {
cout << -1 << endl;
return 0;
}
else q[s[i]] = c[i];
}
if (n>1 && q[0]==0) {
cout << -1 << endl;
return 0;
}
int b = 1, e = 10;
rep(i, n-1) {
b *= 10; e *= 10;
}
if (n == 1) b = 0;
for (int i=b; i<e; ++i) {
int i2 = i;
bool ok = true;
repr(j, n) {
if (q[j]!=-1 && i2%10!=q[j]) ok = false;
i2 /= 10;
}
if (ok) {
cout << i << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=1e5+7;
LL jmp,a,k,n,m,x[N],y[N],p[N],g[N],siz[N],tot,cnt,sum;
bitset <N> vis;
int main()
{
scanf("%lld",&n);
for(int i=1;i<=n;i++)scanf("%lld",&x[i]),p[i]=i;
for(int i=1;i<=n;i++)y[i]=x[i]-x[i-1];
scanf("%lld%lld",&m,&k);
for(int i=1;i<=m;i++)
{
scanf("%lld",&a);
swap(p[a],p[a+1]);
}
for(int i=1;i<=n;i++)if(!vis[i])
{
++cnt;int res=i;
while(!vis[res])
g[res]=cnt,vis[res]=1,res=p[res],++siz[cnt];
}
for(int i=1;i<=n;i++)
{
jmp=k%siz[g[i]];
int res=i;
if(jmp)while(jmp--)res=p[res];
sum+=y[res];
printf("%lld.0\n",sum);
}
} | #include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector>
#include <climits>
#define rep(i, m, n) for(int i=int(m);i<int(n);i++)
#define all(c) begin(c),end(c)
template<typename T1, typename T2>
inline void chmin(T1 &a, T2 b) { if (a > b) a = b; }
template<typename T1, typename T2>
inline void chmax(T1 &a, T2 b) { if (a < b) a = b; }
//改造
typedef long long int ll;
using namespace std;
#define INF (1 << 30) - 1
#define INFl (ll)5e15
#define DEBUG 0 //デバッグする時1にしてね
#define dump(x) cerr << #x << " = " << (x) << endl
#define MOD 1000000007
//ここから編集する
class Solve {
public:
void input() {
}
vector<int> mul(vector<int> f, vector<int> g) {
int n = f.size();
vector<int> ret(n);
rep(i, 0, n) {
ret[i] = g[f[i]];
}
return ret;
}
void solve() {
input();
int N;
cin >> N;
vector<ll> x(N);
rep(i, 0, N) cin >> x[i];
int M;
ll K;
cin >> M >> K;
vector<int> a(M);
rep(i, 0, M) {
cin >> a[i];
}
vector<int> base(N - 1);
rep(i, 0, N - 1) base[i] = i;
vector<int> f = base;
for (int i = 0; i < M; ++i) {
swap(base[a[i] - 2], base[a[i] - 1]);
}
ll rest = K;
while (rest > 0) {
if (rest & 1) f = mul(f, base);
base = mul(base, base);
rest >>= 1;
}
vector<ll> d(N - 1);
vector<ll> neko(N - 1);
for (int i = 0; i < N - 1; ++i) {
d[i] = x[i + 1] - x[i];
}
for (int i = 0; i < N - 1; ++i) {
neko[i] = d[f[i]];
}
vector<ll> ans(N);
ans[0] = x[0];
for (int i = 1; i < N; ++i) {
ans[i] = ans[i - 1] + neko[i - 1];
}
for (int i = 0; i < N; ++i) {
cout << ans[i] << endl;
}
return;
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
Solve().solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n,k,s=1;cin>>n>>k;
for(int i=0;i<n;i++)
if(s*2<=s+k)
s*=2;
else s+=k;
cout<<s;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
void Main() {
int A, B;
cin >> A >> B;
if (A <= 8 && B <= 8) {
cout << "Yay!" << endl;
}
else {
cout << ":(" << endl;
}
}
int main() {
std::cout << std::fixed << std::setprecision(15);
Main();
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long int n;
cin>>n;
cout<<fixed<<setprecision(20)<<n*6.28318530717958623200<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void){
long long int x;
cin>>x;
if (x<=6) {
cout<<1<<endl;
} else {
if (x%11==0) {
cout<<2*(x/11)<<endl;
} else if (x%11<=6) {
cout<<2*(x/11)+1<<endl;
} else {
cout<<2*(x/11)+2<<endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (int)n; i++)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<pi, pi> pp;
typedef pair<ll, ll> pl;
double PI = 3.1415926535897932;
const double EPS = 1e-9;
const ll MOD = 1000000007;
const int inf = 1 << 30;
const ll linf = 1LL << 60;
vector<pl> toppo (pl *p, int si) {
sort(p, p+si);
vector<pl> ret;
ret.push_back(p[0]);
for (int i = 1; i < si; i++) {
while (ret.size() > 1) {
int tmp = ret.size()-1;
if ((p[i].second-ret[tmp-1].second)*(ret[tmp].first-ret[tmp-1].first) >=
(ret[tmp].second-ret[tmp-1].second)*(p[i].first-ret[tmp-1].first)) {
ret.pop_back();
} else {
break;
}
}
ret.push_back(p[i]);
}
vector<pl> ret2;
ret2.push_back(p[si-1]);
for (int i = si-2; i >= 0; i--) {
while (ret2.size() > 1) {
int tmp = ret2.size()-1;
if ((p[i].second-ret2[tmp-1].second)*(ret2[tmp].first-ret2[tmp-1].first) >=
(ret2[tmp].second-ret2[tmp-1].second)*(p[i].first-ret2[tmp-1].first)) {
ret2.pop_back();
} else {
break;
}
}
ret2.push_back(p[i]);
}
ret2.pop_back();
for (int i = 1; i < ret2.size(); i++) ret.push_back(ret2[i]);
return ret;
}
int n;
pl pos[100], tmp[100];
double ans[100];
int main() {
cin >> n;
rep(i,n) cin >> pos[i].first >> pos[i].second;
rep(i,n) tmp[i] = pos[i];
vector<pl> topp = toppo(tmp, n);
int si = topp.size();
for (int i = 0; i < si; i++) {
pl pre = topp[(i-1+si)%si];
pl now = topp[i];
pl nxt = topp[(i+1)%si];
double dy1 = now.second-pre.second, dx1 = now.first-pre.first;
double dy2 = nxt.second-now.second, dx2 = nxt.first-now.first;
double d1 = atan2(dy1, dx1);
double d2 = atan2(dy2, dx2);
double d = abs(d1-d2);
if (d > PI) d = 2*PI-d;
rep(j,n) {
if (topp[i] == pos[j]) {
ans[j] = d/(2*PI);
}
}
}
rep(i,n) {
printf("%.9f\n", ans[i]);
}
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
// Big two primes
#define X 1001100011100001111ll
#define mod 1000000007
#define ll long long
#define all(a) a.begin(),a.end()
#define sortall(a) sort(all(a))
#define fo(i, n) for (int i = 0; i < n; i++)
#define fo1(i, n) for (int i = 1; i <= n; i++)
#define loop(i,a,b) for (int i = a; i < b; i++)
#define nloop(i,a,b) for (int i = a ; i>=b;i--)
#define tc(t) int t; cin >> t; while (t--)
#define arrip(a,n) int a[n]; fo(i, n) cin >> a[i];
#define arrop(n) fo(i,n) cout<<a[i]<<" ";
#define pb push_back
#define mp make_pair
#define itr(it, a) for(auto it = a.begin(); it != a.end(); it++)
#define PI 3.1415926535897932384626
#define fio ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL)
#define rr return 0
#define prec(n) fixed<<setprecision(n)
#define maxpq priority_queue<int>
#define minpq priority_queue<int, vector<int>, greater<int> >
#define inf (int)(1e18)
#define ini(a, i) memset(a, i, sizeof(a))
#define vi vector<int>
#define fi first
#define se second
#define endl "\n"
#define pi pair<int, int>
#define vpi vector<pi>
#define sz(s) s.size()
#define bits(n) __builtin_popcount(n)//Count set bits
const int MAXN = (int)((1e5) + 100);
int gcd(int a, int b) { if (a == 0) return b; return gcd(b % a, a);}
int max(int a, int b) {if (a > b) return a; else return b;}
int min(int a, int b) {if (a < b) return a; else return b;}
int32_t main()
{
#ifndef ONLINE_JUDGE
freopen("atcoderi.txt", "r", stdin);
freopen("atcodero.txt", "w", stdout);
#endif
fio;
int n = 5, k;
arrip(a, n);
cin >> k;
bool f = true;
fo(i, 5)
{
for (int j = i + 1; j < 5; j++)
{
int res = abs(a[i] - a[j]);
if (res > k)
f = false;
}
}
if (f == false)
cout << ":(" << endl;
else
cout << "Yay!" << endl;
} | 0 |
#include <bits/stdc++.h>
#define REP(i,n) for (int i=0;i<(n);++i)
#define all(a) (a).begin(),(a).end()
using namespace std;
using ll = long long;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, K;
cin >> N >> K;
K = min(K, 50);
vector<int> A(N);
REP(i, N) cin >> A[i];
while (K-- > 0) {
vector<int> B(N + 1);
REP(i, N) {
B[max(i - A[i], 0)] += 1;
B[min(i + A[i] + 1, N)] -= 1;
}
REP(i, N) {
B[i + 1] += B[i];
}
A = B;
}
REP(i, N) {
cout << A[i] << " ";
}
cout << endl;
return 0;
}
| #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
int main() {
int n,k;
cin >> n >> k;
vector<int> a(n);
for(int i=0; i<n; i++) cin >> a[i];
vector<int> b(n+1);
vector<int> c(n);
int count = 0;
for(int i=1; i<=k; i++){
for(int i=0; i<n; i++){
b[max(1,1+i-a[i])-1]++;
b[min(n,1+i+a[i])]--;
}
for(int i=0; i<n; i++){
if(i == 0) c[i] = b[i];
else c[i] += c[i-1] + b[i];
}
for(int i=0; i<n; i++){
a[i] = c[i];
b[i] = 0;
c[i] = 0;
}
for(int i=0; i<n; i++){
if(a[i] == n) count++;
}
if(count == n){
break;
}
count = 0;
}
if(n == 1) cout << a[0] << endl;
else{
for(int i=0; i<n-1; i++) cout << a[i] << " ";
cout << a[n-1] << endl;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e6+5;
int n,q;
char s[N];
ll dp[N],f[N],sumd[N],summ[N];
int main()
{
scanf("%d",&n);
scanf("%s",s+1);
scanf("%d",&q);
for(int i=1;i<=n;i++)
{
sumd[i]=sumd[i-1]+(s[i]=='D');
summ[i]=summ[i-1]+(s[i]=='M');
dp[i]=dp[i-1];
f[i]=f[i-1];
if(s[i]=='M') dp[i]+=sumd[i];
if(s[i]=='C') f[i]+=dp[i];
}
while(q--)
{
ll ans=f[n];
int k;scanf("%d",&k);
for(int i=k;i<=n;i++)
if(s[i]=='C')
ans-=dp[i-k]+(summ[i]-summ[i-k])*sumd[i-k];
printf("%lld\n",ans);
}
}
| #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <list>
#include <utility>
#include <tuple>
#include <cstdio>
#include <set>
#include <queue>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <cmath>
#define _GLIBCXX_DEBUG
using namespace std;
const long long INF = 1LL << 60;
typedef long long ll;
int main() {
int A,B,M;
cin >> A >> B >> M;
//
vector<int> a(A);
for(int i=0;i<A;i++){
cin >> a[i];
}
//
vector<int> b(B);
for(int i=0;i<B;i++){
cin >> b[i];
}
//
vector<int> x(M);
vector<int> y(M);
vector<int> c(M);
for(int i=0;i<M;i++){
cin >> x[i] >> y[i] >> c[i] ;
}
//
ll price;
ll min_price;
for(int i=0;i<M;i++){
price = a[x[i]-1] + b[y[i]-1] - c[i];
if(i==0){
min_price = price;
}
else if(min_price > price){
min_price = price;
}
}
sort(a.begin(),a.end());
sort(b.begin(),b.end());
price = a[0] + b[0];
if(min_price > price){
min_price = price;
}
cout << min_price << endl;
} | 0 |
#include <iostream>
#include <algorithm>
#include <string>
using namespace std;
typedef long long ll;
int main(void) {
int n, i, j, l[30] = {};
ll ans = 1;
string a;
cin >> a;
n = a.size();
for (i = 0; i < n; i++) {
l[a[i] - 'a']++;
}
for (i = 0; i < 26; i++) for (j = i + 1; j < 26; j++) {
ans += (ll)l[i] * l[j];
}
cout << ans << endl;
return 0;
} | #pragma GCC optimize ("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse4")
#include"bits/stdc++.h"
using namespace std;
typedef long long ll;
#define int ll
#define all(x) x.begin(), x.end()
#define trav(i,a) for(auto &i:a)
inline int in(){int x;scanf("%lld",&x);return x;}
int f[26];
const int N=2e5+4;
int32_t main()
{
string s;
cin>>s;
int n=s.length();
int ans=1;
for(int i=0;i<n;i++)
{
int cur=s[i]-'a';
int len=i+1;
ans+=i-f[cur];
f[cur]++;
}
cout<<ans;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
vector< int >apply(const vector< int >&v) {
int n = v.size();
vector< int >cu(n, 0);
for (int i = 0; i < n; i++) {
int l = max(i-v[i], 0);
int r = min(i+v[i], n-1);
cu[l]++;
if (r+1 < n) cu[r+1]--;
}
for (int i = 1; i < n; i++) cu[i] += cu[i-1];
return cu;
}
int main() {
int n, k;
cin >> n >> k;
vector< int >a(n);
for (int &x : a) cin >> x;
while (k--) {
vector< int >r = apply(a);
if (a == r) break;
swap(a, r);
}
for (int i = 0; i < n; i++) cout << a[i] << " ";
return 0;
}
| #include<bits/stdc++.h>
typedef long long int ll;
typedef long double ld;
#define sync ios_base::sync_with_stdio(false); cin.tie(NULL)
#define input(arr,n) for(ll i1=0;i1<n;i1++ )cin>>arr[i1]
#define mod 1000000007
#define F first
#define S second
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#pragma GCC optimize("O3")
//recursions\
#pragma comment(linker, "/stack:200000000")
//loops\
#pragma GCC optimize("unroll-loops")
using namespace __gnu_pbds;
#define ordered_set tree<ll, null_type,less_equal<ll>, rb_tree_tag,tree_order_statistics_node_update>//s.order_of_key(val) *s.find_by_order(ind)
using namespace std;
const int N = 1e6 + 5;
int main()
{
sync;
ll n;
cin >> n;
ll a[n], b[n], c[n];
input(a, n);
input(b, n);
sort(b, b + n, greater<ll>());
ll l = 1e9, r = -1;
for(ll i = 0 ; i < n; i++)
{
if(a[i] == b[i])
{
l = min(l, i);
r = max(r, i);
}
}
if(r != -1)
{
for(ll i = 0; i < n; i++)
{
if(l > r)
break;
if(a[i] != a[r] && b[i] != a[r])
{
swap(b[l], b[i]);
l++;
}
}
}
if(l <= r)
cout << "No";
else
{
cout << "Yes\n";
for(ll i = 0; i < n; i++)
cout << b[i] << " ";
}
} | 0 |
#include <iostream>
#include <vector>
#include <set>
#include <deque>
#include <map>
#include <iomanip>
#include <queue>
#include <stack>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <utility>
using namespace std;
int ky[8] = {-1,1,-2,2,-2,2,-1,1};
int kx[8] = {-2,-2,-1,-1,1,1,2,2};
int dy[4] = {-1,0,1,0};
int dx[4] = {0,1,0,-1};
int ddy[8] = {-1,0,1,-1,1,-1,0,1};
int ddx[8] = {-1,-1,-1,0,0,1,1,1};
typedef long long ll;
#define pi pair
#define MP make_pair
#define PB push_back
#define F first
#define S second
#define rep1(i,a,b) for(int i = a; i < b; i++)
#define rep2(i,a,b) for(int i = a; i <= b; i++)
#define INF 999999999999
const double PI = acos(-1.0);
ll n;
ll num;
ll cnt;
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
//freopen("input.txt","r",stdin);
//freopen("output.txt","w",stdout);
cin >> n;
num = 26;
cnt = 1;
while(n > num){
n -= num;
num *= 26;
cnt++;
}
string ans(cnt, '0');
--n;
for(int i = cnt - 1; i >= 0; i--){
ans[i] = (n % 26) + 'a';
n /= 26;
}
cout << ans;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define all(a) a.begin(), a.end()
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef pair<ll,ll> P;
typedef pair<ll,int> pli;
typedef pair<int,int> pii;
#define rep(i,a,b) for(ll i=a ; i<b ; i++)
#define qrep(que, ite) for(auto ite=begin(que) ; ite!=end(que) ; ite++)
const int max_n = 1e5;
const ll mod = 1e9+7;
const ll INF = 1e17;
const int inf = 1e5;
typedef long double ld;
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; }
ll gcd(ll a, ll b) { return a ? gcd(b%a, a) : b; }
int dx[4] = {0,0,1,-1};
int dy[4] = {1,-1,0,0};
struct UnionFind {
vector<int> par;
UnionFind(int n) : par(n, -1) { }
void init(int n) { par.assign(n, -1); }
int root(int x) {
if (par[x] < 0) return x;
else return par[x] = root(par[x]);
}
bool issame(int x, int y) {
return root(x) == root(y);
}
bool merge(int x, int y) {
x = root(x); y = root(y);
if (x == y) return false;
if (par[x] > par[y]) swap(x, y); // merge technique
par[x] += par[y];
par[y] = x;
return true;
}
int size(int x) {
return -par[root(x)];
}
};
struct SegmentTree{
int N;
vector<int> node;
public :
void intit(vector<int>v){
int sz = v.size();
N=1;
while(N<sz) N*=2;
node.resize(N);
for(int i=0 ; i<sz ; i++) node[i+N-1] = v[i];
for(int i=N-2 ; i>=0 ; i--) node[i] = min(node[i*2+1], node[i*2+2]);
}
void update(int x, int val){
x += N-1;
node[x+N-1] = val;
while(x>0){
x = (x-1)/2;
node[x] = min(node[x*2+1], node[x*2+2]);
}
}
int getmin(int a, int b, int k, int l, int r){
if(b<=l || r<=a) return inf;
else if(a<=l && r<=b) return node[k];
else{
int vl = getmin(a, b, 2*k+1, l, (l+r)/2);
int vr = getmin(a, b, 2*k+2, (l+r)/2, r);
return min(vl, vr);
}
}
};
vector<ll> divisor(ll n){
vector<ll> res;
for(ll i=1; i*i<=n ; i++){
while(n%i==0){
++res[i];
n /= i;
}
}
if(n!=1) res[n]=1;
return res;
}
int main(){
ll n; cin >> n;
ll k = n;
int cnt = 1;
while(true){
ll now = pow(26, cnt);
if(k - now > 0){
k -= now;
cnt++;
}else{
break;
}
}
string ans = "";
k--;
for(int i=cnt-1 ; i>=0 ; i--){
ll now = pow(26, i);
ll st = k / now;
for(char c='a' ; c<='z' ; c++){
if(c - 'a' == st){
ans += c;
}
}
k -= now * st;
}
cout << ans << endl;
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <string>
#include <sstream>
using namespace std;
#define MAX_N 10
int n, k;
vector<int> cs;
set<string> ps;
string to_s(int r) {
ostringstream os;
os << r;
return os.str();
}
bool used[MAX_N];
void enumerate(int k_) {
if (k_ == k) {
vector<string> part;
for (int i = 0; i < n; i++) {
if (used[i]) {
part.push_back(to_s(cs[i]));
}
}
sort(part.begin(), part.end());
do {
string p = "";
for (int i = 0; i < k; i++) p.append(part[i]);
ps.insert(p);
} while (next_permutation(part.begin(), part.end()));
return;
}
for (int i = 0; i < n; i++) {
if (!used[i]) {
used[i] = true;
enumerate(k_ + 1);
used[i] = false;
}
}
}
int main() {
while (cin >> n >> k) {
if (n == 0 && k == 0) break;
cs.clear();
cs.resize(n);
ps.clear();
for (int i = 0; i < MAX_N; i++) used[i] = false;
for (int i = 0; i < n; i++) cin >> cs[i];
enumerate(0);
cout << ps.size() << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main(){
while(1){
int n, nums[10] = {0};
cin >> n;
if(!n) break;
for(int i = 0;i < n;i++){
int k;
cin >> k;
nums[k]++;
}
for(int i = 0;i < 10;i++){
if(nums[i] == 0) cout << "-";
else{
for(int j = 0;j < nums[i];j++) cout << "*";
}
cout << endl;
}
}
return 0;
} | 0 |
#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;
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
int N, K;
while(
cin >> N >> K,N){
VI xs(N);
REP(i,N) cin >> xs[i];
SORT(xs);
set<int> ans;
do{
int s = 0;
REP(i,K){
s = s * (xs[i] >= 10? 100: 10) + xs[i];
}
ans.insert(s);
}while(next_permutation(ALL(xs)));
cout << SZ(ans) << endl;
}
return 0;
} | #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class T>
using Table = vector<vector<T>>;
const ld eps=1e-9;
template < class BidirectionalIterator >
bool next_combination(BidirectionalIterator first1,
BidirectionalIterator last1,
BidirectionalIterator first2,
BidirectionalIterator last2)
{
if ((first1 == last1) || (first2 == last2)) {
return false;
}
BidirectionalIterator m1 = last1;
BidirectionalIterator m2 = last2; --m2;
while (--m1 != first1 && !(*m1 < *m2)) {
}
bool result = (m1 == first1) && !(*first1 < *m2);
if (!result) {
// ???
while (first2 != m2 && !(*m1 < *first2)) {
++first2;
}
first1 = m1;
std::iter_swap(first1, first2);
++first1;
++first2;
}
if ((first1 != last1) && (first2 != last2)) {
// ???
m1 = last1; m2 = first2;
while ((m1 != first1) && (m2 != last2)) {
std::iter_swap(--m1, m2);
++m2;
}
// ??¢
std::reverse(first1, m1);
std::reverse(first1, last1);
std::reverse(m2, last2);
std::reverse(first2, last2);
}
return !result;
}
template < class BidirectionalIterator >
bool next_combination(BidirectionalIterator first,
BidirectionalIterator middle,
BidirectionalIterator last)
{
return next_combination(first, middle, middle, last);
}
int main() {
while (1) {
int N; cin >> N; int K; cin >> K;
if (!N)break;
vector<string>sts;
for (int i = 0; i < N; ++i) {
string st; cin >> st;
sts.emplace_back(st);
}
vector<int>nums(N);
iota(nums.begin(), nums.end(), 0);
set<string>anss;
do {
vector<int>anums(K);
iota(anums.begin(), anums.end(), 0);
do {
string ans;
for (int i = 0; i < K; ++i) {
ans += sts[nums[anums[i]]];
}
anss.emplace(ans);
} while (next_permutation(anums.begin(), anums.end()));
} while (next_combination(nums.begin(),nums.begin()+K, nums.end()));
cout << anss.size() << endl;
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n;
cin >> n;
vector<int> a(n);
for(int i = 0; i < n; i++) cin >> a[i];
int ans = 0;
multiset<int> s(a.begin(), a.end());
while(!s.empty()) {
auto it = prev(s.end());
int a = *it;
s.erase(it);
int b = (1LL << (32 - __builtin_clz(a))) - a;
it = s.find(b);
if(it != s.end()) {
ans++;
s.erase(it);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
int n;
cin >> n;
vector<int> a(n);
rep(i, n) cin >> a[i];
int ans = 1e9;
rep(i, n) {
int c = 0;
while (a[i] % 2 == 0) {
a[i] /= 2;
c++;
}
ans = min(ans, c);
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#define len(v) ((int)((v).size()))
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define chmax(x, v) x = max((x), (v))
#define chmin(x, v) x = min((x), (v))
using namespace std;
using ll = long long;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s; cin >> s;
vector<char> r;
for (char c : s) {
if (r.empty() || r.back() == 'T' || c == 'S')
r.push_back(c);
else
r.pop_back();
}
cout << len(r) << "\n";
}
| #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <random>
using namespace std;
using namespace __gnu_pbds;
typedef long long ll;
typedef
tree<ll, null_type, less<ll>, rb_tree_tag, tree_order_statistics_node_update> orderedSet;
#define pb push_back
#define F first
#define S second
#define all(a) (a).begin(), (a).end()
#define for1(i0, l0, r0) for (int i0 = l0; i0 < r0; ++i0)
#define for2(i0, l0, r0) for (int i0 = l0; i0 <= r0; ++i0)
#define forn(i0, n0) for (int i0 = 0; i0 < n0; ++i0)
#define forn1(i0, n0) for (int i0 = 1; i0 < n0; ++i0)
#define forr(i0, n0) for (int i0 = n0; i0 >= 0; --i0)
#define forr1(i0, r0, l0) for (int i0 = r0; i0 > l0; --i0)
#define forr2(i0, r0, l0) for (int i0 = r0; i0 >= l0; --i0)
#define Sort(a) sort(all(a))
#define Reverse(a) reverse(all(a))
#define relaxMax(a, b) a = max(a, b)
#define relaxMin(a, b) a = min(a, b)
typedef long double ld;
#define ui unsigned int
#define ull unsigned long long
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
typedef pair<string, string> pss;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<double> vd;
typedef vector<ld> vld;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<pii> vpii;
typedef vector<pll> vpll;
typedef vector<pdd> vpdd;
typedef vector<vi> vvi;
typedef vector<vd> vvd;
typedef vector<vll> vvll;
typedef vector<vb> vvb;
#define vpss vector<pss>
#define vvs vector<vs>
#define vvpii vector<vpii>
#define vvpll vector<vpll>
#define vpt vector<pt>
#define vvvi vector<vvi>
#define vsi vector<set<int>>
#define ss second
#define ff first
#define printvi(arr) for (int x0 : arr) cout << x0 << ' '; cout << '\n';
#define printvll(arr) for (ll x0 : arr) cout << x0 << ' '; cout << '\n';
#define printpair(pair0) cout << pair0.F << ' ' << pair0.S << '\n';
#define printvp(arr) for (auto pair0 : arr) printpair(pair0);
#define initArray(arr, N0, X0) memset(arr, X0, N0 * sizeof(int))
//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void init() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
//cout.precision(16);
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
}
void solve() {
string s;
cin >> s;
int n = s.length();
vi l(n, -1), r(n, -1);
forn(i, n){
if (i > 0) l[i] = i - 1;
if (i + 1 < n) r[i] = i + 1;
}
int ans = n;
queue<int> q;
forn(i, n - 1){
if (s[i] == 'S' && s[i + 1] == 'T') q.push(i);
}
while (!q.empty()){
int i = q.front();
q.pop();
ans -= 2;
int j = r[i], i1 = l[i], j1 = r[j];
if (i1 == -1 || j1 == -1) continue;
r[i1] = j1;
l[j1] = i1;
if (s[i1] == 'S' && s[j1] == 'T') q.push(i1);
}
cout << ans << '\n';
}
bool multitest = false;
int main() {
init();
int t = 1;
if (multitest) cin >> t;
forn(i, t) solve();
} | 1 |
//Counting of Trees
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
#define int long long
#define rep(i,x,y) for(ll i=x;i<y;i++)
#define nvarep(n,a) ll n;cin>>n;vector<ll>a(n);rep(i,0,n)cin>>a[i]
#define vecrep(n,a,type) vector<type>a(n);rep(i,0,n)cin>>a[i]
#define lcm(a,b) (a/__gcd(a, b)*b)
#define range(a) (a).begin(),(a).end()
#define pb push_back
#define mp make_pair
#define nnn "\n"
#define spa " "
using p = pair<ll, string>;
using graph = vector<vector<ll>>;
const int inf = 2147483647;//2*10^9
const ll INF = 9223372036854775807;//9*10^18
int mpow(int a,int b,int mod){
int ans = 1;
rep(i,0,b)ans=(ans*a)%mod;
if(b==0)return 0;
else return ans;
}
signed main (){
int n;cin>>n;
map<int,int>m{};
int t = 0,ans = 1;
rep(i,0,n){
int a;cin>>a;
if(i==0&&a!=0){
cout<<0<<nnn;
return 0;
}
m[a]++;
t = max(t,a);
}
if(m[0]!=1){
cout<<0<<nnn;
return 0;
}
rep(i,1,t+1){
ans=(ans*mpow(m[i-1],m[i],998244353))%998244353;
}
cout<<ans<<nnn;
return 0;
} | /**-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
*-* *-*
*-* Bismillahir Rahmanir Rahim *-*
*-* *-*
*-* Author: Ahsan Habib (comrade) *-*
*-* Metropolitan University *-*
*-* Language: C++ *-*
*-* *-*
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-**/
#include<bits/stdc++.h>
#include<istream>
#include<cstdio>
#define pii pair<ll,ll >
#include<string>
#define In freopen("ahsan.txt","r",stdin);
#define ll long long
#define ff first
#define ss second
#define NO cout<<"NO"<<endl
#define m1 cout<<"-1"<<endl
#define No cout<<"No"<<endl
#define cinarr0(n) for(int i = 0;i<n;i++)cin>>a[i];
#define cinarr1(n) for(int i = 1;i<=n;i++)cin>>a[i];
#define YES cout<<"YES"<<endl
#define Yes cout<<"Yes"<<endl
#define pb push_back
#define sorta(a) sort(a,a+n)
#define sortv(v) sort(v.begin,v.end())
#define bug(a) cerr << #a << " : " << a << endl
#define all(v) (v.begin(), v.end())
#define sz(x) x.size()
#define fill(x, y) memset(x, y, sizeof(x))
const int mx = 1e6+5;
const ll md = 1e9+7;
using namespace std;
ll a[200010],m,ans,i,t,k,ev=0,od=0,tt=0,n,cas = 1;
vector<int>vec[mx];
int ar[10000][10000];
vector<pii>v;
bool ok = true;
int main()
{
//In;
/// ios::sync_with_stdio(false);
///cin.tie(0);
ll n,tot = 0;
cin>>n;
vector<ll>a(n);
ll ans = 0;
int md = 1000000007;
for(int i = 0 ; i <n; i++)
{
cin>>a[i];
tot = tot + a[i];
tot = tot % md;
}
for(int i = 0 ; i <n; i++)
{
tot = tot - a[i];
if(tot<0)tot+=md;
ans = ans + a[i]*tot;
//bug(ans);
ans = ans%md;
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define reps(i,n) for(int i=1;i<(int)(n);i++)
typedef long long ll;
using namespace std;
int main()
{
ll x;
cin>>x;
if(x<11){
if(x<=6){
cout<<1<<endl;
}else{
cout<<2<<endl;
}
}else{
if(x%11==0){
cout<<2*(x/11)<<endl;
}else if(x%11<=6){
cout<<2*(x/11)+1<<endl;
}else{
cout<<2*(x/11)+2<<endl;
}
}
return 0;
}
| #include <iostream>
#include <string>
#include <vector>
#include <set>
#include <queue>
#include <stack>
#include <map>
#include <algorithm>
#include <math.h>
#include <cassert>
#define rep(i,n) for(int i = 0; i < n; ++i )
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
ll x;
cin >> x;
ll ans = x/11*2;
if(x%11>0) ++ans;
if(x%11>6) ++ans;
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for(int i=0; i<N; i++)
typedef long long ll;
#define dump(x) cerr<<#x<<"="<<x<<endl
using P = pair<int, int>;
int main() {
int n, u, v; cin >> n >> u >> v;
vector<vector<int>> g(n+1);
rep(i, n-1){
int a, b; cin >> a >> b;
g.at(a).push_back(b);
g.at(b).push_back(a);
}
vector<int> distU(n+1, -1);
vector<int> distV(n+1, -1);
queue<int> qu, qv;
qu.push(u);
qv.push(v);
distU.at(u) = 0;
distV.at(v) = 0;
while(!qu.empty()){
int t = qu.front();
qu.pop();
for(auto a:g.at(t)){
if(distU.at(a)!=-1) continue;
distU.at(a) = distU.at(t) + 1;
qu.push(a);
}
}
while(!qv.empty()){
int t = qv.front();
qv.pop();
for(auto a:g.at(t)){
if(distV.at(a)!=-1) continue;
distV.at(a) = distV.at(t) + 1;
qv.push(a);
}
}
int fart = v;
ll dist = 0;
for(int i=1; i<=n; i++){
if(distU.at(i)<distV.at(i)){
if(dist<distV.at(i)){
dist = distV.at(i);
fart = i;
}
}
}
dump(fart);
if(fart==v){
cout << 0 << endl;
}
else{
cout << distV.at(fart) - 1 << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
const ll MOD = 1e9+7;
// const ll MOD = 998244353;
const ll INF = 1ll<<60;
#define FOR(i,a,b) for (ll i=(a);i<(ll)(b);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
#define DEBUG(x) std::cerr << #x << " : " << (x) << std::endl;
//#define DEBUG(x) ;
ll N, u, v;
vector<vector<ll>> G;
vector<ll> du, dv;
int main(int argc, char **argv)
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> u >> v;
--u, --v;
G.resize(N);
du.assign(N, -1);
dv.assign(N, -1);
REP(i, N-1)
{
ll a, b; cin >> a >> b;
--a, --b;
G[a].push_back(b);
G[b].push_back(a);
}
queue<ll> que;
que.push(v);
dv[v] = 0;
while (que.size())
{
ll now = que.front();
que.pop();
for (auto &nv : G[now])
{
if (dv[nv] != -1) continue;
dv[nv] = dv[now] + 1;
que.push(nv);
}
}
que.push(u);
du[u] = 0;
while (que.size())
{
ll now = que.front();
que.pop();
for (auto &nv : G[now])
{
if (du[nv] != -1) continue;
du[nv] = du[now] + 1;
que.push(nv);
}
}
ll res{0};
REP(n, N)
{
if (du[n] < dv[n])
{
res = max(res, dv[n] - 1);
}
}
std::cout << res<< std::endl;
return 0;
}
| 1 |
#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 int INF = 1<<30;
const ll mod = 1000000007LL;
int main(){
string S;
cin>>S;
ll N = S.size();
map<char,ll> m;
for(ll i = 0; i < N; i++) m[S[i]]++;
ll ans = 0LL;
for(auto x:S){
ans+=N-m[x];
}
cout<<ans/2+1<<endl;
} | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define debug(var) cerr << (#var) << " = " << (var) << endl;
#else
#define debug(var)
#endif
void init() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
int h[30];
void solve() {
string s; cin >> s;
for (int i = 0; i < (int)s.size(); ++i) {
++h[s[i]-'a'];
}
long long ans = 1LL*s.size()*(s.size()-1)/2;
for (int i = 0; i < 30; ++i) {
if (!h[i]) continue;
ans -= 1LL*h[i]*(h[i]-1)/2;
}
printf("%lld", ans+1);
}
int main() {
init();
int t = 1; //scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
int num[3];
cin >> n;
if (n == 2){
cin >> num[0] >> num[1];
sort(num, num + 1);
for (int i = 1; i < num[0]; i++){
if (num[0] % i == 0 && num[1] % i == 0){
cout << i << endl;
}
}
}
else if (n == 3){
cin >> num[0] >> num[1] >> num[2];
sort(num, num + 3);
for (int i = 1; i < num[0]; i++){
if (num[0] % i == 0 && num[1] % i == 0 && num[2] % i == 0){
cout << i << endl;
}
}
}
return (0);
}
| #include <bits/stdc++.h>
#define PB push_back
#define MP make_pair
#define REP(i,n) for (int i=0;i<(n);i++)
#define ALL(a) (a).begin(),(a).end()
#define MOD 10000
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> P;
const ull B=100000007;
const int INF=1e9;
int main(){
int n,a[3];
cin>>n;
REP(i,n)cin>>a[i];
sort(a,a+n);
REP(i,a[0]){
bool f=true;
REP(j,n)if(a[j]%(i+1)!=0)f=false;
if(f)cout<<i+1<<endl;
}
} | 1 |
#include <stdio.h>
#include <algorithm>
int n;
int a[100010];
int b[100010];
int c[100010];
long long psum_b[100010];
long long ans;
long long find_bc(int st,int ed,int x){
int mid = (st+ed)/2;
if(ed-st<=1){
if(x<c[st]) return n-st;
if(x>=c[ed]) return n-ed-1;
return n-ed;
}
if(c[mid]<=x) return find_bc(mid,ed,x);
return find_bc(st,mid,x);
}
long long find_ab(int st,int ed,int x){
int mid = (st+ed)/2;
if(ed-st<=1){
if(x<b[st]) return psum_b[st];
if(x>=b[ed]) return psum_b[ed+1];
return psum_b[ed];
}
if(b[mid]<=x) return find_ab(mid,ed,x);
return find_ab(st,mid,x);
}
int main(){
scanf("%d",&n);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
}
std::sort(a,a+n);
for(int i=0;i<n;i++){
scanf("%d",&b[i]);
}
std::sort(b,b+n);
for(int i=0;i<n;i++){
scanf("%d",&c[i]);
}
std::sort(c,c+n);
for(int i=n-1;i>=0;i--){
psum_b[i]=psum_b[i+1]+find_bc(0,n-1,b[i]);
}
for(int i=0;i<n;i++){
ans+=find_ab(0,n-1,a[i]);
}
printf("%lld\n",ans);
} | #include<bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
#define rep(i,n) for(int i=0; i<(n); i++)
int N;
int A[3][100001];
LL dp[3][100001] = {};
int main() {
scanf("%d", &N);
rep(j, 3) { rep(i, N) scanf("%d", &A[j][i]); A[j][N] = 1000000001; }
rep(j, 3) sort(A[j], A[j] + N);
rep(i, N + 1) dp[0][i] = i;
rep(j, 2) {
int p = 0;
rep(i, N) {
while (A[j][p] < A[j + 1][i]) p++;
dp[j + 1][i + 1] += dp[j + 1][i] + dp[j][p];
}
}
printf("%lld\n", dp[2][N]);
return 0;
} | 1 |
#include <bits/stdc++.h>
#include <stdlib.h>
#include <string>
#include <iostream>
#include <algorithm>
#include <map>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef pair<int, int> P;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(),(x).rend()
int main(){
vector <int> dp(8000);
rep(i, 8000) dp[i] = 0;
int N, T; cin >> N >> T;
vector<pair <int, int>>AB;
rep(i, N){
int a, b; cin >> a >> b;
AB.push_back(make_pair(a, b));
}
sort(AB.begin(), AB.end());
rep(i, N){
vector <int> temp;
copy(dp.begin(), dp.end(), back_inserter(temp));
rep(t, T){
dp[t + AB[i].first] = max(temp[t + AB[i].first], temp[t] + AB[i].second);
}
}
int ans = *max_element(dp.begin(), dp.end());
cout << ans <<endl;
} | //#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; ++i)
using namespace std;
using ll = int64_t;
using vi = vector<int>;
using vvi = vector<vi>;
vi color;
vvi G;
bool dfs(int v, int c) {
if(color[v] != -1) {
if(c%2 == color[v]) {
return true;
} else {
return false;
}
}
color[v] = c%2;
for(int next:G[v]){
if(!dfs(next, c+1)) {
return false;
}
}
return true;
}
int main() {
ll N, M;
scanf("%lld%lld", &N, &M);
G.resize(N);
rep(i, M) {
int a, b;
scanf("%d%d", &a, &b);
G[a-1].push_back(b-1);
G[b-1].push_back(a-1);
}
color.assign(N, -1);
if(!dfs(0, 0)) {
cout << N*(N-1)/2-M << '\n';
return 0;
}
int cc=0;
rep(i, N) {
if(color[i]) {
++cc;
}
}
cout << (N-cc)*cc-M << '\n';
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
typedef pair<int, int> ii;
int n;
string s, temp;
vector<int> vec;
int main() {
cin.tie(0), ios::sync_with_stdio(0);
cin >> n;
cout << 0 << "\n";
cout.flush();
cin >> s;
temp = s;
if(temp == "Vacant")
exit(0);
for(int i = 2; i < n; i+=2)
vec.pb(i);
int l = 0;
for(int i = 20; i >= 0; i--){
if(l + (1 << i) < n){
cout << l + (1 << i) << "\n";
cout.flush();
cin >> s;
if(s == "Vacant")
exit(0);
else{
if(temp == s)
l += (1 << i);
}
}
}
cout << l + 1 << "\n";
cout.flush();
cin >> s;
exit(0);
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin>>N;
string temp;
string A[N];
cout<<0<<endl;
cin>>temp;
if(temp=="Vacant"){
cout<<0<<endl;
return 0;
}
if(temp=="Male"){
A[0]="Male";
}
if(temp=="Female"){
A[0]="Female";
}
cout<<N-1<<endl;
cin>>temp;
if(temp=="Vacant"){
cout<<N-1<<endl;
return 0;
}
if(temp=="Male"){
A[N-1]="Male";
}
if(temp=="Female"){
A[N-1]="Female";
}
int l=N-1;
int r=0;
int k=22;
while(k){
k--;
int m=(l+r)/2;
cout<<m<<endl;
cin>>temp;
if(temp=="Vacant"){
cout<<m<<endl;
return 0;
}
if(temp=="Male"){
A[m]="Male";
}
if(temp=="Female"){
A[m]="Female";
}
if((l-m)%2 == 0 && A[l] == A[m]){
l=m;
continue;
}
if((l-m)%2 == 0 && A[l] != A[m]){
r=m;
continue;
}
if((l-m)%2 == 1 && A[l] == A[m]){
r=m;
continue;
}
if((l-m)%2 == 1 && A[l] != A[m]){
l=m;
continue;
}
}
cout<<3<<endl;
return 0;
}
| 1 |
/* */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")
#define sti set<int>
#define stpii set<pair<int, int> >
#define mpii map<int,int>
#define vi vector<int>
#define pii pair<int,int>
#define vpii vector<pair<int,int> >
#define rep(i, a, n) for (int i=a;i<n;++i)
#define per(i, a, n) for (int i=n-1;i>=a;--i)
#define clr clear
#define pb push_back
#define mp make_pair
#define fir first
#define sec second
#define all(x) (x).begin(),(x).end()
#define SZ(x) ((int)(x).size())
#define lson l, mid, rt<<1
#define rson mid+1, r, rt<<1|1
#define getBits(x) __builtin_popcount(x)
#define getBitIdx(x) __builtin_ffs(x)
typedef long long LL;
const int maxn = 45;
int s[maxn][maxn];
int dir[4][2] = {
-1,0, 1,0, 0,-1, 0,1
};
int n, m;
int stx, sty, edx, edy;
int ansd;
inline bool judge(int x, int y) {
return x<0 || x>=n || y<0 || y>=m;
}
void init() {
rep(i, 0, n) {
rep(j, 0, m) {
if (s[i][j] == 2) {
stx = i;
sty = j;
s[i][j] = 0;
} else if (s[i][j] == 3) {
edx = i;
edy = j;
s[i][j] = 0;
}
}
}
}
void dfs(int dep, int x, int y) {
if (dep >= ansd) return;
if (x==edx && y==edy) {
ansd = dep;
return ;
}
int xx, yy;
int flag;
rep(i, 0, 4) {
xx = x;
yy = y;
if (judge(xx+dir[i][0], yy+dir[i][1]) || s[xx+dir[i][0]][yy+dir[i][1]] == 1) continue;
flag = 1;
while (true) {
if (judge(xx+dir[i][0], yy+dir[i][1])) {
flag = 0;
break;
}
if (s[xx+dir[i][0]][yy+dir[i][1]] == 1) {
flag = -1;
break;
}
xx += dir[i][0];
yy += dir[i][1];
if (xx==edx && yy==edy) {
break;
}
}
if (flag == 0) continue;
if (flag == -1) {
s[xx+dir[i][0]][yy+dir[i][1]] = 0;
}
dfs(dep+1, xx, yy);
if (flag == -1) {
s[xx+dir[i][0]][yy+dir[i][1]] = 1;
}
}
}
void solve() {
init();
ansd = 11;
dfs(0, stx, sty);
if (ansd == 11) ansd = -1;
printf("%d\n", ansd);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// #ifndef ONLINE_JUDGE
// freopen("data.in", "r", stdin);
// freopen("data.out", "w", stdout);
// #endif
while (scanf("%d %d", &m,&n)!=EOF && (n||m)) {
rep(i, 0, n)
rep(j, 0, m)
scanf("%d", &s[i][j]);
solve();
}
// #ifndef ONLINE_JUDGE
// printf("time = %ldms.\n", clock());
// #endif
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
typedef vector <int> VI;
typedef vector <VI> VVI;
const int dx[5] = { 0, 0, 0, 1, -1 };
const int dy[5] = { 0, 1, -1, 0, 0 };
int w, h;
int sx, sy, gx, gy;
VVI M;
int answer;
//==================================================
// Tõ
//==================================================
void dfs( int x, int y, int a, int d )
{
if ( d > 10 ) return;
if ( M[y][x] == 3 )
{
if ( answer == -1 )
answer = d;
else
answer = min( answer, d );
}
if ( a > 0 )
{
int nx = x + dx[a];
int ny = y + dy[a];
if ( nx < 0 || nx >= w || ny < 0 || ny >= h )
return;
if ( M[ny][nx] == 1 )
{
M[ny][nx] = 0;
dfs( x, y, 0, d );
M[ny][nx] = 1;
}
else
dfs( nx, ny, a, d );
}
else
{
for ( int i = 1; i < 5; i++ )
{
int nx = x + dx[i];
int ny = y + dy[i];
if ( nx < 0 || nx >= w || ny < 0 || ny >= h )
continue;
if ( M[ny][nx] == 0 || M[ny][nx] == 3 )
{
dfs( nx, ny, i, d+1 );
}
}
}
}
int main( void )
{
while ( cin >> w >> h && w && h )
{
//==================================================
// Ï
//==================================================
M = VVI( h, VI( w, 0 ) );
answer = -1;
//==================================================
// }bvÌüÍ
//==================================================
for ( int i = 0; i < h; i++ )
{
for ( int j = 0; j < w; j++ )
{
int& s = M[i][j];
cin >> s;
// X^[gES[
if ( s == 2 )
{
sx = j;
sy = i;
s = 0;
}
else if ( s == 3 )
{
gx = j;
gy = i;
}
}
}
//==================================================
//
//==================================================
dfs( sx, sy, 0, 0 );
//==================================================
// oÍ
//==================================================
cout << answer << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int n,k;
int sssp(int s, int g,vector<vector<int> > ship){
priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > > q;
vector<bool> used(n+1,false);
q.push(make_pair(0,s));
while(!q.empty()){
int cost=q.top().first,now=q.top().second; q.pop();
used[now]=true;
if(now==g) return cost;
for(int i=1;i<=n;++i){
if(ship[now][i]==1000005) continue;
int ncost=cost+ship[now][i],nexto=i;
if(used[nexto]==false) q.push(make_pair(ncost,nexto));
}
}
return -1;
}
int main(){
while(cin >> n >>k && (n || k)){
vector<vector<int> > ship(n+1,vector<int>(n+1,1000005));
while(k--){
int info; cin >> info;
if(info==0){
int a,b; cin >> a >> b;
cout << sssp(a,b,ship) << endl;
}else{
int c,d,e; cin >> c >> d >> e;
ship[c][d]=ship[d][c]=min(ship[c][d],e);
}
}
}
return 0;
}
| #include <algorithm>
#include <iostream>
#include <limits.h>
#include <string>
#include <vector>
#define el endl
#define fd fixed
using namespace std;
class Point
{
private:
int m_x;
int m_y;
public:
void setX(int x);
void setY(int y);
int getX();
int getY();
Point(int x, int y) {
setX(x);
setY(y);
}
};
void Point::setX(int x) {
m_x = x;
}
void Point::setY(int y) {
m_y = y;
}
int Point::getX() {
return m_x;
}
int Point::getY() {
return m_y;
}
int main() {
int N, x, y, M, l, rx, ry;
string d;
while (1) {
cin >> N;
vector<Point> gems;
if (N == 0) break;
for (int i = 0; i < N; i++) {
cin >> x >> y;
gems.push_back(Point(x, y));
}
cin >> M;
rx = 10;
ry = 10;
while (M--) {
cin >> d >> l;
while (l--) {
if (d == "N") ry++;
if (d == "E") rx++;
if (d == "S") ry--;
if (d == "W") rx--;
for (int i = 0; i < gems.size(); i++) {
if (rx == gems[i].getX() && ry == gems[i].getY()) {
gems.erase(gems.begin()+i);
break;
}
}
}
}
if (gems.empty()) cout << "Yes" << el;
else cout << "No" << el;
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a,b,c,d,ans;
while(cin >> a >> b >> c >> d){
ans = 0;
ans+=min(a,b);
ans+=min(c,d);
cout << ans << endl;
}
}
| #include <algorithm>
#include <iostream>
using namespace std;
using ll = long long;
using ld = long double;
#define ALL(x) begin(x), end(x)
#define REP(i, n) for (size_t i = 0, i##_len = (n); i < i##_len; ++i)
void solve(ll A, ll B, ll C, ll D) {
cout << min(A,B) + min(C,D) << endl;
}
int main() {
ll A;
cin >> A;
ll B;
cin >> B;
ll C;
cin >> C;
ll D;
cin >> D;
solve(A, B, C, D);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, r = 1;
cin >> n >> k;
for (int i = 0; i < n; i++)
r += min(r, k);
cout << r;
} | #include <stdio.h>
int main(){
int n,k,bank = 1;
scanf("%d" , &n);
scanf("%d" , &k);
for(int i = 0 ; i < n ; i++){
if(bank * 2 > bank + k){
bank += k;
}
else{
bank *= 2;
}
}
printf("%d" , bank);
return 0;
} | 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main() {
string S;
cin >> S;
bool a[26];
for (int i = 0; i < 26 ; ++i) a[i] = false;
for (int i = 0; i < S.size(); ++i) {
a[S[i] - 'a'] = true;
}
for (int i = 0; i < 26; ++i) {
if (!a[i]) {
cout << (char)(i + 'a') << endl;
return 0;
}
}
cout << "None" << endl;
return 0;
}
| #include<iostream>
#include<string>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<set>
#include<algorithm>
#include<utility>
#include<map>
using namespace std;
typedef long long ll;
const int mod = 1000000007;
const int INF = 1001001001;
ll pow_mod(ll p, ll n, ll m) {
if (n == 0) return 1;
else if (n == 1) return p % m;
else if (n % 2 == 1) return p * pow_mod(p, n - 1, m) % m;
else {
ll tmp = pow_mod(p, n / 2, m);
return (tmp * tmp) % m;
}
}
ll gcd(ll x, ll y) {
if (y == 0) {
return x;
}
return gcd(y, x % y);
}
ll com_mod(ll n, ll k, ll m) {
if (k == 0) return 1;
else {
ll x = 1;
ll y = 1;
for (ll i = 0; i < k; i++) {
x = (x * (n - i)) % m;
y = (y * (i + 1)) % m;
}
ll res = (x * pow_mod(y, m - 2, m)) % m;
return res;
}
}
int main() {
int r; cin >> r;
if (r < 1200)cout << "ABC" << endl;
else if (r < 2800) cout << "ARC" << endl;
else cout << "AGC" << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#define REP(i,n) for(int i=0;i<(n);++i)
#define ALL(v) (v).begin(),(v).end()
#define debug(x) cerr<<#x<<": "<<(x)<<endl
#define INF (int)1e9
#define EPS (double)1e-9
#define MOD ((int)1e9+7)
using namespace std;
typedef long long llong;
typedef vector<int> vi;
typedef vector<vi > vvi;
typedef vector<vvi > vvvi;
typedef pair<int,int> pii;
template<class Type> void line(const Type &a){int cnt=0;for(const auto &elem:a){if(cnt++)cerr<<' ';cerr<<elem;}cerr<<endl;}
template<typename Type,typename Type_k>
Type ipow(Type n,Type_k k){//n^k. O(log n).
if(k==0) return 1;
Type res=ipow(n*n,k/2);
if(k&1) res*=n;
return res;
}
int main(){//解説参考.
llong n;
cin>>n;
string ans="";
for(int i=0;n!=0;++i){
llong tmp=ipow(-2LL,i);
if(n%(-2*tmp)){
n-=tmp;
ans+='1';
}else ans+='0';
}
if(ans=="") ans="0";
else reverse(ALL(ans));
cout<<ans<<endl;
} | #include <iostream>
#include <cstdio>
using namespace std;
int main()
{
int x;
scanf("%d", &x);
x = x * x * x;
printf("%d\n", x);
return (0);
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define rep1(i, n) for(int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define Would
#define you
#define please
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll N, D;
cin >> N >> D;
int A[200001];
ll C[200001];
C[0] = 1e18;
ll motomoto = (N - 1) * D;
rep1(i, N) {
cin >> A[i];
motomoto += A[i];
C[i] = min(C[i - 1], A[i] - i * D);
}
ll saishou = 1e18;
ll setuyaku = 0;
for (int i = N - 1; i > 1; i--) {
saishou = min(saishou, A[i + 1] + (i + 1) * D);
motomoto += A[i];
ll kari = min(saishou - i * D, C[i - 1] + i * D);
if (A[i] > kari) setuyaku += A[i] - kari;
}
co(motomoto - setuyaku);
Would you please return 0;
} | #include<bits/stdc++.h>
#define maxn 505050
using namespace std;
typedef long long ll;
struct edge{
ll x,y,z;
}e[maxn*4];
ll ans,pre[maxn],fa[maxn],n,a[maxn],b[maxn],c[maxn],d,p,q;
int l[maxn],r[maxn];
int ffind(int x){
if (pre[x]==x) return x;
pre[x]=ffind(pre[x]); return pre[x];
}
void union_(int u,int v){
pre[v]=u;
b[u]=min(b[u],b[v]);
c[u]=min(c[u],c[v]);
}
bool cmp(edge x,edge y){
return x.z<y.z;
}
ll cost(int u,int v){
return 1ll*abs(u-v)*d+a[u]+a[v];
}
ll f[maxn],g[maxn];
int main(){
cin >> n >> d; int cnt=0;
for (int i=1;i<=n;i++) cin >> a[i];
for (int i=1;i<=n;i++) fa[i]=pre[i]=i,b[i]=a[i]-d*i,c[i]=a[i]+d*i;
int tot=n;
while (tot>1){
int p=1; ll res=b[fa[1]];
for (int i=2;i<=tot;i++){
ll tmp=c[fa[i]];
f[i]=tmp+res,g[i]=p;
if (b[fa[i]]<res) res=b[fa[i]],p=i;
}
int q=n; res=c[fa[tot]];
for (int i=tot-1;i;i--){
ll tmp=b[fa[i]];
if (i==1||tmp+res<f[i]) f[i]=tmp+res,g[i]=q;
if (c[fa[i]]<res) res=c[fa[i]],q=i;
}
for (int i=1;i<=tot;i++){
int u=ffind(fa[i]),v=ffind(fa[g[i]]);
if (u!=v) union_(u,v),ans+=f[i];
}
tot=0;
for (int i=1;i<=n;i++){
fa[++tot]=ffind(i);
while (i<n&&ffind(i+1)==fa[tot]) i++;
}
}
cout << ans << endl;
}
| 1 |
#include <iostream>
using namespace std;
int main() {
int n, x;
cin >> n;
cin >> x;
long min = x, max = x, sum = x;
for (int i=2; i<=n; i=i+1) {
cin >> x;
sum = sum + x;
if (x < min) min = x;
if (x > max) max = x;
}
cout << min << " " << max << " " << sum << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <vector>
# include <cstdint>
#define FOR(i,l,r) for(int i=(l);i<(r);++i)
#define RFOR(i,l,r) for(int i=(l);i>=(int)(r);i--)
#define rep(i,n) FOR(i,0,n)
#define rrep(i,n) RFOR(i,n-1,0)
#define int long long
using namespace std;
const int MX = 1e6;
const int inf = 1e13;
const int mod = 1e9+7;
#define ll long long
signed main() {
int n,k;
cin >> n >> k;
vector<int> l(n);
rep(i,n) cin>>l[i];
sort(l.begin(),l.end());
int cnt = 0;
int ans = 0;
rrep(i,n) {
cnt++;
ans+=l[i];
if(cnt==k) break;
}
cout << ans << endl;
return 0;
}
| 0 |
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <string>
#include <cstring>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <utility>
#include <algorithm>
#include <map>
#include <set>
#include <complex>
#include <cmath>
#include <limits>
#include <cfloat>
#include <climits>
#include <ctime>
#include <cassert>
#include <numeric>
#include <fstream>
#include <functional>
#include <bitset>
#define chmin(a, b) ((a)=min((a), (b)))
#define chmax(a, b) ((a)=max((a), (b)))
#define fs first
#define sc second
#define eb emplace_back
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef tuple<int, int, int> T;
const ll MOD=1e9+7;
const ll INF=1e18;
const double pi=acos(-1);
const double eps=1e-10;
int dx[]={1, 0, -1, 0};
int dy[]={0, -1, 0, 1};
int main(){
while(1){
int w, h; cin>>w>>h;
if(w == 0) return 0;
int sx, sy, gx, gy; cin>>sx>>sy>>gx>>gy;
sx--, sy--, gx--, gy--;
int n; cin>>n;
vector<vector<int>> board(h, vector<int>(w, 0));
while(n--){
int c, d, x, y; cin>>c>>d>>x>>y;
x--, y--;
if(d == 0){
for(int i=y; i<=y+1; i++){
for(int j=x; j<=x+3; j++){
board[i][j] = c;
}
}
}
else{
for(int i=y; i<=y+3; i++){
for(int j=x; j<=x+1; j++){
board[i][j] = c;
}
}
}
}
queue<P> que;
que.push(P(sy, sx));
int color = board[sy][sx];
board[sy][sx] = 0;
if(color == 0){
cout << "NG" << endl;
continue;
}
while(que.size()){
int cy, cx;
tie(cy, cx) = que.front();
que.pop();
if(cy == gy && cx == gx){
cout << "OK" << endl;
goto END;
}
for(int i=0; i<4; i++){
int ny = cy + dy[i];
int nx = cx + dx[i];
if(0 <= ny && ny < h && 0 <= nx && nx < w){
if(board[ny][nx] == color){
board[ny][nx] = 0;
que.push(P(ny, nx));
}
}
}
}
cout << "NG" << endl;
END:;
}
}
| #include <iostream>
#include<queue>
#include<string.h>
using namespace std;
#define TATE 1
#define YOKO 0
struct ST {
int x;
int y;
};
int main(void){
int map[101][101];
int board[101][101];
int T[]={0,-1,1,0};
int Y[]={1,0,0,-1};
int w,h,xs,xg,ys,yg,n,color,muki,x,y;
ST RE;
ST GO;
queue <ST> Q;
while(1){
memset(map,0,sizeof(map));
memset(board,0,sizeof(board));
cin>>w>>h;
if(w==0&&h==0)break;
cin>>xs>>ys>>xg>>yg>>n;
for(int i=0;i<n;i++){
cin>>color>>muki>>x>>y;
if(muki==YOKO){
for(int j=0;j<4;j++){
board[y][x+j]=board[y+1][x+j]=color;
}
}
else{
for(int j=0;j<4;j++){
board[y+j][x]=board[y+j][x+1]=color;
}
}
}
/* for(int i=1;i<=h;i++){
for(int j=1;j<=w;j++){
cout<<board[i][j];
}
cout<<endl;
}*/
RE.x=xs;
RE.y=ys;
map[ys][xs]=1;
Q.push(RE);
int flag=0;
while(!Q.empty()){
RE=Q.front();
Q.pop();
if(RE.x==xg&&RE.y==yg&&board[RE.y][RE.x]==board[yg][xg]){
flag=1;
//cout<<RE.x<<" "<<RE.y<<endl;
break;
}
else{
for(int i=0;i<4;i++){
GO=RE;
if(GO.x+Y[i]>0&&GO.y+T[i]>0&&GO.x+Y[i]<101&&GO.y+T[i]<101&&board[GO.y+T[i]][GO.x+Y[i]]==board[GO.y][GO.x]&&map[GO.y+T[i]][GO.x+Y[i]]!=1){
GO.x+=Y[i];
GO.y+=T[i];
map[GO.y][GO.x]=1;
Q.push(GO);
}
}
}
}
/* for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
cout<<board[i][j];
}
cout<<endl;
}*/
if(flag==1){
cout<<"OK"<<endl;
}
else{
cout<<"NG"<<endl;
}
}
}
| 1 |
#include<bits/stdc++.h>
#define rep(i, n) for(int i=0; i<n; i++)
#define repo(i, n) for(int i=1; i<=n; i++)
#define INF 1001001001
#define INFll 100100100100100
// debug用
#define PrintVec(x) for (auto elementPrintVec: x) { cout << elementPrintVec << " "; } cout << endl;
using namespace std;
using ull = unsigned long long;
using ll = long long;
using P = pair<int, int>;
const int mod = 1000000007;
int main(){
int n, m;
cin >> n >> m;
vector<int> s(m);
vector<int> c(m);
rep(i, m){
cin >> s[i] >> c[i];
}
bool zero=true;
rep(i, m){
if(c[i]!=0){
zero=false;
break;
}
}
if(zero && n==1){
cout << "0" << endl;
return 0;
}
repo(i, 999){
int i2=i;
bool nflag=true;
rep(j, n){
if(i2==0){
nflag=false;
break;
}
i2/=10;
}
if(i2!=0){
nflag=false;
}
if(!nflag){
continue;
}
bool scflag=true;
rep(j, m){
int i3=i;
int sn=n-s[j];
rep(k, sn){
i3/=10;
}
i3%=10;
if(i3!=c[j]){
scflag=false;
break;
}
}
if(scflag){
cout << i << endl;
return 0;
}
}
cout << "-1" << endl;
return 0;
}
| /*
* Author: ylx
* Lang: c++
* Prog: agc002F
*/
#include <bits/stdc++.h>
#define ll long long
using namespace std;
void qmax(int &x, int y)
{
if (x < y)
x = y;
}
void qmin(int &x, int y)
{
if (x > y)
x = y;
}
inline ll read()
{
char s;
ll k = 0, base = 1;
while ((s = getchar()) != '-' && s != EOF && !(isdigit(s)))
;
if (s == EOF)
exit(0);
if (s == '-')
base = -1, s = getchar();
while (isdigit(s))
k = k * 10 + (s ^ '0'), s = getchar();
return k * base;
}
inline void write(ll x)
{
static char cnt, num[20];
cnt = 0;
if (!x)
{
putchar('0');
return;
}
for (; x; x /= 10)
num[++cnt] = x % 10;
for (; cnt; putchar(num[cnt--] + 48))
;
}
const int maxn = 4e6 + 100;
const ll mod = 1e9 + 7;
int jie[maxn], ny[maxn];
int n, m;
ll ksm(ll x, int y)
{
ll sum = 1;
while (y)
{
if (y & 1)
sum = sum * x % mod;
x = x * x % mod;
y >>= 1;
}
return sum;
}
void init()
{
n = 4e6;
jie[0] = 1;
for (int i = 1; i <= n; i++)
jie[i] = (ll)jie[i - 1] * i % mod;
ny[n] = ksm(jie[n], mod - 2);
for (int i = n; i >= 1; i--)
ny[i - 1] = (ll)ny[i] * i % mod;
}
ll C(int x, int y)
{
if (x < y)
return 0;
return (ll)jie[x] * ny[x - y] % mod * ny[y] % mod;
}
ll f[2][2030];
int main()
{
#ifdef ylx
freopen("agc002F.in", "r", stdin);
freopen("agc002F.out", "w", stdout);
#endif
init();
n = read(), m = read();
if (m == 1)
{
cout << 1 << endl;
return 0;
}
f[0][0] = 1;
for (int i = 1, p; i <= n; i++)
{
p = i & 1;
memset(f[p], 0, sizeof(f[p]));
for (int j = 0; j <= i; j++)
{
if (!j)
{
f[p][j] = f[p ^ 1][j];
continue;
}
f[p][j] = f[p ^ 1][j] + f[p][j - 1] * (n - j + 1) % mod * C((n - j + 1) * (m - 1) + n - i - 1, m - 2) % mod;
}
}
write(f[n & 1][n]);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
using P = pair<int, int>;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
#define all(a) (a).begin(), (a).end()
ll keta(ll a, ll b)
{
int cnt_a = 0, cnt_b = 0;
while (a)
{
cnt_a++;
a /= 10;
}
while (b)
{
cnt_b++;
b /= 10;
}
ll ans = max(cnt_a, cnt_b);
return ans;
}
int main()
{
ll n;
cin >> n;
ll ans = 1001001001;
for (ll a = 1; a * a <= n; a++)
{
if (n % a)
{
continue;
}
ll b = n / a;
ans = min(ans, keta(a, b));
}
cout << ans << '\n';
return (0);
}
| #include <algorithm>
#include <functional>
#include <iostream>
#include <numeric>
#include <queue>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using vll = vector<ll>;
void solve();
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
#define ini(...) \
int __VA_ARGS__; \
in(__VA_ARGS__)
#define inl(...) \
ll __VA_ARGS__; \
in(__VA_ARGS__)
#define ins(...) \
string __VA_ARGS__; \
in(__VA_ARGS__);
void in() {}
template <typename T, class... U>
void in(T& t, U&... u) {
cin >> t;
in(u...);
}
void out() {
cout << endl;
}
template <typename T, class... U>
void out(const T& t, const U&... u) {
cout << t;
if (sizeof...(u))
cout << " ";
out(u...);
}
#define rep(i, n) for (long long i = 0; i < n; i++)
void solve();
#ifndef ONLINE_JUDGE
#include "./lib.hpp"
#endif
void solve() {
inl(N, A, B);
vll X(N);
rep(i, N) cin >> X[i];
ll ret = 0;
rep(i, N - 1)
ret += min(A * (X[i + 1] - X[i]), B);
out(ret);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, long long> pil;
bool cmp(pil lhs, pil rhs)
{
return (lhs.first < rhs.first);
}
int main()
{
int n;
while (cin >> n, n){
vector<pil> p(n);
int cnt = 0;
for (int i = 0; i < n; i++){
int a, b, c;
bool f = true;
cin >> a >> b >> c;
for (int j = 0; j <= cnt; j++){
if (p[j].first == a){
p[j].second += b * c;
f = false;
}
}
if (f){
p[cnt].first += a;
p[cnt].second += b * c;
cnt++;
}
}
bool fl = true;
for (int i = 0; i < cnt; i++){
if (1000000 <= p[i].second){
cout << p[i].first << endl;
fl = false;
}
}
if (fl){
cout << "NA" << endl;
}
}
return (0);
} | #include <iostream>
using namespace std;
#define N 8
int row[N], col[N], dpos[N * 2 - 1], dneg[N * 2 - 1];
int putQueen(int i) {
int res = 0;
if (i == N) return 1;
if (row[i] != -1) return putQueen(i + 1);
for (int j = 0; j < N; j++) {
if (col[j] || dpos[i + j] || dneg[i - j + (N - 1)]) continue;
row[i] = j;
col[j] = dpos[i + j] = dneg[i - j + (N - 1)] = 1;
res = putQueen(i + 1);
if (res) return 1;
col[j] = dpos[i + j] = dneg[i - j + (N - 1)] = 0;
row[i] = -1;
}
return 0;
}
int main() {
int k, r, c;
for (int i = 0; i < N; i++) {
row[i] = -1;
col[i] = 0;
}
for (int i = 0; i < N * 2 - 1; i++) dpos[i] = dneg[i] = 0;
cin >> k;
for (int i = 0; i < k; i++) {
cin >> r >> c;
row[r] = c;
col[c] = 1;
dpos[r + c] = 1;
dneg[r - c + (N - 1)] = 1;
}
putQueen(0);
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++)
if (row[i] == j)
cout << "Q";
else
cout << ".";
cout << endl;
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define mx 200011
int main(){
ll n,i;
cin>>n;
ll a[n+9],b[n+9];
for(i=1;i<=n;i++){
cin>>a[i];
}
sort(a+1,a+1+n);
ll s=0,p=0,q=0;
for(i=n;i>1;i--){
if(a[i]==a[i-1] && a[i]!=p){
if(s==0) {
p=a[i];
s=1;
}
if(s==1 && a[i]!=p){
q=a[i];
break;
}
}
}
ll x=0;
for(i=n;i>1;i--){
if(a[i]==a[i-1] && a[i]==a[i-2]&& a[i]==a[i-3]){
x=a[i];
break;
}
}
if(x==0 && p*q==0){
cout<<0<<endl;
}
else if(p*q>x*x){
cout<<p*q<<endl;
}
else cout<<x*x<<endl;
}
| #include<bits/stdc++.h>
using namespace std;
struct node
{
int num,fa,ls,rs;
node(int _num,int _fa)
{
num=_num;
fa=_fa;
ls=rs=-1;
}
};
typedef vector<node> Tree;
Tree T;
void insert(int t,int n)
{
if(T[0].num==INT_MAX)
T[0].num=n;
else if(T[t].num>n)
if(T[t].ls==-1)
{
T[t].ls=T.size();
T.push_back(node(n,t));
}
else insert(T[t].ls,n);
else
if(T[t].rs==-1)
{
T[t].rs=T.size();
T.push_back(node(n,t));
}
else insert(T[t].rs,n);
}
void find(int t,int x)
{
if(T.size()==0||t==-1)
printf("no\n");
else if(T[t].num==x)
printf("yes\n");
else if(x<T[t].num)
find(T[t].ls,x);
else find(T[t].rs,x);
}
void lc(int fa,int son)
{
T[fa].ls=son;
if(son!=-1) T[son].fa=fa;
}
void rc(int fa,int son)
{
T[fa].rs=son;
if(son!=-1) T[son].fa=fa;
}
void del(int t,int x)
{
if(t==-1) return ;
if(T[t].num==x)
{
if(T[t].ls==-1)
if(T[t].rs==-1)
if(T[T[t].fa].ls==t)
T[T[t].fa].ls=-1;
else T[T[t].fa].rs=-1;
else
if(T[T[t].fa].ls==t)
{
T[T[t].fa].ls=T[t].rs;
T[T[t].rs].fa=T[t].fa;
}
else
{
T[T[t].fa].rs=T[t].rs;
T[T[t].rs].fa=T[t].fa;
}
else if(T[t].rs==-1)
if(T[T[t].fa].ls==t)
{
T[T[t].fa].ls=T[t].ls;
T[T[t].ls].fa=T[t].fa;
}
else
{
T[T[t].fa].rs=T[t].ls;
T[T[t].ls].fa=T[t].fa;
}
else
{
int mir=T[t].rs;
while(T[mir].ls!=-1) mir=T[mir].ls;
del(t,T[mir].num);
T[t].num=T[mir].num;
}
}
else if(x<T[t].num)
del(T[t].ls,x);
else del(T[t].rs,x);
}
void Preorder(int t)
{
if(t==-1) return;
printf(" %d",T[t].num);
Preorder(T[t].ls);
Preorder(T[t].rs);
}
void Inorder(int t)
{
if(t==-1) return;
Inorder(T[t].ls);
printf(" %d",T[t].num);
Inorder(T[t].rs);
}
void print()
{
Inorder(T[1].ls);
printf("\n");
Preorder(T[1].ls);
printf("\n");
}
int main()
{
T.clear();
T.push_back(node(INT_MAX,1));
T.push_back(node(-1,-1));
T[1].ls=0;
int n;
scanf("%d",&n);
while(n--)
{
char s[10];
scanf("%s",s);
if(s[0]=='i')
{
int t;
scanf("%d",&t);
insert(T[1].ls,t);
}
else if(s[0]=='f')
{
int t;
scanf("%d",&t);
find(T[1].ls,t);
}
else if(s[0]=='d')
{
int t;
scanf("%d",&t);
del(T[1].ls,t);
}
else print();
}
return 0;
} | 0 |
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
const ld eps = 1e-9;
//// < "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\a.txt" > "d:\d_download\visual studio 2015\projects\programing_contest_c++\debug\b.txt"
int main() {
string st;
map<char, int>mp;
mp['I'] = 0;
mp['V'] = 1;
mp['X'] = 2;
mp['L'] = 3;
mp['C'] = 4;
mp['D'] = 5;
mp['M'] = 6;
vector<int>values{ 1,5,10,50,100,500,1000 };
while (cin >> st) {
vector<int>nums;
for (auto c : st) {
nums.push_back(mp[c]);
}
int sum = 0;
for (int i = 0; i < nums.size(); ++i) {
if (i == nums.size() - 1 || nums[i] >= nums[i + 1])sum += values[nums[i]];
else sum -= values[nums[i]];
}
cout << sum << endl;
}
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int roma[128];
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
roma['I']=1;
roma['V']=5;
roma['X']=10;
roma['L']=50;
roma['C']=100;
roma['D']=500;
roma['M']=1000;
ios::sync_with_stdio(false);
cin.tie(0);
string str;
while(getline(cin, str)){
int ans=roma[(unsigned)str[str.length()-1]];
for(int i=str.length()-2; i>=0; i--){
int rn=roma[(unsigned)str[i]];
if(rn>=roma[(unsigned)str[i+1]]) ans+=rn;
else ans-=rn;
}
cout<<ans<<'\n';
}
return 0;
} | 1 |
#include<cstdio>
int main(){
int n;
for(;;){
scanf("%d",&n);
if(n==0) break;
for(int i=0;i<n;i++){
int p[3];
char r='C';
for(int j=0;j<3;j++){
scanf("%d",&p[j]);
}
int sum=0,sumb=0;
for(int j=0;j<3;j++){
if(p[j]==100){
r='A';
}
sum+=p[j];
if(j!=2) sumb+=p[j];
}
if(r=='C'){
if(sumb/2>=90||sum/3>=80) r='A';
else if(sum/3>=70) r='B';
else if(sum/3>=50 && (p[0]>=80 || p[1]>=80)) r='B';
}
printf("%c\n",r);
}
}
} | #include <bits/stdc++.h>
#define l(i) (n / 2 - (n - i + 1) / 2)
#define r(i) ((i + 1) / 2)
#define st(i) (i / 2 - 1)
using namespace std;
typedef long long ll;
int n, a[200005];
ll dp[200005][3], ans = -1e16; // j�ķ�Χ��i/2-1��(i+1)/2�����3��
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++)
for (int j = 0; j < 3; j++) dp[i][j] = -1e16;
dp[1][1 - st(1)] = a[1], dp[1][0 - st(1)] = 0;
for (int i = 2; i <= n; i++) {
for (int j = l(i); j <= r(i); j++) {
if (j == 0)
dp[i][j - st(i)] = 0;
else {
for (int k = i - 2; l(k) <= j - 1 && r(k) >= j - 1 && k >= 0;
k--)
dp[i][j - st(i)] =
max(dp[i][j - st(i)], dp[k][j - 1 - st(k)] + a[i]);
}
}
}
for (int i = n / 2; i <= n; i++)
for (int j = l(i); j <= r(i); j++)
if (j == n / 2) ans = max(ans, dp[i][j - st(i)]);
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll M = 998244353;
int main() {
int N;
cin >> N;
vector<ll> a(N);
ll ans = 1LL, sum = 0;
for (int i = 0; i < N; i++) {
cin >> a[i];
sum += a[i];
ans *= 3LL;
ans %= M;
}
vector<vector<ll>> dp(500, vector<ll>(100000, 0));
vector<vector<ll>> dp2(500, vector<ll>(100000, 0));
dp[0][0] = dp2[0][0] = 1;
for (int i = 0; i < N; i++) {
for (int j = 0; j <= sum; j++) {
dp[i + 1][j + a[i]] += dp[i][j];
dp[i + 1][j + a[i]] %= M;
dp[i + 1][j] += 2 * dp[i][j];
dp[i + 1][j] %= M;
dp2[i + 1][j + a[i]] += dp2[i][j];
dp2[i + 1][j + a[i]] %= M;
dp2[i + 1][j] += dp2[i][j];
dp2[i + 1][j] %= M;
}
}
ll x = 0;
for (int i = (sum + 2 - 1) / 2; i <= sum; i++) {
x += dp[N][i];
x %= M;
}
ans -= 3 * x;
if (sum % 2 == 0) ans += 3 * dp2[N][sum / 2];
cout << (ans % M + M) % M << endl;
} | #include <bits/stdc++.h>
using namespace std;
//#define cerr if (false) cerr
#define db(x) cerr << #x << "=" << x << endl
#define db2(x, y) cerr << #x << "=" << x << "," << #y << "=" << y << endl
#define db3(x, y, z) cerr << #x << "=" << x << "," << #y << "=" << y << "," << #z << "=" << z << endl
#define dbv(v) cerr << #v << "="; for (auto _x : v) cerr << _x << ", "; cerr << endl
#define dba(a, n) cerr << #a << "="; for (int _i = 0; _i < (n); ++_i) cerr << a[_i] << ", "; cerr << endl
typedef long long ll;
typedef long double ld;
const ll MOD = 998244353;
void add(ll& x, ll y) {
x += y;
if (x >= MOD) x -= MOD;
}
void sub(ll& x, ll y) {
x -= y;
if (x < 0) x += MOD;
}
int main() {
int n;
scanf("%d", &n);
vector<ll> ndp(90001), dp(90001);
vector<ll> ndp2(90001), dp2(90001);
dp[0] = dp2[0] = 1;
ll sum = 0;
for (int i = 0; i < n; ++i) {
int a;
scanf("%d", &a);
sum += a;
fill(ndp.begin(), ndp.end(), 0);
fill(ndp2.begin(), ndp2.end(), 0);
for (int s = 0; s <= i * 300; ++s) {
add(ndp[s], dp[s]);
add(ndp[s], dp[s]);
add(ndp[s + a], dp[s]);
add(ndp2[s], dp2[s]);
add(ndp2[s + a], dp2[s]);
}
// for (int s = 0; s <= 10; ++s) db2(s, ndp[s]);
swap(dp, ndp);
swap(dp2, ndp2);
}
ll ans = 1;
for (int i = 1; i <= n; ++i) ans = ans * 3 % MOD;
for (int i = (sum + 1) / 2; i <= sum; ++i) {
// db2(i, dp[i]);
sub(ans, dp[i] * 3 % MOD);
}
if (sum % 2 == 0) {
add(ans, dp2[sum / 2] * 3 % MOD);
}
printf("%lld\n", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
#define SPEED ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define MOD 1000000007
#define N 1000000
#define pb push_back
int a[N][2];
signed main()
{
SPEED;
int n;
cin>>n;
string s[n];
for(int i=0;i<n;++i)
{
cin>>s[i];
int c1=0,c2=0;
for(int j=0;j<s[i].length();++j)
{
if(s[i][j]==')')
c1++;
else
c2++;
a[i][0]=max(a[i][0],c1-c2);
}
c1=0;c2=0;
int l=s[i].length();
for(int j=l-1;j>=0;--j)
{
if(s[i][j]=='(')
c1++;
else
c2++;
a[i][1]=max(a[i][1],c1-c2);
}
}
vector<pair<int,int>> s1,s2;
for(int i=0;i<n;++i)
{
if(a[i][1]-a[i][0]>=0)
s1.pb({a[i][0],a[i][1]});
else
s2.pb({a[i][1],a[i][0]});
}
sort(s1.begin(),s1.end());
sort(s2.rbegin(),s2.rend());
int j=0,k=0,sum=0,f=0;
for(int i=0;i<n;++i)
{
if(j<s1.size())
{
sum-=s1[j].first;
if(sum<0)
break;
sum+=s1[j].second;
j++;
}
else
{
sum-=s2[k].second;
if(sum<0)
break;
sum+=s2[k].first;
k++;
}
}
if(sum!=0)
cout<<"No";
else
cout<<"Yes";
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#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()
const string YES = "Yes";
const string NO = "No";
int main(){
ll n;
cin >> n;
vector<pair<ll, ll>> up, down;
REP(i, n){
ll cur = 0, bottom = 0;
string s;
cin >> s;
for(char c : s){
if(c == '('){
cur++;
}else{
cur--;
}
bottom = min(cur, bottom);
}
if(cur >= 0){
up.emplace_back(bottom, cur);
}else{
down.emplace_back(bottom - cur, - cur);
}
}
sort(up.rbegin(), up.rend());
ll cur_up = 0;
for(auto p : up){
ll btm = p.first;
if(cur_up + btm < 0){
cout << NO << endl;
return 0;
}
cur_up += p.second;
}
sort(down.rbegin(), down.rend());
ll cur_down = 0;
for(auto p : down){
ll btm = p.first;
if(cur_down + btm < 0){
cout << NO << endl;
return 0;
}
cur_down += p.second;
}
if(cur_up != cur_down){
cout << NO << endl;
}else{
cout << YES << endl;
}
return 0;
}
| 1 |
#include<cstdio>
long double sqrt(double);
int main(void){
long double d;
double x1,y1,x2,y2,D;
scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
D=(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
sqrt(D);
d=sqrt(D);
printf("% 8.8Lf\n",d);
return 0;
}
long double sqrt(double a){
int i;
long double b=3;
for(i=0;i<256;i++){
b=(b/2)+(a/(2*b));
}
return b;
} | #include<iostream>
#include<cctype>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<cctype>
#include<cstring>
#include<utility>
#include<cmath>
const int inf=0x7fffffff;
typedef long long int ll;
using namespace std;
int main()
{
//#ifdef DEBUG
// freopen("in", "r", stdin);
//// freopen("out", "w", stdout);
//#endif
double x,y,x2,y2;
//cout<<sizeof(double);
scanf("%lf%lf%lf%lf", &x,&y,&x2,&y2);
printf("%f\n",hypot(x-x2,y-y2));
//insert code above
return 0;
}
//aoj1_10_a.cc | 1 |
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
#define MOD 1000000007
using namespace std;
typedef long long ll;
template <typename Tp> inline void getint(Tp &num){
register int ch, neg = 0;
while(!isdigit(ch = getchar())) if(ch == '-') neg = 1;
num = ch & 15;
while(isdigit(ch = getchar())) num = num * 10 + (ch & 15);
if(neg) num = -num;
}
inline int fastpow(int bas, int ex){
register int res = 1;
for(; ex; ex >>= 1, bas = bas * (ll)bas % MOD) if(ex & 1) res = res * (ll)bas % MOD;
return res;
}
inline int kazu(int a, const int &b) {return (a += b) >= MOD ? a - MOD : a;}
inline int hiku(int a, const int &b) {return (a -= b) < 0 ? a + MOD : a;}
int N, A = 0, a[500005], sum0[500005], ans = 0;
int nxt[1 << 20], head[1 << 20], id[500005], top, cnt0[1000005], f[1000005][2];
inline int calc_even(const int &x){
if(head[x] > N) return 0; id[top = 1] = head[x];
while(nxt[id[top]] <= N) id[top + 1] = nxt[id[top]], top++;
register int M = 0;
for(register int i = 1; i <= top; i++){
cnt0[++M] = -1;
if(i < top) cnt0[++M] = sum0[id[i + 1]] - sum0[id[i]];
}
f[0][0] = 1, f[0][1] = 0;
for(register int i = 1; i <= M; i++){
if(cnt0[i] == -1) f[i][0] = f[i - 1][0], f[i][1] = kazu(f[i - 1][1], f[i - 1][0]);
else f[i][1] = f[i - 1][1], f[i][0] = kazu(f[i - 1][0], f[i - 1][1] * (ll)cnt0[i] % MOD);
}
return f[M][1];
}
inline int calc_odd(const int &x){
if(head[x] > N) return 0; id[top = 1] = head[x];
while(nxt[id[top]] <= N) id[top + 1] = nxt[id[top]], top++;
register int M = 0;
for(register int i = 1; i < top; i++){
cnt0[++M] = -1;
cnt0[++M] = sum0[id[i + 1]] - sum0[id[i]];
}
f[0][0] = 1, f[0][1] = 0;
for(register int i = 1; i <= M; i++){
if(cnt0[i] == -1) f[i][0] = f[i - 1][0], f[i][1] = kazu(f[i - 1][1], f[i - 1][0]);
else f[i][1] = f[i - 1][1], f[i][0] = kazu(f[i - 1][0], f[i - 1][1] * (ll)cnt0[i] % MOD);
}
return f[M][0];
}
int main(){
getint(N);
for(register int i = 1; i <= N; i++) getint(a[i]), A = max(A, a[i] ^= a[i - 1]);
for(register int i = 1; i <= N; i++) sum0[i] = sum0[i - 1] + (a[i] == 0);
for(register int i = 0; i <= A; i++) head[i] = N + 1;
for(register int i = N; i; i--) nxt[i] = head[a[i]], head[a[i]] = i;
if(a[N]) ans = calc_odd(a[N]);
else{
ans = fastpow(2, sum0[N] - 1);
for(register int i = 1; i <= A; i++) ans = kazu(ans, calc_even(i));
}
return printf("%d\n", ans), 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define REP(NAME, NUM) for (int NAME = 0; NAME < (NUM); ++NAME)
#define BREP(NAME, NUM) for (int NAME = (NUM)-1; NAME >= 0; --NAME)
#define ALL(NAME) (NAME).begin(), (NAME).end()
#define cMOD 1000000007ll
constexpr int cN = ( 1 << 20 ) + 1;
ll pool0[cN];
ll pool1[cN];
ll poolCount[cN];
ll fib( ll a )
{
ll b = 1; ll c = 1;
REP( i, a - 2 )
{
ll d = c;
c = ( c + b ) % cMOD;
b = d;
}
return c;
}
template <typename T>
T mod_pow(T x, T n, T mod)
{
T res = 1;
while (n > 0)
{
if (n & 1)
res = (res * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return res;
}
int main()
{
memset( pool0, 0, sizeof( pool0 ) );
memset( pool1, 0, sizeof( pool1 ) );
memset( poolCount, 0, sizeof( poolCount ) );
ll n;
cin >> n;
vector<ll> v(n,0);
ll sum = 0;
REP(i,n)
{
cin >> v[i];
sum ^= v[i];
}
ll left = 0;
ll count = 0;
REP(i,cN) pool0[i] = 1;
REP(i,n)
{
left ^= v[i];
if( left == 0 ) ++count;
else
{
pool0[left] = ( pool0[left] + pool1[left] * ( count - poolCount[left] ) ) % cMOD;
poolCount[left] = count;
pool1[left] = ( pool1[left] + pool0[left] ) % cMOD;
}
}
ll ans = 0;
if( sum == 0 )
{
ans = mod_pow( 2ll, count - 1, cMOD );
REP(i, cN)
{
if( i == 0 ) continue;
ans = ( ans + pool1[i] ) % cMOD;
}
}
else
{
ans = pool0[sum];
}
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
#define REP(i,n) for (int i = 0; i <(n); ++i)
#define ALL(v) v.begin(), v.end()
using namespace std;
using ll = long long;
using P = pair<int,int>;
static const double PI = acos(-1);
int main(){
int k, x;
cin >> k >> x;
int l = x - (k-1);
int r = x + (k-1);
for(int i = l; i < r ; ++i){
cout << i << " ";
}
cout << r << endl;
return 0;
} | #include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <iomanip>
#include <math.h>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
//#define local
#ifdef local
#include "dbg-macro/dbg.h"
#endif
//#define hacks
#ifdef hacks
#include <boost/multiprecision/cpp_int.hpp>
#endif
#define p std::pair
#define ll long long
#define ld long double
#define ull unsigned long long
#define pi std::pair<int, int>
#define stdabs std::abs
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (unsigned long long i = 0; i < (unsigned long long)(n); ++i)
#define vec std::vector
#define oreq |=
#define npm next_permutation
using namespace std;
std::vector<unsigned ll> genprimevec(const unsigned ll N);
ll extgcd(ll a, ll b, ll& x, ll& y);
ll nCr(ll n, ll r);
void stat();
template <typename T> T fact(T num);
constexpr ll mod = 1000000000 + 7;
int main()
{
stat();
int k,x;
cin >> k>>x;
for(int i=x-k+1;i!=x+k;++i){
if(i<-1000000||1000000<i){continue;}
if(i==x+k-1){cout<<i<<endl;break;}
cout<<i<<' ';
}
return 0;
}
ll extgcd(ll a, ll b, ll& x, ll& y)
{
if (b == 0) {
x = 1, y = 0;
return a;
}
ll d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
std::vector<unsigned ll> genprimevec(const unsigned ll N)
{
std::vector<bool> is_prime(N + 1);
for (unsigned ll i = 0; i <= N; i++) {
is_prime[i] = true;
}
std::vector<unsigned ll> P;
for (unsigned ll i = 2; i <= N; i++) {
if (is_prime[i]) {
for (unsigned ll j = 2 * i; j <= N; j += i) {
is_prime[j] = false;
}
P.emplace_back(i);
}
}
return P;
}
void stat(){
#ifdef local
rep(i, 2){std::cout << "local enable" << std::endl;
}
#endif
#ifdef hacks
rep(i, 2) { std::cout << "boost enable" << std::endl; }
#endif
}
ll nCr(ll n, ll r)
{
ll num = 1;
for (ll i = 1; i <= r; i++) {
num = num * (n - i + 1) / i;
}
return num;
}
template <typename T> T fact(T num)
{
if (num == 1) { return 1; }
return num * fact(num - 1);
}
| 1 |
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#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...);}
#ifndef ONLINE_JUDGE
#define deb(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define deb(x...)
#endif
//------------------------------//
typedef long long int ll;
typedef pair<int,int> pi;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pi> vpi;
typedef vector<pll> vpll;
#define ff first
#define ss second
#define pb push_back
#define IOS ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define all(x) (x).begin(), (x).end()
#define ps(x,y) fixed<<setprecision(y)<<x
#define rep(i,a,b) for(ll i=a ; i<b ; ++i)
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
const ll maxn = 1e6 + 4;
// dp[i][2] -> dp[i][
void solve(){
int n;
cin >> n;
vi v(n);
for(int i=0;i<n;i++)cin >> v[i];
vector<vector<ll>> dp(n+1,vector<ll>(2));
// dp[i][0] max if here operation is applied;
for(int i=1;i<=n;i++){
if(i==1){
dp[i][0] = -v[i-1];
dp[i][1] = v[i-1];
}
else{
dp[i][0] = max(dp[i-1][0]+v[i-1],dp[i-1][1]-v[i-1]);
dp[i][1] = max(dp[i-1][0]-(v[i-1]),dp[i-1][1] + v[i-1]);
}
}
cout << dp[n][1];
}
int main(){
IOS
solve();
//cerr <<endl <<"[ Time : " << (float)clock() / CLOCKS_PER_SEC << " secs ]" << endl;
}
// integer overflow | #include <stdio.h>
int main(){
int a[6],sum=0,min=100;
for (int i=0;i<6;i++) scanf("%d",a+i);
for (int i=0;i<6;i++) sum += a[i];
for (int i=0;i<4;i++) min = (min > a[i])?(a[i]):(min);
sum -= min;
sum -= (a[4] < a[5])?a[4]:a[5];
printf("%d\n",sum);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, K;
cin >> N >> K;
int sum=1;
for(int i=0; i<N; i++){
if(sum*2 > sum+K) sum+=K;
else sum*=2;
}
cout << sum << endl;
return 0;
}
| #include <iostream>
#include <bits/stdc++.h>
#define ll long long int
#define d 1000000007
using namespace std;
int main()
{
int t;
t=1;
while(t--)
{
int n,k;
cin >> n;
cin >> k;
int result=1;
while(n>0)
{
result=min(result*2,result+k);
n--;
}
cout << result << endl;
}
return 0;
} | 1 |
#include <stdio.h>
#include <string.h>
int main() {
char s[11];
scanf("%s", s);
if (strlen(s)%2==1) printf("No\n");
else {
for (int i=0;s[i]!='\0';i++) {
if (i%2==0&&s[i]!='h'||i%2==1&&s[i]!='i') {
printf("No\n");
return 0;
}
}
printf("Yes\n");
}
}
| #include<stdio.h>
int main()
{
int n,i,j=0,k;
char str[1008],temp;
scanf("%d",&n);
temp=getchar();
for(i=0;i<n;i++){
for(j=0;;j++){
str[j] = getchar();
if(str[j] == '\n'){
str[j] = '\0';
break;
}
}
for(k=0;k<j;k++){
if(str[k]=='H' && str[k+1]=='o' && str[k+2]=='s' && str[k+3]=='h' && str[k+4]=='i' && str[k+5]=='n' && str[k+6]=='o')str[k+6]='a';
}
printf("%s\n",str);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (int64_t i = 0; i < (int64_t)(n); i++)
using vi = vector<int64_t>;
using vvi = vector<vi>;
using ll = long long ;
using P = pair<ll,ll>;
ll INF = 1000000007;
// ll INF = 9223372036854775807;
// ll INF = 998244353;
int main() {
// fasten cin
cin.tie(0);
ios::sync_with_stdio(false);
// implement
ll n;
cin >> n;
vi v(n);
rep(i,n) cin >> v.at(i);
// 全部同じはダメ
vi a(100100,0);
vi b(100100,0);
rep(i,n){
if(i%2){
// 奇数
a.at(v.at(i))++;
}else{
// 偶数
b.at(v.at(i))++;
}
}
vector<P> va;
vector<P> vb;
rep(i,a.size()){
va.push_back(make_pair(a.at(i),i));
}
rep(i,b.size()){
vb.push_back(make_pair(b.at(i),i));
}
sort(va.begin(), va.end(), greater<>());
sort(vb.begin(), vb.end(), greater<>());
ll a1=va.at(0).first;
ll a2=va.at(1).first;
ll b1=vb.at(0).first;
ll b2=vb.at(1).first;
ll a1i=va.at(0).second;
ll b1i=vb.at(0).second;
cerr << "a1:" << a1 << " b1:" << b1 << endl;
cerr << "a2:" << a2 << " b2:" << b2 << endl;
ll res = 0;
if(a1i!=b1i){
res += (n/2) - a1;
res += (n/2) - b1;
}else{
if(a2 >= b2){
res += (n/2) - a2;
res += (n/2) - b1;
}else{
res += (n/2) - a1;
res += (n/2) - b2;
}
}
cout << res << endl;
}
| #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <queue>
#include <bitset>
#include <stack>
#include <functional>
#ifdef LOCAL
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#else
#define eprintf(...) 42
#endif
#define rep_(i, a_, b_, a, b, ...) for (int i = (a), i##_len = (b); i < i##_len; ++i)
#define rep(i, ...) rep_(i, __VA_ARGS__, __VA_ARGS__, 0, __VA_ARGS__)
#define reprev_(i, a_, b_, a, b, ...) for (int i = (b-1), i##_min = (a); i >= i##_min; --i)
#define reprev(i, ...) reprev_(i, __VA_ARGS__, __VA_ARGS__, 0, __VA_ARGS__)
#define all(x) (x).begin(), (x).end()
template <class T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return 1; } return 0; }
template <class T> bool chmin(T &a, const T &b) { if (b < a) { a = b; return 1; } return 0; }
// template <class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair <int,int> P;
typedef long double ld;
int main (void)
{
cin.tie(0);
ios::sync_with_stdio(false);
ll n, m, v, p; cin >> n >> m >> v >> p;
vector<int> a(n); rep (i, n) cin >> a[i];
sort(all(a), greater<int>());
ll ans = 0, piv = a[p - 1];
if (v <= p) {
while (ans < n && a[ans] + m >= piv) ans++;
} else {
int ok = -1, ng = n;
while (ng - ok > 1) {
int med = (ng + ok) / 2;
if (a[med] + m < piv) {ng = med; continue;}
ll rest = 0, vv = v - (n - med);
rep (j, med) rest += max((j < p - 1 ? m : 0LL), (a[med] + m) - a[j]);
eprintf("%d, %lld %lld\n", med, rest, m * vv);
if (rest >= m * vv) ok = med;
else ng = med;
}
ans = ok + 1;
}
cout << ans << "\n";
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n;
cin >> n;
vector<int> l(n);
rep(i, n) cin >> l.at(i);
int ans = 0;
rep(i, n) rep(j, n) rep(k, n) {
if (i < j && j < k) {
int x = l.at(i), y = l.at(j), z = l.at(k);
if (x == y || y == z || z == x) continue;
if (x + y <= z || y + z <= x || z + x <= y) continue;
++ans;
}
}
cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define INF 1000000007
#define LINF (1LL << 62)
#define PI 3.14159265358979
typedef long long i64;
typedef pair<i64,i64> P;
inline i64 mod(i64 a, i64 m) { return (a % m + m) % m; }
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int n, a[101010];
void solve(){
cin >> n;
int cnt = 0;
for(int i = 1; i <= n; i++){
cin >> a[i];
cnt += abs(a[i]-a[i-1]);
}
cnt += abs(a[n]);
for(int i = 1; i <= n; i++){
cout << cnt-(abs(a[i]-a[i-1])+abs(a[i]-a[i+1]))+abs(a[i-1]-a[i+1]) << endl;
}
}
int main(){
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int t = 1;
//cin >> t;
while(t--){
solve();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
#define endl '\n'
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string S;
cin >> S;
S[3] = '8';
cout << S << endl;
}
| #include <cstdio>
using namespace std;
int main() {
int y, m, d;
scanf("%d/%d/%d", &y, &m, &d);
printf("2018/%02d/%02d\n", m, d);
} | 1 |
#include <iostream>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <algorithm>
#include <iomanip>
#include <numeric>
#include <queue>
#include <cmath>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n, 0);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
if (v[0] > 0) {
cout << -1 << endl;
return 0;
}
long long int res = 0;
int last = 0;
for (int i = 1; i < n; i++) {
if (v[i] == 0) {
last = 0;
continue;
}
last++;
if (last < v[i]) {
cout << -1 << endl;
return 0;
}
if (v[i] - v[i - 1] >= 2) {
cout << -1 << endl;
return 0;
}
if (v[i] >= 2 && v[i - 1] == 0) {
cout << -1 << endl;
return 0;
}
if (v[i] == v[i - 1] + 1) {
res++;
continue;
}
res += v[i];
}
cout << res << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define rep(i,n) for(ll (i)=0; (i)<(ll)(n); (i)++)
#define frep(i,m,n) for(ll (i)=(m); (i)<=(ll)(n); (i)++)
#define rrep(i,n) for(ll (i)=(n)-1; (i)>-1; (i)--)
#define frrep(i,m,n) for(ll (i)=(n); (i)>(ll)(m); (i)--)
#define ALL(x) (x).begin(), (x).end()
const ll INF = 100100100100100100;
const ll MOD = 1000000007;
// get abs
ll my_abs(ll a);
// a^n
ll a_n(ll a, ll n);
// get gcd
ll my_gcd(ll a, ll b);
// a^(-1) % MOD
ll inv(ll a);
// (a+b+c)%MOD
ll madd(ll a, ll b, ll c);
// (a-b)%MOD
ll msub(ll a, ll b);
// (a*b*c)%MOD
ll mtime(ll a, ll b, ll c);
int main() {
ll n, ans = 0; cin >> n;
vector<ll> a(n), b(n, 0);
rep(i, n) cin >> a[i];
if(a[0] != 0) {
cout << -1 << endl;
return 0;
}
else {
rep(i, n-1) {
if(a[i]+1 < a[i+1]) {
cout << -1 << endl;
return 0;
}
}
rep(i, n) {
b[i-a[i]]++;
}
ll index = 0;
rep(i, n) {
rep(j, b[i]) {
a[index] = i;
index++;
}
}
set<ll> s;
rep(i, n) {
if(!s.count(a[n-1-i])) {
s.insert(a[n-1-i]);
ans += (n-1-i) - a[n-1-i];
}
}
cout << ans << endl;
}
return 0;
}
ll my_abs(ll a) {
if(a >= 0) return a;
else return -1 *a;
}
ll a_n(ll a, ll n) {
if(n == 0) return 1;
ll ret = a, count = 1;
while(count * 2 < n) {
ret *= ret;
count *= 2;
}
if(count == n) return ret;
else return (ret * a_n(a, n-count));
}
ll my_gcd(ll a, ll b) {
if(b == 0) return a;
return my_gcd(b, a%b);
}
ll inv(ll a) {
return a_n(a, MOD-2);
}
ll madd(ll a, ll b, ll c) {
ll ret = (a+b) % MOD;
return (ret+c) % MOD;
}
ll msub(ll a, ll b) {
if(a < b) return (a-b+MOD) % MOD;
else return (a-b) % MOD;
}
ll mtime(ll a, ll b, ll c) {
ll ret = (a*b) % MOD;
return (ret*c) % MOD;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for (ll i = 0; i < (n); i++)
typedef pair<int, int> P;
ll gcd(ll a, ll b) { return b?gcd(b,a%b):a;}
ll lcm(ll a, ll b) { return a/gcd(a,b)*b;}
const ll INF = 100100100100100100;
const ll MAX_V = 1000;
const ll MAX_E = 1000;
vector<vector<ll>> cost(MAX_V,vector<ll>(MAX_E,INF));
struct edge{
// Dijkstraでは隣接リストを用いるのでfromはいらない
// int from;
int to;
int c;
public:
edge(ll to, ll c){
this->to = to;
this->c = c;
}
};
// 集合Xからの辺の最小コスト
vector<ll> mincost(MAX_V);
ll prim(const ll &V, const vector<vector<edge>> &ed){
// V:頂点数
ll res = 0;
vector<bool> used(V+5,false);
priority_queue<P, vector<P>, greater<P>> pq; // first:その頂点を接続するのに必要なコスト ,second:頂点番号
P ps;
ps.first = 0;
ps.second = 0;
pq.push(ps);
// pq.push(P(0,0)):
while(!pq.empty()){
P p = pq.top();
pq.pop();
if(used[p.second]) continue; // もう集合Xに入っていたら無視
used[p.second] = true;
res += p.first; // priorityQueueを用いていることで必ず最適な辺を取得することができる．
for(edge e : ed[p.second]){
if(!used[e.to]) pq.push({e.c,e.to});
}
}
return res;
}
int main(){
ll V;
cin >> V;
vector<vector<edge>> ed(V);
vector<P> X;
vector<P> Y;
rep(i,V){
ll x,y; cin >> x >> y;
X.push_back(P(x,i));
Y.push_back(P(y,i));
}
sort(X.begin(),X.end());
sort(Y.begin(),Y.end());
rep(i,V-1){
ll z1, z2 ,c, from, to;
z1 = X[i].first;
z2 = X[i+1].first;
c = abs(z1-z2);
from = X[i].second;
to = X[i+1].second;
edge e(from,c);
edge re(to,c);
ed[to].push_back(e);
ed[from].push_back(re);
}
rep(i,V-1){
ll z1, z2 ,c, from, to;
z1 = Y[i].first;
z2 = Y[i+1].first;
c = abs(z1-z2);
from = Y[i].second;
to = Y[i+1].second;
edge e(from,c);
edge re(to,c);
ed[to].push_back(e);
ed[from].push_back(re);
}
// rep(i,V){
// cout << i << " :" << endl;
// rep(j,ed[i].size()){
// cout << ed[i][j].to << " " << ed[i][j].c << endl;
// }
// }
cout << prim(V, ed) << endl;
return 0;
} | #include<cstdio>
#include<algorithm>
#include<vector>
#define ll long long
using namespace std;
int p[100010];
vector<pair<ll,ll>> vt;
vector<pair<ll, ll>> vt1;
vector<pair<ll, pair<ll, ll>>> vt2;
int find(int u)
{
if (u == p[u])return u;
return p[u] = find(p[u]);
}
int merge(int u, int v)
{
u = find(u), v = find(v);
if (u == v)return 0;
p[u] = v;
return 1;
}
int main()
{
ll n;
scanf("%lld", &n);
for (int i = 1; i <= n; i++)
{
p[i] = i;
ll q, w;
scanf("%lld %lld", &q, &w);
vt.push_back({ q,i });
vt1.push_back({ w,i });
}
sort(vt.begin(), vt.end());
sort(vt1.begin(), vt1.end());
for (int i = 1; i < n; i++)
{
vt2.push_back({vt[i].first-vt[i-1].first ,{ vt[i].second,vt[i - 1].second } });
vt2.push_back({ vt1[i].first - vt1[i - 1].first ,{ vt1[i].second,vt1[i - 1].second } });
}
sort(vt2.begin(), vt2.end());
ll dap = 0;
for (int i = 0; i < vt2.size(); i++) {
if (merge(vt2[i].second.first, vt2[i].second.second))
{
dap += vt2[i].first;
}
}
printf("%lld", dap);
} | 1 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<cstdint>
#include<cstdlib>
template<typename T>
void fin(T const& t){ std::cout << t << std::endl; exit(0); }
int64_t const INF = 1e18;
int main() {
std::cin.tie(0); std::ios::sync_with_stdio(false);
int N; std::cin >> N;
std::vector<int64_t> A(N);
int64_t S = 0;
for(int i = 0; i < 3; ++i) std::cin >> A[i];
for(int i = 3; i < N; ++i) { std::cin >> A[i]; S += A[i]; }
int64_t P[4] = { A[0], A[1], A[2], S }, ans = INF;
int j = 1, l = 3;
for(int k = 2; k < N-1; ++k) {
while(j < k-1 && std::abs(P[0]-P[1]) > std::abs(P[0]+A[j]-(P[1]-A[j]))) {
P[0] += A[j];
P[1] -= A[j];
++j;
}
while(l < N-1 && std::abs(P[2]-P[3]) > std::abs(P[2]+A[l]-(P[3]-A[l]))) {
P[2] += A[l];
P[3] -= A[l];
++l;
}
ans = std::min(ans, *std::max_element(P, P+4) - *std::min_element(P, P+4));
P[1] += A[k];
P[2] -= A[k];
}
fin(ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 200010;
int a[N], n;
ll sum[N];
ll get(int l, int r){
return sum[r] - sum[l - 1];
}
inline void chkmin(ll& a, ll b){
if(a > b) a = b;
}
inline void chkmax(ll& a, ll b){
if(a < b) a = b;
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> n;
for(int i = 1; i <= n; i++)
cin >> a[i];
for(int i = 1; i <= n; i++)
sum[i] = sum[i - 1] + a[i];
ll ans = 1LL << 60;
for(int i = 3; i <= n - 1; i++){
ll a[4];
int low = i, high = n - 1;
int step = 100;
int mid1, mid2;
while(step-- && low <= high){
mid1 = (low + low + high) / 3;
mid2 = (low + high + high) / 3;
ll s1 = get(i, mid1), s2 = get(mid1 + 1, n);
ll s3 = get(i, mid2), s4 = get(mid2 + 1, n);
if(abs(s1 - s2) > abs(s3 - s4))
low = mid1 + 1;
else
high = mid2;
}
vector<pair<ll, ll> > vp1;
for(int j = -2; j <= 2; j++){
int nh = high + j;
if(nh >= i && nh + 1 <= n)
vp1.emplace_back(get(i, nh), get(nh + 1, n));
}
low = 2, high = i - 1;
step = 100;
while(step-- && low <= high){
mid1 = (low + low + high) / 3;
mid2 = (low + high + high) / 3;
ll s1 = get(mid1, i - 1), s2 = get(1, mid1 - 1);
ll s3 = get(mid2, i - 1), s4 = get(1, mid2 - 1);
if(abs(s1 - s2) > abs(s3 - s4))
low = mid1 + 1;
else
high = mid2;
}
a[2] = get(high, i - 1), a[3] = get(1, high - 1);
vector<pair<ll, ll> > vp2;
for(int j = -2; j <= 2; j++){
int nh = high + j;
if(nh <= i - 1 && 1 <= nh - 1)
vp2.emplace_back(get(nh, i - 1), get(1, nh - 1));
}
for(auto it : vp1) for(auto jt : vp2){
ll a[4] = {it.first, it.second, jt.first, jt.second};
ll xv = 0, nv = 1LL << 60;
for(int j = 0; j < 4; j++)
chkmax(xv, a[j]), chkmin(nv, a[j]);
chkmin(ans, xv - nv);
}
}
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <iomanip>
#include <math.h>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
//#define local
#ifdef local
#include "dbg-macro/dbg.h"
#endif
//#define hacks
#ifdef hacks
#include <boost/multiprecision/cpp_int.hpp>
#endif
#define p std::pair
#define ll long long
#define ld long double
#define ull unsigned long long
#define pi std::pair<int, int>
#define stdabs std::abs
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (unsigned long long i = 0; i < (unsigned long long)(n); ++i)
#define vec std::vector
#define oreq |=
#define npm next_permutation
using namespace std;
std::vector<unsigned ll> genprimevec(const unsigned ll N);
ll extgcd(ll a, ll b, ll& x, ll& y);
ll nCr(ll n, ll r);
void stat();
template <typename T> T fact(T num);
constexpr ll mod = 1000000000 + 7;
int main()
{
stat();
int k,x;
cin >> k>>x;
for(int i=x-k+1;i!=x+k;++i){
if(i<-1000000||1000000<i){continue;}
if(i==x+k-1){cout<<i<<endl;break;}
cout<<i<<' ';
}
return 0;
}
ll extgcd(ll a, ll b, ll& x, ll& y)
{
if (b == 0) {
x = 1, y = 0;
return a;
}
ll d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
std::vector<unsigned ll> genprimevec(const unsigned ll N)
{
std::vector<bool> is_prime(N + 1);
for (unsigned ll i = 0; i <= N; i++) {
is_prime[i] = true;
}
std::vector<unsigned ll> P;
for (unsigned ll i = 2; i <= N; i++) {
if (is_prime[i]) {
for (unsigned ll j = 2 * i; j <= N; j += i) {
is_prime[j] = false;
}
P.emplace_back(i);
}
}
return P;
}
void stat(){
#ifdef local
rep(i, 2){std::cout << "local enable" << std::endl;
}
#endif
#ifdef hacks
rep(i, 2) { std::cout << "boost enable" << std::endl; }
#endif
}
ll nCr(ll n, ll r)
{
ll num = 1;
for (ll i = 1; i <= r; i++) {
num = num * (n - i + 1) / i;
}
return num;
}
template <typename T> T fact(T num)
{
if (num == 1) { return 1; }
return num * fact(num - 1);
}
| #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef long long LL;
int main() {
int K, X; cin >> K >> X;
for (int i = X - K + 1; i < X + K; ++i) {
cout << i << " ";
}
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long double ld;
typedef long long ll;
typedef pair<double, double> pdd;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef vector<pii> vii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
const int mod = 998244353;
ll mpow(ll x, ll n) {
ll res = 1;
while (n) {
if (n & 1) res = res * x % mod;
x = x * x % mod;
n /= 2;
}
return res;
}
vl fac(3e6, 1);
vl invfac(fac.size(), 1);
ll bin(int n, int k) {
if (k < 0 || k > n) return 0;
return fac[n] * invfac[k] % mod * invfac[n - k] % mod;
}
int main() {
std::ios::sync_with_stdio(false); std::cin.tie(0);
for (int i = 2; i < (int)fac.size(); ++i) {
fac[i] = fac[i - 1] * i % mod;
invfac[i] = mpow(fac[i], mod - 2);
}
int n, m;
cin >> n >> m;
ll res = 0;
for (int k = m % 2; k <= m; k += 2) {
int a = (m - k) / 2;
res = (res + (bin(n - 1 + m + a, n - 1) - (n - k) * bin(n - 1 + a - 1, n - 1) - k * bin(n - 1 + a, n - 1)) % mod * bin(n, k)) % mod;
}
cout << (res % mod + mod) % mod << endl;
return 0;
}
| #include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
#include<vector>
#include<ctime>
#include<map>
#include<bitset>
#include<set>
#define LL long long
#define mp(x,y) make_pair(x,y)
#define pll pair<long long,long long>
#define pii pair<int,int>
using namespace std;
inline LL read()
{
LL f=1,x=0;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
int stack[20];
template<typename T>inline void write(T x)
{
if(x<0){putchar('-');x=-x;}
if(!x){putchar('0');return;}
int top=0;
while(x)stack[++top]=x%10,x/=10;
while(top)putchar(stack[top--]+'0');
}
template<typename T>inline void pr1(T x){write(x);putchar(' ');}
template<typename T>inline void pr2(T x){write(x);putchar('\n');}
const int mod=998244353;
const int MAXN=3000005;
int pre[MAXN],inv[MAXN];
int C(int n,int m)
{
if(n<m)return 0;
return 1LL*pre[n]*inv[m]%mod*inv[n-m]%mod;
}
int n,m;
void ad(int &x,int y){x+=y;if(x>=mod)x-=mod;}
void dl(int &x,int y){x-=y;if(x<0)x+=mod;}
int pow_mod(int a,int b)
{
int ret=1;
while(b)
{
if(b&1)ret=1LL*ret*a%mod;
a=1LL*a*a%mod;b>>=1;
}
return ret;
}
int main()
{
pre[0]=1;for(int i=1;i<MAXN;i++)pre[i]=1LL*pre[i-1]*i%mod;
inv[MAXN-1]=pow_mod(pre[MAXN-1],mod-2);
for(int i=MAXN-2;i>=0;i--)inv[i]=1LL*inv[i+1]*(i+1)%mod;
n=read();m=read();
int ans=0;
for(int i=0;i<=m;i++)
if(!((3*m-i)&1))
ad(ans,1LL*C(n,i)*C(((3*m-i)>>1)+n-1,n-1)%mod);
// dl(ans,1LL*n*C(m-2+n-1,n-1)%mod);
dl(ans,1LL*n*C(m-1+n-1,n-1)%mod);
pr2(ans);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define pi 3.141592653589793238
#define fast ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define MOD 1000000007
void solve()
{
ll n;
cin>>n;
map<ll,ll> mp;
ll ans=0;
for(ll i=0;i<n;i++)
{
ll x;
cin>>x;
mp[x]++;
}
// cout<<mp[16];
for(auto c:mp)
{
ans+=(c.second%2);
}
cout<<ans;
return;
}
int main()
{
fast;
int q;
q=1;
// cin>>q;
while(q--)
{
solve();
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int n;
cin >> n;
set<int> s;
for(int i=0; i<n; i++){
int a;
cin >> a;
if(s.count(a)) s.erase(a);
else s.insert(a);
}
cout << s.size() << endl;
} | 1 |
#include <bits/stdc++.h>
#define EPS 1e-9
#define INF 1070000000LL
#define MOD 1000000007LL
#define fir first
#define foreach(it,X) for(auto it=(X).begin();it!=(X).end();it++)
#define numa(x,a) for(auto x: a)
#define ite iterator
#define mp make_pair
#define mt make_tuple
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
#define pb push_back
#define pf push_front
#define sec second
#define sz(x) ((int)(x).size())
#define ALL( c ) (c).begin(), (c).end()
#define gcd(a,b) __gcd(a,b)
#define endl "\n"
using namespace std;
template <int POS, class TUPLE> void deploy(std::ostream &os, const TUPLE &tuple){}
template <int POS, class TUPLE, class H, class ...Ts> void deploy(std::ostream &os, const TUPLE &t){ os << (POS == 0 ? "" : ", ") << get<POS>(t); deploy<POS + 1, TUPLE, Ts...>(os, t); }
template <class T> std::ostream& operator<<(std::ostream &os, std::vector<T> &v){ int remain = v.size(); os << "{"; for(auto e: v) os << e << (--remain == 0 ? "}" : ", "); return os; }
template <class T> std::ostream& operator<<(std::ostream &os, std::set<T> &v){ int remain = v.size(); os << "{"; for(auto e: v) os << e << (--remain == 0 ? "}" : ", "); return os; }
template <class T, class K> std::ostream& operator<<(std::ostream &os, std::map<T, K> &mp){ int remain = mp.size(); os << "{"; for(auto e: mp) os << "(" << e.first << " -> " << e.second << ")" << (--remain == 0 ? "}" : ", "); return os; }
#define DEBUG1(var0) { std::cerr << (#var0) << "=" << (var0) << endl; }
#define DEBUG2(var0, var1) { std::cerr << (#var0) << "=" << (var0) << ", ";DEBUG1(var1); }
#define DEBUG3(var0, var1, var2) { std::cerr << (#var0) << "=" << (var0) << ", ";DEBUG2(var1,var2); }
#define DEBUG4(var0, var1, var2, var3) { std::cerr << (#var0) << "=" << (var0) << ", ";DEBUG3(var1,var2,var3); }
#define DEBUG5(var0, var1, var2, var3, var4) { std::cerr << (#var0) << "=" << (var0) << ", ";DEBUG4(var1,var2,var3,var4); }
#define DEBUG6(var0, var1, var2, var3, var4, var5) { std::cerr << (#var0) << "=" << (var0) << ", ";DEBUG5(var1,var2,var3,var4,var5);}
typedef long long ll;
#define MAX_V 100100
int V;
vector <pair <int,ll> > edge[MAX_V];
vector <pair <int,ll> > Redge[MAX_V];
vector <int> vs;
bool used[MAX_V];
int cmp[MAX_V];
void reverse_edge(){
rep2(i,1,V+1){//1-indexedにしてます
rep(j,sz(edge[i])){
Redge[edge[i][j].fir].pb(mp(i,edge[i][j].sec));
}
}
}
void dfs(int now){
used[now] = true;
rep(i,sz(edge[now])){
if(!used[edge[now][i].fir]){
dfs(edge[now][i].fir);
}
}
vs.pb(now);
}
void rdfs(int now,int k){
used[now] = true;
cmp[now] = k;
rep(i,sz(Redge[now])){
if(!used[Redge[now][i].fir]){
rdfs(Redge[now][i].fir,k);
}
}
}
int scc(){
memset(used,0,sizeof(used));
vs.clear();
rep2(v,1,V+1){//1-indexed
if(!used[v]){
dfs(v);
}
}
memset(used,0,sizeof(used));
reverse_edge();
int k = 0;
for(int i = sz(vs)-1;i >= 0;i--){
if(!used[vs[i]]){
k += 1;
rdfs(vs[i],k);
}
}
}
int main(){
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> V;
int E;
cin >> E;
rep(i,E){
int x,y;
cin >> x >> y;
x += 1;
y += 1;
edge[x].pb(mp(y,1));
}
scc();
int Q;
cin >> Q;
rep(i,Q){
int x,y;
cin >> x >> y;
x += 1;
y += 1;
if(cmp[x] == cmp[y]){
cout << 1 << endl;
}else{
cout << 0 << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long // <-----!!!!!!!!!!!!!!!!!!!
#define rep(i,n) for (int i=0;i<(n);++i)
#define rep2(i,a,b) for (int i=(a);i<(b);++i)
#define rrep(i,n) for (int i=(n)-1;i>=0;--i)
#define rrep2(i,a,b) for (int i=(a)-1;i>=b;--i)
#define chmin(a,b) (a)=min((a),(b));
#define chmax(a,b) (a)=max((a),(b));
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define printV(_v) cout<<(#_v)<<":";for(auto(_x):(_v)){cout<<" "<<(_x);}cout<<endl;
#define printVS(vs) cout<<(#vs)<<":"<<endl;for(auto(s):(vs)){cout<<(s)<< endl;}
#define printVV(vv) cout<<(#vv)<<":"<<endl;for(auto(v):(vv)){for(auto(x):(v)){cout<<" "<<(x);}cout<<endl;}
#define printP(p) cout<<(#p)<<(p).first<<" "<<(p).second<<endl;
#define printVP(vp) cout<<(#vp)<<":"<<endl;for(auto(p):(vp)){cout<<(p).first<<" "<<(p).second<<endl;}
inline void output(){ cout << endl; }
template<typename First, typename... Rest>
inline void output(const First& first, const Rest&... rest) {
cout << first << " "; output(rest...);
}
using ll = long long;
using Pii = pair<int, int>;
using TUPLE = tuple<int, int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
const int inf = 1ll << 60;
const int mod = 1e9 + 7;
using Graph = vector<vector<int>>;
class SCC {
private:
const int n;
vector<vector<int>> G;
vector<vector<int>> rG;
vector<int> vs;
vector<bool> used;
vector<int> cmp;
public:
SCC(int _n) : n(_n), G(_n), rG(_n), used(_n), cmp(_n) {}
void addEdge(int from, int to) {
G[from].emplace_back(to);
rG[to].emplace_back(from);
}
void dfs(int v) {
used[v] = true;
for (auto nxt : G[v]) if (!used[nxt]) dfs(nxt);
vs.emplace_back(v);
}
void rdfs(int v, int k) {
used[v] = true;
cmp[v] = k;
for (auto nxt : rG[v]) if (!used[nxt]) rdfs(nxt, k);
vs.emplace_back(v);
}
int scc() {
used.assign(n, false);
rep(v, n) if (!used[v]) dfs(v);
used.assign(n, false);
int k = 0;
for (int i = (int)vs.size() - 1; i >= 0; i--) {
int v = vs[i];
if (!used[v]) rdfs(v, k++);
}
return k;
}
bool same(int a, int b) {
return cmp[a] == cmp[b];
}
};
main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n, m;
cin >> n >> m;
SCC scc(n);
rep(i, m) {
int a, b;
cin >> a >> b;
scc.addEdge(a, b);
}
scc.scc();
int q;
cin >> q;
rep(i, q) {
int a, b;
cin >> a >> b;
cout << scc.same(a, b) << endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 567890, maxm = 1<<20, mod = 1000000007;
int mul(long long a, long long b){
return a * b % mod;
}
int q0[maxn];
int a[maxn];
vector<int> where[maxm];
int main(){
int n; scanf("%d", &n);
for(int i = 1; i <= n; i++) scanf("%d", a + i);
for(int i = 1; i <= n; i++) a[i] ^= a[i - 1];
int cnt0 = 0;
vector<int> could;
for(int i = 1; i <= n; i++){
if(a[i] == 0) cnt0++;
q0[i] = cnt0;
could.push_back(a[i]);
}
sort(could.begin(), could.end());
could.erase(unique(could.begin(), could.end()), could.end());
for(int i = n; i >= 1; i--) where[a[i]].push_back(i);
int ans = 0;
for(int i: could){
if(i == 0){
int now = a[n] == 0;
for(int j = where[i].size(); j > 1; j--){
ans += now;
if(ans >= mod) ans -= mod;
now = now + now;
if(now >= mod) now -= mod;
}
ans += a[n] == 0;
if(ans >= mod) ans -= mod;
continue;
}
int normal = a[n] == i, adapt = mul(normal, q0[n]);
if(a[n] == i){
ans += 1;
if(ans >= mod) ans -= mod;
}
for(int j : where[i]){
if(j == n) continue;
int gap = adapt + mod - mul(normal, q0[j]);
if(gap >= mod) gap -= mod;
gap += (a[n] == 0);
if(gap >= mod) gap -= mod;
ans += gap;
if(ans >= mod) ans -= mod;
normal += gap;
if(normal >= mod) normal -= mod;
adapt += mul(gap, q0[j]);
if(adapt >= mod) adapt -= mod;
}
}
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <vector>
#include <chrono>
#include <random>
std::mt19937 rng((int) std::chrono::steady_clock::now().time_since_epoch().count());
const int ms = 1 << 20;
const int MOD = 1e9 + 7;
int trans[ms][2];
int main() {
std::ios_base::sync_with_stdio(false); std::cin.tie(NULL);
int n;
std::cin >> n;
std::vector<int> a(n + 1, 0);
for(int i = 1; i <= n; i++) {
std::cin >> a[i];
a[i] ^= a[i-1];
}
for(int i = 0; i <= n; i++) {
//std::cout << a[i] << (i == n ? '\n' : ' ');
}
for(int i = 0; i < ms; i++) {
trans[i][0] = 1;
}
int zero = 1;
int ans = 0;
int o = a.back() == 0 ? 1 : 0;
for(int i = 1; i <= n; i++) {
if(a[i] == 0) {
if(a.back() == 0 && i != n) {
o = (o + o) % MOD;
}
zero++;
} else {
long long val = ((long long) trans[a[i]][1] * zero % MOD + trans[a[i]][0]) % MOD;
if(a.back() == 0) {
ans = (ans + val) % MOD;
} else if(i == n) {
ans = val;
}
trans[a[i]][0] = (trans[a[i]][0] - val * zero % MOD + MOD) % MOD;
trans[a[i]][1] = (trans[a[i]][1] + val % MOD) % MOD;
}
}
std::cout << (ans + o) % MOD << '\n';
} | 1 |
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#define ll long long
int main()
{
ll A, B;
std::cin >> A >> B;
ll sum = A * B;
std::cout << sum << std::endl;
} | // Hail god Yato
#include <bits/stdc++.h>
using namespace std;
#define hs ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
typedef long long ll;
const ll mod = 1000000007;
const ll INF = 1e18;
const ll MAX = 100001;
//
//
void solve(){
ll a, b;
cin>>a>>b;
cout<<a*b;
}
int main(){
hs;
ll t;
t=1;
// cin>>t;
for (int i=1; i<=t; i++){
//cout<<"Case #"<<i<<": ";
solve();
}
return 0;
} | 1 |
#include <iostream>
#include <string>
int main(){
char s[10];
for (int i = 0; i < 10; i++){
std::cin >> s[i];
if (i == 3){
s[i] = '8';
}
}
for (int i = 0; i < 10; i++){
std::cout << s[i];
}
std::cout << std::endl;
return 0;
} | #include <stdio.h>
int main (){
char year[4],month[2],day[2];
scanf ("%[^/]/ %[^/]/ %s",year,month,day);
printf ("2018/01/%s",day);
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = (int) 2e5 + 20;
#define LL long long
LL n, x;
LL B[maxn], L[maxn], R[maxn];
LL sum[maxn];
LL tsum[maxn];
int rk[maxn];
bool vis[maxn];
int gao(LL score)
{
LL tot = 0;
LL les = score % x;
for(int i = 0; i < n; i++)
{
rk[i] = i;
vis[i] = 0;
tot -= B[i] * L[i];
sum[i] = (x - B[i]) * R[i] + B[i] * L[i];
if(les >= B[i]) tsum[i] = (les - B[i]) * R[i] + B[i] * L[i];
else tsum[i] = les * L[i];
}
sort(rk, rk + n, [](int x, int y){
if(sum[x] == sum[y]) return tsum[x] < tsum[y];
return sum[x] > sum[y];
});
int k = score / x;
LL pre = 0;
for(int i = 0; i < k; i++) pre += sum[rk[i]];
if(k == n) return tot + pre >= 0;
LL k1 = sum[rk[k]];
LL mx = 0;
for(int i = 0; i < n; i++)
{
if(i < k) mx = max(mx, pre - sum[rk[i]] + k1 + tsum[rk[i]]);
else mx = max(mx, pre + tsum[rk[i]]);
}
return tot + mx >= 0;
}
void work()
{
cin >>n >>x;
for(int i = 0; i < n; i++)
cin >>B[i] >>L[i] >>R[i];
LL l = 0, r = n * x, mid, ans = -1;
while(l <= r)
{
mid = (l + r) / 2;
if(gao(mid))
{
r = mid - 1;
ans = mid;
}
else
{
l = mid + 1;
}
}
cout <<ans <<endl;
}
int main()
{
#ifdef yukihana0416
freopen("in.txt","r",stdin);
#endif // yukihana0416
work();
return 0;
}
| #include<bits/stdc++.h>
const int N = 100010;
typedef long long ll;
ll x[N], p[N];
int main(){
int n, s;
scanf("%d%d", &n, &s);
for (int i = 0; i < n; ++ i){
scanf("%lld%lld", &x[i], &p[i]);
}
int sit = std::lower_bound(x, x + n, s) - x;
int left = 0, right = n - 1;
ll ans = 0;
int previouschoice = -1;
while (true){
if (left == sit){
ans += x[right] - s;
break;
}
if (right == sit - 1){
ans += s - x[left];
break;
}
if ((p[left] >= p[right]) != previouschoice){
ans += x[right] - x[left];
previouschoice = p[left] >= p[right];
}
if (p[left] >= p[right]){
p[left] += p[right];
-- right;
}
else{
p[right] += p[left];
++ left;
}
}
printf("%lld\n", ans);
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
int n;
int a[5]={0};
long double dp[305][305][305];
long double solve(int n1,int n2,int n3)
{
if( (n1<0) || (n2<0) || (n3<0))
return 0;
if(n1==0 && n2==0 && n3==0)
return 0;
if(dp[n1][n2][n3]!=0)
return dp[n1][n2][n3];
long double &ans=dp[n1][n2][n3];
int cnt=0;
int x=n-n1-n2-n3;
long double nn=n1+n2+n3;
long double nn1=(long double)n1/nn;
long double nn2=(long double)n2/nn;
long double nn3=(long double)n3/nn;
long double c=solve(n1-1,n2,n3);
if(c>0)
{
long double xx= (long double)(((long double)n1+(long double)x*nn1)/((long double)n1));
//cout<<xx<<" "<<c<<"\n";
xx+=c;
xx*=nn1;
ans+=xx;
}
c=solve(n1+1,n2-1,n3);
if(c>0)
{
long double xx= (long double)(((long double)n2+(long double)x*nn2)/((long double)n2));
//cout<<xx<<" ";
xx+=c;
xx*=nn2;
ans+=xx;
//cnt++;
}
c=solve(n1,n2+1,n3-1);
if(c>0)
{
long double xx= (long double)(((long double)n3+(long double)x*nn3)/((long double)n3));
//cout<<xx<<" ";
xx+=c;
xx*=nn3;
ans+=xx;
//cnt++;
}
//ans=ans/cnt;
//cout<<n1<<" "<<n2<<" "<<n3<<" "<<ans<<" "<<cnt<<"\n";
return ans;
}
int32_t main()
{
ios::sync_with_stdio(false);
cin.tie(0);
memset(dp,0,sizeof(dp));
cin>>n;
dp[1][0][0]=n;
for(int i=0;i<n;i++)
{
int x;
cin>>x;
a[x]++;
}
//cout<<a[1]<<" "<<a[2]<<" "<<a[3]<<"\n";
std::cout << std::setprecision(15) << solve(a[1],a[2],a[3]) << '\n';
}
| #include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <iomanip>
#define rep(i,n) Rep(i,0,n)
#define Rep(i,k,n) for(int i=k ; i<n ; i++)
#define vi vector<int>
#define Sort(v) sort(v.begin(),v.end())
//const int MOD = 1000000007;
//const int INF = 1<<30;
using namespace std;
int main(){
int n;
cin >> n;
int maxn = -1000000 , minn=1000000;
long long sum=0;
rep(i,n){
int a; cin >> a;
sum += a;
maxn = max(maxn,a);
minn = min(minn,a);
}
cout << minn << " " << maxn << " " <<sum << endl;
}
| 0 |
#include<iostream>
#include<cstring>
#include<cstdio>
#define MN 1000000
using namespace std;
inline int read()
{
int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
char s[MN+5],t[MN+5];
int last[MN+5][26],a[MN+5],n,ans=0;
int main()
{
n=read();
scanf("%s%s",s+1,t+1);
for(int i=1;i<=n;++i)
{
memcpy(last[i],last[i-1],sizeof(last[0]));
last[i][s[i]-'a']=i;
}
for(int i=n,j=n,r=0,k=0;i;--i)
{
if(j>i) j=i;
if(s[j]!=t[i])
{
if(!last[j][t[i]-'a']) return 0*puts("-1");
j=last[j][t[i]-'a'];
++r;++k;ans=max(ans,k);
++a[j+r];
}
k-=a[i+r];a[i+r]=0;
}
cout<<ans;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int n;
char s[1000100];
char t[1000100];
queue<int>q;
int main()
{
scanf("%d",&n);
scanf("%s",s+1);
scanf("%s",t+1);
int ans=0;
for(int i=1;i<=n;++i)
if(s[i]!=t[i]){ans=1;break;}
if(!ans)
{
puts("0");
return 0;
}
for(int up=n,dn=n;dn;--dn)
{
while(t[dn-1]==t[dn])dn--;
up=min(up,dn);
while(s[up]!=t[dn]&&up)up--;
if(!up)
{
puts("-1");
return 0;
}
while(!q.empty())
{
if(q.front()-q.size()+1>dn)q.pop();
else break;
}
if(up!=dn)q.push(up);
ans=max(ans,(int)q.size()+1);
}
printf("%d\n",ans);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define vi vector<int>
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define pi 3.141592653589793238
#define rep(i,a,b) for (int i = a; i <= b; i++)
#define zip(i,a,b) for(int i=a;i<b;i++)
#define rzip(i,a,b) for(int i=a;i>=b;i--)
#define ll unsigned int
#define test int t;cin>>t; while(t--)
#define en '\n'
typedef pair<int, int> pii;
typedef pair<char, int> pci;
typedef pair<char, char> pcc;
typedef vector<pii> vii;
typedef long double ld;
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(),v.rend()
#define sz(x) (int)x.size()
#define INF (1e18+5)
#define inf (1e9+5)
#define mod 1000000007
void __print(int 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");}
// You should only debug a pair of simple data types. For example,
// the debug won't work if one of pair's elements is collection type
// (std::vector, std::map, std::set...).
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i : x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
// bool check_prime(int n) return whether a number is prime or not O(sqrt(N));
// int BE(int x,int n,int m) return x^n%m; O(logN);
// void sieve() from number 1-1000001 saare prime store kar lega in bool is_prime[1000001] array
// vector<int> z_array(string s) return vector which is Z-array of string s;
// vector<int> lps(string s) return vector which is lps array of string s;
// int power(int x,int n) return x^n; O(logN);
// using_ordered_set (template for using ordered set , replace first 2 lines of this page with this code..);
const int gf = 1e6 + 9;
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
#ifndef ONLINE_JUDGE
if (fopen("input.txt", "r"))
{
freopen ("input.txt" , "r" , stdin);
freopen ("output.txt" , "w" , stdout);
}
#endif
//_______________________________-code starts-_______________________________________________
int n;
cin >> n;
int a[n], b[n];
zip(i, 0, n)
{
cin >> a[i];
}
zip(i, 0, n)cin >> b[i];
sort(b, b + n, greater<int>());
int l = 0, r = n - 1;
zip(i, 0, n)
{
if (a[i] == b[i])
{
if (a[l] != b[i] && a[i] != b[l])
{
swap(b[l], b[i]);
l++;
}
else if (a[r] != b[i] && b[r] != a[i])
{
swap(b[r], b[i]);
r--;
}
else
{
cout << "No" << en;
return 0;
}
}
}
zip(i, 0, n)
{
if (a[i] == b[i])
{
cout << "No" << en;
return 0;
}
}
cout << "Yes" << en;
zip(i, 0, n)cout << b[i] << " ";
return 0;
}
| #include <iostream>
using namespace std;
int main(int argc, const char * argv[]) {
int N;
cin>>N;
int *vCount=new int[N],*b=new int[N],*c=new int[N+1];
for(int i=0;i<N;++i){
vCount[i]=0;
}
bool yesFlg=true;
int oldA=-1,ci=0;
for(int i=0;i<N;++i){
int a1;
cin>>a1;
++vCount[a1-1];
if(vCount[a1-1]>N){
yesFlg=false;
break;
}
if(oldA!=a1){
for(;ci<a1;++ci){
c[ci]=i;
}
oldA=a1;
}
}
for(;ci<=N;++ci){
c[ci]=N;
}
int oldB=-1,di=0;
int x=0;
for(int i=0;i<N&&yesFlg;++i){
int b1;
cin>>b1;
b[i]=b1;
++vCount[b1-1];
if(vCount[b1-1]>N){
yesFlg=false;
break;
}
if(oldB!=b1){
for(;di<b1;++di){
int d=i;
int x1=c[di+1]-d;
if(x<x1){
x=x1;
}
}
oldB=b1;
}
}
for(;di<N;++di){
int d=N;
int x1=c[di+1]-d;
if(x<x1){
x=x1;
}
}
if(yesFlg){
cout<<"Yes"<<endl;
for(int i=0;i<N;++i){
int idx=(i-x)%N;
if(idx<0){
idx+=N;
}
int b1=b[idx];
if(i==0){
cout<<b1;
}else{
cout<<" "<<b1;
}
}
cout<<endl;
}else{
cout<<"No"<<endl;
}
delete[] b;
delete[] c;
delete[] vCount;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
int n;
ll x;
cin>>n>>x;
vector<ll>a(n);
for(int i=0;i<n;i++)cin>>a[i];
sort(a.begin(),a.end());
int ans=0;
int i=0;
while(x>0 && i<n){
x-=a[i];
if(x>=0)ans++;
i++;
}
if(x>0)ans--;
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FOR(i, a, b) for(ll i = (a); i < (b); ++i)
#define REP(i, n) for(ll i = 0; i < (n); ++i)
#define ARRAY_LENGTH(array) sizeof(array)/sizeof(*array)
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
const ll INF = 1LL << 60;
int main() {
ll N, x;
cin >> N >> x;
vector<ll> a(N);
REP(i, N) cin >> a[i];
vector<vector<ll>> dp(N + 1, vector<ll>(N + 10, -INF));
dp[0][0] = 0;
for(ll i = 1; i <= N; ++i) {
for(ll sum_cnt = 0; sum_cnt < i; ++sum_cnt) {
dp[i][sum_cnt] = dp[i - 1][sum_cnt];
if(i >= 1) {
chmin(dp[i][sum_cnt], dp[i - 1][sum_cnt - 1] + a[i - 1]);
}
}
dp[i][i] = dp[i - 1][i - 1] + a[i - 1];
}
ll ans_i = 0;
while(ans_i < N && dp[N][ans_i + 1] <= x) {
++ans_i;
}
if(dp[N][ans_i] < x && ans_i == N) {
--ans_i;
}
cout << ans_i << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
#define pb push_back
#define all(a) a.begin(), a.end()
#define sz(a) (int)a.size()
#define x first
#define y second
#define debug(...) cout << "[" << #__VA_ARGS__ << ": " << __VA_ARGS__ << "]\n"
#define rd() abs((int)rng())
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int>pii;
const int maxn = 1e5 + 100;
const int mod = 1e9 + 7;
mt19937 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
int n;
ll X, b[maxn], l[maxn], r[maxn], base;
vector<pair<ll, int> >sums;
bool can(ll c)
{
ll full = c / X, rem = c - full * X;
ll sum = 0;
for(int i = 0; i < full; i++)
sum += sums[i].x;
ll mx = 0;
for(int i = 0; i < n; i++)
{
int j = sums[i].y;
ll add;
if(rem >= b[j])
add = b[j] * l[j] + r[j] * (rem - b[j]);
else
add = l[j] * rem;
if(i < full)
mx = max(mx, sum - sums[i].x + add + (full == n ? 0 : sums[full].x));
else
mx = max(mx, sum + add);
}
return mx >= base;
}
int main()
{
ios_base::sync_with_stdio(false), cin.tie(0);
cin >> n >> X;
for(int i = 0; i < n; i++)
{
cin >> b[i] >> l[i] >> r[i];
base += l[i] * b[i];
sums.pb({(X - b[i]) * r[i] + b[i] * l[i], i});
}
sort(all(sums), greater<pair<ll, int> >());
ll lo = 0, hi = X * n;
while(lo < hi)
{
ll mid = (lo + hi) / 2;
if(can(mid))
hi = mid;
else
lo = mid + 1;
}
cout << lo << "\n";
return 0;
} | #include <bits/stdc++.h>
#define Maxn 100007
using namespace std;
int n,x;
int b[Maxn],l[Maxn],r[Maxn];
bool flag[Maxn];
priority_queue<pair<long long,int> >pq;
long long solve(int id,long long tmp)
{
if (tmp<=0LL) return 0LL;
if (tmp<=1LL*l[id]*b[id])
{
return (tmp+l[id]-1)/l[id];
} else
{
tmp-=1LL*l[id]*b[id];
return (tmp+r[id]-1)/r[id]+b[id];
}
}
int main()
{
scanf("%d%d",&n,&x);
while (!pq.empty()) pq.pop();
long long tmp=0LL;
for (int i=1;i<=n;i++)
{
scanf("%d%d%d",&b[i],&l[i],&r[i]);
tmp+=1LL*l[i]*b[i];
pq.push(make_pair(1LL*r[i]*(x-b[i])+1LL*l[i]*b[i],i));
}
long long ans=1LL*x*n;
int cnt=0;
while ((!pq.empty())&&tmp>=0)
{
tmp-=pq.top().first;
int id=pq.top().second;
flag[id]=true;
pq.pop();
++cnt;
}
ans=min(ans,1LL*cnt*x);
--cnt;
long long t=x;
for (int i=1;i<=n;i++)
if (flag[i])
{
tmp+=1LL*r[i]*(x-b[i])+1LL*l[i]*b[i];
t=min(t,solve(i,tmp));
tmp-=1LL*r[i]*(x-b[i])+1LL*l[i]*b[i];
}
ans=min(ans,1LL*cnt*x+t);
while (!pq.empty()) pq.pop();
tmp=0LL;
for (int i=1;i<=n;i++)
{
tmp+=1LL*l[i]*b[i];
pq.push(make_pair(1LL*r[i]*(x-b[i])+1LL*l[i]*b[i],i));
}
memset(flag,false,sizeof(flag));
cnt=0;
while ((!pq.empty())&&tmp>pq.top().first)
{
tmp-=pq.top().first;
int id=pq.top().second;
flag[id]=true;
pq.pop();
++cnt;
}
ans=min(ans,1LL*cnt*x+x);
t=x;
for (int i=1;i<=n;i++)
if (!flag[i]) t=min(t,solve(i,tmp));
ans=min(ans,1LL*cnt*x+t);
printf("%lld\n",ans);
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int Max=1e6+7;
ll a[Max]; int n,k;
int main(){
ios::sync_with_stdio(0);
scanf("%d%d",&n,&k);
for(int i=1; i<=n; i++) scanf("%lld",&a[i]);
ll ans=0;
//cout<<"OK"<<endl;
if(a[1]>=0) ans=a[k];
else if(a[n]<=0) ans=-a[n-k+1];
else{
int index=0;
for(int i=1; i<=n; i++){
if(a[i]>=0) {
index=i; break;
}
}
ans=0x3f3f3f3f;
for(int i=index; i<index+k && i<=n; i++){
ll tot=abs(a[i]);
if(i-index+1<k){
tot+=abs(a[i]);
if(i-k+1>=1){
tot+=abs(a[i-k+1]);
//cout<<tot<<endl;
ans=min(tot,ans);
}
}else{
//cout<<tot<<endl;
ans=min(tot,ans);
}
}
index--;
for(int i=index; i>=1 && i>=index-k+1; i--){
ll tot=abs(a[i]);
if(index-i+1<k){
tot+=abs(a[i]);
if(k+i-1<=n){
tot+=abs(a[k+i-1]);
ans=min(ans,tot);
}
}
else{
ans=min(ans,tot);
}
}
}
cout<<ans<<endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
inline int read(){
char c=getchar(); int res=0;
while(!isdigit(c)) c=getchar();
while(isdigit(c)){ res=(c&15)+(res<<1)+(res<<3); c=getchar(); }
return res;
}
int n,*a,*b;
int main(){
n=read();
a=new int[n]; b=new int[n+1];
pair<int,int>*bound=new pair<int,int>[n+1];
for(int i=0;i<=n;i++) bound[i]=make_pair(-1,-1);
for(int i=0,cur=0;i<n;i++){
a[i]=read();
if(cur!=a[i]){
bound[cur].second=i-1;
bound[a[i]].first=i;
cur=a[i];
}
}
bound[a[n-1]].second=n-1;
for(int i=0;i<n;i++) b[i]=read();
int*off=new int[n+3]; off[0]=0; off++;
for(int i=0;i<=n+1;i++) off[i]=0;
for(int i=0,l,r;i<n;i++){
l=bound[b[i]].first;
r=bound[b[i]].second;
if(l!=-1&&r!=-1){
if(i<l){
off[l-i]--;
off[r-i+1]++;
}else if(i>r){
off[n+l-i]--;
off[n+r-i+1]++;
}else{
off[0]--;
off[r-i+1]++;
off[n+l-i]--;
}
}
}
for(int i=0;i<n;i++) off[i]+=off[i-1];
int res=-1;
for(int i=0;i<n;i++){
if(off[i]==0){
res=i;
break;
}
}
if(res==-1){
printf("No");
}else{
printf("Yes\n");
for(int i=n;i<n<<1;i++){
printf("%d ",b[(i-res)%n]);
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 1e5 + 5;
int a[NMAX], sol, n, m, s;
int main() {
cin >> n >> m;
for(int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
a[x]++;
a[y + 1]--;
}
for(int i = 1; i <= n; i++) {
s += a[i];
if(s == m) {
sol++;
}
}
cout << sol;
return 0;
}
| #include<bits/stdc++.h>
#define maxn 100005
using namespace std;
int n,m;
int main()
{
int x,y,l=0,r=maxn;
scanf("%d %d",&n,&m);
for(int i=1;i<=m;i++)
{
scanf("%d %d",&x,&y);
l=max(x,l),r=min(y,r);
}
if(l>r)printf("0");
else printf("%d\n",r-l+1);
return 0;
} | 1 |
/*#include <boost/multiprecision/cpp_dec_float.hpp>
#include <boost/multiprecision/cpp_int.hpp>
#include <boost/rational.hpp>
*/
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
using ll = long long;
using ld = long double;
#define rep2(i, s, n) for (ll i = (s); i < (ll)(n); i++)
#define rep3(i, n) for (ll i = 1; i < (ll)(n+1); i++)
#define rep4(i, s, n) for (ll i = (s); i < (ll)(n+1); i++)
#define repr(i,n) for (ll i = (n-1); i>=0;i--)
#define repr3(i,n) for(ll i = (n);i>0;i--)
#define repr4(i,s,n) for(ll i = (n);i>=(s);i--)
#define stlen(s) ll s.size()-1
#define all(v) v.begin(), v.end()
#define allr(v) v.rbegin(), v.rend()
#define cout(n) cout<<std::fixed<<std::setprecision(n)
using Graph = vector<vector<int>>;
using Graphw = vector<vector<pair<ll,ll>>>;
#define INF1 INT_MAX;
#define INF2 LLONG_MAX;
#define PI 3.14159265358979323846;
#define MOD 1000000007;
/*
namespace mp = boost::multiprecision;
// 任意長整数型
using Bint = mp::cpp_int;
// 仮数部長が32の浮動小数点数型
using Real32 = mp::number<mp::cpp_dec_float<32>>;
// 仮数部長が1024の浮動小数点数型
using Real1024 = mp::number<mp::cpp_dec_float<1024>>;
// 有理数型
using Rat = boost::rational<Bint>;
*/
const int mod = 1000000007;
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int main(){
ll n,m,d;
cin>>n>>m>>d;
if(d==0){
cout<<(ld)(m-1)/n<<endl;
}
else{
cout(10)<<(ld)2*(n-d)*(m-1)/(n*n)<<endl;
}
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<vector>
#include<functional>
#include<algorithm>
#include<stdlib.h>
#include<string>
#include<string.h>
#define _USE_MATH_DEFINES
#include<math.h>
#include<deque>
#include<set>
#include<map>
#include<queue>
#include<list>
#include<iostream>
using namespace std;
typedef long long ll;
#define rep(i,a,b) for(auto i=a;i<b;i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
//ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
int main() {
double n, m, d;
cin >> n >> m >> d;
printf("%f\n", (n - d) / n / n * (d == 0 ? 1 : 2) * (m - 1));
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int a;
cin>>a;
cout<<a+a*a+a*a*a;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> Pii;
typedef pair<int, ll> Pil;
typedef pair<ll, ll> Pll;
typedef pair<ll, int> Pli;
typedef vector < vector<ll> > Mat;
#define fi first
#define se second
const ll MOD = 1e9 + 7;
const ll MOD2 = 998244353;
const ll MOD3 = 1812447359;
const ll INF = 1ll << 62;
const double PI = 2 * asin(1);
void yes() {printf("yes\n");}
void no() {printf("no\n");}
void Yes() {printf("Yes\n");}
void No() {printf("No\n");}
void YES() {printf("YES\n");}
void NO() {printf("NO\n");}
ll N, K, ans = 1e18;
int Solve(ll num, ll turn){
if (turn == N){
ans = min(ans, num);
return 0;
}
Solve(num * 2, turn + 1);
Solve(num + K, turn + 1);
return 0;
}
int main(){
cin >> N >> K;
Solve(1, 0);
cout << ans << endl;
return 0;
}
| 0 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
template<typename T>
class SegTree {
public:
explicit SegTree(int n, T def) : N(calcN_(n)), def(def), mVal(2*calcN_(n)-1, def) {}
void update(int idx, T value){
int i = N + idx - 1;
update_(mVal[i], value);
while(i > 0){
i = (i-1)/2;
mVal[i] = operate(mVal[2*i+1], mVal[2*i+2]);
}
}
T get(int l, int r){
return getImpl_(l, r, 0, 0, N);
}
private:
int calcN_(int n){
int res = 1;
while(res < n) res *= 2;
return res;
}
T getImpl_(int l, int r, int idx, int rangeL, int rangeR){
if(r <= rangeL || rangeR <= l) return def;
if(l <= rangeL && rangeR <= r) return mVal[idx];
int rangeM = (rangeL+rangeR)/2;
T a = getImpl_(l, r, 2*idx+1, rangeL, rangeM);
T b = getImpl_(l, r, 2*idx+2, rangeM, rangeR);
return operate(a, b);
}
T update_(T& data, T val) { data = val; }
T operate(T a, T b) { return min(a, b); }
const int N;
const T def;
vector<T> mVal;
};
class UnionFind {
public:
explicit UnionFind(int N) : root(N, -1), size(N, 1) {}
int getRoot(int u){ return root[u] == -1 ? u : root[u] = getRoot(root[u]); }
int getSize(int u){ return size[getRoot(u)]; }
int same(int a, int b){
return getRoot(a) == getRoot(b);
}
int merge(int a, int b){
int u = getRoot(a);
int v = getRoot(b);
if(u != v){
root[u] = v;
size[v] += size[u];
}
}
private:
vector<int> root;
vector<int> size;
};
int main(){
int N; long long D;
while(cin >> N >> D){
vector<long long> A(N);
for(auto& t : A) cin >> t;
vector<pair<long long, int>> key;
for(int i=0;i<N;i++) key.emplace_back(A[i], i);
sort(key.begin(), key.end());
SegTree<pair<long long, int>> left(N, make_pair(1LL << 60, -1));
SegTree<pair<long long, int>> right(N, make_pair(1LL << 60, -1));
vector<pair<long long, pair<int, int>>> edge;
for(auto& p : key){
int idx = p.second;
int idxL = left.get(0, idx).second;
int idxR = right.get(idx+1, N).second;
if(idxL != -1){
edge.emplace_back((idx-idxL)*D + p.first + A[idxL], make_pair(idxL, idx));
}
if(idxR != -1){
edge.emplace_back((idxR-idx)*D + p.first + A[idxR], make_pair(idxR, idx));
}
left.update(idx, make_pair((N-idx)*D + A[idx], idx));
right.update(idx, make_pair(idx*D + A[idx], idx));
}
long long res = 0;
UnionFind uf(N);
sort(edge.begin(), edge.end());
for(auto & e : edge){
int u = uf.getRoot(e.second.first);
int v = uf.getRoot(e.second.second);
if(u != v){
uf.merge(u, v);
res += e.first;
}
}
cout << res << endl;
}
} | #pragma GCC optimize(2)
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define ll long long
#define mp make_pair
#define pb push_back
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
const int maxn = 2e5 + 5;
int n, d, a[maxn];
ll dp[maxn];
int main() {
scanf("%d %d", &n, &d);
for (int i = 0; i < n; ++ i)
scanf("%d", &a[i]);
for (int i = 0; i < n; ++ i) dp[i] = a[i];
for (int i = 0; i + 1 < n; ++ i)
dp[i + 1] = min(dp[i + 1], dp[i] + d);
for (int i = n - 1; i; -- i)
dp[i - 1] = min(dp[i - 1], dp[i] + d);
ll ans = 0;
for (int i = 0; i < n; ++ i) ans += a[i];
for (int i = 1; i < n - 1; ++ i) ans += dp[i];
printf("%lld\n", ans + 1LL * d * (n - 1));
return 0;
}
| 1 |
#include <vector>
#include <string>
#include <iostream>
#include <queue>
#include <algorithm>
#include <functional>
#include <map>
#include <array>
#include <cmath>
using namespace std;
long long PRIME = 1000000007;
struct info{
long long b;
long long l;
long long u;
long long d_max;
};
bool comp(const info& l, const info& r){
return l.d_max > r.d_max;
}
vector<info> info_vec;
vector<long long> sum_vec;
long long X;
long long N;
long long checkX(long long S){
long long num = S / X;
long long rest = S % X;
if(rest == 0){
return sum_vec[num];
}
long long ret = -1;
for(int i = 0; i < N; ++i){
long long val;
if(i < num){
val = sum_vec[num + 1];
val -= info_vec[i].d_max;
}
else{
val = sum_vec[num];
}
if(rest < info_vec[i].b){
val += info_vec[i].l * rest;
}
else{
val += info_vec[i].l * info_vec[i].b + info_vec[i].u * (rest - info_vec[i].b);
}
ret = max(ret, val);
}
return ret;
}
int main(int argc, char* argv[]){
cin >> N >> X;
info_vec.resize(N);
sum_vec.resize(N + 1);
long long b;
long long l;
long long u;
long long cost_zero = 0;
for(int i = 0; i < N; ++i){
cin >> b >> l >> u;
info_vec[i].b = b;
info_vec[i].u = u;
info_vec[i].l = l;
info_vec[i].d_max = (X - b) * u + b * l;
cost_zero -= l * b;
}
if(cost_zero == 0){
cout << 0;
return 0;
}
std::sort(info_vec.begin(), info_vec.end(), comp);
sum_vec[0] = cost_zero;
for(int i = 1; i <= N; ++i){
sum_vec[i] = sum_vec[i-1] +info_vec[i-1].d_max;
}
long long min_X = 0;
long long max_X = X * N;
long long mid_X;
long long cost;
while(max_X - min_X > 1){
mid_X = (min_X + max_X) / 2;
cost = checkX(mid_X);
if(cost < 0){
min_X = mid_X;
}
else{
max_X = mid_X;
}
}
cout << max_X;
}
| #include <iostream>
#include <cstring>
#include <cstdio>
#define Maxn 4010
#define Maxm 4010
using namespace std;
int read() {
int x = 0,f = 1;
char c = getchar();
while(c < '0' || c > '9') {
if(c == '-') f = -1;
c = getchar();
}
while('0' <= c && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int N,M,Q;
int mp[Maxn][Maxm],sum1[Maxn][Maxm],sum2[Maxn][Maxm];
int main() {
N = read(); M = read(); Q = read();
char ch;
for(int i = 1;i <= N; i++)
for(int j = 1;j <= M; j++) {
int x = i * 2 - 1,y = j * 2 - 1;
ch = getchar();
while(ch != '0' && ch != '1') ch = getchar();
if(ch == '1') mp[x][y] = 1;
}
for(int i = 1;i <= N; i++)
for(int j = 1;j <= M; j++) {
int x = i * 2 - 1,y = j * 2 - 1;
if(mp[x][y]) {
if(mp[x - 2][y]) mp[x - 1][y] = 2;
if(mp[x + 2][y]) mp[x + 1][y] = 2;
if(mp[x][y + 2]) mp[x][y + 1] = 2;
if(mp[x][y - 2]) mp[x][y - 1] = 2;
}
}
for(int i = 1;i < N * 2; i++)
for(int j = 1;j < M * 2; j++) {
if(mp[i][j] == 1) sum1[i][j] = sum1[i - 1][j] + sum1[i][j - 1] - sum1[i - 1][j - 1] + 1;
else sum1[i][j] = sum1[i - 1][j] + sum1[i][j - 1] - sum1[i - 1][j - 1];
if(mp[i][j] == 2) sum2[i][j] = sum2[i - 1][j] + sum2[i][j - 1] - sum2[i - 1][j - 1] + 1;
else sum2[i][j] = sum2[i - 1][j] + sum2[i][j - 1] - sum2[i - 1][j - 1];
}
int i_1,j_1,i_2,j_2,x_1,y_1,x_2,y_2;
for(int k = 1;k <= Q; k++) {
i_1 = read(); j_1 = read(); i_2 = read(); j_2 = read();
x_1 = i_1 * 2 - 1; y_1 = j_1 * 2 - 1;
x_2 = i_2 * 2 - 1; y_2 = j_2 * 2 - 1;
int ans1 = sum1[x_2][y_2] + sum1[x_1 - 1][y_1 - 1] - sum1[x_2][y_1 - 1] - sum1[x_1 - 1][y_2];
int ans2 = sum2[x_2][y_2] + sum2[x_1 - 1][y_1 - 1] - sum2[x_2][y_1 - 1] - sum2[x_1 - 1][y_2];
printf("%d\n",ans1 - ans2);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
/*
int a, b;
cin >> a >> b ;
//*/
//*
vector<int> vec(3);
cin >> vec.at(0) >> vec.at(1) >> vec.at(2) ;
sort(vec.begin(), vec.end());
//*/
/*
if( a < 6 ){
cout << 0 << endl;
} else if (a < 13){
cout << b / 2 << endl;
} else {
cout << b << endl;
}
//*/
cout << vec.at(0) + vec.at(1) << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define M_PI 3.14159265358979323846 // pi
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef tuple<ll, ll, ll> t3;
#define rep(a,n) for(ll a = 0;a < n;a++)
static const ll INF = 1e15;
static const ll mod = 1e9+7;
template<typename T>
static inline void chmin(T& ref, const T value) {
if (ref > value) ref = value;
}
template<typename T>
static inline void chmax(T& ref, const T value) {
if (ref < value) ref = value;
}
struct MaxFlowCalculator {
int max_flow(int s, int t, const vector<vector<pair<int, int>>>& g) {
struct edge_ { int to, cap, rev; };
vector<bool> used(g.size(), false);
vector<vector<edge_>> G(g.size());
for (int i = 0; i < g.size(); i++) for (int j = 0; j < g[i].size(); j++)
{
int from = i, to = g[i][j].second;
int cap = g[i][j].first;
G[from].push_back({ to, cap, (int)G[to].size() });
G[to].push_back({ from, 0, (int)G[from].size() - 1 });
}
auto dfs = [&](auto&& f, int v, int t, int fl)->int {
if (v == t) return fl;
used[v] = true;
rep(i, G[v].size()) {
edge_& e = G[v][i];
if (!used[e.to] && e.cap > 0) {
int d = f(f, e.to, t, min(fl, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
};
int flow = 0;
while (1) {
used.assign(used.size(), false);
int f = dfs(dfs, s, t, INT_MAX);
if (f == 0) return flow;
flow += f;
}
}
};
int main() {
ll p, r, q;
cin >> p >> r >> q;
ll a1 = p + r;
ll a2 = r + q;
ll a3 = p + q;
cout << min(a1, min(a2, a3)) << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define REP(i,m,n) for(int i=(m);i<(n);i++)
#define rep(i,n) REP(i,0,n)
#define pb push_back
#define all(a) a.begin(),a.end()
#define rall(c) (c).rbegin(),(c).rend()
#define mp make_pair
#define endl '\n'
#define vec vector<ll>
#define mat vector<vector<ll> >
#define fi first
#define se second
typedef long long ll;
typedef pair<ll,ll> pll;
typedef long double ld;
const ll inf=1e9+7;
const ll mod=1e9+7;
signed main(){
ll n;cin>>n;
vector<ll>x(n);
rep(i,n)cin>>x[i];
ll l,q;cin>>l>>q;
vector<ll>nxt(n);
vector<pll>b(0);
for(int i=n-1;i>=0;i--){
if(i==n-1){
b.pb(mp(-x[i],i));
nxt[i]=i;
continue;
}
pll k=*lower_bound(all(b),mp(-x[i]-l,-1LL));
nxt[i]=k.second;
b.pb(mp(-x[i],i));
}
vector<vector<ll> >dp(n,vector<ll>(32));
rep(i,n)dp[i][0]=nxt[i];
REP(i,1,32){
rep(j,n){
dp[j][i]=dp[dp[j][i-1]][i-1];
}
}
rep(i,32){
//cout<<dp[0][i]<<endl;
}
while(q){
q--;
ll a,b;cin>>a>>b;
a--;b--;
if(a>b){
swap(a,b);
}
ll l=0,r=n;
while(r-l>1){
ll mid=(r+l)/2;
ll x=a;
rep(j,32){
if(mid&(1LL<<j)){
x=dp[x][j];
}
}
if(q==3){
//cout<<mid<<' '<<a<<' '<<b<<endl;
}
if(x>=b)r=mid;
else l=mid;
}
cout<<r<<endl;
}
} | #include <bits/stdc++.h>
#define pb emplace_back
#define ll long long
#define fi first
#define se second
#define mp make_pair
using namespace std;
const int N = int(3e5) + 7;
const int logN = 17;
const int mod = int(1e9) + 7;
typedef pair<int, int> pii;
int p[N][logN + 1], x[N], n, l, q, a, b;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
#define Task "test"
if(fopen(Task".inp", "r")) {
freopen(Task".inp", "r", stdin);
freopen(Task".out", "w", stdout);
}
cin >> n;
for(int i = 1; i <= n; ++i) cin >> x[i];
cin >> l;
for(int i = 1, j = 1; i <= n; ++i) {
while(j <= n && x[j] - x[i] <= l) ++j;
p[i][0] = j - 1;
}
for(int j = 1; j <= logN; ++j) {
for(int i = 1; i <= n; ++i)
p[i][j] = p[p[i][j - 1]][j - 1];
}
cin >> q;
while(q --) {
cin >> a >> b; int res = 1;
if(a > b) swap(a, b);
for(int j = logN; j >= 0; --j)
if(p[a][j] < b) res += (1 << j), a = p[a][j];
cout << res << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define ALL(a) (a).begin(),(a).end()
#define rALL(a) (a).rbegin(),(a).rend()
typedef pair<int, int> Pint;
typedef pair<int64_t, int64_t> Pll;
int main() {
string S;
int w;
cin >> S >> w;
for (int i = 0; i < S.size(); i += w){
cout << S.at(i);
}
cout << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repi(i, s, n) for (int i = (s); i < (n); i++)
#ifdef LOCAL
#define INPUT_FILE \
ifstream in("atcoder-problems/abc112_d.txt"); \
cin.rdbuf(in.rdbuf());
#define print_vec(v) \
rep(l, v.size()) { cout << v[l] << " "; } \
cout << endl;
#else
#define INPUT_FILE
#define print_vec(v)
#endif
#define CIN_OPTIMIZE \
cin.tie(0); \
ios::sync_with_stdio(false);
typedef pair<int, int> P;
typedef long long ll;
typedef pair<ll, ll> pl;
const int INF = 100100100;
const ll LINF = 1e18 + 100;
const int MOD = 1e9 + 7;
int main() {
INPUT_FILE CIN_OPTIMIZE;
ll N, M;
cin >> N >> M;
ll ans = 1;
for (ll i = 1; i * i <= M; i++) {
if (M % i == 0) {
if (M / i >= N) ans = max(ans, i);
if (i >= N) ans = max(ans, M / i);
}
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (int)n; i++)
using ll = long long;
const ll INF = 1e17;
template<typename T, typename E, typename F, typename G, typename H>
class LazySegmentTree {
int n, height;
F f; G g; H h; const T ti; const E ei;
vector<T> dat; vector<E> laz; vector<int> highest;
void propagate(int k) {
if(laz[k] != ei) {
laz[2*k] = h(laz[2*k],laz[k]); laz[2*k+1] = h(laz[2*k+1],laz[k]);
dat[k] = g(dat[k],laz[k],n/highest[k]);
laz[k] = ei;
}
}
inline void recalc(int k) {
while(k >>= 1) dat[k] = f(g(dat[2*k],laz[2*k],n/highest[2*k]),g(dat[2*k+1],laz[2*k+1],n/highest[2*k+1]));
}
inline void thrust(int k) {
for(int i = height; i > 0; i--) propagate(k >> i);
}
public:
LazySegmentTree(int _n, F f, G g, H h, T ti, E ei): f(f), g(g), h(h), ti(ti), ei(ei) {
n = 1; height = 0;
while(n < _n) n <<= 1, height++;
dat.assign(2*n,ti); laz.assign(2*n,ei); highest.assign(2*n,0);
int c = 1;
for(int i = 1; i < 2*n; i++) {
if(c*2 <= i) c <<= 1;
highest[i] = c;
}
}
void set(int k, T x) {
dat[k+n] = x;
}
void build() {
for(int i = n-1; i >= 0; i--) {
dat[i] = f(dat[2*i],dat[2*i+1]);
}
}
void update(int a, int b, const E x) {
thrust(a += n); thrust(b += n-1);
for(int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if(l & 1) laz[l] = h(laz[l],x), ++l;
if(r & 1) --r, laz[r] = h(laz[r],x);
}
recalc(a); recalc(b);
}
T query(int a, int b) {
thrust(a += n); thrust(b += n-1);
T l = ti, r = ti; b++;
while(a < b) {
if(a & 1) l = f(l,g(dat[a],laz[a],n/highest[a])), a++;
if(b & 1) b--, r = f(g(dat[b],laz[b],n/highest[b]),r);
a >>= 1; b >>= 1;
}
return f(l,r);
}
};
int main(){
int n, q;
cin >> n >> q;
auto f = [](ll a, ll b){return a+b;};
auto g = [](ll a, ll b, int l){return b == INF ? a : b*l;};
auto h = [&](ll a, ll b) {return b;};
LazySegmentTree<ll,ll,decltype(f),decltype(g),decltype(h)> lst(n,f,g,h,0,INF);
rep(i,n) lst.set(i,((ll)1<<31)-1);
lst.build();
vector<ll> ans;
rep(i,q) {
int t;
cin >> t;
if(t == 0) {
int l, r; ll x;
cin >> l >> r >> x;
lst.update(l,r+1,x);
} else {
int p;
cin >> p;
ans.push_back(lst.query(p,p+1));
}
}
for(auto x : ans) cout << x << endl;
return 0;
}
| #include <bits/stdc++.h>
#define mod 1000000007
#define sp ' '
#define intmax 2147483647
#define llmax 9223372036854775807
#define nyan "(=^･ω･^=)"
#define mkp make_pair
#define mkt make_tuple
#define lP pair<ll, ll>
#define iP pair<int,int>
typedef long long ll;
using namespace std;
int n, q, s, t, x, u;
iP a[1<<18];
bool b;
int update(int s, int t, int x, int k, int l, int r, int i) {
if (t < l || r < s)return 0;
else if (s <= l&&r <= t) {
a[k] = mkp(x, i);
return 0;
}
else {
update(s, t, x, k * 2, l, (l + r) / 2, i);
update(s, t, x, k * 2 + 1, (l + r) / 2 + 1, r, i);
return 0;
}
}
int find(int x) {
int y, z = -2;
x += u;
while (x) {
if (z < a[x].second) {
y = a[x].first;
z = a[x].second;
}
x /= 2;
}
return y;
}
int main(){
cin >> n >> q;
for (int i = 1;; ++i) {
if ((1 << i) / n >= 2) {
u = (1 << i - 1);
break;
}
}
for (int i = 1; i != u * 2; ++i)
a[i] = mkp(intmax, -1);
for (int i = 0; i != q; ++i) {
cin >> b >> s;
if (b) {
cout << find(s) << endl;
}
else {
cin >> t >> x;
update(s, t, x, 1, 0, u - 1, i);
}
}
return 0;
}
| 1 |
#include<cstdio>
#include<math.h>
#include<algorithm>
#include<vector>
#include<queue>
#include<string>
#include<set>
#include<cstring>
#include<map>
using namespace std;
#define int long long int
#define rep(i,n) for(int i=0;i<n;i++)
#define INF 1001001001
#define LLINF 1001001001001001001
#define mp make_pair
#define pb push_back
#define mod 1000000007
//#define mod 998244353
int D,G;
int p[15],c[15];
int dp[15][1500];
signed main(){
scanf("%lld %lld",&D,&G);
int maxp=0;
rep(i,D){
scanf("%lld %lld",&p[i],&c[i]);
maxp=max(maxp,p[i]);
}
rep(i,D+1)rep(j,D*maxp+1)dp[i][j]=-INF;
rep(i,D){
rep(j,D*maxp+1){
if(i==0&&j==0)dp[i][j]=0;
rep(p_num,p[i]+1){
if(p_num!=p[i])dp[i+1][j+p_num]=max(dp[i+1][j+p_num],dp[i][j]+p_num*(i+1)*100);
else dp[i+1][j+p_num]=max(dp[i+1][j+p_num],dp[i][j]+p_num*(i+1)*100+c[i]);
}
}
}
int ans=-1;
rep(j,D*maxp+1){
//printf("%lld/",dp[D][j]);
if(dp[D][j]>=G){ans=j;break;}
}
printf("%lld\n",ans);
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
#define ll long long
#define itn int
#define endl '\n'
#define co(ans) cout<<ans<<endl
#define COYE cout<<"YES"<<endl
#define COYe cout<<"Yes"<<endl
#define COye cout<<"yes"<<endl
#define CONO cout<<"NO"<<endl
#define CONo cout<<"No"<<endl
#define COno cout<<"no"<<endl
#define FORE(i,a) for(auto &i:a)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define FFOR(i,a,b) for(int i=(a);i<=(b);++i)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) FFOR(i,1,n)
#define PB push_back
#define MP make_pair
#define ALL(V) (V).begin(),(V).end()
#define SORT(V) sort((V).begin(),(V).end())
#define REVERSE(V) reverse((V).begin(),(V).end())
#define EACH(V,i) for(typeof((V).begin()) i=(V).begin();i!=(V).end();++i)
#define equals(a,b) (fabs((a)-(b))<EPS)
#define INF ((1LL<<62)-(1LL<<31))
#define EPS 1e-10
#define PI 3.141592653589793238
#define MOD 1000000007
#define MAX 5100000
using namespace std;
using Graph=vector<vector<int>>;
inline int toInt(string s){int v;istringstream sin(s);sin>>v;return v;}
template<class T>inline string toString(T x){ostringstream sout;sout<<x;return sout.str();}
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;}
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
const int dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
int main() {
int H,W;
cin>>H>>W;
char A[H+2][W+2];
int DIS[H+2][W+2];
queue<pair<int,int>> Q;
for(int i=1; i<=H; ++i){
for(int j=1; j<=W; ++j){
cin>>A[i][j];
DIS[i][j]=MAX;
if(A[i][j]=='#'){
Q.emplace(i,j);
DIS[i][j]=0;
}
}
}
while(!Q.empty()){
auto P=Q.front();
Q.pop();
REP(i,4){
int ny=P.first+dy[i],nx=P.second+dx[i];
if(nx<=0||nx>=W+1||ny<=0||ny>=H+1) continue;
if(DIS[ny][nx]<MAX) continue;
DIS[ny][nx]=DIS[P.first][P.second]+1;
Q.emplace(ny,nx);
}
}
int ans=0;
for(int i=1; i<=H; ++i){
for(int j=1; j<=W; ++j){
chmax(ans,DIS[i][j]);
}
}
co(ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int K,X;
cin >> K >> X;
for (int i = 0; i < K*2-1; i++) {
if (i == K*2-2){
cout << X - K + 1 + i << endl;
}
else {
cout << X - K + 1 + i << ' ';
}
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,int> P;
struct edge {int to; ll cost; };
int dx[] = {-1, 1, 0, 0};
int dy[] = { 0, 0, 1, -1};
int main(){
int k, x;
cin >> k >> x;
for(int i=x-k+1; i<x+k; i++){
if(i==x+k-1) cout << i << endl;
else cout << i << " ";
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define REP(i,n) for(int i=0;i<n;i++)
#define RREP(i,n) for(int i=n;i>=0;i--)
#define FOR(i,m,n) for(int i=m;i<n;i++)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
using namespace std;
typedef long long ll;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
//const ll INF = 1LL << 60;
//const int INF = 1001001001;
map< int64_t, int > prime_factor(int64_t n) {
map< int64_t, int > ret;
for(int64_t i = 2; i * i <= n; i++) {
while(n % i == 0) {
ret[i]++;
n /= i;
}
}
if(n != 1) ret[n] = 1;
return ret;
}
ll gcd(ll a, ll b) { return b?gcd(b,a%b):a;}
int main(void){
ll a,b;
cin >> a >> b;
auto v=prime_factor(gcd(a,b));
cout << v.size()+1 << endl;
return 0;
} | #pragma region header
#include <bits/stdc++.h>
#define int long long
#define all(a) begin(a), end(a)
#define rall(a) rbegin(a), rend(a)
#define mp make_pair
#define mt make_tuple
#define rep1(i, n) for (decltype(+n) i = 0; i < (n); i++)
#define rrep1(i, n) for (auto i = n - 1; i > static_cast<decltype(i)>(-1); i--)
#define rep2(i, a, b) for (auto i = (a); i < (b); i++)
#define rrep2(i, a, b) for (auto i = b - 1; i >= a; i--)
#define GET_MACRO(_1, _2, _3, NAME, ...) NAME
#define rep(...) GET_MACRO(__VA_ARGS__, rep2, rep1) (__VA_ARGS__)
#define rrep(...) GET_MACRO(__VA_ARGS__, rrep2, rrep1) (__VA_ARGS__)
#define each(i, a) for (auto &&i : (a))
using namespace std;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vi>;
using vs = vector<string>;
using vvs = vector<vs>;
using vd = vector<ld>;
using vvd = vector<vd>;
using vb = vector<bool>;
using vvb = vector<vb>;
using pii = pair<int, int>;
using vp = vector<pii>;
using vvp = vector<vp>;
using mii = map<int, int>;
using vm = vector<mii>;
using vvm = vector<vm>;
template <class T, class U>
using umap = unordered_map<T, U>;
using umii = umap<int, int>;
using seti = set<int>;
template <class T>
using uset = unordered_set<T>;
using useti = uset<int>;
template <class T>
using less_queue = priority_queue<T>;
template <class T>
using greater_queue = priority_queue<T, vector<T>, greater<T>>;
constexpr int INF = 1e18;
template <class T>
void SORT(T &a) { stable_sort(all(a)); }
template <class T>
void RSORT(T &a) { stable_sort(rall(a)); }
template <class T>
void rev(T &a) { reverse(rall(a)); }
template <class T>
void uniq(T &a) { a.erase(unique(all(a)), end(a)); }
template <class T>
auto min_of(T a) { return *min_element(all(a)); }
template <class T>
auto max_of(T a) { return *max_element(all(a)); }
template <class T>
int sum_of(T a) { return accumulate(all(a), 0ll); }
template <class T, class U>
auto sum_of(T a, U init) { return accumulate(all(a), init); }
template <class T, class U>
int count_of(T a, U i) { return count(all(a), i); }
template <class T, class U>
bool has(T a, U i) { return find(all(a), i) != end(a); }
template <class T>
int sz(T a) { return a.size(); };
template <class T>
void COUT(T x) { cout << x << endl; }
template <class T, class U>
void COUT(T x, U y) { cout << x << ' ' << y << endl; }
template <class T, class U, class V>
void COUT(T x, U y, V z) { cout << x << ' ' << y << ' ' << z << endl; }
template <class T>
void CSP(T x) { cout << x << ' '; }
template <class T>
void CVEC(T v) {
int c = v.size() - 1;
for (size_t i = 0; i < c; i++) cout << v[i] << ' ';
if (c > -1) cout << v[c];
cout << endl;
}
template <class T>
bool amin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
bool amax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int ceil_div(int x, int y) { return (x - 1) / y + 1; }
#pragma endregion header
// no MOD
void solve(int N, int x, vi a) {
int ans = 0;
each(c, a) if(c > x) {
ans += c - x;
c = x;
}
rep(i, N - 1) {
if(a[i] + a[i + 1] > x) {
ans += a[i] + a[i + 1] - x;
a[i + 1] = x - a[i];
}
}
COUT(ans);
}
#pragma region main
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(15);
int N;
cin >> N;
int x;
cin >> x;
vi a(N);
for(int i = 0 ; i < N ; i++){
cin >> a[i];
}
solve(N, x, move(a));
}
#pragma endregion main
| 0 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(ri,n) for(int ri = (int)(n-1); ri >= 0; ri--)
#define rep2(i,x,n) for(int i = (int)(x); i < (int)(n); i++)
#define rrep2(ri,x,n) for(int ri = (int)(n-1); ri >= (int)(x); ri--)
#define repit(itr,x) for(auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr,x) for(auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
int main(){
int n, m;
cin >> n >> m;
vector<int> a(n);
rep(i, n) cin >> a.at(i);
map<int, int> mp;
mp[0] = 1;
int ms = 0;
rep(i, n){
ms += a.at(i);
ms %= m;
mp[ms]++;
}
ll ans = 0;
for(auto p : mp){
ans += (ll)p.second * (p.second-1)/2;
}
cout << ans << endl;
return 0;
} | //2020年4月17日現在
#include<stdio.h>
#include<cmath>
#include<math.h>
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<complex>
#include<queue>
#include<set>
#include<utility>
#include<iomanip>
#include<limits>
#include<thread>
#include<map>
#include<stack>
#include<numeric>
#include<cassert>
#include<random>
#include<chrono>
#include<unordered_set>
#include<unordered_map>
#include<fstream>
#include<list>
#include<functional>
#include<bitset>
#include<tuple>
#include <cstdio>
#include <iterator>
using namespace std;
template <class... A>
void prints() { cout << "\n"; }
template <class... A>
void prints_rest() { cout << "\n"; }
template <class T, class... A>
void prints_rest(const T &first, const A &... rest) { cout << " " << first; prints_rest(rest...); }
template <class T, class... A>
void prints(const T &first, const A &... rest) { cout << first; prints_rest(rest...); }
namespace {
// printElems(&a[0], &a[n]); みたいな感じで使う。
void printElems(const int* begin, const int* end)
{
for (const int* p = begin; p != end; ++p) {
std::cout << *p << ' ';
}
std::cout << std::endl;
}
}
#define rep(i,n) for(int i=0; i<n; i++)
#define rep1(i,n) for(int i=1; i<n+1; i++)
#define repr(i,n) for(int i=n-1; i>=0; i--)
#define repr1(i,n) for(int i=n; i>0; i--)
#define FOR(i,j,n) for(int i=j; i < n; i++)
#define souatari(i,j,n) rep1(i,n-1)rep(j,i)
#define souatari1(i,j,n) for(int i=2; i<n+1; i++)rep1(j,i-1)
#define mp make_pair
#define F first
#define S second
#define elif else if
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<pii> vpii;
typedef array<int,3> arr3;
typedef long double D;
const ll llinf = numeric_limits<ll>::max();
const ll _llinf = numeric_limits<ll>::lowest();
const int inf = numeric_limits<int>::max();
const int _inf = numeric_limits<int>::lowest();
const double dinf = numeric_limits<double>::infinity();
const ll MOD = 1000000007;
const ll BIG = 10000000000000000;
ll a[200005];
bool af[200005];
int main(){
ll n;
cin >> n;
rep(i,n) cin >> a[i];
map<ll,ll,greater<ll>> m;
rep(i,n){
if(m.find(a[i]) != m.end()){
m[a[i]]++;
}
else{
m.insert(mp(a[i],1));
}
}
int cnt = 0;
//if(if(m.find(3) != m.end() && m.at(3)>0))
for(auto i=m.begin(); i!= m.end(); ++i){
ll tmp = 1;
ll key = i->first;
ll val = i->second;
while(tmp<key) tmp*=2;
//prints(key,val,tmp);
if(tmp == key){
cnt+=val/2;
m[key] -= val/2;
continue;
}
else{
if(m.find(tmp-key) != m.end() && m.at(tmp-key)>0){
cnt+=min(val,m[tmp-key]);
m[tmp-key]-=min(val,m[tmp-key]);
}
}
}
prints(cnt);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
int N = 100;
vector<vector<bool>> G(N, vector<bool>(N));
for (int i = 0; i < N / 2; i++) {
for (int j = 0; j < N; j++) {
G[i][j] = 1;
}
}
int i = 0, j = 0;
for (int c = 0; c < A - 1; c++) {
G[i][j] = 0;
j += 2;
if (j >= N) {
i += 2;
j = 0;
}
}
i = N / 2 + 1, j = 0;
for (int c = 0; c < B - 1; c++) {
G[i][j] = 1;
j += 2;
if (j >= N) {
i += 2;
j = 0;
}
}
cout << "100 100" << endl;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (G[i][j]) {
cout << '#';
} else {
cout << '.';
}
}
cout << endl;
}
return 0;
}
/* vim:set fdm=marker: */
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define rep(i, n) FOR(i, 0, n)
#define whole(x) (x).begin(),(x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
using P = pair<int, int>;
#define debug(var) cerr << "[" << #var << "] " << var << endl
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
const ll mod = 1000000007;
const int dx[] = {-1,0,1,0};
const int dy[] = {0,-1,0,1};
int main(){
int a, b;
cin >> a >> b;
int ans = 0;
int h = 100;
int w = 100;
vector<string> c(h, string(w, '.'));
rep(i, h) rep(j, w) {
if (i<h/2) c[i][j] = '.';
else c[i][j] = '#';
}
a--; b--;
cout << h << " " << w << endl;
while (b) {
int x = b*3;
int i = x/h+1;
int j = x%h;
c[i][j] = '#';
b--;
}
while (a) {
int x = a*3;
int i = x/h + h/2+1;
int j = x%h;
c[i][j] = '.';
a--;
}
rep(i, h) cout << c[i] << endl;
return 0;
}
| 1 |
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); ++i)
int main() {
int n;
cin >> n;
char *ho = "Hoshino";
rep(i,n+1) {
char c, s[2010];
rep(j, 2000) {
scanf("%c", &c);
if(c == '\n') {
s[j] = '\0';
break;
} else {
s[j] = c;
}
}
for(int j = 0; s[j] != '\0'; ++j) {
int f = 1;
rep(k,7) {
if(s[j + k] != ho[k]) {
f = 0;
break;
}
}
if(f) s[j + 6] = 'a';
}
if(i != 0) {
printf("%s",s);
cout << endl;
}
}
return 0;
} | #include <stdio.h>
#include <string>
#include <iostream>
using namespace std;
int main(int argc, char const* argv[])
{
string find_str("Hoshino"),rep_str("Hoshina"),target;
int n;
cin >> n;
getchar();
for( int i = 0;i < n;i++ ){
getline(cin,target);
for( string::size_type pos = target.find( find_str ); pos != string::npos; pos = target.find( find_str, rep_str.size() + pos ) ){
target.replace( pos, find_str.size(), rep_str );
}
cout << target << endl;
}
return 0;
} | 1 |
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <queue>
#include <stack>
#include <cstdlib>
#include <map>
#include <iomanip>
#include <set>
#include <stdio.h>
#include <ctype.h>
#include <random>
#include <string.h>
#include <cmath>
#include <unordered_map>
#include <cstdio>
using namespace std;
#define all(vec) vec.begin(),vec.end()
typedef long long ll;
ll gcd(ll x, ll y) {
if (y == 0)return x;
return gcd(y, x%y);
}
ll lcm(ll x, ll y) {
return x / gcd(x, y)*y;
}
ll kai(ll x, ll y, ll m) {
ll res = 1;
for (ll i = x - y + 1; i <= x; i++) {
res *= i; res %= m;
}
return res;
}
ll mod_pow(ll x, ll y, ll m) {
ll res = 1;
while (y > 0) {
if (y & 1) {
res = res * x % m;
}
x = x * x % m;
y >>= 1;
}
return res;
}
ll comb(ll x, ll y, ll m) {
if (y > x)return 0;
return kai(x, y, m) * mod_pow(kai(y, y, m), m - 2, m) % m;
}
int n, k, a[100010];
vector<int> vec[100010];
int ans;
int dfs(int v, int p) {
int res = 0;
for (int i = 0; i < (int)vec[v].size(); i++) {
if (vec[v][i] == p)continue;
res = max(res, dfs(vec[v][i], v));
}
if (res == k - 1) {
if (p > 1)ans++;
return 0;
}
return res + 1;
}
signed main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (i != 1)vec[a[i]].push_back(i);
}
if (a[1] != 1)ans++;
dfs(1, 0);
cout << ans << endl;
}
| #include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=2e5+500;
int fa[N],dep[N],siz[N],stack[N],dfs_cnt,top,nid[N],tag[N<<1],a[N<<1],dfn[N],K,kfa[N],n;
int fst[N],nxt[N],to[N],mm;
void ade(int u,int v){to[++mm]=v,nxt[mm]=fst[u],fst[u]=mm;}
void dfs(int u)
{
dep[u]=dep[fa[u]]+1;dfn[u]=++dfs_cnt;nid[dfs_cnt]=u;
siz[u]=1;
stack[++top]=u;
if(dep[u]>=K)kfa[u]=stack[dep[u]-K+1];
for(int i=fst[u];i;i=nxt[i])
{
int v=to[i];dfs(v);
siz[u]+=siz[v];
}
--top;
}
void upd(int rot){a[rot]=0,tag[rot]=1;}
void build(int rot,int lt,int rt)
{
if(lt==rt){a[rot]=nid[lt];return;}
int mid=(lt+rt)>>1;
build(rot<<1,lt,mid),build(rot<<1|1,mid+1,rt);
a[rot]=dep[a[rot<<1]]>dep[a[rot<<1|1]]?a[rot<<1]:a[rot<<1|1];
}
void pushdown(int rot)
{
if(tag[rot]){upd(rot<<1),upd(rot<<1|1),tag[rot]=0;}
}
void update(int rot,int lt,int rt,int lq,int rq)
{
if(lt>=lq&&rt<=rq){upd(rot);return;}
int mid=(lt+rt)>>1;pushdown(rot);
if(lq<=mid)update(rot<<1,lt,mid,lq,rq);
if(rq>mid)update(rot<<1|1,mid+1,rt,lq,rq);
a[rot]=dep[a[rot<<1]]>dep[a[rot<<1|1]]?a[rot<<1]:a[rot<<1|1];
}
int main()
{
scanf("%d%d",&n,&K);
for(int i=1;i<=n;i++)
{
scanf("%d",fa+i);
if(i!=1)ade(fa[i],i);
}
if(K==1)
{
int ans=0;
for(int i=1;i<=n;i++)if(fa[i]!=1)++ans;
cout<<ans<<endl;
return 0;
}
int ans=0;if(fa[1]!=1)++ans;
dfs(1);
build(1,1,n);
while(dep[a[1]]>K+1)
{
++ans;int u=kfa[a[1]];
update(1,1,n,dfn[u],dfn[u]+siz[u]-1);
}
cout<<ans<<endl;
} | 1 |
#include<bits/stdc++.h>
#define ll long long
#define all(a) a.begin(),a.end()
#define sz(a) a.size()
#define re return
#define MP make_pair
#define pb push_back
#define pii pair<int,int>
#define se second
#define fi first
using namespace std;
string s;
signed main(){
ios_base::sync_with_stdio(0);
cin>>s;
for(int i=0;i+2<sz(s);i++){
if(s[i]==s[i+1]||s[i]==s[i+2]||s[i+1]==s[i+2]){
cout<<i+1<<' '<<i+3;
re 0;
}
}
if(sz(s)==2&&s[0]==s[1]) cout<<"1 2";
else cout<<"-1 -1";
re 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
string s; cin >> s;
int n = s.size();
for(int i = 0; i < n; i++){
if(i < n-1 && s[i] == s[i+1]){
cout << i+1 << " " << i+2 << endl;
return 0;
}else if(i < n-2 && s[i] == s[i+2]){
cout << i+1 << " " << i+3 << endl;
return 0;
}
}
cout << "-1 -1" << 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, m, n) for (int i = (m); i < (n); i++)
constexpr long long mod = 998244353;
int main() {
string s; int k; cin >> s >> k;
k = min<int>(k, count(s.begin(), s.end(), '1'));
vector<int> a = { 0 };
for (auto c : s) if (c == '1') a.back()++; else a.push_back(0);
reverse(a.begin(), a.end());
int n = a.size();
static long long dp[305][305][305]; // i, kx, carry
dp[0][0][0] = 1;
rep(i, n) rep(kx, k+1) rep(carry, k+1) {
if ((dp[i][kx][carry] %= mod) == 0) continue;
rep2(fw, 1, a[i]+1) dp[i+1][kx][carry+fw] += dp[i][kx][carry];
rep(take, carry+1) dp[i+1][kx+take][carry-take] += dp[i][kx][carry];
}
long long res = 0;
rep(kx, k+1) res += dp[n][kx][0];
cout << res % mod << "\n";
} | #include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
#define N 303
const int mod=998244353;
inline int read(){
int x=0,f=1;
char c=getchar();
while(c<'0'||c>'9'){
if(c=='-')f=-1;
c=getchar();
}
while(c>='0'&&c<='9'){
x=(x<<1)+(x<<3)+c-'0';
c=getchar();
}
return x*f;
}
int n,m,gu,dp[N][N][N],a[N],ans,sum[N];
char s[N];
int main(){
scanf("%s",s+1);
n=strlen(s+1),m=read();
s[++n]='0';
m=min(n,m);
for(int i=1;i<=n;++i){
if(s[i]=='0')++gu;
else ++a[gu+1];
}
for(int i=1;i<=gu;++i){
sum[i]=a[i]+sum[i-1];
}
dp[0][0][0]=1;
for(int i=1;i<=gu;++i){
for(int j=sum[i];j<=n-gu;++j){
int lim=min(j,n-sum[i-1]-gu);
for(int k=0;k<=m;++k){
for(int p=0;p<=lim;++p){
if(max(0,p-a[i])<=k)dp[i][j][k]=(dp[i][j][k]+dp[i-1][j-p][k-max(0,p-a[i])])%mod;
}
}
}
}
for(int k=0;k<=m;++k){
ans=(ans+dp[gu][n-gu][k])%mod;
}
cout<<ans<<endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#include <boost/range/adaptors.hpp>
#include <boost/range/irange.hpp>
using namespace std;
using namespace boost;
using namespace boost::adaptors;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s;
cin >> s;
int64_t m = s.size();
vector a(1, 0L);
int64_t t = 0;
for (auto c : s) {
if (c == '0') {
a.push_back(t);
} else {
++t;
}
}
a.push_back(t);
int64_t k;
cin >> k;
k = min(k, a.back());
int64_t n = a.size();
constexpr auto M = 998244353L;
vector dp(vector(k + 1, vector(a.back() + 1, 0L)));
int64_t mk = 0;
dp[0][0] = 1;
for (auto i : irange(0L, n - 1)) {
for (auto j : irange(mk, -1L, -1L)) {
auto r = min(k - j, a[i + 1] - a[i]);
for (auto d : irange(1L, r + 1L)) {
auto w = j + d;
for (auto c : irange(0L, a.back() - a[i + 1] + 1)) {
auto b = c + d;
dp[w][c] += dp[j][b];
if (dp[w][c] >= M) {
dp[w][c] -= M;
}
}
}
for (auto c : irange(1L, a.back() - a[i + 1] + 1)) {
dp[j][c] += dp[j][c - 1];
if (dp[j][c] >= M) {
dp[j][c] -= M;
}
}
}
mk = min(k, mk + a[i + 1] - a[i]);
}
int64_t ans = 0;
for (auto i : irange(0L, mk + 1)) {
ans += dp[i][0];
}
cout << ans % M << "\n";
}
| #include<bits/stdc++.h>
#define cs const
#define pb push_back
using namespace std;
cs int Mod = 998244353;
int add(int a, int b){ return a + b >= Mod ? a + b - Mod : a + b; }
int dec(int a, int b){ return a - b < 0 ? a - b + Mod : a - b; }
void Add(int &a, int b){ a = add(a,b); }
cs int N = 305;
int n, K; char S[N];
int a[N], len, dp[2][N][N];
int main(){
#ifdef FSYolanda
freopen("1.in","r",stdin);
#endif
scanf("%s%d",S+1,&K);
K=min(K,n=strlen(S+1));S[n+1]='0';
for(int i=1,pt=0; i<=n+1; i++){
if(S[i]=='1')continue;
a[++len]=i-pt-1; pt=i;
} int now=0, nxt=1;
dp[0][0][0]=1;
// for(int i=1; i<=len; i++)
// cout << a[i] << " "; cout << endl;
for(int i=1; i<=len; i++){
memset(dp[nxt],0,sizeof(dp[nxt]));
for(int k=0; k<=K; k++){
static int sm[N]; sm[0]=0;
for(int l=1; l<=K; l++)
sm[l]=add(sm[l-1],dp[now][l][k]);
for(int j=0; j<=K; j++)
Add(dp[nxt][j][k],dec(sm[min(K,j+a[i])],sm[j]));
} static int sm[N][N];
for(int j=0; j<=K; j++)
for(int k=0; k<=K; k++){
sm[j][k] = dp[now][j][k];
if(j && k) Add(sm[j][k],sm[j-1][k-1]);
Add(dp[nxt][j][k],sm[j][k]);
} swap(now, nxt);
}
int ans = 0;
for(int j=0; j<=K; j++)
Add(ans, dp[now][0][j]);
cout << ans; return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <string>
using namespace std;
class Node {
public:
int key;
Node* parent;
Node* left;
Node* right;
Node(int key) {
this->key = key;
this->parent = NULL;
this->left = NULL;
this->right = NULL;
}
void append_left(Node* left) {
this->left = left;
}
void append_right(Node* right) {
this->right = right;
}
void append_parent(Node* parent) {
this->parent = parent;
}
};
Node* root;
void insert(int key) {
Node* z = new Node(key);
Node* cur = root; Node* x = root;
while(cur != NULL) {
x = cur;
if(z->key > cur->key)
cur = cur->right;
else
cur = cur->left;
}
if(z->key > x->key) {
x->append_right(z);
}
else {
x->append_left(z);
}
z->append_parent(x);
}
Node* find(int key) {
Node* z = root;
while(z != NULL) {
if(key == z->key)
return z;
else if(key > z->key)
z = z->right;
else
z = z->left;
}
return NULL;
}
void delete_node(Node *z) {
if(z==NULL) return;
int degree = 0;
if(z->left != NULL) degree++;
if(z->right != NULL) degree++;
if(degree == 0) {
Node* parent = z->parent;
if(parent == NULL) {
delete z;
root = NULL;
return;
}
if(parent->left == z) parent->left = NULL;
else parent->right = NULL;
delete z;
}
else if(degree == 1) {
Node* parent = z->parent;
Node* child;
if(z->left != NULL) child = z->left;
else child = z->right;
if(parent == NULL) {
root = child;
root->parent = NULL;
delete z;
return;
}
if(parent->left == z) parent->left = child;
else parent->right = child;
child->parent = parent;
delete z;
return;
}
else if(degree == 2) {
Node *y = z->right;
while(y->left != NULL) {
y = y->left;
}
z->key = y->key;
delete_node(y);
}
return;
}
void print_crawl_preorder(Node* node) {
if(node == NULL) return;
cout << " " << node->key;
if(node->left != NULL) {
print_crawl_preorder(node->left);
}
if(node->right != NULL) {
print_crawl_preorder(node->right);
}
return;
}
void print_crawl_inorder(Node* node) {
if(node == NULL) return;
if(node->left != NULL) {
print_crawl_inorder(node->left);
}
cout << " " << node->key;
if(node->right != NULL) {
print_crawl_inorder(node->right);
}
return;
}
int main() {
int n; cin >> n;
root = NULL;
for(int i=0;i<n;i++) {
string command; cin >> command;
if(command == "insert") {
int key; cin >> key;
if(root == NULL) {
root = new Node(key);
}
else {
insert(key);
}
}
else if(command == "find") {
int key; cin >> key;
if(find(key) != NULL) cout << "yes" << endl;
else cout << "no" << endl;
}
else if(command == "delete") {
int key; cin >> key;
delete_node(find(key));
}
else if(command == "print") {
print_crawl_inorder(root); cout << endl;
print_crawl_preorder(root); cout << endl;
}
}
} | #include <cstdio>
#include <list>
#define N 100
using namespace std;
/** Crazy Motor-Cycle */
struct cmc
{
int a;
int b;
int c;
};
/** Application main entry point. */
int
main (
int argc,
char * argv[ ]
)
{
int i;
for ( ; ; )
{
list<struct cmc> lis;
int d[ 3 * N ];
int a, b, c;
int n;
scanf ( "%d%d%d", &a, &b, &c );
if ( !( a | b | c ) ) break ;
b += a; c += b;
for ( i = 0; i < c; ++i )
{
d[ i ] = 2;
}
scanf ( "%d", &n );
while ( n-- )
{
struct cmc t;
int s;
scanf ( "%d%d%d%d", &t.a, &t.b, &t.c, &s );
--t.a; --t.b; --t.c;
if ( s )
{
d[ t.a ] =
d[ t.b ] =
d[ t.c ] = 1;
}
else
{
lis.push_back ( t );
}
}
for ( list<struct cmc>::iterator it = lis.begin ( )
; it != lis.end ( ); )
{
if ( ( d[ it->a ] == 2 && d[ it->b ] == 1 && d[ it->c ] == 1 )
|| ( d[ it->a ] == 1 && d[ it->b ] == 2 && d[ it->c ] == 1 )
|| ( d[ it->a ] == 1 && d[ it->b ] == 1 && d[ it->c ] == 2 ) )
{
if ( d[ it->a ] == 2 ) d[ it->a ] = 0;
else if ( d[ it->b ] == 2 ) d[ it->b ] = 0;
else d[ it->c ] = 0;
lis.erase ( it );
it = lis.begin ( );
}
else ++it;
}
for ( i = 0; i < c; ++i )
{
printf ( "%d\n", d[ i ] );
}
}
return ( 0 );
} | 0 |
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cassert>
#include<iostream>
#define llong long long
using namespace std;
inline int read()
{
int x=0; bool f=1; char c=getchar();
for(;!isdigit(c);c=getchar()) if(c=='-') f=0;
for(; isdigit(c);c=getchar()) x=(x<<3)+(x<<1)+(c^'0');
if(f) return x;
return -x;
}
const int N = 2e6;
const int P = 998244353;
llong fact[N+3],finv[N+3];
llong quickpow(llong x,llong y)
{
llong cur = x,ret = 1ll;
for(int i=0; y; i++)
{
if(y&(1ll<<i)) {y-=(1ll<<i); ret = ret*cur%P;}
cur = cur*cur%P;
}
return ret;
}
llong comb(llong x,llong y) {return x<0||y<0||x<y ? 0ll : fact[x]*finv[y]%P*finv[x-y]%P;}
llong calc(llong n,llong m,llong k)
{
llong ret = 0ll;
for(int i=0; i<=k; i++)
{
if((m-i)&1) continue;
llong tmp = comb(n,i)*comb(((m-i)>>1)+n-1,n-1)%P;
ret = (ret+tmp)%P;
}
// printf("calc %lld %lld %lld=%lld\n",n,m,k,ret);
return ret;
}
int n,m;
int main()
{
fact[0] = 1ll; for(int i=1; i<=N; i++) fact[i] = fact[i-1]*i%P;
finv[N] = quickpow(fact[N],P-2); for(int i=N-1; i>=0; i--) finv[i] = finv[i+1]*(i+1)%P;
scanf("%d%d",&n,&m);
llong ans = calc(n,3*m,m);
ans = (ans-n*(calc(n,m,m)-calc(n-1,m,m)+P)%P+P)%P;
printf("%lld\n",ans);
return 0;
} | #include<bits/stdc++.h>
#define LL long long
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
using namespace std;
inline int read(){
int v=0,f=1;
char c=getchar();
while (c<'0' || c>'9'){
if (c=='-') f=-1;
c=getchar();
}
while (c>='0' && c<='9'){
v=v*10+c-'0';
c=getchar();
}
return v*f;
}
const int Maxn=2000005;
const int mod=998244353;
int fact[Maxn],ivf[Maxn];
int qp(int x,int p){
int ret=1;
while (p){
if (p&1) ret=1ll*ret*x%mod;
x=1ll*x*x%mod;
p>>=1;
}
return ret;
}
int inv(int x){
return qp(x,mod-2);
}
int C(int x,int y){
return 1ll*fact[x]*ivf[y]%mod*ivf[x-y]%mod;
}
void _init(){
fact[0]=1;
for (int i=1;i<Maxn;i++){
fact[i]=1ll*fact[i-1]*i%mod;
ivf[i]=inv(fact[i]);
}
ivf[0]=1;
}
int main(){
_init();
int n,m;
scanf("%d %d",&n,&m);
int ans=0;
for (int i=m;i>=0;i-=2){
if (i>n) continue;
int rem=(3*m-i)/2;
ans+=1ll*C(n,i)*C(rem+n-1,n-1)%mod;
if (ans>=mod) ans-=mod;
}
// cout<<ans<<endl;
for (int i=m;i>=0;i-=2){
if (i>n) continue;
int rem=(3*m-i)/2;
rem-=m;
ans-=1ll*C(n,i)*C(rem+n-1,n-1)%mod*i%mod;
if (ans<0) ans+=mod;
}
for (int i=m;i>=0;i-=2){
if (i>n) continue;
int rem=(3*m-i)/2;
rem-=m+1;
if (rem<0) continue;
ans-=1ll*C(n,i)*C(rem+n-1,n-1)%mod*(n-i)%mod;
if (ans<0) ans+=mod;
}
printf("%d\n",ans);
return 0;
} | 1 |
Subsets and Splits