code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
if ((A - C) * (B - C) < 0) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| #include <iostream>
#include <iomanip>
typedef long long ll;
using namespace std;
const ll INF = 1e9;
const ll MOD = 1e9 + 7;
#define repi(i, n, init) for (ll i = init; i < (n); i++)
int main()
{
int a, b, c;
cin >> a >> b >> c;
cout << (a <= c && c <= b || b <= c && c <= a ? "Yes" : "No") << endl;
return 0;
} | 1 |
/*
g++ --std=c++17 A.cpp
*/
#include <iostream>
#include <iomanip> //! for setprecision(20)
#include <math.h>
#include <algorithm>
#include <functional>
#include <string>
#include <vector>
#include <cstring>
#include <set>
#include <map>
#include <queue>
#include <utility>
#include <limits.h>
#include <atcoder/all>
using namespace std;
using namespace atcoder;
typedef long long LL;
#define rep(i,n) for (int i = 0; i < int(n); ++i)
#define dump(c) { for (auto it = c.begin(); it != c.end(); ++it) if (it == c.begin()) cout << *it; else cout << ' ' << *it; cout << endl; }
#define dumpMap(m) { for (auto it: m) cout << it.first << "=>" << it.second << ' '; }
const int MOD = 1000000007;
using mint = static_modint<MOD>;
/*
== AC Library Cheat sheet
documentation: file:///Users/nobu/Downloads/ac-library/document_ja/index.html
mint
mint m.pow(int p) //! return m^p
mint m.inv() //! returns i that gives (m * i).val() == 1
int m.val()
fenwick_tree (BIT)
fenwick_tree<T> fw(int n) //! init a[0] .. a[n-1] with all 0
void fw.add(int idx, T x); //! a[idx] += x
T fw.sum(int l, int r); //! return a[l] + .. + a[r-1]
dsu (UnionFind)
dsu d(int n) //! prepare dsu with n nodes
void d.merge(int x, int y) //! connect node x and y
bool d.same(int x, int y) //! return true if node x and y are connected
int d.leader(int x) //! return the leader node of the connected group
int d.size(int x) //! return the size of the group that node x belongs to
vector<vector<int>> d.groups() //! return a vector of vectors that contain the nodes in each group
*/
int main()
{
cin.tie(0);
ios::sync_with_stdio(0);
int n, q;
cin >> n >> q;
fenwick_tree<LL> fw(n);
rep(i, n) {
int a;
cin >> a;
fw.add(i, a);
}
rep(i, q) {
int t;
cin >> t;
if (t == 0) {
int p, x;
cin >> p >> x;
fw.add(p, x);
} else if (t == 1) {
int l, r;
cin >> l >> r;
cout << fw.sum(l, r) << endl;
}
}
return 0;
}
| #include <algorithm>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <iomanip>
#include <map>
#include <numeric>
#include <stack>
#include <string>
#include <vector>
#define _GLIBCXX_DEBUG
using namespace std;
using ll = long long;
int main()
{
int n,m;
cin >> n >> m;
int max = 0,min = 1e9;
vector<vector<int>> G(m,vector<int>(2));
for (int i = 0; i < m; i++)
{
for (int j = 0; j < 2; j++)
{
cin >> G[i][j];
}
if (max < G[i][0])
{
max = G[i][0];
}
if (min > G[i][1])
{
min = G[i][1];
}
}
if (max > min)
{
cout << "0" << endl;
}else{
cout << min-max+1 << endl;
}
} | 0 |
#include <iostream>
#include <algorithm>
using namespace std;
int main(void){
int a,b,c;
while(cin>>a>>b>>c && (a||b||c)){
int i,n;
cin>>n;
int res[a+b+c+1];
int tmp[n][3];
fill(res,res+a+b+c+1,2);
for(i=0;i<n;i++){
int I,J,K,R;
cin>>I>>J>>K>>R;
if(R == 1){
res[I] = res[J] = res[K] = 1;
i--;
n--;
}
else{
tmp[i][0] = I;
tmp[i][1] = J;
tmp[i][2] = K;
}
}
int size = i;
for(i=0;i<size;i++){
if(res[tmp[i][0]] == 1 && res[tmp[i][1]] == 1) res[tmp[i][2]] = 0;
else if(res[tmp[i][0]] == 1 && res[tmp[i][2]] == 1) res[tmp[i][1]] = 0;
else if(res[tmp[i][1]] == 1 && res[tmp[i][2]] == 1) res[tmp[i][0]] = 0;
}
for(i=1;i<=a+b+c;i++){
cout<<res[i]<<endl;
}
}
return 0;
} | #include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
struct Data
{
int p[3], r;
};
int main()
{
int a, b, c;
while(scanf("%d%d%d", &a, &b, &c), a){
int n;
scanf("%d", &n);
vector<int> state(a+b+c, 2);
vector<Data> d(n);
for(int i=0; i<n; ++i){
for(int j=0; j<3; ++j){
scanf("%d", &d[i].p[j]);
d[i].p[j]--;
}
scanf("%d", &d[i].r);
if(d[i].r == 1){
for(int j=0; j<3; ++j)
state[d[i].p[j]] = 1;
}
}
for(int i=0; i<n; ++i){
if(d[i].r == 0){
for(int j=0; j<3; ++j){
if(state[d[i].p[j]]==1 && state[d[i].p[(j+1)%3]]==1 && state[d[i].p[(j+2)%3]]==2){
state[d[i].p[(j+2)%3]] = 0;
break;
}
}
}
}
for(int i=0; i<a+b+c; ++i)
printf("%d\n", state[i]);
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int E[N];
int main() {
int n;
string s;
cin >> n >> s;
for (int i = n - 1; i >= 0; i--) {
E[i] = E[i+1] + (s[i] == 'E');
}
int W = 0, res = n;
for (int i = 0; i < n; i++) {
res = min(res, W + E[i+1]);
W += s[i] == 'W';
}
cout << res;
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int n, q, t, cnt = 0;
cin >> n;
int s[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
}
cin >> q;
for (int i = 0; i < q; i++) {
cin >> t;
for (int j = 0; j < n; j++) {
if (t == s[j]) {
cnt += 1;
break;
}
}
}
cout << cnt << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
int a[n + 2];
memset(a, 0, sizeof a);
for (int i = 0; i < m ; i++)
{
int x, y;
cin >> x >> y;
a[x]++;
a[y + 1] --;
}
for(int i = 1; i <= n; ++i){
a[i] += a[i-1];
}
int count = 0;
for(int i = 1; i <= n; ++i){
if(a[i] == m){
count++;
}
}
cout << count << endl;
}
| #include<bits/stdc++.h>
using namespace std;
#define flash ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define F first
#define S second
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define endl "\n"
#define int long long int
#define ll long long
#define ld long double
#define vi vector<int>
#define vvi vector<vector<int>>
#define Yes() cout << "Yes" << endl
#define YES() cout << "YES" << endl
#define No() cout << "No" << endl
#define NO() cout << "NO" << endl
const int mod = 1000000007;
const int N=200005;
const int inf=1e18;
vector<vector<int>>adj(N);
bool isPrime(ll n){if(n<2)return false;for(ll i=2;i*i<=n;++i){if(n%i==0){return false;}}return true;}
ll power(ll x,ll y){ll res=1;x=x;while(y>0){if(y&1)res=(res*x)%mod;y=y>>1;x=(x*x)%mod;}return res%mod;}
ll gcd(ll a,ll b){if (a==0)return b;return gcd(b%a,a);}
void fun(){
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
}
signed main(){
flash;
fun();
int t=1;
//cin>>t;
while(t--){
int n,m;
cin>>n>>m;
int l,r;
int ans1=-inf,ans2=inf;
while(m--){
cin>>l>>r;
ans1=max(l,ans1);
ans2=min(ans2,r);
}
int ans=ans2-ans1+1;
if(ans>0)
cout<<ans<<endl;
else
{
cout<<0;
}
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll N=42, Max=(1<<17)+10, MOD=1e9+7;
ll n, x, y, z, f[N][Max], sum=1, ans;
inline ll M(ll a){return a%MOD;}
void work(){
for(int i = 0; i < n; i++) sum = M(sum*10);
ll cnt = (1<<x+y+z) -1;
ll tot = (1<<x-1) | (1<<x+y-1) | (1<<x+y+z-1);
f[0][0] = 1;
for(int i = 1; i <= n; i++)
for(int j = 0; j <= cnt; j++)
for(int h = 1;h <= 10; h++){
ans = (j<<h)|(1<<h-1);
ans &= cnt;
if((ans&tot)!=tot) f[i][ans] = M(f[i][ans]+f[i-1][j]);
}
for(int i = 0; i <= cnt; i++)
sum = M(sum-f[n][i]+MOD);
}
int main(){
scanf("%lld%lld%lld%lld",&n,&x,&y,&z);
work();
printf("%lld",sum);
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define ll long long
const ll mod = 998244353;
vector<ll> fac(200005);
vector<ll> ifac(200005);
ll modpow(ll x, ll n){
ll ans = 1;
while(n != 0){
if(n & 1)
ans = ans * x % mod;
x = x * x % mod;
n = n >> 1;
}
return ans;
}
ll comb(ll a, ll b){
if(a == 0 && b == 0)
return 1;
if(a < b || a < 0)
return 0;
ll tmp = ifac[a - b] * ifac[b] % mod;
return tmp * fac[a] % mod;
}
int main(){
int n, m, k;
cin >> n >> m >> k;
fac[0] = 1;
ifac[0] = 1;
for(ll i = 0; i < n; i++){
fac[i + 1] = fac[i] * (i + 1) % mod;
ifac[i + 1] = ifac[i] * modpow(i + 1, mod - 2) % mod;
}
ll ans = 0;
n--;
for(int i = 0; i <= k; i++){
ll p = modpow(m - 1, n - i) * comb(n, i) % mod;
ans = (ans + p) % mod;
}
ans = ans * m % mod;
cout << ans << endl;
return 0;
} | 0 |
/*
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\ = /O
____/`---'\____
.' \| |// `.
/ \||| : |||// \
/ _||||| -:- |||||- \
| | \\ - /// | |
| \_| ''\---/'' | |
\ .-\__ `-` ___/-. /
___`. .' /--.--\ `. . __
."" '< `.___\_<|>_/___.' >'"".
| | : `- \`.;`\ _ /`;.`/ - ` : | |
\ \ `-. \_ __\ /__ _/ .-` / /
======`-.____`-.___\_____/___.-`____.-'======
`=---='
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
pass the Test!
*/
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
using Map = map<string,ll>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
ll INF=1LL<<60;
ll MOD=1000000007;
int main(){
ll N;
cin >> N;
ll M;
cin >> M;
ll V;
cin >> V;
ll P;
cin >> P;
vector<ll> A(N,0);
for(ll i=0;i<N;i++){
cin>>A[i]
;}
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
vector<ll> ikou(N+1,0);
for(ll i=N-1;i>=0;i--){
ikou[i]=ikou[i+1]+A[i]
;}
ll ans=P-1;
for(ll i=P;i<N;i++){
if(A[P-1]-A[i]<=M&&M*V-M*(N-i+P-1)<=(A[i]+M)*(i-P+1)-(ikou[P-1]-ikou[i]))ans=i;
else break;
;}
cout<<ans+1<<endl;
return 0;
}
| #include <iostream>
#include <iomanip>
#include <algorithm>
#include <complex>
#include <utility>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#include <tuple>
#include <cmath>
#include <bitset>
#include <cctype>
#include <set>
#include <map>
#include <numeric>
#include <functional>
#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define PRINT(V) cout << V << "\n"
#define SORT(V) sort((V).begin(),(V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
using namespace std;
using ll = long long;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
inline void Yes(bool condition){ if(condition) PRINT("Yes"); else PRINT("No"); }
template<class itr> void cins(itr first,itr last){
for (auto i = first;i != last;i++){
cin >> (*i);
}
}
template<class itr> void array_output(itr start,itr goal){
string ans = "",k = " ";
for (auto i = start;i != goal;i++) ans += to_string(*i)+k;
if (!ans.empty()) ans.pop_back();
PRINT(ans);
}
ll gcd(ll a, ll b) {
return a ? gcd(b%a,a) : b;
}
const ll INF = 1e10;
const ll MOD = 100000000;
const ll MOD2 = 998244353;
typedef pair<ll,ll> P;
const ll MAX = 100;
constexpr ll nx[8] = {1,0,-1,0,-1,-1,1,1};
constexpr ll ny[8] = {0,1,0,-1,-1,1,-1,1};
typedef pair<ll,ll> P;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
ll n,m,v,p;
cin >> n >> m >> v >> p;
vector<ll> a(n);
cins(all(a));
SORT(a);
v--;
ll l = -1,r = n-1;
while(r-l > 1){
vector<ll> b = a;
ll mid = (l+r)/2;
b[mid] += m;
ll cnt = 0,same = 0,big = 0;
vector<ll> mod;
rep(i,n){
if (i == mid) continue;
if (b[mid] > b[i]){
if (b[mid]-b[i] >= m) cnt += m;
else{
cnt += b[mid]-b[i];
mod.push_back(m-(b[mid]-b[i]));
}
}
else if (b[mid] == b[i]){
same++;
}
else{
big++;
cnt += m;
}
}
RSORT(mod);
if (cnt >= v*m){
//NONE
}
else if (cnt+same*m >= v*m){
ll s = v*m-cnt;
big += (s%m ? s/m+1 : s/m);
}
else{
ll s = v*m-(cnt+same*m);
big += same;
ll i = 0;
while(s > 0){
s -= mod[i];
big++;
i++;
}
}
if (big < p) r = mid;
else l = mid;
//PRINT(a[mid] << " " << cnt << " " << same << " " << big);
}
//PRINT(a[r]);
PRINT(a.end()-lower_bound(all(a),a[r]));
}
| 1 |
#include <iostream>
#include <vector>
using namespace std;
int main(void){
int n,t;
cin>>n>>t;
vector<int>time(n);
for(int i=0;i<n;i++){
cin>>time[i];
}
int dif;
long long sum=t;
for(int i=1;i<n;i++){
dif=time[i]-time[i-1];
if(dif<=t)sum+=dif;
else sum+=t;
}
cout<<sum<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
#define txt \
freopen("ip.txt", "r", stdin); \
freopen("op.txt", "w", stdout)
#define a3 INT_MAX
#define i3 INT_MIN
#define a6 INT64_MAX
#define i6 INT64_MIN
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define fo(i, n) for (int i = 0; i < (int)n; i++)
#define rep(i, k, n) for (int i = k; k < (int)n ? i < (int)n : i > (int)n; k < (int)n ? i += 1 : i -= 1)
#define quickie \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
#define div2(a) (!(a & 1))
#define deb(x) cout << (#x) << " " << (x) << "\n";
#define newl cout << "\n"
#define all(s) s.begin(), s.end()
#define pi 3.14159265358979323846
#define fp(x) fixed << setprecision(x) <<
template <class T>
T mod(T a)
{
if (a < 0)
{
a += 1000000007;
}
return a % 1000000007;
}
template <class T>
T addmod(T a, T b)
{
return (mod(a) + mod(b)) % 1000000007;
}
template <class T>
T prodmod(T a, T b)
{
return (mod(a) * mod(b)) % 1000000007;
}
template <class T>
T bin_exp(T a, T b)
{
T res = 1;
T temp = 1;
if (b <= 1)
return a;
if (b % 2 == 0)
res = bin_exp(a * a, b / 2);
else
{
res *= a;
temp = bin_exp(a, --b);
}
return res * temp;
}
template <class T>
T bin_expmod(T a, T b)
{
T res = 1;
T temp = 1;
if (b <= 1)
return a;
if (b % 2 == 0)
res = bin_expmod(prodmod(a, a), b / 2);
else
{
res = prodmod(a, res);
temp = bin_exp(a, --b);
}
return prodmod(res, temp);
}
template <class T>
int digit(T a)
{
vector<long long> dig = {
0,
9,
99,
999,
9999,
99999,
999999,
9999999,
99999999,
999999999,
9999999999,
99999999999,
999999999999,
9999999999999,
99999999999999,
999999999999999,
9999999999999999,
99999999999999999,
999999999999999999,
INT64_MAX};
auto it = lower_bound(dig.begin(), dig.end(), a);
int idx = (it - dig.begin());
return idx;
}
template <class T>
int sumAllInts(T n)
{
int a = 1;
int su = 0;
while (n)
{
su += n % 10;
n /= 10;
}
return su;
}
template <class T>
void split(char c, T s)
{
int n = s.size();
int i = 0;
while ((cout << s[i], i += 1) && (i < n) && (cout << c << ' '))
;
}
void print(vi &vec)
{
for (int i = 0; i < vec.size(); i++)
{
cout << vec[i] << " ";
}
}
void solve()
{
int n,t;
cin>>n>>t;
int temp;cin>>temp;
ll ans = t;
fo(i,n-1){
int te; cin>>te;
int diff = te - temp;
ans+=min(diff,t);
temp = te;
}
cout<<ans;
}
int main()
{
quickie;
//txt;
int t = 1;
while (t--)
{
solve();
newl;
}
return 0;
} | 1 |
#include <iostream>
#include <vector>
int main() {
int n;
std::vector<int> v;
std::cin >> n; //skip
while (std::cin >> n) {
v.push_back(n);
}
for (auto&& e = v.crbegin(); e != v.crend(); ++e) {
std::cout << ((e == v.crbegin()) ? "" : " ") << *e;
}
std::cout << std::endl;
}
| #include<iostream>
using namespace std;
int main(){
int array[110]={};
int n;
cin>>n;
for(int i=0;i<n;i++){
cin>>array[i];
}
for(int i=n-1;i>=1;i--){
cout<<array[i]<<" ";
}
if(n != 0){
cout<<array[0]<<endl;
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
using Long = long long;
int main(){
int n;
cin >>n;
vector<int> v(n);
for( auto &i : v ) cin >> i;
int mx = 0;
Long ans = 0LL;
for( int i = 0 ; i < n ; ++i ){
mx = max( mx , v[i]);
ans += 1LL * ( mx - v[i] );
}
cout << ans << endl;
return 0;
} | #include<iostream>
#include <algorithm>
#include <cmath>
#include <set>
#include<map>
#include<cstring>
#include<iomanip>
#include <string>
#include <vector>
#include<unordered_map>
#include<unordered_set>
using namespace std;
typedef long long unsigned llu;
typedef long double ld;
#define ll long long
#define PI 3.14159265358979323846
#define For(i, a, b) for (int i = a, sz = (int)b; i < sz; i++)
#define rFor(i, a, b, c) for (int i = (a); i >= (b); i -= (c))
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define fill(a, b) memset(a, b, sizeof(a))
#define IO ios_base::sync_with_stdio(false), cin.tie(0),cout.tie(0)
const int mod = 1000000007;
const ll inf = 1000000000009;
ll gcd(ll a,ll b) { return b?gcd(b,a%b):a;}
ll lcm(ll a,ll b) { return a*b/gcd(a,b);}
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdoutn
int main()
{
IO;
int n{};
cin>>n;
vector<ll>v(n);
For(i,0,n)cin>>v[i];
ll ans{};
For(i,1,n)
{
if(v[i]<v[i-1])ans+=v[i-1]-v[i],v[i]=v[i-1];
}
cout<<ans<<'\n';
// system("pause");
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int D,l,cnt[100];
ll pw[100],v[100];
int getlen(ll x){
int len=0;
while(x)++len,x/=10;
return len;
}
ll dfs(int i,ll now){
if(i==l/2)return now==D;
ll ret=0;
for(int d=-9;d<=9;++d){
ll nxt=now+v[i]*d;
if(abs(nxt-D)>v[i])continue;
ret+=(cnt[d+9]-(i==0&&d>=0))*dfs(i+1,nxt);
}
return ret;
}
int main(){
scanf("%d",&D);
for(int i=pw[0]=1;i<19;++i)pw[i]=10*pw[i-1];
for(int i=0;i<=9;++i)for(int j=0;j<=9;++j)++cnt[i-j+9];
int ld=getlen(D);
ll ans=0;
for(l=ld;l<=2*ld;++l){
for(int i=0;i<=(l-1)/2;++i)v[i]=pw[l-i-1]-pw[i];
ll tmp=dfs(0,0);
if(l%2)tmp*=10;
ans+=tmp;
}
printf("%lld\n",ans);
return 0;
}
| #include <iostream>
#include <cstring>
#include <cmath>
using namespace std;
typedef long long ll;
ll Power[20];
ll dfs(ll l , ll r , ll d) {
if(l >= r) {
if(d == 0) return l == r ? 10 : 1;
return 0;
}
if(d % 10 == 0) {
if(l != 1) return 10 * dfs(l + 1 , r - 1 , d / 10);
return 9 * dfs(l + 1 , r - 1 , d / 10);
}
ll differ = d % 10 - 10;//选取的数一定要使l位进1否则取反之后的必定小与改数，那么显然不可能。所以differ是d % 10 - 10
ll next = d - differ + differ * Power[r - l];//这里先让d进一位，然后由于对称性，r位+differ=l位+differ所以选择+ differ * Power[r - l]，这样才能满足对称条件
if(l == 1) return (9 + differ) * dfs(l + 1 , r - 1 , abs(next) / 10);
return (10 + differ) * dfs(l + 1 , r - 1 , abs(next) / 10);
}
int main() {
ll d;
cin >> d;
Power[0] = 1;
for(int i = 1 ; i <= 18 ; i++) {
Power[i] = Power[i - 1] * 10;
}
ll ans = 0;
for(int i = 2 ; i <= 18 ; i++) {
ans += dfs(1 , i , d);
}//这里选择18位由于原来的数也就最多9位，如果取得数位数是两倍的话显然是不可能的。
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n , dp[5005][5005];
pair<ll,ll> a[5005];
bool cmp(pair<ll,ll> x,pair<ll,ll> y){
return x.first+x.second < y.first+y.second;
}
int main(){
ios_base:: sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
cin>>n;
for(ll i=0;i<n;i++)cin>>a[i].first>>a[i].second;
sort(a,a+n,cmp);
memset(dp,0x3f,sizeof(dp));
dp[0][0]=0;
for(ll i=0;i<n;i++){
for(ll j=0;j<=i;j++){
if(dp[i][j]<=a[i].first)
dp[i+1][j+1]=min(dp[i+1][j+1] , dp[i][j] + a[i].second);
dp[i+1][j]=min(dp[i+1][j],dp[i][j]);
}
}
for(ll i=n;i>=0;i--)if(dp[n][i]<(1e16))return cout<<i , 0;
} |
#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <list>
#include <numeric>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define int long long int
#define rep(i, n) for (int i = 0; i < n; ++i)
#define all(x) (x).begin(), (x).end()
#define capi(x) int x;cin>>x
#define fastio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
using vi = vector<int>;
using pi = pair<int, int>;
using vp = vector<pi>;
template<class T>bool chmax(T &a, const T &b){if(a<b){a=b;return 1;}return 0;}
template<class T>bool chmin(T &a, const T &b){if(b<a){a=b;return 1;}return 0;}
#define P (1'000'000'007)
signed main() {
int d, g;
cin >> d >> g;
vi vs;
vp vc;
rep(i, d) {
int p, c;
cin >> p >> c;
vs.push_back(p - 1);
vc.push_back(make_pair(p, (i + 1) * 100 * p + c));
}
int ans = INT_MAX;
rep(i, 1 << d) {
int cost = g;
int res = 0;
rep(j, d) {
if (((1 << j) & i) > 0) {
cost -= vc[j].second;
res += vc[j].first;
}
}
for (int j = d - 1; j >= 0; --j) {
if (cost <= 0) break;
if(((1 << j) & i) > 0) continue;
int x = min(vs[j], 1 + (cost - 1) / ((j + 1) * 100));
res += x;
cost -= x * (j + 1) * 100;
}
if (cost <= 0) {
chmin(ans, res);
}
}
cout << ans;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vll vector<ll>
#define vpii vector<pair<int,int>>
#define vpll vector<pair<ll,ll>>
#define fr(i,k,n) for (int i = k; i < n; ++i)
#define fri(i,k,n) for (int i = k; i >= n; --i)
#define INF (int)1e9
#define MOD 1000000007
#define pb push_back
#define mp make_pair
#define all(arr) arr.begin(),arr.end()
void boost(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
const int N=5e5+5;
ll tree[N];
ll read(int idx) {
ll sum = 0;
while (idx > 0) {
sum += tree[idx];
idx -= (idx & -idx);
}
return sum;
}
void update(int idx, ll val) {
while (idx <N) {
tree[idx] += val;
idx += (idx & -idx);
}
}
void solve(){
int n,q;
cin>>n>>q;
int x;
fr(i,1,n+1){
cin>>x;
update(i,x);
}
int t,l,r;
while(q--){
cin>>t>>l>>r;
if(t==0){
update(l+1,r);
}
else{
cout<<read(r)-read(l)<<endl;
}
}
return;
}
int main()
{
boost();
int tc=1;
//cin>>tc;
while(tc--)
solve();
return 0;
} | #include<bits/stdc++.h>
#include<atcoder/fenwicktree>
using ll = int_fast64_t;
#define REP(i,b,e) for(ll i=b; i<e; i++)
int main(){
int n, q;
scanf("%d %d", &n, &q);
atcoder::fenwick_tree<ll> bit(n);
REP(i, 0, n){
ll a;
scanf("%ld", &a);
bit.add(i, a);
}
REP(i, 0, q){
ll t, x, y;
scanf("%ld %ld %ld", &t, &x, &y);
if(t==0) bit.add(x, y);
else printf("%ld\n", bit.sum(x, y));
}
return 0;
}
| 1 |
#include <cmath>
#include <cstring>
#include <iostream>
#include <ostream>
#include <vector>
using std::cin;
using std::cout;
using std::cerr;
using std::endl;
template <typename T>
std::ostream& operator<<(std::ostream& os, std::vector<T> v) {
os << "[";
for(int i = 0; i < int(v.size()); i++) {
os << v[i] << (i == int(v.size()) - 1 ? "" : ", ");
}
os << "]";
return os;
}
// n 以下の素数のリストを返す O(nlog(log(n)))
std::vector<int> eratosthenes(int n) {
std::vector<int> is_prime(n + 1, 1);
std::vector<int> primes;
is_prime[0] = is_prime[1] = 0;
primes.push_back(2);
for(int i = 3; i <= n; i += 2) {
if(is_prime[i]) {
primes.push_back(i);
for(int j = 3; i * j <= n; j += 2) {
is_prime[i * j] = 0;
}
}
}
return primes;
}
int main() {
int n;
std::vector<int> primes = eratosthenes(10000);
while(cin >> n, n) {
int a = 2, b = 3;
for(int i = 1; i < primes.size(); i++) {
if (primes[i] > n) break;
if(primes[i] - primes[i - 1] == 2) {
a = primes[i - 1];
b = primes[i];
}
}
cout << a << " " << b << endl;
}
return 0;
}
| #include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <bitset>
#include <cstring>
#include <string.h>
#include <cmath>
#include <queue>
#include <string>
#include <stack>
#include <utility>
#include <queue>
#include <cmath>
#define mp make_pair
#define pii pair<int,int>
#define ff first
#define ss second
#define ll long long
#define vi vector<int>
using namespace std;
ll _sieve_size;
bitset<10000010> bs;
vi primes;
void sieve(ll upperbound) {
_sieve_size = upperbound + 1;
bs.set();
bs[0] = bs[1] = 0;
for (ll i = 2; i <= _sieve_size; i++) if (bs[i]) {
for (ll j = i * i; j <= _sieve_size; j += i) bs[j] = 0;
primes.push_back((int)i);
} }
bool isPrime(ll N) {
if (N <= _sieve_size) return bs[N];
for (int i = 0; i < (int)primes.size(); i++)
if (N % primes[i] == 0) return false;
return true;
}
int a;
int main()
{
sieve(11000);
while(1)
{
scanf("%d",&a);
if(a==0)break;
if(a%2==0)
a-=3;
else
a-=2;
//printf("%d",b);
while(1)
{
if(isPrime(a)&&isPrime(a+2))
{
printf("%d %d\n",a,a+2);
break;
}
a-=2;
}
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(i, n) for(int i = 0; i < (int)(n); i++)
const int MOD = (int)1e9 + 7;
const int INF = (int)1e9 * 2;
int main() {
int a[3];
rep(i, 3) cin >> a[i];
int k;
cin >> k;
sort(a, a + 3, greater<int>());
ll out = a[0] * pow(2, k) + a[1] + a[2];
cout << out << endl;
}
| #include <bits/stdc++.h>
#define rep(i, start, end) for (long long i = start; i < end; ++i)
#define repreverse(i, start, end) for (long long i = start; i >= end; --i)
#define all(x) (x).begin(), (x).end()
#define len(x) ((long long)(x).size())
#define lcm(a, b) ((a) / __gcd((a), (b)) * (b))
using namespace std;
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vllvll = vector<vll>;
using pll = pair<ll, ll>;
template<class T>void print1d(T x,ll n=-1){if(n==-1)n=x.size();rep(i,0,n){cout<<x[i]<<' ';}cout<<'\n';}
template<class T>void print2d(T x,ll r=-1,ll c=-1){if(r==-1)r=x.size();if(c==-1)c=x[0].size();rep(i,0,r)print1d(x[i],c);}
template<class T, class U>bool haskey(T mp, U key) { return mp.find(key) != mp.end(); }
template<class T, class U>bool isin(T el, U container) { return find(all(container), el) != container.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>bool even(T n) { return ! (n & 1); }
template<class T>bool odd(T n) { return n & 1; }
template<class T>ld deg2rad(T deg) { return M_PI * deg / 180.0; }
template<class T>ld rad2deg(T rad) { return 180.0 * rad / M_PI; }
ll intpow(ll a,ll n){ll p=1;while(n){if(n&1)p*=a;a*=a;n>>=1;}return p;}
const long double pi = M_PI;
const long long big = 1LL << 50;
const long long inf = 1LL << 60;
const long long mod = 1e9 + 7;
int main()
{
vll nums(3);
cin >> nums[0] >> nums[1] >> nums[2];
ll K;
cin >> K;
rep(i, 0, K) {
*max_element(all(nums)) *= 2;
}
cout << accumulate(all(nums), 0LL) << endl;
} | 1 |
#include <iostream>
#include <vector>
using namespace std;
int simulate(vector<long long int> A){
int N = A.size(), ret = 0;
while(1){
int t = 0;
for(int i = 0; i < N; ++i){
if(A[i] > A[t]) t = i;
}
if(A[t] < N) break;
for(int i = 0; i < N; ++i){
if(i != t) ++A[i];
else A[i] -= N;
}
++ret;
}
return ret;
}
int main(){
long long int K, M = 1e16 + 1e3 + 1;
cin >> K;
vector<long long int> A(50);
for(long long int i = 0; i < 50; ++i) A[i] = i + K/50;
K %= 50;
for(int i = 0; i < K; ++i) ++A[49-i];
//cout << simulate(A) << endl;
cout << 50 << endl;
cout << A[0];
for(int i = 1; i < 50; ++i) cout << " " << A[i];
cout << endl;
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
vector<int> permMul(const vector<int>& a, const vector<int>& b){
vector<int> res(a.size());
for(int i=0;i<a.size();i++) res[i] = a[b[i]];
return res;
}
vector<int> permPow(const vector<int>& p, long long K){
if(K == 0){
vector<int> res = p;
for(int i=0;i<res.size();i++) res[i] = i;
return res;
}
vector<int> half = permPow(p, K/2);
vector<int> res = permMul(half, half);
if(K%2 == 1) res = permMul(res, p);
return res;
}
int main(){
int N;
while(cin >> N){
vector<long long> x(N);
for(auto& t : x) cin >> t;
vector<long long> d(N-1);
for(int i=0;i<N-1;i++) d[i] = x[i+1] - x[i];
int M; long long K;
cin >> M >> K;
vector<int> s(N-1);
for(int i=0;i<N-1;i++) s[i] = i;
for(int i=0;i<M;i++){
int a; cin >> a;
swap(s[a-2], s[a-1]);
}
cout << x[0] << endl;
s = permPow(s, K);
for(int i=1;i<N;i++){
x[i] = x[i-1] + d[s[i-1]];
cout << x[i] << endl;
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define rep(i,n) for( int i = 0; i < n; i++ )
#define REP(i,s,t) for( int i = s; i < t; i++ )
#define dump(x) cerr << #x << " = " << (x) << endl;
#define INF 2000000000
#define mod 1000000007
#define INF2 1000000000000000000
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int N;
cin >> N;
int x[N], y[N];
rep(i, N) cin >> x[i] >> y[i];
int cnt[N] = {};
rep(i, 250000) {
double maxd = -INF;
int index = 0;
double theta = (i/125000.0) * M_PI;
rep(j, N) {
if (maxd < x[j] * cos(theta) + y[j] * sin(theta)){
index = j;
maxd = x[j] * cos(theta) + y[j] * sin(theta);
}
}
cnt[index]++;
}
cout << fixed;
rep(i, N) cout << cnt[i] / 250000.0 << endl;
return 0;
}
| #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
using P = pair<ll, ll>;
using mat = vector<vector<ll>>;
void IOS() { ios::sync_with_stdio(false), cin.tie(0); }
const ll INF = 1e16;
const ll MOD = 1e9 + 7;
const ld EPS = 1e-10;
template <typename T> void dump(T x) { cout << x << endl; }
void dumpf(ld x, int t) { cout << setprecision(t) << fixed << x << endl; }
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
fill((T *)array, (T *)(array + N), val);
}
ll mod(ll a, ll b) {
if (a > 0) return a % b;
if (a % b == 0) return 0;
ll x = -a / b + 1;
a += x * b;
return a % b;
}
// ll dx[4] = {1, 0, -1, 0};
// ll dy[4] = {0, 1, 0, -1};
// ll pas[5001][5002];
ld add(ld a, ld b) {
if (abs(a + b) < EPS * (abs(a) + abs(b))) return 0;
return a + b;
}
struct Point {
ld x, y;
int num;
Point() {}
Point(ld x, ld y) : x(x), y(y) {}
Point(ld x, ld y, int n) : x(x), y(y), num(n) {}
Point operator+(const Point &p) { return Point(add(x, p.x), add(y, p.y)); }
Point operator-(const Point &p) {
return Point(add(x, -p.x), add(y, -p.y));
}
bool operator==(const Point &p) { return x == p.x && y == p.y; }
bool operator!=(const Point &p) { return *this == p; }
bool operator<(const Point &p) {
if (x != p.x)
return x < p.x;
else
return y < p.y;
}
friend Point operator*(ld k, const Point &p) {
return Point(k * p.x, k * p.y);
}
ld dot(const Point &p) { return add(x * p.x, y * p.y); }
ld det(const Point &p) { return add(x * p.y, -y * p.x); }
};
vector<Point> convex_hull(vector<Point> p) {
sort(p.begin(), p.end());
int n = p.size();
int k = 0;
vector<Point> q(2 * n);
for (int i = 0; i < n; i++) {
while (k > 1 && (q[k - 1] - q[k - 2]).det(p[i] - q[k - 1]) <= 0) k--;
q[k++] = p[i];
}
for (int i = n - 2, t = k; i >= 0; i--) {
while (k > t && (q[k - 1] - q[k - 2]).det(p[i] - q[k - 1]) <= 0) k--;
q[k++] = p[i];
}
q.resize(k - 1);
return q;
}
ld dist(Point p1, Point p2) { return (p1 - p2).dot(p1 - p2); }
ld dif(Point p1, Point p2) { return sqrt(dist(p1, p2)); }
ld longestdist(vector<Point> t) {
int n = t.size();
ld M = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) { M = max(M, dist(t[i], t[j])); }
}
return M;
}
int main() {
IOS();
ll n;
cin >> n;
vector<Point> p(n);
vector<ld> ans(n, 0);
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
p[i] = Point(x, y, i);
}
vector<Point> q = convex_hull(p);
int m = q.size();
for (int j = 0; j < m; j++) {
ld costh = (q[mod(j - 1, m)] - q[j]).dot(q[mod(j + 1, m)] - q[j]);
costh /= dif(q[mod(j - 1, m)], q[j]) * dif(q[mod(j + 1, m)], q[j]);
if (abs(costh - 1) <= EPS) costh = 1.0;
if (abs(costh + 1) <= EPS) costh = -1.0;
ans[q[j].num] = (M_PI - acos(costh)) / (2 * M_PI);
}
for (int i = 0; i < n; i++) { dumpf(ans[i], 8); }
return 0;
} | 1 |
#include<bits/stdc++.h>
#define DBG(x) cerr << #x << “ = ” << (x) << endl
#define Rep(i,a,b) for (int i = a, to = b; i < to; i++)
#define pb push_back
#define all(v) v.begin(), v.end()
#define sz(v) (int)v.size()
typedef long long Long;
using namespace std;
int main(){
ios::sync_with_stdio(0);
cin.tie(NULL);
Long n,x,t;
cin>>n>>x>>t;
cout<<((n+x-1)/x)*t;
return 0;
} | #define _USE_MATH_DEFINES
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string>
#include <sstream>
#include <iomanip>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <algorithm>
#include <stack>
#include <queue>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <bitset>
#include <utility>
#include <numeric>
#include <iterator>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ldouble = long double;
const ll inf = 1ll << 60;
const ll mod = (ll)1e9 + 7;
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define print(s) cout << s;
#define println(s) cout << s << endl;
#define printd(s) cout << fixed << setprecision(10) << s << endl;
int main()
{
vector<string> a(3);
string res = "YES";
for (ll i = 0; i < 3; i++)
{
cin >> a[i];
if (i > 0)
{
if (a[i - 1].back() != a[i].front())
{
res = "NO";
}
}
}
println(res);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#ifdef KACTL
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define sz(x) (int)(x).size()
#endif
#define all(x) begin(x), end(x)
using ll = int64_t;
using ld = long double;
using pii = pair<int32_t, int32_t>;
using vi = vector<int32_t>;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
int h, w, a, b;
cin >> h >> w >> a >> b;
/* h = w, a = b
* do the jagged thing
*
* XX.
* .XX
* X.X
*
* XX..
* .XX.
* ..XX
* X..X
*
*
* some can be 1s and some can be zeros
* 2 4 1 1
*
* 3 3 1 1
*/
vector<string> res(h, string(w, '0'));
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
res[i][j] ^= (i < b) ^ (j < a);
}
}
for (auto& row : res)
cout << row << '\n';
return 0;
}
| #include <iostream>
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
int main(void) {
int H, W, A, B;
cin >> H >> W >> A >> B;
if ((H / 2) < B || (W / 2) < A) {
cout << -1 << endl;
return 0;
}
rep(i, H) {
char out = '0';
if (i >= B) out = '1';
rep(j, W) {
if (j < A)
cout << out;
else
cout << ((out == '0') ? '1' : '0');
}
cout << endl;
}
return 0;
} | 1 |
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
int A, B, C, D, E, F;
cin >> A >> B >> C >> D >> E >> F;
cout << max(E, F) + max({ A + B + C, A + B + D, A + C + D, B + C + D }) << endl;
}
| #include<bits/stdc++.h>
#define rep(i, n) for (int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
int main(void){
int h, w, a, b;
cin>>h>>w>>a>>b;
vector<vector<int> > v(h, vector<int>(w));
if(w/2>=a && h/2>=b){
vector<int> s1(w);
vector<int> s2(w);
rep(i, a){
s1[i] = 1;
}
for(int i = a;i<=w-1;i++){
s2[i] = 1;
}
rep(i, b){
v[i] = s1;
}
for(int i = b;i<=h-1;i++){
v[i] = s2;
}
rep(i, h){
rep(j, w) cout<<v[i][j];
cout<<endl;
}
}
else cout<<"No"<<endl;
return 0;
} | 0 |
// -*- mode:c++; coding:utf-8; indent-tabs-mode:nil; -*-
// ALDS1_2-D
#include <algorithm>
#include <cstdio>
static void print_ints(const int as[], const unsigned int n,
const char* sep = " ") {
const char* out_sep = "";
for (unsigned int i = 0; i < n; ++i) {
std::printf("%s%d", out_sep, as[i]);
out_sep = sep;
}
std::puts("");
}
static void print_int(const unsigned int n) {
std::printf("%d\n", n);
}
static unsigned int cnt = 0;
inline
static void insert(int as[], const unsigned int i, const unsigned int d) {
const int asi = as[i];
unsigned int j = i;
while (j >= d && asi < as[j-d]) {
as[j] = as[j-d];
j -= d;
++cnt;
}
as[j] = asi;
}
void insertion_sort(int as[], const unsigned int n, const unsigned int d) {
for (unsigned int i = d; i < n; ++i) {
insert(as, i, d);
}
}
inline
unsigned int next_g(const unsigned int g) { return 3*g + 1; }
unsigned int gen_m(const unsigned int n) {
unsigned int m = 1;
for (unsigned int g = 1;;) {
g = next_g(g);
if (n < g) break;
++m;
}
return m;
}
void shell_sort(int as[], const unsigned int n) {
cnt = 0;
unsigned int m = gen_m(n);
int gs[m];
for (unsigned int g = 1, i = 0; i < m; ++i) {
gs[m-1-i] = g;
g = next_g(g);
}
print_int(m);
print_ints(gs, m);
for(unsigned int i = 0; i < m; ++i) {
insertion_sort(as, n, gs[i]);
}
print_int(cnt);
}
int main(void) {
unsigned int n;
std::scanf("%d", &n);
int as[n];
for (unsigned int i = 0; i < n; ++i) {
std::scanf("%d", &as[i]);
}
shell_sort(as, n);
print_ints(as, n, "\n");
return 0;
}
// end | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll maxSubarrayXOR(ll a[], int n) {
int index = 0;
for(int i = 60; i >= 0; i--) {
int pos = index;
int f = 0;
for(int j = index; j < n; j++) {
if(a[j] & (1LL << i)) f = 1, pos = j;
}
if(!f) continue;
swap(a[index], a[pos]);
for(int j = 0; j < n; j++) {
if(j != index && (a[j] & (1LL << i))) a[j] ^= a[index];
}
index++;
}
ll res = 0;
for(int i = 0; i < n; i++) res ^= a[i];
return res;
}
int n;
ll a[100010], ans = 0;
int main() {
cin >> n;
for(int i = 0; i < n; i++) {
scanf("%lld", a+i);
ans ^= a[i];
}
for(int i = 0; i < n; i++) a[i] &= ~ans;
cout << ans + 2*maxSubarrayXOR(a, n);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(ll (i) = (0);(i) < (n);++i)
#define REV(i,n) for(ll (i) = (n) - 1;(i) >= 0;--i)
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v,n) {REP(WW,n)cerr << v[WW] << ' ';cerr << endl << endl;}
#define SHOW2d(v,WW,HH) {REP(W_,WW){REP(H_,HH)cerr << v[W_][H_] << ' ';cerr << endl;}cerr << endl;}
#define ALL(v) v.begin(),v.end()
#define Decimal fixed<<setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
#define MOD 1000000007
typedef long long ll;
typedef pair<ll,ll> P;
char mp[2222][2222];
bool ng[2222][2222];
int high[2222][2222];
int seica(ll h,ll w){
ll ret = 0;
REP(i,h){
stack<pair<ll,ll>> st;
REP(j,w){
ll tmp = j;
while(!st.empty() && st.top().FI > high[i][j]){
auto now = st.top();
st.pop();
ret = max(ret,(j - now.SE) * now.FI);
tmp = min(tmp,now.SE);
//cout << i << " " << j << " " << now.FI << " " << now.SE << " " << (j - now.SE) * now.FI << endl;
}
if(st.empty() || st.top().FI < high[i][j])st.push(MP(high[i][j],tmp));
if(st.empty() || st.top().FI < i + 1)st.push(MP(i + 1,j));
}
while(!st.empty()){
auto now = st.top();
st.pop();
ret = max(ret, (w - now.SE) * now.FI);
//cout << i << " " << w << " " << now.FI << " " << now.SE << " " << (w - now.SE) * now.FI << endl;
}
}
return ret;
}
int main(){
int h,w;cin >> h >> w;
REP(i,h){
REP(j,w){
cin >> mp[i][j];
}
}
REP(i,h-1){
REP(j,w-1){
int y = i + 1;
int x = j + 1;
int cou = 0;
if(mp[y][x] == '#')cou++;
if(mp[y][x-1] == '#')cou++;
if(mp[y-1][x] == '#')cou++;
if(mp[y-1][x-1] == '#')cou++;
if(cou % 2)ng[y][x] = true;
}
}
REP(i,h){
REP(j,w){
if(i == 0)high[i][j] = 1;
else {
if(ng[i][j])high[i][j] = 1;
else high[i][j] = high[i-1][j] + 1;
}
}
}
cout << seica(h,w) << endl;
return 0;
}
|
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <queue>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <fstream>
#include <complex>
#include <cstdint>
#include <tuple>
#include <numeric>
#define M_PI 3.14159265358979323846
using namespace std;
//conversion
//------------------------------------------
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(); }
//typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
//container util
//------------------------------------------
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define MT make_tuple
#define SZ(a) int((a).size())
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define FILL(a, x) memset(a, x, sizeof(a))
//repetition
//------------------------------------------
#define FOR(i,s,n) for(int i=s;i<(int)n;++i)
#define REP(i,n) FOR(i,0,n)
const int N = 2005;
char board[N][N];
int val[N][N];
class UnionFind {
public:
vector<int> data;
UnionFind(int n) : data(n, -1) {}
int find(int x) {
if (data[x] < 0)return x;
return data[x] = find(data[x]);
}
bool unite(int x, int y) {
x = find(x), y = find(y);
if (x == y)return false;
if (data[x] > data[y])swap(x, y);
data[x] += data[y];
data[y] = x;
return true;
}
bool same(int x, int y) {
return find(x) == find(y);
}
int size(int x) {
return -data[find(x)];
}
};
int main() {
int h, w;
scanf("%d%d", &h, &w);
REP(i, h)scanf("%s", board[i]);
REP(i, w)val[0][i] = w - i;
FOR(i, 1, h) {
val[i][w - 1] = 1;
bool same = (board[i - 1][w - 1] == board[i][w - 1]);
for (int j = w - 2; j >= 0; j--) {
if (same ^ (board[i - 1][j] == board[i][j])) {
val[i][j] = 1;
same = !same;
}
else val[i][j] = val[i][j + 1] + 1;
}
}
int ans = max(h, w);
REP(j, w) {
UnionFind uf(h);
vector<PII> vpii(h - 1);
FOR(i, 1, h)vpii[i - 1] = MP(val[i][j], i);
sort(ALL(vpii), greater<PII>());
REP(i, h - 1) {
if (uf.unite(vpii[i].second - 1, vpii[i].second)) {
ans = max(ans, uf.size(vpii[i].second) * vpii[i].first);
}
}
}
printf("%d\n", ans);
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int h, w, ah, aw;
while(cin >> h >> w, h || w){
ah = aw = 1000;
for(int i = 1; i <= 150; i++){
for(int j = i+1; j <= 150; j++){
if(i*i + j*j > h*h + w*w || i*i + j*j == h*h + w*w && i > h){
if(i*i + j*j < ah*ah + aw*aw || i*i + j*j == ah*ah + aw*aw && i < ah) ah = i, aw = j;
}
}
}
cout << ah << " " << aw << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i,x,y) for(int i=(x);i<(y);++i)
#define mp(a,b) make_pair((a),(b))
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif
typedef long long int ll;
typedef pair<int,int> pii;
//template<typename T> using vec=std::vector<T>;
const int INF=1<<30;
const long long int INF_=1LL<<58;
const double EPS=1e-9;
const int dx[]={1,0,-1,0},dy[]={0,1,0,-1};
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec){
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
struct S{
int h,w,l;
S(int h,int w):h(h),w(w){
l=h*h+w*w;
}
bool operator<(const S &s)const{
if(l==s.l) return h<s.h;
return l<s.l;
}
};
void Solve(){
vector<S> rects;
rep(i,1,151) rep(j,i+1,151) rects.push_back(S{i,j});
sort(rects.begin(),rects.end());
int h,w;
while(true){
cin >> h >> w;
if(h==0&&w==0) break;
auto it=++lower_bound(rects.begin(),rects.end(),S{h,w});
cout << it->h << ' ' << it->w << endl;
}
}
int main(){
std::ios::sync_with_stdio(false);
std::cin.tie(0);
Solve();
return 0;
} | 1 |
#include<cstdio>
int main(){
int x,S;
1<=x>=100;
scanf("%d", &x);
S=x*x*x;
printf("%d\n", S);
return 0;
} | #include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <limits.h>
#include <string>
#include <string.h>
#include <sstream>
#include <set>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <stack>
#include <queue>
using namespace std;
typedef long long ll;
int main(){
int num;
cin >> num;
printf("%d\n", (int)pow( num, 3 ));
return 0;
} | 1 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
int main(){
long double n,m,d;
cin>>n>>m>>d;
if(d==0){
cout<<fixed<<setprecision(10);
cout<<(m-1)/n<<endl;
return 0;
}
cout<<fixed<<setprecision(10);
cout<<(2*(n-d)*(m-1))/(n*n)<<endl;
} |
//#include<bits/stdc++.h>
#include<iostream>
#include<cstring>
#include<stdio.h>
#include<cmath>
#include<vector>
#include<algorithm>
#include<map>
#include<set>
#include<string>
#include<cstdlib>
#include<bitset>
#include<sstream>
#include<queue>
#include<stack>
#include<list>
#include<limits>
#include<iomanip>
using namespace std;
typedef long long int ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int,int> pt;
typedef pair<ll,ll> pll;
#define Max 1000001
#define intinf 2147483647
#define longlonginf 9223372036854775807
#define MOD 998244353
#define MOD2 1000000007
#define fastio ios_base::sync_with_stdio(false),cin.tie(NULL),cout.tie(NULL)
#define vint vector<int>
#define vll vector<long long>
#define endl '\n'
#define fi first
#define se second
#define pb push_back
#define F(i,n) for(int i = 0;i<n;i++)
#define Fr(i,l,r) for(int i = l;i <= r;i++)
#define rF(i,n) for(int i = n-1;i>=0;i--)
//#define min(a,b) a>b?b:a
//#define max(a,b) a>b?a:b
#define all(arr) arr.begin(),arr.end()
//#define sort(vec) sort(vec.begin(),vec.end())
//#define reverse(vec) reverse(vec.begin(),vec.end())
const ll m = 1e9 + 9;
ll Lpow(ll a,ll b)
{
ll ans = 1;
while(b > 0)
{
if(b%2)
ans = (ans*a)%m;
a = (a*a)%m;
b = b/2;
}
return ans;
}
ll gcd(ll a,ll b)
{
if(a%b==0)
return b;
else
return gcd(b,a%b);
}
signed main()
{
fastio;
int h1,m1,h2,m2,k;
cin >> h1 >> m1 >> h2 >> m2 >> k;
int ans = (h2-h1)*60 + m2 - m1;
if(ans <= 0)
ans += 24*60;
ans = max(ans-k,0);
cout << ans << endl;
return 0;
}
| 0 |
// clang-format off
#include <bits/stdc++.h>
#define int long long
#define main signed main()
// #define main int main()
#define loop(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) loop(i, 0, n)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define prec(n) fixed << setprecision(n)
#define stlice(from, to) substr(from, (to) - (from) + 1)
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
using namespace std;
using pii = pair<int, int>;
using vi = vector<int>;
using vd = vector<double>;
using vc = vector<char>;
using vb = vector<bool>;
using vs = vector<string>;
using vpii = vector<pii>;
using vvi = vector<vi>;
using vvb = vector<vb>;
using vvpii = vector<vpii>;
template<typename A> using fn = function<A>;
constexpr int INF = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
constexpr int MOD = 1000000007;
constexpr double PI = acos(-1);
template<typename A, typename B> bool cmin(A &a, const B &b) { return a > b ? (a = b, true) : false; }
template<typename A, typename B> bool cmax(A &a, const B &b) { return a < b ? (a = b, true) : false; }
constexpr bool odd(const int &n) { return n & 1; }
constexpr bool even(const int &n) { return !odd(n); }
void solve();
main { solve(); return 0; }
// clang-format on
template<typename M>
void warshallFloyd(M &m, const int &n) {
rep(k, n) rep(i, n) rep(j, n) cmin(m[i][j], m[i][k] + m[k][j]);
}
void solve() {
int n;
while (cin >> n, n) {
vvi t(n, vi(n));
int m;
cin >> m;
rep(i, n) rep(j, n) t[i][j] = i == j ? 0 : INF;
while (m--) {
int a, b;
cin >> a >> b;
a--, b--;
t[a][b] = t[b][a] = 1;
}
warshallFloyd(t, n);
int s = 0;
rep(i, n) s += 1 <= t[0][i] && t[0][i] <= 2;
cout << s << endl;
}
} | #include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
int main()
{
for(;;){
int n, m;
cin >> n >> m;
if(n == 0)
return 0;
vector<vector<int> > edges(n);
for(int i=0; i<m; ++i){
int a, b;
cin >> a >> b;
edges[a-1].push_back(b-1);
edges[b-1].push_back(a-1);
}
vector<bool> check(n, false);
check[0] = true;
for(int i=0; i<2; ++i){
vector<bool> next = check;
for(int j=0; j<n; ++j){
if(check[j]){
for(unsigned k=0; k<edges[j].size(); ++k)
next[edges[j][k]] = true;
}
}
check = next;
}
int ret = -1;
for(int i=0; i<n; ++i){
if(check[i])
++ ret;
}
cout << ret << endl;
}
} | 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 pie 3.141592653589793238462643383279
#define int long long
#define P pair<int,int>
#define all(vec) vec.begin(),vec.end()
int gcd(int x, int y) {
if (y == 0)return x;
return gcd(y, x%y);
}
int lcm(int x, int y) {
return x / gcd(x, y)*y;
}
int kai(int x, int y, int m) {
int res = 1;
for (int i = x - y + 1; i <= x; i++) {
res *= i; res %= m;
}
return res;
}
int mod_pow(int x, int y, int m) {
int res = 1;
while (y > 0) {
if (y & 1) {
res = res * x % m;
}
x = x * x % m;
y >>= 1;
}
return res;
}
int comb(int x, int y, int m) {
if (y > x)return 0;
return kai(x, y, m) * mod_pow(kai(y, y, m), m - 2, m) % m;
}
int n, m, q;
string s[2010];
int cum1[2010][2010], cum2[2010][2010], cum3[2010][2010];
signed main() {
cin >> n >> m >> q;
for (int i = 0; i < n; i++)cin >> s[i];
for (int i = 0; i < n; i++)for (int j = 0; j < m; j++) {
if (s[i][j] == '1')cum1[i][j]++;
if (i)cum1[i][j] += cum1[i - 1][j];
if (j)cum1[i][j] += cum1[i][j - 1];
if (i&&j)cum1[i][j] -= cum1[i - 1][j - 1];
}
for (int i = 0; i < n - 1; i++)for (int j = 0; j < m; j++) {
if (s[i][j] == '1'&&s[i + 1][j] == '1')cum2[i + 1][j]++;
}
for (int i = 0; i < n; i++)for (int j = 0; j < m - 1; j++) {
if (s[i][j] == '1'&&s[i][j + 1] == '1')cum3[i][j + 1]++;
}
for (int i = 0; i < n; i++)for (int j = 0; j < m; j++) {
if (i)cum2[i][j] += cum2[i - 1][j];
if (j)cum2[i][j] += cum2[i][j - 1];
if (i&&j)cum2[i][j] -= cum2[i - 1][j - 1];
if (i)cum3[i][j] += cum3[i - 1][j];
if (j)cum3[i][j] += cum3[i][j - 1];
if (i&&j)cum3[i][j] -= cum3[i - 1][j - 1];
}
for (int i = 0; i < q; i++) {
int x, y, xx, yy; cin >> x >> y >> xx >> yy; x--; y--; xx--; yy--;
int p = cum1[xx][yy];
if (x)p -= cum1[x - 1][yy];
if (y)p -= cum1[xx][y - 1];
if (x&&y)p += cum1[x - 1][y - 1];
int q = cum2[xx][yy] - cum2[x][yy] + cum3[xx][yy] - cum3[xx][y];
if (y)q -= cum2[xx][y - 1];
if (y)q += cum2[x][y - 1];
if (x)q -= cum3[x - 1][yy];
if (x)q += cum3[x - 1][y];
cout << p - q << endl;
}
} | #include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
const int maxn = 2e3 + 5;
char readch() {
char ch = getchar();
while (ch != '1' && ch != '0') ch = getchar();
return ch;
}
int s[maxn][maxn], n, m;
int sn[maxn][maxn], sve[maxn][maxn], she[maxn][maxn];
inline int Sum(int s[][maxn], int x1, int y1, int x2, int y2) {
return s[x2][y2] - s[x2][y1 - 1] - s[x1 - 1][y2] + s[x1 - 1][y1 - 1];
}
int main() {
int T; scanf("%d%d%d", &n, &m, &T);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
char ch = readch();
if (ch == '1') s[i][j] = 1;
else s[i][j] = 0;
}
//calc sn, sve, she
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
sn[i][j] = sn[i-1][j] + sn[i][j-1] - sn[i-1][j-1] + s[i][j];
sve[i][j] = sve[i-1][j] + sve[i][j-1] - sve[i-1][j-1] + (s[i][j] && s[i+1][j]);
she[i][j] = she[i-1][j] + she[i][j-1] - she[i-1][j-1] + (s[i][j] && s[i][j+1]);
}
while (T--) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
printf("%d\n", Sum(sn, x1, y1, x2, y2) - Sum(sve, x1, y1, x2-1, y2) - Sum(she, x1, y1, x2, y2-1));
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using int64 = long long;
struct Edge {
int from, to;
};
vector<vector<Edge>> ReadDirectedGraph(
int n, int m, bool is_one_indexed=false) {
vector<vector<Edge>> graph(n);
for (int i = 0; i < m; i++) {
int v1, v2;
cin >> v1 >> v2;
if (is_one_indexed) {
v1--;
v2--;
}
graph[v1].push_back(Edge({v1, v2}));
}
return graph;
}
vector<int> StronglyConnectedComponents(const vector<vector<Edge>>& graph) {
int n = graph.size();
vector<int> vs;
vector<int> visited1(n);
function<void(int)> dfs1 = [&](int v) {
if (visited1[v]) return;
visited1[v] = 1;
for (const auto& e : graph[v]) dfs1(e.to);
vs.push_back(v);
};
for (int v = 0; v < n; v++) dfs1(v);
reverse(vs.begin(), vs.end());
vector<vector<Edge>> r_graph(n);
for (int v = 0; v < n; v++) {
for (const auto& e : graph[v]) {
r_graph[e.to].push_back(Edge({e.to, e.from}));
}
}
vector<int> to_id(n);
int current_id = 0;
vector<int> visited2(n);
function<void(int)> dfs2 = [&](int v) {
if (visited2[v]) return;
visited2[v] = 1;
to_id[v] = current_id;
for (const auto& e : r_graph[v]) dfs2(e.to);
};
for (int v : vs) {
if (!visited2[v]) {
dfs2(v);
current_id++;
}
}
return to_id;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
auto graph = ReadDirectedGraph(n, m, false);
auto to_scc_id = StronglyConnectedComponents(graph);
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int v1, v2;
cin >> v1 >> v2;
if (to_scc_id[v1] == to_scc_id[v2]) {
cout << 1 << endl;
} else {
cout << 0 << endl;
}
}
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define sqr(x) ((x)*(x))
#define mp make_pair
#define uint unsigned
#define ld long double
#define PI pair<int,int>
inline char gc(){
static char buf[100000],*p1=buf,*p2=buf;
return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
#define gc getchar
inline ll read(){
ll x = 0; char ch = gc(); bool positive = 1;
for (; !isdigit(ch); ch = gc()) if (ch == '-') positive = 0;
for (; isdigit(ch); ch = gc()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(ll a){
if(a<0){
a=-a; putchar('-');
}
if(a>=10)write(a/10);
putchar('0'+a%10);
}
inline void writeln(ll a){write(a); puts("");}
inline void wri(ll a){write(a); putchar(' ');}
inline ull rnd(){
return ((ull)rand()<<30^rand())<<4|rand()%4;
}
const int N=100005;
int dq,n,s,tot,q[N];
ll sum,ans;
int x[N],p[N];
signed main(){
n=read(); s=read();
for(int i=1;i<=n;i++){
x[i]=read(); p[i]=read();
}
int l=1,r=n;
int pos=lower_bound(&x[1],&x[n+1],s)-x;
dq=0;
if(pos==1){
cout<<x[n]-s<<endl; return 0;
}
if(pos>n){
cout<<s-x[1]<<endl; return 0;
}
if(p[1]<p[n]){dq=1; sum=p[1]; q[++tot]=x[1]; l++;}else {sum=p[n]; q[++tot]=x[n]; r--;}
while(1){
if(dq){
if(r<pos)break;
if(p[r]>sum){
dq^=1; q[++tot]=x[r];
}
sum+=p[r];
r--;
}else{
if(l>=pos)break;
if(p[l]>=sum){
dq^=1; q[++tot]=x[l];
}
sum+=p[l];
l++;
}
}
reverse(&q[1],&q[tot+1]);
q[0]=s; for(int i=1;i<=tot;i++)ans+=abs(q[i]-q[i-1]);
cout<<ans<<endl;
} | 0 |
/**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author rahdirigs
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
template <typename T> void s_max(T& a, T b) {
if (a < b) {
a = b;
}
}
class TaskU {
public:
int N;
vector<vector<int>> a;
vector<ll> dp, scores;
vector<int> rem;
void solve(std::istream& in, std::ostream& out) {
in >> N;
a.resize(N, vector<int> (N));
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
in >> a[i][j];
}
}
scores.resize(1 << N, 0);
dp.resize(1 << N, 0);
pre_calc();
for (int mask = 0; mask < (1 << N); mask++) {
rem.clear();
for (int i = 0; i < N; i++) {
if (!(mask & (1 << i))) rem.push_back(i);
}
rec(0, dp[mask], mask, 0);
}
out << dp[(1 << N) - 1];
}
void pre_calc() {
for (int mask = 0; mask < (1 << N); mask++) {
for (int i = 0; i < N; i++) {
for (int j = i + 1; j < N; j++) {
if ((mask & (1 << i)) && (mask & (1 << j)))
scores[mask] += a[i][j];
}
}
}
}
void rec(int pos, ll score, int mask, int group) {
if (pos == (int) rem.size()) {
s_max(dp[mask], score + scores[group]);
return;
}
rec(pos + 1, score, mask ^ (1 << rem[pos]), group ^ (1 << rem[pos]));
rec(pos + 1, score, mask, group);
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
TaskU solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| #include<bits/stdc++.h>
#define MOD (long long)(1e9+7)
using namespace std;
long long n,a[20][20],dp[1<<17],sum[1<<17];
int main()
{
cin >> n;
for(int i=0; i<n; i++) for(int j=0; j<n; j++) cin >> a[i][j];
for(int i=0; i<(1<<n); i++) for(int j=0; j<n; j++) for(int k=j+1; k<n; k++)
if((i&(1<<j)) && (i&(1<<k))) sum[i]+=a[j][k];
for(int i=0; i<(1<<n); i++)
{
vector<int> pos;
for(int j=0; j<n; j++) if(i&(1<<j)) pos.push_back(1<<j);
int m=pos.size();
for(int j=0; j<(1<<m); j++)
{
int c=0;
for(int k=0; k<m; k++) if(j&(1<<k)) c+=pos[k];
dp[i]=max(dp[i],dp[i-c]+sum[c]);
}
}
long long ans=0;
for(int i=0; i<(1<<n); i++) ans=max(ans,dp[i]);
cout << ans;
return 0;
} | 1 |
#include <stdio.h>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <list>
#include <iterator>
#pragma warning(disable:4996)
typedef long long ll;
#define MIN(a, b) ((a)>(b)? (b): (a))
#define MAX(a, b) ((a)<(b)? (b): (a))
#define LINF 9223300000000000000
#define INF 2140000000
#define MOD 1000000007
using namespace std;
ll dp[205][100005];
int main(int argc, char* argv[])
{
long n, x;
scanf("%ld%ld", &n, &x);
vector<long> s(n);
long i,j;
for(i=0; i<n; i++) {
scanf("%ld", &s[i]);
}
sort(s.rbegin(), s.rend());
dp[0][x]=1;
for(i=0; i<n; i++) {
for(j=0; j<=x; j++) {
if(dp[i][j]) {
if(i<n-1) {
dp[i+1][j] = (dp[i+1][j] + (dp[i][j]* (n-i-1)))%MOD;
dp[i+1][j%s[i]] = (dp[i+1][j%s[i]] + dp[i][j])%MOD;
}
else {
dp[i+1][j%s[i]] = (dp[i+1][j%s[i]] + dp[i][j])%MOD;
}
}
}
}
ll ans=0;
for(i=0; i<s[n-1]; i++) {
ans = (ans + i*dp[n][i])%MOD;
}
printf("%lld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using LL = long long;
using vi = vector<int>;
using pii = pair<int,int>;
#define ST first
#define ND second
#define PB push_back
const int nax = 301;
const int mod = 998244353;
int n,a[nax];
int dp[nax][nax*nax];
int ans,sum,sub;
int main() {
scanf("%d",&n);
for(int i=1; i<=n;i++) {
scanf("%d",&a[i]);
sum+=a[i];
}
ans=1;
for(int i=1; i<n;i++) {
ans=((LL)ans*3)%mod;
}
dp[0][0] = 1;
for(int i=1; i<=n;i++) {
for(int s=0; s<=sum; s++) {
dp[i][s] = (2*dp[i-1][s])%mod;
if(s-a[i]>=0) {
dp[i][s]= (dp[i][s]+dp[i-1][s-a[i]])%mod;
}
}
}
for(int i=1; i<=sum;i++) {
if(i>=(sum+1)/2) {
sub=(sub+dp[n][i])%mod;
}
}
dp[0][0] = 1;
for(int i=1; i<=n;i++) {
for(int s=0; s<=sum;s++) {
dp[i][s] = dp[i-1][s];
if(s-a[i]>=0) {
dp[i][s]= (dp[i][s]+dp[i-1][s-a[i]])%mod;
}
}
}
if(sum%2==0) {
sub=(sub-dp[n][sum/2]+mod)%mod;
}
int res = (((ans-sub)%mod)+mod)%mod;
res = ((LL)res*3)%mod;
printf("%d",res);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define ull unsigned long long
#define ld long double
#define vi vector<int>
#define vll vector<ll>
#define vc vector<char>
#define vs vector<string>
#define vpii vector<pii>
#define vpll vector<pll>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define repr(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rep1r(i, n) for (int i = ((int)(n)); i >= 1; i--)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define RSORT(x) sort(rall(x));
#define pb push_back
#define mp make_pair
#define INF (1e9)
#define PI (acos(-1))
#define EPS (1e-7)
ull gcd(ull a, ull b) { return b ? gcd(b, a % b) : a; }
ull lcm(ull a, ull b) { return a / gcd(a, b) * b; }
int main(){
int n;
cin >> n;
string s, t;
cin >> s >> t;
int len = 0;
rep(i, n) {
if (s.substr(n-1-i, i+1) == t.substr(0, i+1)) len = i+1;
}
cout << (2*n-len) << endl;
return 0;
}
| #pragma GCC optimize(2)
#include<bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define maxn 1000005
#define inf 1e9
#define pb push_back
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define per(i,a,b) for(int i=a;i>=b;i--)
using namespace std;
inline int read()
{
int x=0,w=1; char c=getchar();
while(c<'0'||c>'9') {if(c=='-') w=-1; c=getchar();}
while(c<='9'&&c>='0') {x=(x<<1)+(x<<3)+c-'0'; c=getchar();}
return w==1?x:-x;
}
ll n,a[maxn],b[maxn],c[maxn],d[maxn];
ull h[maxn],tmp,B[maxn];
vector <int> ans;
int main()
{
n=read(); B[0]=1; rep(i,1,n) a[i]=read(),a[i+n]=a[i]; rep(i,1,n) b[i]=read();
rep(i,1,2*n-1) c[i]=a[i]^a[i+1]; c[n]=a[1]^a[n];
rep(i,1,n-1) d[i]=b[i]^b[i+1]; d[n]=b[1]^b[n];
rep(i,1,n) tmp=tmp*233+d[i],B[i]=B[i-1]*233;
rep(i,1,2*n) h[i]=h[i-1]*233+c[i];
//rep(i,1,2*n) cout<<c[i]<<" "; cout<<endl;
//rep(i,1,n) cout<<d[i]<<" "; cout<<endl<<endl;
for(int i=1;i<=n;i++)
{
ull p=h[i+n-1]-h[i-1]*B[n];
if(p==tmp) ans.pb(i-1);
}
for(int i=0;i<ans.size();i++) printf("%lld %lld\n",ans[i],b[1]^a[1+ans[i]]);
return 0;
} | 0 |
#include <bits/stdc++.h>
#include <vector>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define size_of_array(array) (sizeof(array)/sizeof(array[0]))
using ll =long long;
using namespace std;
using Graph=vector<vector<int>>;
using Field=vector<vector<int>>;
template<class T> inline bool chmin(T& a,T b){if(a>b){a=b;return 1;}return 0;}
template<class T> inline bool chmax(T& a,T b){if(a<b){a=b;return 1;}return 0;}
int main(){
ll n;
cin>>n;
ll a[5]={};
rep(i,5)cin>>a[i];
ll b[5]={};
rep(i,5){
ll s=n%a[i];
ll t=n/a[i];
if(s!=0)b[i]=t+1+4;
else b[i]=t+4;
}
ll ans=0;
rep(i,5){
ans=max(ans,b[i]);
}
cout<<ans<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
long N,A,B,C,D,E;;
cin >> N >> A >> B >> C >> D >> E;
long slow = min(min(A,B),min(C,min(D,E)));
cout << (N + slow - 1) / slow + 4 << endl;
} | 1 |
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int a,b;
cin >> a >> b;
if(a == b){
cout << a+b << endl;
}else{
int m = max(a,b);
cout << m + (m-1) << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a) for(int i=0; i<(int)(a); i++)
typedef long long ll;
const ll INF = 1LL<<60;
const ll mod = 998244353;
int main()
{
int n, m; cin>>n>>m;
bool flg = false;
for (int i=1; i<=m; i++) {
int l = i;
int r = n-i;
if (n%2 == 0 && !flg && r-l <= n/2) flg = true;
if (flg) r--;
printf("%d %d\n", l, r);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ALL(v) v.begin(), v.end()
#define V vector
#define P pair
using ll = long long;
using ld = long double;
const int MOD = 1e9+7;
const ll INF = 1LL << 60;
int main() {
int x, y; cin >> x >> y;
if(x + y == 2) cout << 1000000 << endl;
else if(x + y == 3) cout << 500000 << endl;
else if(x + y == 4) cout << 400000 << endl;
else if(x + y == 5) cout << 300000 << endl;
else if(x + y == 6) cout << 200000 << endl;
else if(x == 3 || y == 3) cout << 100000 << endl;
else cout << 0 << endl;
return 0;
}
| #include <iostream>
#include <vector>
#include <algorithm>
#include <map>
#include <stack>
#include <set>
#include <queue>
#include <iomanip>
using namespace std;
long long mod = 1000000007;
long long pow(long long x, long long k)
{
if (k == 0)
{
return 1LL;
}
long long temp = pow(x, k / 2);
if (k % 2 == 1)
{
return (((temp * temp) % mod) * x) % mod;
}
else
{
return (temp * temp) % mod;
}
}
long long modular_inverse(long long x)
{
return pow(x, mod - 2);
}
long long binomial(long long n, long long k)
{
long long rez = 1;
for (int i = n - k + 1; i <= n; i++)
{
rez *= i;
rez %= mod;
}
long long temp = 1;
for (int i = 1; i <= k; i++)
{
temp *= i;
temp %= mod;
}
rez *= modular_inverse(temp);
rez %= mod;
return rez;
}
int score(int x)
{
return max(100000 * (4 - x), 0);
}
int main()
{
int x, y;
cin >> x >> y;
cout << score(x) + score(y) + ((x == y && x == 1) ? 400000 : 0);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
//#include <boost/multiprecision/cpp_int.hpp>
//typedef boost::multiprecision::cpp_int ll;
typedef long double dd;
#define i_7 (ll)(1E9+7)
//#define i_7 998244353
#define i_5 i_7-2
ll mod(ll a){
ll c=a%i_7;
if(c>=0)return c;
return c+i_7;
}
typedef pair<ll,ll> l_l;
ll inf=(ll)1E16;
#define rep(i,l,r) for(ll i=l;i<=r;i++)
#define pb push_back
ll max(ll a,ll b){if(a<b)return b;else return a;}
ll min(ll a,ll b){if(a>b)return b;else return a;}
void Max(ll &pos,ll val){pos=max(pos,val);}//Max(dp[n],dp[n-1]);
void Min(ll &pos,ll val){pos=min(pos,val);}
void Add(ll &pos,ll val){pos=mod(pos+val);}
dd EPS=1E-9;
#define fastio ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
////////////////////////////
#define N 100004
ll d[N+1];
ll a[N+1];
vector<ll>c[N+1];
void dfs(ll k){
for(auto x:c[k]){
d[x]=d[k]+1;
dfs(x);
}
}
int main(){fastio
ll n,k;cin>>n>>k;
rep(i,1,n){
cin>>a[i];
if(i!=1)c[a[i]].pb(i);
}
ll ans=0;
if(k==1){
rep(i,1,n)if(a[i]!=1)ans++;
cout<<ans<<endl;
return 0;
}
if(a[1]!=1)ans++;
dfs(1);d[1]=0;
vector<ll>dep[N];
rep(i,1,n)dep[d[i]].pb(i);
l_l dp[n+1];
for(ll i=N-1;i>=0;i--){
if(i==0){
for(auto x:c[1]){
ans+=dp[x].first;
}
}
for(auto x:dep[i]){
ll ma=0,sum=0;
for(auto y:c[x]){
sum+=dp[y].first;
if(dp[y].second==k){
sum++;
}else{
Max(ma,dp[y].second);
}
}
dp[x]=l_l(sum,ma+1);
}
}
//rep(i,1,n)cout<<dp[i].first<<" "<<dp[i].second<<endl;
cout<<ans<<endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define maxn 100001
int n,k,he[maxn],ver[2*maxn],nxt[2*maxn],tot,cnt;
void add(int x,int y){
ver[++tot]=y;nxt[tot]=he[x];he[x]=tot;
}
int dfs(int x,int fa){
int maxx=0;
for(int i=he[x];i;i=nxt[i]){
if(ver[i]==fa)continue;
maxx=max(maxx,dfs(ver[i],x));
}if(x==1)return 0;
if(maxx==k-1&&fa!=1){
//cout<<x<<endl;
cnt++;return 0;
}else return maxx+1;
}
int main(){
scanf("%d%d",&n,&k);
int x;
for(int i=1;i<=n;i++){
scanf("%d",&x);
if(i!=1)add(i,x),add(x,i);
else if(x!=1)cnt++;
}dfs(1,0);
printf("%d",cnt);
} | 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using vi=vector<int>;
using P = pair<int,int>;
using Graph = vector<vector<int>>;
template<typename T> void ndarray(vector<T> &vec, int len) { vec.resize(len); }
template<typename T, typename... Args> void ndarray(vector<T> &vec, int len, Args... args) { vec.resize(len); for (auto &v : vec) ndarray(v, args...); }
vector<int> Eratosthenes(int N){
vector<int> arr(N,1);
vector<int> res;
for(int i = 2; i < sqrt(N); i++){
if(arr[i]){
for(int j = 0; i * (j + 2) < N; j++){
arr[i *(j + 2)] = 0;
}
}
}
for(int i = 1; i < N; i++){
if(arr[i]){
res.push_back(i);
}
}
return res;
}
const ll INF = 1LL << 60;
ll N;
vector<ll> a;
int main() {
cin >> N;
a.resize(N + 1);
rep(i, N) cin >> a[i + 1];
vector<ll> ans(N + 1, -1);
for (int i = N; i > 0; i--) {
int loop_cnt = N / i;
if (loop_cnt >= 2) {
ll tmp = 0;
for (int j = i + i; j <= N; j += i) {
tmp += ans[j];
}
tmp = tmp % 2;
ans[i] = tmp ^ a[i];
} else {
ans[i] = a[i];
}
}
set<ll> st;
for (int i = 1; i <= N; i++) {
if (ans[i] == 1) {
st.insert(i);
};
}
cout << st.size() << endl;
for (auto v : st) {
cout << v << " ";
}
cout << "\n";
} | #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define uu unsigned
#define io ios_base::sync_with_stdio(false);cin.tie(NULL)
#define MOD 1000000007
#define pl pair<ll,ll>
#define mkp make_pair
#define ss second
#define ff first
#define mit(a,b) map<a,b>::iterator
#define sit(a) set<a>::iterator
#define vi vector<int>
#define vl vector<ll>
#define pb push_back
#define printcas cout<<"Case "<<cas<<": "
#define _ continue;
#define endl '\n'
#define __ cout<<endl;continue;
const ll oo=(1ll<<60);
int gi(){
int x=0,w=1;char ch=getchar();
while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
if(ch=='-')w=0,ch=getchar();
while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
return w?x:-x;
}
vector<vector<vector<double>>> dp(305,vector<vector<double>>(305,vector<double>(305,-1.0)));
double n;
double e(double t1,double t2,double t3)
{
if(dp[(int)t1][(int)t2][(int)t3]!=-1) return dp[(int)t1][(int)t2][(int)t3];
return dp[(int)t1][(int)t2][(int)t3]=(1.0/(t1+t2+t3))*(n+((!t1)?0:(t1*e(t1-1.0,t2,t3)))+((!t2)?0:(t2*e(t1+1.0,t2-1.0,t3)))+((!t3)?0:(t3*e(t1,t2+1.0,t3-1.0))));
}
int main()
{
//io;
//string hudai(1000000,'a');
int T=1;
//T=gi();
for(int cas=1;cas<=T;cas++)
{
double t1=0.0,t2=0.0,t3=0.0,x;
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>x;
if(x==1)t1+=1.0;
else if(x==2) t2+=1.0;
else t3+=1.0;
}
// int mx=max(t1,max(t2,t3));
// for(int i=0;i<=n+2;i++)for(int j=0;j<=n+2;j++)for(int k=0;k<=n+2;k++)dp[i][j][k]=-1;
dp[0][0][0]=0;
printf("%.15lf",e(t1,t2,t3));
}
return 0;
}
| 0 |
#include<iostream>
#include<math.h>
#include<algorithm>
#include<stdint.h>
#include<vector>
#include<deque>
#include<stack>
#include<functional>
#include<string>
#include<cstring>
#include<time.h>
#include<array>
#include<iomanip>
#include<list>
#include<set>
#include<map>
#include<random>
#include<unordered_map>
#include<unordered_set>
#include<bitset>
#include <queue>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using ldb = long double;
//BDD,ZDD,kdtree, bdtree,bicalc, bolonoy, doloney, tree, chinesemod,segmenttree,daikusutora, saidairyuu, 2bugurahu, heirokenshutu, topologicalsort, kyourenketuseibun
#define REP(i,a,b) for(ll i = a; i < b; ++i)
#define PRI(s) cout << s << endl
#define PRIF(v, n) printf("%."#n"f\n", v)
#define PRIY PRI("Yes")
#define PRIN PRI("No")
#define MINS(a,b) a = min(a,(decltype(a))(b))
#define MAXS(a,b) a = max(a,(decltype(a))(b))
using arr = array<ll, 3>;
int main() {
auto proc = [](string str) {
int bra = 0;
int cket = 0;
for (char c : str) {
if (c == '(') {
++bra;
}
else {
if (bra > 0) --bra;
else ++cket;
}
}
return arr{cket, bra, bra - cket};
};
auto cmp = [](arr a, arr b) {
if (a[0] == b[0])return a[1] > b[1];
return a[0] < b[0];
};
auto cmp2 = [](arr a, arr b) {
if (a[0] == b[0])return a[1] > b[1];
return a[0] > b[0];
};
ll N;
cin >> N;
vector<arr> plus,minus;
REP(i, 0, N) {
string str;
cin >> str;
auto a = proc(str);
if (a[2] >= 0) plus.push_back(a);
else minus.push_back(a);
}
sort(plus.begin(), plus.end(), cmp);
if (plus.size() == 0 || plus[0][0] > 0) {
PRIN;
return 0;
}
sort(minus.begin(), minus.end(), cmp2);
int last = -1;
REP(i, 0, minus.size()) {
if (minus[i][1] == 0) {
last = i;
break;
}
}
if (last == -1) {
if (minus.size() != 0)PRIN;
else {
for (auto p : plus) {
if (p[0] != 0 || p[1] != 0) {
PRIN;
return 0;
}
}
PRIY;
}
return 0;
}
int cur = 0;
for (auto p : plus) {
cur -= p[0];
if (cur < 0) {
PRIN;
return 0;
}
cur += p[1];
}
REP(i, 0, minus.size()) {
if (i == last)continue;
auto p = minus[i];
cur -= p[0];
if (cur < 0) {
PRIN;
return 0;
}
cur += p[1];
}
cur -= minus[last][0];
if (cur == 0)PRIY;
else PRIN;
return 0;
} | #include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <iomanip>
using ll = long long;
using uint = unsigned int;
using graph = std::vector<std::vector<ll>>;
using wGraph = std::vector<std::vector<std::pair<ll,ll>>>;
#define rep(i,n) for (int i=0; i < int(n); i++)
using namespace std;
ll MOD7 = 1000000007;
ll MOD9 = 1000000009;
vector<ll> InputVec(ll N){
vector<ll> A(N);
for (int i = 0; i < N; ++i) {
cin >> A[i];
}
return A;
}
void OutputVec(vector<ll> A){
for (int i = 0; i < A.size(); ++i) {
cout << A[i] << ",";
}
cout << endl;
}
vector<vector<ll>> InputVec2d(ll H,ll W){
vector<vector<ll>> A(H);
for (int yi = 0; yi < H; ++yi) {
A[yi] = vector<ll>(W);
}
for (int yi = 0; yi < H; ++yi) {
for (int xi = 0; xi < W; ++xi) {
cin >> A[yi][xi];
}
}
return A;
}
vector<vector<char>> InputVec2dStr(ll H,ll W){
vector<vector<char>> A(H);
for (int yi = 0; yi < H; ++yi) {
A[yi] = vector<char>(W);
}
for (int yi = 0; yi < H; ++yi) {
string S;
cin >> S;
for (int xi = 0; xi < W; ++xi) {
A[yi][xi] = S[xi];
}
}
return A;
}
void OutputVec2d(vector<vector<ll>> A){
for (int yi = 0; yi < A.size(); ++yi) {
for (int xi = 0; xi < A[yi].size(); ++xi) {
cout << A[yi][xi] << ",";
}
cout << endl;
}
}
graph InputGraph(ll N,ll M){
graph G(N);
for (int i = 0; i < M; ++i) {
ll a,b;
cin >> a >> b;
a--;b--;
G[a].push_back(b);
G[b].push_back(a);
}
return G;
}
graph InputDGraph(ll N,ll M){
graph G(N);
for (int i = 0; i < M; ++i) {
ll a,b;
cin >> a >> b;
a--;b--;
G[a].push_back(b);
}
return G;
}
wGraph InputWGraph(ll N,ll M){
wGraph G(N);
for (int i = 0; i < M; ++i) {
ll a,b,c;
cin >> a >> b >> c;
a--;b--;
G[a].push_back(make_pair(b,c));
G[b].push_back(make_pair(a,c));
}
return G;
}
wGraph InputDWGraph(ll N, ll M){
wGraph G(N);
for (int i = 0; i < M; ++i) {
ll a,b,c;
cin >> a >> b >> c;
a--;b--;
G[a].push_back(make_pair(b,c));
}
return G;
}
void OutputGraph(graph G){
for (int i = 0; i < G.size(); ++i) {
cout << i << ":";
for (int j = 0; j < G[i].size(); ++j) {
cout << G[i][j]<< ",";
}
cout << endl;
}
}
void OutputGraph(wGraph G){
for (int i = 0; i < G.size(); ++i) {
cout << i << ":";
for (int j = 0; j < G[i].size(); ++j) {
cout << G[i][j].first <<"/" << G[i][j].second << ",";
}
cout << endl;
}
}
void OutputAnswerBool(bool b,bool isUpperCase = false){
if(b){
if(isUpperCase){
cout << "YES" << endl;
}else{
cout << "Yes" << endl;
}
}else{
if(isUpperCase){
cout << "NO" << endl;
}else{
cout << "No" << endl;
}
}
}
int main() {
string N;
cin >> N;
ll digit = N.size();
vector<vector<ll>>memo(2);
for (int yi = 0; yi < 2; ++yi) {
memo[yi] = vector<ll>(digit);
for (int xi = 0; xi < digit; ++xi) {
memo[yi][xi] = (1ll << 50);
}
}
ll first = N[0] - '0';
memo[0][0] = min(11 - first,first);
memo[1][0] = min(11 - first - 1,first + 1);
for (int i = 1; i < digit; ++i) {
ll num = N[i] - '0';
memo[0][i] = min(memo[0][i-1] + num,memo[1][i-1] + (10 - num));
memo[1][i] = min(memo[0][i-1] + num + 1,memo[1][i-1] + (10 - num - 1));
}
cout << (memo[0][digit-1]) << endl;
}
| 0 |
/*{{{*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<string>
#include<iostream>
#include<sstream>
#include<set>
#include<map>
#include<queue>
#include<bitset>
#include<vector>
#include<limits.h>
#include<assert.h>
#define SZ(X) ((int)(X).size())
#define ALL(X) (X).begin(), (X).end()
#define REP(I, N) for (int I = 0; I < (N); ++I)
#define REPP(I, A, B) for (int I = (A); I < (B); ++I)
#define FOR(I, A, B) for (int I = (A); I <= (B); ++I)
#define FORS(I, S) for (int I = 0; S[I]; ++I)
#define RS(X) scanf("%s", (X))
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()), c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
#define GET_POS(c,x) (lower_bound(c.begin(),c.end(),x)-c.begin())
#define CASET int ___T; scanf("%d", &___T); for(int cs=1;cs<=___T;cs++)
#define MP make_pair
#define PB push_back
#define MS0(X) memset((X), 0, sizeof((X)))
#define MS1(X) memset((X), -1, sizeof((X)))
#define LEN(X) strlen(X)
#define F first
#define S second
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef long double LD;
typedef pair<int,int> PII;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef pair<LL,LL> PLL;
typedef vector<PLL> VPLL;
template<class T> void _R(T &x) { cin >> x; }
void _R(int &x) { scanf("%d", &x); }
void _R(LL &x) { scanf("%lld", &x); }
void _R(double &x) { scanf("%lf", &x); }
void _R(char &x) { scanf(" %c", &x); }
void _R(char *x) { scanf("%s", x); }
void R() {}
template<class T, class... U> void R(T &head, U &... tail) { _R(head); R(tail...); }
template<class T> void _W(const T &x) { cout << x; }
void _W(const int &x) { printf("%d", x); }
void _W(const LL &x) { printf("%lld", x); }
void _W(const double &x) { printf("%.16f", x); }
void _W(const char &x) { putchar(x); }
void _W(const char *x) { printf("%s", x); }
template<class T,class U> void _W(const pair<T,U> &x) {_W(x.F); putchar(' '); _W(x.S);}
template<class T> void _W(const vector<T> &x) { for (auto i = x.begin(); i != x.end(); _W(*i++)) if (i != x.cbegin()) putchar(' '); }
void W() {}
template<class T, class... U> void W(const T &head, const U &... tail) { _W(head); putchar(sizeof...(tail) ? ' ' : '\n'); W(tail...); }
#ifdef HOME
#define DEBUG(...) {printf("# ");printf(__VA_ARGS__);puts("");}
#else
#define DEBUG(...)
#endif
int MOD = 1e9+7;
void ADD(LL& x,LL v){x=(x+v)%MOD;if(x<0)x+=MOD;}
/*}}}*/
const int SIZE = 1e6+10;
int N,X;
LL b[SIZE],l[SIZE],u[SIZE];
bool used[SIZE];
int main(){
R(N,X);
LL need=0;
priority_queue<PLL>h0,h1,h2;
REP(i,N){
R(b[i],l[i],u[i]);
need+=b[i]*l[i];
h0.push({l[i]*b[i]+u[i]*(X-b[i]),i});
}
LL an=0;
while(need>=h0.top().F){
an+=X;
used[h0.top().S]=1;
need-=h0.top().F;
h0.pop();
}
if(need<=0){
W(an);
return 0;
}
int add_id=h0.top().S;
LL add_v=l[add_id]*b[add_id]+u[add_id]*(X-b[add_id]);
LL mi=1e18;
REP(i,N){
if(used[i]){
LL need2=need-add_v+l[i]*b[i]+u[i]*(X-b[i]);
if(l[i]*b[i]>=need2){
mi=min(mi,(need2+l[i]-1)/l[i]);
}
else{
mi=min(mi,(need2-l[i]*b[i]+u[i]-1)/u[i]+b[i]);
}
}
else{
if(l[i]*b[i]+u[i]*(X-b[i])<need)continue;
if(l[i]*b[i]>=need){
mi=min(mi,(need+l[i]-1)/l[i]);
}
else{
mi=min(mi,(need-l[i]*b[i]+u[i]-1)/u[i]+b[i]);
}
}
}
an+=mi;
W(an);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define mp make_pair
typedef pair<int, int> pii;
typedef long long ll;
const int MOD = 1000000007;
const int BASE = 27;
const int oo = 1e9;
const double EPS = 1e-9;
const int MX = 2e5 + 1;
int n;
ll x;
struct exam {
ll b, u, v;
};
exam e[MX];
struct line {
ll a, b, idx;
line() {
a = b = idx = 0;
}
line(ll _a, ll _b, int _idx) {
a = _a, b = _b, idx = _idx;
}
ll eval(ll x) {
return a * x + b;
}
bool operator<( line &rhs) {
if(eval(x) == rhs.eval(x))
return a < rhs.a;
return eval(x) < rhs.eval(x);
}
};
bool check(ll rem) {
vector<line> all;
ll sc = 0;
for (int i = 1; i <= n; ++i) {
sc -= e[i].u * e[i].b;
ll a1 = e[i].v;
ll b1 = -e[i].b * (e[i].v - e[i].u);
all.push_back(line(a1, b1, i));
}
if(sc == 0)return true;
if(rem == 0)return false;
sort(all.begin(),all.end());
ll g1 = rem/x,g2;
if(rem%x == 0)
g2 = x,g1--;
else g2 = rem%x;
ll sm = 0;
for(int j = all.size()-1;j>= all.size()-g1;--j)
sm += all[j].eval(x);
for(int j = all.size()-g1; j < all.size();++j){
ll nwSm = sm-all[j].eval(x)+all[all.size()-g1-1].eval(x);
ll mx = max(all[j].eval(g2),line(e[all[j].idx].u,0,all[j].idx).eval(g2));
if(mx+nwSm+sc >= 0)
return true;
}
for(int j = 0 ; j+g1 < all.size();++j){
ll mx = max(all[j].eval(g2),
line(e[all[j].idx].u,0,all[j].idx).eval(g2));
if(mx+sm+sc >= 0)return true;
}
return false;
}
int main() {
cin >> n >> x;
for (int b, l, u, i = 1; i <= n; ++i) {
scanf("%lld%lld%lld", &e[i].b, &e[i].u, &e[i].v);
}
ll lo = 0 , hi = 1ll * n * x, best = -1;
while (lo <= hi) {
ll md = (lo + hi) / 2;
if (check(md)) {
best = md;
hi = md - 1;
} else {
lo = md + 1;
}
}
cout << best << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
vector<int>a(5);
for (int i = 0; i < 5; i++)cin >> a.at(i);
sort(a.begin(), a.end());
int k;
cin >> k;
for (int i = 0; i < 4; i++) {
for (int j = i; j < 5; j++) {
if (a.at(j) - a.at(i) <= k)continue;
else {
cout << ":(" << endl;
return 0;
}
}
}
cout << "Yay!" << endl;
} | #include<iostream>
using namespace std;
class dice
{
private:
int status[6];
public:
dice();
int showfront(void);
bool is(int,int);
bool isfront(int);
void rotate(char);
bool rtfront(int);
bool operator==(dice);
bool eqv(dice);
};
bool dice::eqv(dice di2)
{
if(!di2.rtfront((*this).showfront()))
return false;
else
{
int i;
for(i=0;i<4;i++)
{
if ((*this)==di2)
{
return true;
}
di2.rotate('E');
}
if(i==4) return false;
}
}
bool dice::rtfront(int a)
{
int j;
for(j=0;j<=3;j++)
{
if((*this).isfront(a)) break;
(*this).rotate('N');
}
if(j==4)
{
(*this).rotate('E');
(*this).rotate('S');
}
if(!(*this).isfront(a))
{
(*this).rotate('N');
(*this).rotate('N');
}
if(!(*this).isfront(a))
return false;
else
return true;
}
bool dice::operator==(dice d)
{
int i=0;
for(i=0;i<6;i++)
if((*this).status[i]!=d.status[i]) break;
if(i==6) return true;
else return false;
}
dice::dice()
{
for(int i=0;i<6;i++)
cin>>status[i];
}
bool dice::isfront(int a)
{
if(status[1]==a) return true;
else return false;
}
bool dice::is(int a,int b)
{
if((status[0]==a)&&(status[1]==b)) return true;
else return false;
}
int dice::showfront()
{
return status[1];
}
void dice::rotate(char s)
{
switch(s)
{
int tmp;
case 'N':
tmp=status[0];
status[0]=status[1];
status[1]=status[5];
status[5]=status[4];
status[4]=tmp;
break;
case 'E':
tmp=status[0];
status[0]=status[3];
status[3]=status[5];
status[5]=status[2];
status[2]=tmp;
break;
case 'W':
tmp=status[0];
status[0]=status[2];
status[2]=status[5];
status[5]=status[3];
status[3]=tmp;
break;
case 'S':
tmp=status[0];
status[0]=status[4];
status[4]=status[5];
status[5]=status[1];
status[1]=tmp;
break;
}
}
int main()
{
int n;
cin>>n;
dice di[n];
bool ans=true;
for(int i=0;i<n;i++)
for(int j=i+1;j<n;j++)
if(di[i].eqv(di[j]))
{
ans=false;
break;
}
if(ans==true)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
} | 0 |
#include <iostream>
#include<algorithm>
using namespace std;
//upper_bound, lower_boundを用いた
//のになぜか通らない・・・
int main(){
int n;
long long a;
if(scanf("%d", &n)==EOF){return 0;}
long long top[n];
long long center[n];
long long down[n];
for(int i = 0; i<n; i++){if(scanf("%lld", &a)==EOF){return 0;} top[i] = a;}
for(int i = 0; i<n; i++){if(scanf("%lld", &a)==EOF){return 0;} center[i] = a;}
for(int i = 0; i<n; i++){if(scanf("%lld", &a)==EOF){return 0;} down[i] = a;}
// top, downをソート
sort(top, top+n);
sort(down, down+n);
//for(int i = 0; i<n; i++){cout << top[i] << ", "<<endl;}
//for(int i = 0; i<n; i++){cout << down[i] << ", "<<endl;}
long long sum = 0;
//int ok1, ng1, ok2, ng2, mid;
int ok1, ok2;
for(int i = 0; i< n; i++){
//center[i]より小さいtopの数を探す
ok1 = lower_bound(top, top+n, center[i]) - top;
ok2 = upper_bound(down, down+n, center[i]) - down;
//cout << "top[ok1-1]" << top[ok1-1] << ", center:"<< center[i] <<", top[ok1]:"<< top[ok1] << endl;
//cout << "down[ok2-1]:" << down[ok2-1] <<", center:"<< center[i] <<", down[ok2]:" << down[ok2] << endl;
sum += (long long)ok1 * (long long)(n - ok2);
}
cout << sum << endl;
return 0;
} | //include,using,define等
#pragma region header
#include <algorithm>
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <math.h>
#include <cstring>
// ===============================================================
//using系
#pragma region header
using namespace std;
using ll = long long;
using lint = long long;
using vl = vector<long long>;
using vvl = vector<vector<long long>>;
using vvi = vector<vector<int>>;
using vs = vector<string>;
using vc = vector<char>;
using vcc = vector<vector<char>>;
using vm = vector<short>;
using vmm = vector<vector<short>>;
using pii = pair<int, int>;
using psi = pair<string, int>;
using ld = long double;
using ull = unsigned long long;
using ui = unsigned int;
using qul = queue<ll>;
using pql = priority_queue<ll>;
const int dx[] = { 1,0,-1,0 };
const int dy[] = { 0,1,0,-1 };
constexpr ll mod = 1000000007;
constexpr long double pi = 3.141592653589793238462643383279;
#pragma endregion
// ========================================================================
//define
#pragma region header
#define rep(i, n) for(ll i = 0; i < n; i++)
#define REP(i, n) for(ll i = 1; i <= n; i++)
#define INF (ll)10000000000000000
#define mod (ll)1000000007
#pragma endregion
#pragma endregion
int main() {
int n; cin >> n;
vector<int> a(n), b(n), c(n);
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < n; i++)
cin >> b[i];
for (int i = 0; i < n; i++)
cin >> c[i];
vector<int> d(n);
vector<int> e(n);
sort(a.begin(), a.end());
sort(b.begin(), b.end());
sort(c.begin(), c.end());
lint Finalans = 0;
for (int i = 0; i < n; i++) {
Finalans += (lower_bound(a.begin(), a.end(), b[i]) - a.begin()) * (n - (upper_bound(c.begin(),c.end(),b[i])-c.begin()));
}
printf("%lld\n", Finalans);
return 0;
} | 1 |
/* be name khoda */
// #define stream_enable
// #define long_enable
#include <iostream>
#include <algorithm>
#include <cstring>
#include <numeric>
#include <iomanip>
#include <sstream>
#include <vector>
#include <queue>
#include <set>
#include <map>
using namespace std;
#ifdef stream_enable
#define cin sss
#endif
#ifdef long_enable
typedef long long int ll;
#else
typedef int ll;
#endif
typedef pair<ll, ll> pii;
typedef pair<pii, ll> ppi;
typedef pair<ll, pii> pip;
typedef vector<ll> vi;
typedef vector<pii> vpii;
const ll MOD = 1000000007;
const long long BIG = 1446803456761533460;
const int Big = 336860180;
#define F first
#define S second
#define pb push_back
#define eb emplace_back
#define all(x) (x).begin(), (x).end()
#define debug(x) cout << #x << " -> " << (x) << endl
#define debug2(x, y) cout << #x << ' ' << #y << " -> " << (x) << ' ' << (y) << endl
#define debug3(x, y, z) cout << #x << ' ' << #y << ' ' << #z << " -> " << (x) << ' ' << (y) << ' ' << (z) << endl
#define debug4(x, y, z, t) cout << #x << ' ' << #y << ' ' << #z << ' ' << #t << " -> " << (x) << ' ' << (y) << ' ' << (z) << ' ' << (t) << endl
#define debugp(x) cout << #x << " -> " << "(" << (x).F << ", " << (x).S << ")" << endl
#define debuga(x, n) cout << #x << " -> "; fori (i1_da, n) { cout << (x)[i1_da] << ' '; } cout << endl
#define debugap(x, n) cout << #x << " ->\n"; fori (i1_dap, n) { cout << "(" << (x)[i1_dap].F << ", " << (x)[i1_dap].S << ")\n"; } cout << endl
#define debugaa(x, n, m) cout << #x << " ->\n"; fori (i1_daa, n) { fori (i2_daa, m) { cout << (x)[i1_daa][i2_daa] << ' '; } cout << '\n'; } cout << endl
#define debugav(x, n) cout << #x << " ->\n"; fori (i1_dav, n) { fori (i2_dav, (x)[i1_dav].size()) { cout << (x)[i1_dav][i2_dav] << ' '; } cout << '\n'; } cout << endl
#define debugia(x, n) cout << #x << " ->\n"; fori (i1_dia, n) { cout << i1_dia << " : " << (x)[i1_dia] << '\n'; } cout << endl
#define forifrom(i, s, n) for(ll i = (s); i < (n); ++i)
#define forirto(i, n, e) for(ll i = (n) - 1; i >= (e); --i)
#define fori(i, n) forifrom (i, 0, n)
#define forir(i, n) forirto (i, n, 0)
#define smin(a, b) a = min(a, (b))
#define smax(a, b) a = max(a, (b))
#define Add(a, b) a = ((a) + (b)) % MOD
#define Mul(a, b) a = (1LL * (a) * (b)) % MOD
stringstream sss;
// -----------------------------------------------------------------------
const ll maxn = 1010;
ll n;
char R[maxn][maxn];
string G[8][7] = {{},{},{},
{"aab",
"b.b",
"baa"},
{"aacd",
"bbcd",
"cdaa",
"cdbb"},
{"aabba",
"bcc.a",
"b..cb",
"a..cb",
"abbaa"},
{"aabcc.",
"b.b..c",
"baa..c",
"c..aab",
"c..b.b",
".ccbaa"},
{"aabbaa.",
"ccd...a",
"d.d...a",
"dcc...b",
"...ccdb",
"...d.da",
"...dcca"}};
void MAIN() {
cin >> n;
if (n == 2) {cout << "-1\n"; return;}
memset(R, '.', sizeof R);
ll i = n;
while (i >= 8) {
i -= 4;
fori (j, 4) fori (k, 4) R[i + j][i + k] = G[4][j][k];
}
fori (j, i) fori (k, i) R[j][k] = G[i][j][k];
fori (i, n) {
fori (j, n) {
cout << R[i][j];
}
cout << '\n';
}
}
// -----------------------------------------------------------------------
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(10);
sss << R"(
)";
MAIN();
return 0;
}
| #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, n) for(int i = 0, i##_len = (n); i < i##_len; ++i)
#define repp(i, m, n) for(int i = m, i##_len = (n); i < i##_len; ++i)
#define reprev(i, n) for(ll i = (n-1LL); i >= 0; --i)
#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 <ll,ll> P;
typedef long double ld;
int main(void)
{
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
if (n <= 2) {
cout << "-1\n";
} else if (n % 3 == 0) {
rep (i, n) {
rep (j, n) {
if (i / 3 == j / 3 && ((i % 3 == 0) ^ (j % 3 == 0))) cout << 'a';
else cout << '.';
}
cout << "\n";
}
} else if (n == 7) {
cout << "abb...a\n"
<< "a.a...a\n"
<< "bba...c\n"
<< "...abbc\n"
<< "...a.ab\n"
<< "...bbab\n"
<< "bbaacc.\n";
} else if (n == 11) {
cout << "bccaabbccaa\n"
<< "babb...abbc\n"
<< "ca.a...a.ac\n"
<< "cbba...bbab\n"
<< "baccbcc...b\n"
<< "ba.ab.b...a\n"
<< "accaccb...a\n"
<< "a...baacaab\n"
<< "b...b.bc.cb\n"
<< "b...aabaaca\n"
<< "ccaabbccbba\n";
} else {
int a, b;
for (int i = n / 5; i >= 0; i--) {
if ((n - 5 * i) % 4 == 0) {
a = i;
b = (n - 5 * i) / 4;
break;
}
}
// eprintf("a=%d, b=%d\n", a, b);
vector<string> s4 = {"aaca", "bbca", "acbb", "acaa"},
s5 = {"aacca", "c.bba", "cb..c", "ab..c", "accaa"};
rep (i, n) {
rep (j, n) {
if (i / 5 == j / 5 && i / 5 < a) {
// cout << 1;
cout << s5[i % 5][j % 5];
} else if ((i - 5 * a) / 4 == (j - 5 * a) / 4 && i - 5 * a >= 0 && j - 5 * a >= 0) {
// cout << 2;
cout << s4[(i - 5 * a) % 4][(j - 5 * a) % 4];
} else {
// cout << 3;
cout << '.';
}
}
cout << "\n";
}
}
return 0;
} | 1 |
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
int a;
cin>>a;
a=a+pow(a,2)+pow(a,3);
cout<<a;
}
| #include<bits/stdc++.h>
using namespace std;
int main()
{
int a;
cin>>a;
a= a + a*a + a*a*a;
cout<<a;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
void solve(){
int n; cin>>n;
vector<unsigned long long> a(n);
rep(i,n) cin>>a[i];
string s; cin>>s;
vector<unsigned long long> B;
for(int i=n-1;i>=0;i--){
auto v=a[i];
for(auto b:B) v=min(v,v^b);
if(v!=0){
if(s[i]=='1'){
puts("1");
return;
}
B.emplace_back(v);
}
}
puts("0");
}
int main(){
int q; scanf("%d",&q); rep(_,q) solve();
return 0;
}
| #include <cstdio>
#include <cctype>
#include <cstring>
#include <algorithm>
#define rr register
using namespace std;
const int d[10]={6,2,5,5,4,5,6,3,7,6};
int m,n,x[10],f[10011];
inline signed iut(){
rr int ans=0; rr char c=getchar();
while (!isdigit(c)) c=getchar();
while (isdigit(c)) ans=(ans<<3)+(ans<<1)+(c^48),c=getchar();
return ans;
}
inline signed max(int a,int b){return a>b?a:b;}
signed main(){
m=iut(),n=iut(),memset(f,0xcf,sizeof(f));
for (rr int i=1;i<=n;++i) x[i]=iut();
sort(x+1,x+1+n),reverse(x+1,x+1+n),f[0]=0;
for (rr int i=1;i<=n;++i)
for (rr int j=d[x[i]];j<=m;++j)
f[j]=max(f[j],f[j-d[x[i]]]+1);
while (m){
for (rr int i=1;i<=n;++i)
if (m>=d[x[i]]&&f[m]==f[m-d[x[i]]]+1){
putchar(x[i]+48),m-=d[x[i]];
break;
}
}
return !putchar(10);
} | 0 |
//Zory-2019
#include<bits/stdc++.h>
using namespace std;
namespace mine
{
typedef long long ll;
#define pr pair<int,int>
#define FR first
#define SE second
#define MP make_pair
#define PB push_back
#define vc vector
#define all(x) (x).begin(),(x).end()
#define sz(x) ((int)(x).size())
#define bin(x) (1ll<<(x))
#define GG(x) if(x) {puts("error");exit(666);}
#define fo(i,l,r) for(int i=(l),I=(r);i<=I;i++)
#define fd(i,r,l) for(int i=(r),I=(l);i>=I;i--)
ll qread()
{
ll ans=0,f=1;char c=getchar();
while(c<'0' or c>'9') {if(c=='-')f=-1;c=getchar();}
while('0'<=c and c<='9') ans=ans*10+c-'0',c=getchar();
return ans*f;
}
void write(ll num)
{
if(num<0) putchar('-'),num=-num;
if(num>=10) write(num/10);
putchar('0'+num%10);
}
void write1(ll num){write(num);putchar(' ');}
void write2(ll num){write(num);putchar('\n');}
template<typename T> void chmax(T &x,const T y) {x=(x>y?x:y);}
template<typename T> void chmin(T &x,const T y) {x=(x<y?x:y);}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
const int INF=0x3f3f3f3f;
const int MOD=1e9+7;
int mm(const int x){return x>=MOD?x-MOD:x;}
template<typename T> void add(T &x,const int &y){x=(x+y>=MOD?x+y-MOD:x+y);}
ll qpower(ll x,ll e,int mod=MOD){ll ans=1;GG(e<0)while(e){if(e&1)ans=ans*x%mod;x=x*x%mod;e>>=1;}return ans;}
ll invm(ll x){return qpower(x,MOD-2);}
const int N=1e6+10;
struct BIT
{
int bit[N];BIT(){memset(bit,0,sizeof bit);}
int lowbit(int x){return x&-x;}
void add(int x,int c){while(x<N)bit[x]+=c,x+=lowbit(x);}
int ask(int x){int ans=0;while(x>=1)ans+=bit[x],x-=lowbit(x);return ans;}
}bit[2];
int fm[3][N];int getid(int num){return 1+(num-1)/3;}
void gg(){puts("No");exit(0);}
int inv[2],flip[2];
void main()
{
int n=qread();fo(op,0,2) fo(i,1,n) fm[op][i]=qread();
fo(i,1,n)
{
if(getid(fm[0][i])!=getid(fm[1][i]) or getid(fm[1][i])!=getid(fm[2][i])) gg();
bool x=fm[0][i]<fm[1][i] and fm[1][i]<fm[2][i],y=fm[0][i]>fm[1][i] and fm[1][i]>fm[2][i];
if(!x and !y) gg();flip[i&1]+=y;
int id=getid(fm[0][i]);if((id&1)^(i&1)) gg();
inv[i&1]+=bit[i&1].ask(n-id+1),bit[i&1].add(n-id+1,1);
}
if((inv[0]&1)^(flip[1]&1) or (inv[1]&1)^(flip[0]&1)) gg();
puts("Yes");
}
};//(ans+MOD)%MOD
signed main()
{
srand(time(0));
mine::main();
}
| //IOI 2021
#include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define ff first
#define ss second
typedef long long ll;
typedef pair<int, int> pii;
const int MAXN = 4 * 100 * 1000 + 17;
int n, a[4][MAXN], b[4][MAXN], p[MAXN], q[MAXN], fen[MAXN];
vector<int> v[2];
void add(int x) {
for (; x <= n; x += x & (-x))
fen[x]++;
}
int get(int x) {
int res = 0;
for (; x; x -= x & (-x))
res += fen[x];
return res;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= n; j++)
cin >> a[i][j], b[i][j] = j * 3 + i - 3, p[b[i][j]] = j, q[b[i][j]] = i;
for (int j = 1; j <= n; j++) {
if (p[a[1][j]] != p[a[2][j]] || p[a[2][j]] != p[a[3][j]] || q[a[2][j]] != 2 || p[a[1][j]] % 2 != j % 2)
return cout << "No" << endl, 0;
v[j % 2].pb(j);
}
for (int k = 0; k < 2; k++) {
int inv = 0;
for (int i = v[k].size() - 1; i >= 0; i--)
(inv += get(p[a[1][v[k][i]]])) %= 2, add(p[a[1][v[k][i]]]);
int up = 0;
for (int i = 0; i < v[1 - k].size(); i++)
if (a[1][v[1 - k][i]] % 3 == 0)
up++;
if (up % 2 != inv % 2)
return cout << "No" << endl, 0;
for (int i = 1; i <= n; i++)
fen[i] = 0;
}
cout << "Yes" << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
//type
typedef long long ll;
#define pii pair<int, int>
#define vi vector<int>
//x * y * 1.0 can cause overflow
//constant
#define inf (int)(1e9+7)
#define mod (ll)(1e9+7)
#define eps 1e-10
//omission
#define eb emplace_back
#define F first
#define S second
#define SZ(x) ((int)(x).size())
#define all(v) v.begin(), v.end()
#define ios cin.tie(0); ios::sync_with_stdio(false)
#define FIX(a) cout << fixed << setprecision(a)
//manip
#define chmax(a, b) a = max(a, b)
#define chmin(a, b) a = min(a, b)
#define UNIQUE(v) v.erase(unique(v.begin(), v.end(), v.end());
#define fill(x, y) memset(x, y, sizeof(x))
#define ceil(a, b) a / b + !!(a % b)
template<class T> T power(T a, T b)
{return b ? power(a * a % inf, b / 2) * (b % 2 ? a : 1) % inf : 1;}
#define LB(v, x) (int)(lower_bound(v.begin(), v.end(), x) - v.begin())
#define UB(v, x) (int)(upper_bound(v.begin(), v.end(), x) - v.begin())
template<typename T> T gcd(T a, T b) {if (b == 0) return a; return gcd(b, a % b);}
template<typename T> T lcm(T a, T b) {return a / gcd(max(a, b), min(a, b)) * b;} //先に割る!!
#define outa(a, n) rep(i, n) cout << a[i] << " "; cout << endl
#define out(a) cout << a << endl
#define outv(v) rep(i, SZ(v)) cout << v[i] << " "; cout << endl
//loop
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define rep3(i, st, n) for (int i = st; i < n; ++i)
//algorithm
//double pointer, l start, how many adds, can be 0 -> init r = l, sum = 0
//bfs, not x, y, i, j
//not !(i % 2), i % 2 == 0
//minimal required terms
//cast caution
//look constraints always
/*
最小全域木
どうやってcostでsortするかがpointかな
組み合わせ考えたらN^2
解説見た
ある点と、その点から2本以上の辺を通って着く点との距離は、すべての点で隣だけ見たら求まる
cost = min(|a - c|, |b - d|)より
*/
class UnionFind {
public:
vector<int> Parent;
UnionFind(int N) {
Parent = vector<int>(N, -1);
}
int root(int A) {
if (Parent[A] < 0) return A;
return Parent[A] = root(Parent[A]);
}
int size(int A) {
return -Parent[root(A)];
}
bool connect(int A, int B) {
A = root(A);
B = root(B);
if (A == B) {
return true;
}
if (size(A) < size(B)) swap(A, B);
Parent[A] += Parent[B];
Parent[B] = A;
return false;
}
};
bool comp(pair<int, pii> a, pair<int, pii> b) {
return a.S.F < b.S.F;
}
bool comp2(pair<int, pii> a, pair<int, pii> b) {
return a.S.S < b.S.S;
}
bool compv(pair<pii, int> a, pair<pii, int> b) {
return a.S < b.S;
}
int main() {
int n; cin >> n;
pair<int, pii> p[n];
rep(i, n) {cin >> p[i].S.F >> p[i].S.S; p[i].F = i;}
sort(p, p + n, comp);
vector<pair<pii, int> > v; //id1, id2, cost
rep3(i, 1, n) {
v.eb(pii(p[i].F, p[i - 1].F), p[i].S.F - p[i - 1].S.F);
}
sort(p, p + n, comp2);
//cout << endl; rep(i, n) cout << p[i].F << " " << p[i].S.F << " " << p[i].S.S << endl;
rep3(i, 1, n) {
v.eb(pii(p[i].F, p[i - 1].F), p[i].S.S - p[i - 1].S.S);
}
sort(all(v), compv);
//cout << endl; rep(i, SZ(v)) cout << v[i].F.F << " " << v[i].F.S << " " << v[i].S << endl;
UnionFind uni(n);
ll ans = 0;
rep(i, SZ(v)) {
if (uni.connect(v[i].F.F, v[i].F.S) == 1) continue;
//cout << v[i].F.F << " " << v[i].F.S << " " << v[i].S << endl;
ans += v[i].S;
}
out(ans);
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int n;
int p[N];
pair<pair<int, int>, int> c[N];
pair< int, pair<int, int> > e[N];
int group(int a) {
if (p[a] == -1) {
return a;
}
return p[a] = group(p[a]);
}
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
#endif
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x, y;
scanf("%d %d", &x, &y);
c[i] = make_pair(make_pair(x, y), i);
}
for (int it = 0; it < 2; it++) {
sort(c, c + n);
for (int i = 0; i < n - 1; i++) {
int x = c[i].second;
int y = c[i + 1].second;
int d = abs(c[i + 1].first.first - c[i].first.first);
e[it * (n - 1) + i] = make_pair(d, make_pair(x, y));
}
for (int i = 0; i < n; i++) {
swap(c[i].first.first, c[i].first.second);
}
}
sort(e, e + 2 * n - 2);
fill_n(p, n, -1);
long long ans = 0;
for (int i = 0; i < 2 * n - 2; i++) {
int x = group(e[i].second.first);
int y = group(e[i].second.second);
int d = e[i].first;
if (x == y) {
continue;
}
p[x] = y;
ans += d;
}
printf("%lld\n", ans);
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()
{
ll n;
cin >> n;
ll sum = 26;
ll cnt = 1;
while (1)
{
if (n <= sum)
break;
sum = sum * 26 + 26;
cnt++;
}
vector<string> res(cnt);
rep(i, cnt)
{
n--;
int ans = n % 26;
res[cnt - i - 1] = (char)('a' + ans);
n /= 26;
}
rep(i, res.size()) cout << res[i];
cout << endl;
}
| #include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <set>
#include <cmath>
#include <stdio.h>
#include <list>
#include <numeric>
#include <stack>
#include <queue>
#include <tuple>
#include <bitset>
#include <map>
#include <math.h>
//ceil(a/b) (a + (b - 1))/ b
using namespace std;
#define rep(i,n) for(int i = 0; i < (n); i++)
typedef long long ll;
typedef pair<int,int> P;
const int inf=1000000007;
const ll mod=1000000007;
const double PI=3.14159265358979323846;
int dx[] = {1,-1,0,0};
int dy[] = {0,0,1,-1};
ll gcd(ll a, ll b){
if (b==0) return a;
else return gcd(b,a%b);
}
int cans(bool f){
if(f) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
}
int main(){
ll N;
cin >> N;
char a[28];
string s = "";
for(char i='a'; i<='z';i++){
a[int(i) - int('a')] = i;
}
while(N){
N--;
s += a[N%26];
N /= 26;
}
reverse(s.begin(), s.end());
cout << s << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int h,w;
int maps[101][101];
int check[101][101];
int dy[]={-1,0,1,0};
int dx[]={0,-1,0,1};
int color;
int sy,sx,gy,gx;
int by0[]={0,0,1,1,0,0,1,1};
int bx0[]={0,1,1,0,2,3,2,3};
int by1[]={0,0,1,1,2,3,2,3};
int bx1[]={0,1,1,0,0,0,1,1};
bool solve(int y,int x);
int main(){
int n,c,d,x,y;
while(cin>>w>>h,w|h){
cin>>sx>>sy;
cin>>gx>>gy;
cin>>n;
memset(check,0,sizeof(check));
for(int i=0;i<n;i++){
cin>>c>>d>>x>>y;
x--;y--;
if(d==0){
for(int i=0;i<8;i++){
maps[y+by0[i]][x+bx0[i]]=c;
}
}
if(d==1){
for(int i=0;i<8;i++){
maps[y+by1[i]][x+bx1[i]]=c;
}
}
}
sy--;sx--;gy--;gx--;
color=maps[sy][sx];
if(solve(sy,sx))cout<<"OK"<<endl;
else cout<<"NG"<<endl;
}
}
bool solve(int y,int x){
check[y][x]=1;
if(y==gy && x==gx)return true;
bool b=false;
for(int i=0;i<4;i++){
int ny=y+dy[i];
int nx=x+dx[i];
if(ny>=0 && ny<h && nx>=0 && nx<w && maps[ny][nx]==color && check[ny][nx]==0){
b=b | solve(ny,nx);
}
}
return b;
}
| #include <iostream>
using namespace std;
int F[102][102];
int xg,yg,ok;
void Maze(int X,int Y,int C){
//cout << X<<Y<<F[X][Y]<<endl;
if(F[X][Y]!=C)
return;
if(X==xg&&Y==yg){
cout << "OK"<<endl;
ok++;
}
F[X][Y]='.';
Maze(X-1,Y ,C);
Maze(X ,Y+1,C);
Maze(X+1,Y ,C);
Maze(X ,Y-1,C);
}
int main(){
while(1){
ok=0;
for(int i=1; i<=100; i++)
for(int j=1; j<=100; j++)
F[j][i]=0;
for(int i=0; i<102;i++){
F[0][i]=6;
F[i][0]=6;
}
int w,h,xs,ys,n,c,d,x,y;
cin >>w>>h;
if(w==0&&h==0)
return 0;
cin >>xs>>ys;
cin >>xg>>yg;
cin >>n;
for(int i=0; i<=w;i++)
F[w+1][i]=6;
for(int i=0; i<=h;i++)
F[i][h+1]=6;
int N=0;
while(N<n){
//cout <<N;
cin >>c>>d>>x>>y;
//cout<<c<<d<<x<<y<<endl;
if(d){
for(int i=x; i<x+2; i++)
for(int j=y; j<y+4; j++){
F[i][j]=c;
//cout <<F[i][j];
}
//cout <<endl;
}else{
for(int i=x; i<x+4; i++)
for(int j=y; j<y+2; j++){
F[i][j]=c;
//cout <<F[i][j];
}
//cout <<endl;
}
N++;
}
//for(int i=0; i<=101; i++){
//for(int j=0; j<=101; j++){
//cout <<F[j][i];
//}
//cout << endl;
//}
Maze(xs,ys,F[xs][ys]);
if(ok==0)
cout <<"NG"<<endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int n,m,ans,li[505][505],h[10005],a,b;
int main(){
while(1){
cin >> n >>m;
if(n==0&&m==0)break;
for(int i=0;i<m;i++){
cin >> a >> b;
li[a][b]=1;
}
for(int i=2;i<=n;i++){
if(li[1][i]==1||li[i][1]==1){
if(h[i]==0){
h[i]=1;
ans++;
}
for(int j=2;j<=n;j++){
if(li[j][i]==1||li[i][j]==1){
if(h[j]==0){
h[j]=1;
ans++;
}
}
}
}
}
cout << ans << endl;
for(int i=0;i<=n;i++)h[i]=0;
std::fill(li[0],li[504],0);
ans=0;
}
return 0;
} | #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <utility>
#include <numeric>
#include <algorithm>
#include <bitset>
#include <complex>
#include <fstream>
using namespace std;
typedef vector<int> vint;
typedef pair<int,int> pint;
#define rep(i,n) for(int i = 0; i < n; i++)
#define MSG(a) cout << #a << " " << a << endl;
template<class T, class C> pair<T,C> mp(T a, C b){ return make_pair(a, b);}
int main()
{
int n;
while(cin >> n && n)
{
vector<vector<bool> > s(n, vector<bool>(n));
rep(i,n+1) fill(s[0].begin(), s[0].end(), false);
int m;
cin >> m;
rep(i,m)
{
int a, b;
cin >> a >> b;
s[a-1][b-1] = s[b-1][a-1] = true;
}
int res = 0;
for(int i = 1; i < n; i++)
{
if(s[0][i]) res++;
else
{
for(int j = 1; j < n; j++)
{
if(s[0][j] && s[j][i])
{
res++;
break;
}
}
}
}
cout << res << endl;
}
} | 1 |
#include <bits/stdc++.h>
#include <string>
#include <cstring>
#include <algorithm>
#include <math.h>
#include <map>
#include <bitset>
#include <cmath>
#include <set>
#include <utility>
#define INF 1000000000000
#define MOD 1000000007 //10^9+7:合同式の法
using namespace std;
typedef long long ll;
//マクロ
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#define FORD(i,a,b) for(ll i=a;i>=(ll)(b);i--)
int main(){
int A,B,C,D;
cin >> A >> B >> C >> D;
if(A + B > C + D)
cout << "Left" << endl;
else if(A + B == C + D)
cout << "Balanced" << endl;
else
cout << "Right" << endl;
} | #include <stdio.h>
int main (){
int baris,kolom,warna,x;
scanf ("%d",&baris);
scanf ("%d",&kolom);
scanf ("%d",&warna);
if (baris > kolom){
x = (warna - 1)/baris +1;
}
else {
x = (warna - 1)/kolom +1;
}
printf ("%d",x);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
// type
typedef long long ll;
typedef long double ld;
// loop
//#define For(i, l, r, x) for (int i = l; i < r; i+=x)
//#define ForE(i, l, r, x) for (int i = l; i <= r; i+=x)
//#define Ford(i, r, l) for (int i = r; i > l; i--)
//#define FordE(i, r, l) for (int i = r; i >= l; i--)
//#define Fora(i, a) for (auto i : a)
// I/O
#define FAST_IO std::ios::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
//#define PrintV(a) Fora(ii, a) cout << ii << ' '; cout << rl;
//#define PrintVl(a) Fora(ii, a) cout << ii << rl;
//#define PrintA(a, l, r) for (int ii = l; ii <= r; ii++) cout << a[ii] << ' '; cout << rl;
//#define PrintAl(a, l, r) for (int ii = l; ii <= r; ii++) cout << a[ii] << rl;
//#define Ptest(x) return cout << x, 0;
#define setpre(n) fixed << setprecision(n)
// pair
#define F first
#define S second
#define pii pair<int, int>
#define pll pair<ll, ll>
#define pdd pair<ld, ld>
// vector & !!?(string)
#define eb emplace_back
#define pb push_back
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define sz(a) a.size()
#define len(a) a.length()
// geometry calc
#define pi acos(-1.0)
#define g_sin(a) sin(a*pi/180)
#define g_cos(a) cos(a*pi/180)
#define g_tan(a) tan(a*pi/180)
// set val
#define ms0(a) memset(a, 0, sizeof(a));
#define ms1(a) memset(a, 1, sizeof(a));
#define msn1(a) memset(a, -1, sizeof(a));
#define msinf(a) memset(a, 0x3f3f3f, sizeof(a));
// constant
const int mod1 = 998244353, mod = 1e9+7;
const int MAXN = 100005, MAX_M = 200010;
// code
//#define int long long
int x[MAXN];
int sps[MAXN][20];
int n, q, l;
void Solve() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> x[i];
cin >> l >> q;
int jump = n;
for (int i = n; i >= 1; i--){
while(x[jump] - x[i] > l) jump--;
sps[i][0] = jump;
}
for (int d = 1; d <= 19; d++){
for (int i = 1; i + (1 << d) <= n; i++)
sps[i][d] = sps[ sps[i][d-1] ][d-1];
}
while (q--){
int a, b, ans = 0;
cin >> a >> b;
if (a > b) swap(a, b);
for (int d = 19; d >= 0; d--){
if (sps[a][d] < b && sps[a][d]){
a = sps[a][d];
ans += (1 << d);
}
}
ans ++;
cout << ans << endl;
}
}
signed main(){
FAST_IO;
int TC = 1;
//cin >> TC;
while(TC--) Solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<int, int> Pi;
typedef vector<ll> Vec;
typedef vector<int> Vi;
typedef vector<string> Vs;
typedef vector<vector<ll>> VV;
typedef vector<vector<int>> VVi;
#define REP(i, a, b) for(ll i=(a); i<(b); i++)
#define PER(i, a, b) for(ll i=(a); i>=(b); i--)
#define rep(i, n) REP(i, 0, n)
#define per(i, n) PER(i, n, 0)
const ll INF=1e18+18;
const ll MAX=100005;
const ll MOD=1000000007;
#define Yes(n) cout << ((n) ? "Yes" : "No") << endl;
#define YES(n) cout << ((n) ? "YES" : "NO") << endl;
#define ALL(v) v.begin(), v.end()
#define rALL(v) v.rbegin(), v.rend()
#define pb(x) push_back(x)
#define mp(a, b) make_pair(a,b)
#define Each(a,b) for(auto &a :b)
#define REPM(i, mp) for (auto i = mp.begin(); i != mp.end(); ++i)
#define dbg(x_) cerr << #x_ << ":" << x_ << endl;
#define dbgmap(mp) cerr << #mp << ":"<<endl; for (auto i = mp.begin(); i != mp.end(); ++i) { cerr << i->first <<":"<<i->second << endl;}
#define dbgarr(n,m,arr) rep(i,n){rep(j,m){cerr<<arr[i][j]<<" ";}cerr<<endl;}
#define dbgdp(n,arr) rep(i,n){cerr<<arr[i]<<" ";}cerr<<endl;
#define sum(v) accumulate(ALL(v),0)
#define fi first
#define se second
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return true; } return false; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return true; } return false; }
template<typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) { return s<<"("<<p.first<<", "<<p.second<<")"; }
// vector
template<typename T>
ostream &operator<<(ostream &s, const vector<T> &v) {
int len=v.size();
for(int i=0; i<len; ++i) {
s<<v[i];
if(i<len-1) s<<" ";
}
return s;
}
// 2 dimentional vector
template<typename T>
ostream &operator<<(ostream &s, const vector<vector<T> > &vv) {
int len=vv.size();
for(int i=0; i<len; ++i) {
s<<vv[i]<<endl;
}
return s;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout<<std::setprecision(10);
ll a,b;
cin>>a>>b;
//a 白 b 黒
VV g(100,Vec(100,0));
rep(i,50){
rep(j,100){
g[i][j] = 1;
}
}
a--;b--;
REP(i,0,a){
ll h = i/50;
ll w = i%50;
g[h*2][w*2] = 0;
}
REP(i,0,b){
ll h = i/50;
ll w = i%50;
g[99-h*2][w*2] = 1;
}
cout<<100<<" "<<100<<endl;
rep(i,100){
string s;
rep(j,100){
s += g[i][j]==1?'#':'.';
}
cout<<s<<endl;
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define SORT(v) sort(v.rbegin() , v.rend())
#define si(n) scanf( "%d" , &n)
#define sii(n , m) scanf( "%d %d" , &n , &m)
#define sl(n) scanf( "%lld" , &n)
#define sll(n , m) scanf( "%lld %lld" , &n, &m)
#define ss(cad) scanf( "%s" , cad)
#define sz(x) (int)x.size()
#define PB push_back
#define fst first
#define scn second
#define DBG(x) cerr << #x << " = " << (x) << endl
#define M 1000000007
#define N_MAX 1000010
#define EPS 1e-9
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<bool> vb;
typedef vector<ll> vll;
typedef pair<int,int> pi;
typedef pair<ll,ll> pll;
typedef vector<pi> vp;
void mostrar(set<pi> ls){
for(auto x: ls)
printf("(%d, %d) ", x.fst, x.scn);
}
int main(){
int h, w;
sii(h, w);
set<pi> lista;
multiset<int> num;
for(int i = 1; i <= w; i++){
lista.insert({i, 1});
num.insert(1);
}
int cnt = 0;
while(h--){
int a, b;
sii(a, b);
bool sw = 0;
auto pt = lista.lower_bound(pi(a, -1));
auto pt2 = pt;
pi mitad = {-1, -1};
pi inicio;
if(pt != lista.begin()){
sw = 1;
pt--;
mitad = *pt;
inicio = *pt;
pt++;
}
while(pt != lista.end() && pt->fst <= b){
pt2 = pt;
mitad = *pt;
num.erase(num.lower_bound(mitad.scn));
pt++;
lista.erase(pt2);
}
pt2 = lista.lower_bound(pi(b+1, -1));
if(mitad.fst != -1 && b != w){
if(pt2 != lista.end() && pt2->fst != b+1){
int val = mitad.scn + b-mitad.fst+1;
//update(val, 1);
num.insert(val);
lista.insert({b+1, val});
}
else if(pt2 == lista.end()){
int val = mitad.scn + b-mitad.fst+1;
//update(val, 1);
num.insert(val);
lista.insert({b+1, val});
}
}
if(sw){
int val = inicio.scn + a-inicio.fst;
//update(val, 1);
num.insert(val);
lista.insert({a, val});
}
if(num.empty())
printf("-1\n");
else
printf("%d\n", *num.begin()+cnt);
//mostrar(lista);
//cout << endl;
cnt++;
}
return 0;
} | /*
Though leaves are many , the root is one.
Through all the lying days of my youth
I swayed my leaves and flowers in the sun.
Now I may wither into the truth.
- William Butler Yeats
*/
//#pragma GCC optimize("Ofast,no-stack-protector")
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx")
//#pragma GCC target("avx,tune=native")
#include<bits/stdc++.h>
#pragma comment("-Wl,--stack=1024000000")
//#include<ext/pb_ds/assoc_container.hpp>
using namespace std;
//using namespace __gnu_pbds;
const int inf=0x3f3f3f3f;
const double eps=1e-6;
const int mod=1000000007;
typedef long long ll;
#ifndef LOCAL
#define cerr if(0)cout
#define eprintf(...) 0
#else
#define eprintf(...) fprintf(stderr, __VA_ARGS__)
#endif
inline string getstr(string &s,int l,int r){string ret="";for(int i=l;i<=r;i++)ret.push_back(s[i]);return ret;}
int modpow(int x,int y,int md=mod){int ret=1;do{if(y&1)ret=(ll)ret*x%md;x=(ll)x*x%md;}while(y>>=1);return ret;}
inline int Rand(){return rand()*32768+rand();}
int n,m,sz,cnt;
vector<int>g[100005];
int col[100005],id[100005];
void dfs(int x,int ind){
sz++;
for(auto to:g[x]){
if(!col[to]){
col[to]=3-col[x];
id[to]=ind;
dfs(to,ind);
}
}
}
bool bin[100005];
int main(){
cin>>n>>m;
for(int i=1;i<=m;i++){
int x,y;cin>>x>>y;
g[x].push_back(y);
g[y].push_back(x);
}
int tot=0;
for(int i=1;i<=n;i++){
if(!col[i]){
col[i]=1;
id[i]=++tot;
sz=0;
dfs(i,tot);
if(sz==1)cnt++;
}
}
for(int i=1;i<=tot;i++)bin[i]=1;
for(int i=1;i<=n;i++){
for(auto to:g[i]){
if(col[i]==col[to]){
bin[id[i]]=0;
}
}
}
int cnt1=-cnt,cnt2=0;
for(int i=1;i<=tot;i++){
if(bin[i])cnt1++;
else cnt2++;
}
cout<<(ll)n*n-(ll)(n-cnt)*(n-cnt)+(ll)(tot-cnt)*(tot-cnt)+(ll)cnt1*cnt1<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool isStraight(vector<int> v, int s) {
for (int i = 1; i < v.size(); ++i) {
if (v[(s+i)%v.size()] != (v[(s+i-1+v.size())%v.size()]+1)%13) {
return false;
}
}
return true;
}
bool isStraight(vector<int> v) {
return isStraight(v, 0) || (v[0] == 0 && isStraight(v, 1));
}
int main() {
vector<int> a(5);
while ( scanf("%d,%d,%d,%d,%d", &a[0], &a[1], &a[2], &a[3], &a[4]) != EOF ) {
for (int i = 0; i < a.size(); ++i) {
--a[i];
}
sort(a.begin(), a.end());
vector<int> v(1, 1);
int prev = a[0];
for (int i = 1; i < a.size(); ++i) {
if (prev == a[i]) {
++v[v.size()-1];
}
else {
v.push_back(1);
prev = a[i];
}
}
sort(v.begin(), v.end(), greater<int>());
if (v[0] >= 4) {
cout << "four card" << endl;
}
else if (v.size() >= 2 && v[0] >= 3 && v[1] >= 2) {
cout << "full house" << endl;
}
else if ( isStraight(a) ) {
cout << "straight" << endl;
}
else if (v[0] >= 3) {
cout << "three card" << endl;
}
else if (v.size() >= 2 && v[1] >= 2) {
cout << "two pair" << endl;
}
else if (v[0] >= 2) {
cout << "one pair" << endl;
}
else {
cout << "null" << endl;
}
}
} |
#define _USE_MATH_DEFINES
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
#include <cstring>
#include <vector>
#include <map>
#include <utility>
#include <complex>
#include <stack>
#include <climits>
#include <set>
#include <numeric>
using namespace std;
int t[5];
bool straight()
{
if(t[0] == 1 && t[1] == 10 && t[2] == 11 && t[3] == 12 && t[4] == 13) return true;
for (int i = 0; i < 4; i++){
if(t[i+1]-t[i] != 1) return false;
}
return true;
}
int main()
{
while(~scanf("%d,%d,%d,%d,%d",t,t+1,t+2,t+3,t+4)){
sort(t,t+5);
if(t[0] == t[3] || t[1] == t[4])
puts("four card");
else if( (t[0] == t[1] && t[2] == t[4]) || (t[0] == t[2] && t[3] == t[4]))
puts("full house");
else if(straight())
puts("straight");
else if(t[0] == t[2] || t[1] == t[3] || t[2] == t[4])
puts("three card");
else if( (t[0] == t[1] && (t[2] == t[3] || t[3] == t[4])) || (t[1] == t[2] && t[3] == t[4]) )
puts("two pair");
else if( t[0] == t[1] || t[1] == t[2] || t[2] == t[3] || t[3] == t[4])
puts("one pair");
else
puts("null");
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#define mo 998244353
#define int long long
using namespace std;
const int N = 100001;
int f[N], inv[N], k, n;
inline int read() {
int x = 0, flag = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') flag = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - 48;
ch = getchar();
}
return x * flag;
}
inline int qp(int base, int pow) {
int res = 1;
while (pow) {
if (pow & 1)
res = res * base, res %= mo;
base = base * base;
base %= mo;
pow >>= 1;
}
return res;
}
inline void pre() {
f[0] = 1;
for (register int i = 1; i <= 100000; ++i) {
f[i] = f[i - 1] * i;
f[i] %= mo;
}
inv[100000] = qp(f[100000], mo - 2);
for (register int i = 99999; i >= 0; --i) {
inv[i] = inv[i + 1] * (i + 1) % mo;
}
}
inline int C(int n, int m) {
if (n < m) return 0;
return f[n] * inv[n - m] % mo * inv[m] % mo;
}
void solve(int x) {
int t = 0;
for (int i = 1; i <= x / 2; ++i) {
int a = i, b = x - i;
if (a <= k && b <= k) t++;
}
// printf("%lld %lld\n", x, t);
int flag = 1, w = t, res = 0;
for (int i = 1; i <= t; ++i) {
(res += C(n + k - 1 - 2 * i, k - 1) * flag * C(t, i) % mo) %= mo;
w--;
flag = -flag;
}
int ans = (C(n + k - 1, k - 1) - res + mo) % mo;
printf("%lld\n", ans);
}
signed main() {
pre();
k = read(), n = read();
for (int i = 2; i <= 2 * k; ++i) {
solve(i);
}
return 0;
} | #include<cstdio>
#include<algorithm>
using std::max;
#define int long long
const int mod=998244353;
int K,n,_2[5010],C[5010][5010];
signed main(){
scanf("%lld%lld",&K,&n);
C[0][0]=1;
for(int i=1;i<=5000;i++){
C[i][0]=1;
for(int j=1;j<=i;j++)
C[i][j]=(C[i-1][j-1]+C[i-1][j])%mod;
}
_2[0]=1;
for(int i=1;i<=5000;i++)
_2[i]=_2[i-1]*2%mod;
for(int i=2;i<=2*K;i++)
if(i&1){
int y=abs(K-i+1),x=(K-y)/2,ans=0;
for(int j=0;j<=x;j++)
(ans+=C[x][j]*_2[j]%mod*C[n+y-1][j+y-1]%mod)%=mod;
printf("%lld\n",ans);
}
else{
int y=abs(K-i+1),x=(K-y)/2,ans=0;
for(int j=0;j<=x;j++)
(ans+=C[x][j]*_2[j]%mod*(C[n+y-1][j+y-1]+C[n+y-2][j+y-1])%mod)%=mod;
printf("%lld\n",ans);
}
} | 1 |
#include<iostream>
using namespace std;
int main(){
int n,x,i=3;
cin >> n;
while(n>=i){
x=i;
if(i%3==0){
cout << ' ' << i;
} else if(i%10==3){
cout << ' ' << i;
} else {
while(x!=0){
x/=10;
if(x%10==3){
cout << ' ' << i;
break;
}
}
}
i++;
}
cout << endl;
}
| // @author: arch_
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n; cin >> n;
for (int i = 1; i <= n; i++) {
if (i % 3 == 0
|| to_string(i).find("3") != string::npos)
cout << " " << i;
} cout << "\n";
return 0;
} | 1 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
template <typename T> using oset = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define ull unsigned long long int
#define ll long long int
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(),x.end()
#define MOD (ull)(double)(1e9 + 7)
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vi vector<int>
#define vb vector<bool>
#define vd vector<double>
#define vll vector<ll>
#define vpii vector<pii>
#define vpll vector<pll>
#define vvi vector<vi>
#define vvll vector<vll>
#define vs vector<string>
#define pull pair<ull, ull>
#define F first
#define S second
#define m_p make_pair
#define debug(x) cout << #x << " " << x << endl
#define printArr(a, start, end)for(int i=start ; i<end ; ++i)cout << a[i] << " ";cout << '\n';
#define readArr(a, start, end)for(int i=start ; i<end ; ++i)cin >> a[i];
#define read2D(mat, n, m)for(int i=0 ; i<n ; ++i)for(int j=0 ; j<m ; ++j)cin >> mat[i][j];
const long double PI = 3.141592653589793238462643383279502884197169399;
// Find Set LSB = (x&(-x)), isPowerOfTwo = (x & (x-1))
void solve(){
int n;
cin >> n;
vi a(n);
for(int& x : a)cin >> x;
vi b(n);
for(int& x : b)cin >> x;
reverse(all(b));
int l=0, r=n-1;
for(int i=0 ; i<n ; ++i){
if(a[i] == b[i]){
if(a[l] != b[i] && b[l] != b[i]){
swap(b[i], b[l]);
++l;
}
else if(a[r] != b[i] && b[r] != b[i]){
swap(b[i], b[r]);
--r;
}
else{
cout << "No\n";
return;
}
}
}
for(int i=0 ; i<n ; ++i){
if(a[i] == b[i]){
cout << "No\n";
return;
}
}
cout << "Yes\n";
for(int& x : b)cout << x << " ";
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(10);
int tt=1;
//cin >> tt;
while(tt--){
solve();
}
}
| #include <vector>
#include <stack>
#include <queue>
#include <list>
#include <bitset>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <algorithm>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <string>
#include <chrono>
#include <random>
#include <cmath>
#include <cassert>
#include <climits>
#include <cstring>
#include <cstdlib>
#include <functional>
#include <sstream>
using namespace std;
int main(int argc, char** argv) {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; ++i) {
cin >> A[i];
--A[i];
}
vector<int> B(n);
for (int i = 0; i < n; ++i) {
cin >> B[i];
--B[i];
}
const int INF = 1 << 24;
vector<pair<int,int>> rangesA(n, make_pair(INF, -INF));
vector<pair<int,int>> rangesB(n, make_pair(INF, -INF));
for (int i = 0; i < n; ++i) {
int l = i;
int x = A[i];
while (i + 1 < n && A[i + 1] == x) {
++i;
}
int r = i;
rangesA[x] = make_pair(l, r);
}
for (int i = 0; i < n; ++i) {
int l = i;
int x = B[i];
while (i + 1 < n && B[i + 1] == x) {
++i;
}
int r = i;
rangesB[x] = make_pair(l, r);
}
bool ok = true;
for (int i = 0; i < n; ++i) {
int cntA = rangesA[i].second - rangesA[i].first + 1;
int cntB = rangesB[i].second - rangesB[i].first + 1;
if (cntA > 0 && cntB > 0 && cntA > n - cntB) {
ok = false;
break;
}
}
if (!ok) {
cout << "No\n";
return 0;
}
vector<int> cnts(2 * n + 1, 0);
for (int i = 0; i < n; ++i) {
int la = rangesA[i].first, ra = rangesA[i].second;
int lb = rangesB[i].first, rb = rangesB[i].second;
if (la >= n || lb >= n) {
continue;
}
int r = ra - lb;
if (r < 0) {
r += n;
}
int l = (la - (rb - lb)) - lb;
while (l < 0) {
l += n;
}
while (l > r) {
r += n;
}
// cout << i << " : " << l << " - " << r << endl;
cnts[l] += 1;
cnts[r + 1] -= 1;
}
for (int i = 1; i < cnts.size(); ++i) {
cnts[i] += cnts[i - 1];
}
int offset = -1;
for (int i = 0; i < n; ++i) {
if (cnts[i] + cnts[i + n]== 0) {
offset = i;
break;
}
}
vector<int> res(n, 0);
for (int i = 0; i < n; ++i) {
res[i] = (B[(i - offset + n) % n]);
}
cout << "Yes\n";
for (int i = 0; i < n; ++i) {
cout << res[i] + 1 << (i == n - 1 ? '\n' : ' ');
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, init, n) for(int i = (int)(init); i < (int)(n); i++)
#define vi vector<int>
#define vl vector<long>
#define vvi vector<vector<int>>
#define vvl vector<vector<long>>
#define pint pair<int, int>
#define plong pair<long, long>
int INF = (1 << 29);
int main() {
int N, M;
cin>> N >> M;
vvi G(N);
REP(i, 0, M){
int a, b;
cin >> a >> b;
a--; b--;
G[a].emplace_back(b);
}
int shortest = N + 1;
vi ans;
REP(i, 0, N){
vi dist(N, -1), prev(N, -1);
queue<int> que;
que.push(i);
dist[i] = 0;
while(!que.empty()){
auto cur = que.front(); que.pop();
for(int x: G[cur]){
if(dist[x] == -1){
dist[x] = dist[cur] + 1;
prev[x] = cur;
que.push(x);
}
}
}
REP(j, 0, N){
if(j == i || dist[j] == -1) continue;
for(auto nj: G[j]){
if(nj == i){
vi tmp({i+1});
int cur = j;
while(cur != i) tmp.push_back(cur+1), cur = prev[cur];
if(shortest > tmp.size()){
shortest = tmp.size();
ans = tmp;
}
}
}
}
}
if(shortest == N+1) cout << -1 << endl;
else{
cout << ans.size() << endl;
for(auto v: ans) cout << v << endl;
}
} | #include<iostream>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
//1000000000000223
#define ll long long
#define ld long double
#define IO ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
using namespace std;
int n, m, vis[1009], vis2[1009],par[1009],go[1009][1009] ;
vector<int> v[1009];
vector<int> ans;
void solve()
{
int sz=ans.size();
for(int i=0; i<sz; i++)
{
for(int j=i+2; j<sz; j++)
if(go[ans[i]][ans[j]])
{
ans.erase(ans.begin()+i+1,ans.begin()+j);
solve();
return ;
}
int j=0;
if(i==sz-1)
j=1;
for(; j<i; j++)
if(go[ans[i]][ans[j]])
{
ans.erase(ans.begin()+i+1,ans.end());
ans.erase(ans.begin(),ans.begin()+j);
solve();
return ;
}
}
cout<<ans.size()<<endl;
for(auto i : ans)
cout<<i<<"\n";
}
void dfs(int node)
{
if(vis2[node])
{
int x=node;
while(par[x]!=node)
ans.push_back(x), x=par[x];
ans.push_back(x);
reverse(ans.begin(),ans.end());
solve();
exit(0);
}
if(vis[node])
return ;
vis2[node]++;
vis[node]++;
for(auto i : v[node])
{
par[i]=node;
dfs(i);
}
vis2[node]--;
}
int main()
{
IO
cin>>n>>m;
while(m--)
{
int x, y ;
cin>>x>>y;
go[x][y]=1;
v[x].push_back(y);
}
for(int i=1; i<=n; i++)
dfs(i);
cout<<-1;
return 0;
}
| 1 |
#include<iostream>
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> pi;
#define F first
#define S second
#define PB push_back
#define MP make_pair
#define what_is(x) cerr << #x << " is " << x << endl;
#define MT make_tuple
#define eb emplace_back
#define rep(i, begin, end) for (__typeof(end) i = (begin) - ((begin) > (end)); i != (end) - ((begin) > (end)); i += 1 - 2 * ((begin) > (end)))
#define REP(i,a,b) for (int i = a; i <= b; i++)
#define FOR(i,n) for (int i=0;i < n ; i++)
#define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
void err(istream_iterator<string> it) {}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
int main(){
int n;
cin >> n;
ll a[n];
FOR(i,n) cin >>a[i];
sort(a,a+n);
int j=n-1;
while(j>=1 && a[j]!=a[j-1]) j--;
if(j==0) {
cout <<0;
return 0;
}
else {
int k=j-2;
while(k>=1 && a[k]!=a[k-1]) k--;
if(k==0) {
cout << 0;
return 0;
}
else cout << a[j]*a[k];
}
return 0;
} | #include <iostream>
#include <string>
using namespace std;
bool isPlain(string secret){
bool find_the,find_that,find_this;
find_the = (secret.find("the") != string::npos);
find_that = (secret.find("that") != string::npos);
find_this = (secret.find("this") != string::npos);
return (find_the || find_that || find_this);
}
string decipher(string secret){
int gap = 1;
string plain;
bool check;
//"the", "that", "this"
check = isPlain(secret);
if(check){
plain = secret;
}
else {
while(gap<=26){
string::iterator it = secret.begin();
for (; it != secret.end(); it += 1){
if('a'<=*it & *it <='z')
*it = (*it!='z') ? *it + 1 : 'a';
//cout << *it;
}
//cout << endl;
gap++;
if(isPlain(secret)) break;
}
}
return secret;
}
int main (int argc, char const* argv[]){
string secret, plain;
//暗号文の取得
getline(cin,secret);
while(!secret.empty()){
//暗号解読
plain = decipher(secret);
//平文の出力
cout << plain << endl;
getline(cin,secret);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool solve(){
int n;
cin >> n;
if(n == 0) return true;
vector<pair<double,string> > ls;
for(int i=0;i<n;i++){
string l;
int p, a, b, c, d, e, f, s, m;
cin >> l >> p >> a >> b >> c >> d >> e >> f >> s >> m;
int X = f*s*m - p, Y = a+b+c+(d+e)*m;
ls.emplace_back(make_pair(double(-X)/Y,l));
}
sort(ls.begin(), ls.end());
for(int i=0;i<n;i++){
cout << ls[i].second << endl;
}
cout << '#' << endl;
return false;
}
int main(){
while(!solve());
return 0;
}
| #include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
int n, x[105], y[105];
double mx, z[105], PI = acos(-1.0);
int main() {
int i, j, k;
scanf("%d", &n);
for(i=0; i<n; i++) scanf("%d%d", &x[i], &y[i]);
for(i=0; i<n; i++) {
for(j=k=0; j<n; j++) if(i!=j) z[k++] = atan2(y[j]-y[i], x[j]-x[i]);
sort(z, z+k);
mx = z[0] - z[k-1] + 2*PI ;
for(j=1; j<k; j++) mx = max(mx, z[j] - z[j-1]);
printf("%.9f\n", max(0., (mx-PI)/2./PI));
}
return 0;
} | 0 |
#include <cstdio>
#include <iostream>
using namespace std;
int main(){
int n,i,x;
scanf("%d",&n);
i=1;
do {
x=i;
if(x%3==0){
cout << " " << i;
} else do {
if ( x%10 == 3 ) {
cout << " " << i;
x=0;
}
} while (x/=10,x>0);
} while (++i <= n);
cout << endl;
};
| // C++ 14
#include <bits/stdc++.h>
using namespace std;
template <typename T> ostream& operator<<(ostream& os, const vector<T>& v) { os << "["; for (int i = 0; i < v.size(); ++i) { os << v[i]; if (i != v.size() - 1) os << ", "; } os << "]"; return os; }
template <typename T> void print(T v, string s = "\n") { cout << v << s; }
template <typename T> void in(T &v) { cin >> v; }
#define ll long long
#define loop(__x, __start, __end) for(int __x = __start; __x < __end; __x++)
int main() {
int n; ll m; in(n),in(m);
vector<ll> A(n);
loop(i,0,n) in(A[i]);
loop(i,0,n) A[i]%=m;
ll rem = 0;
map<ll, ll> C;
C[rem]++;
loop(i,0,n) {
rem = (rem + A[i]) % m;
C[rem]++;
}
ll ans = 0;
for (auto &&c: C) {
ans += (c.second * (c.second - 1)) / 2;
}
print(ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define sc(x) scanf("%d", &x)
#define pr(x) printf("%d\n", x)
#define lowbit(x) (x & -x)
#define ll long long
#define N 500010
using namespace std;
ll tot = 0, head[N], v[N], dis[N], n, m, cnt;
struct Xiao
{
int next, to, w;
}f[N * 3];
void add(int x, int y, int z)
{
f[++tot].to = y;
f[tot].next = head[x];
f[tot].w = z;
head[x] = tot;
}
void spfa()
{
memset(dis, 127, sizeof dis);
memset(v, 0, sizeof v);
queue <int> q;
q.push(1);
v[1] = 1;
dis[1] = 0;
while (q.size())
{
int x = q.front();
q.pop();
for (int i = head[x]; i; i = f[i].next)
{
int y = f[i].to;
if (dis[y] > dis[x] + f[i].w)
{
dis[y] = dis[x] + f[i].w;
if (!v[y])
{
v[y] = 1;
q.push(y);
}
}
}
v[x] = 0;
}
}
map < pair <int, int>, int > p;
int get(int x, int y)
{
if (p.find(make_pair(x, y)) != p.end()) return p[make_pair(x, y)];
else return p[make_pair(x, y)] = ++cnt;
}
int main()
{
//freopen("railway.in", "r", stdin);
//freopen("railway.out", "w", stdout);
sc(n);
sc(m);
cnt = n;
for (int i = 1; i <= m; i++)
{
int x, y, z;
sc(x);
sc(y);
sc(z);
int p1 = get(x, z);
int p2 = get(y, z);
add(p2, p1, 0);
add(p1, p2, 0);
add(x, p1, 1);
add(p1, x, 1);
add(y, p2, 1);
add(p2, y, 1);
}
spfa();
printf("%lld\n", dis[n] > 2 * n ? -1 : dis[n] / 2);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pll pair<long long,long long>
#define ii pair<int,int>
#define mod 1000000007
#define endl '\n'
#define IOS std::ios::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL);
ll power(ll a,ll b){
ll ans=1;
while(b>0){
if(b%2!=0){
ans=(ans*a)%mod;
}
a=((a%mod)*(a%mod))%mod;
b>>=1;
}
return ans;
}
void sieve(int n){
bool prime[n+1];
memset(prime,true,sizeof(prime));
for(int p=2;p*p<=n;p++){
if(prime[p]){
for(int i=p*p;i<=n;i+=p)
prime[i]=false;
}
}
for(int p=2;p<=n;p++){
if(prime[p])
cout<<p<<" ";
}
}
int main() {
IOS;
int t=1;
//cin>>t;
while(t--){
int k,x;
cin>>k>>x;
for(int i=(x-k+1);i<=x+k-1;i++){
cout<<i<<" ";
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct StQuery
{
StQuery() : m_nLeft(0), m_nRigt(0) { }
int m_nLeft;
int m_nRigt;
};
void fnInput(string& rsStr, vector<StQuery>& rvoQuery)
{
int nStrSiz, nQuerySiz;
cin >> nStrSiz >> nQuerySiz;
rvoQuery.resize(nQuerySiz);
cin >> rsStr;
for (StQuery& roQuery : rvoQuery)
cin >> roQuery.m_nLeft >> roQuery.m_nRigt;
}
void fnSubStrACCnt(string sStr, const vector<StQuery>& cnrvoQuery)
{
const string cnsAC = "AC";
int nACCnt = 0;
vector<int> vnACCnt(sStr.size());
for (int nBgn = 0; nBgn < vnACCnt.size() - 1; nBgn++)
{
if (sStr.substr(nBgn, 2) == cnsAC) nACCnt++;
vnACCnt[ nBgn + 1 ] = nACCnt;
}
for (int i = 0; i < cnrvoQuery.size(); i++)
{
cout << vnACCnt[ cnrvoQuery[i].m_nRigt - 1 ] - vnACCnt[ cnrvoQuery[i].m_nLeft - 1];
cout << endl;
}
}
int main()
{
string sStr;
vector<StQuery> voQuery;
fnInput(sStr, voQuery);
fnSubStrACCnt(sStr, voQuery);
return 0;
} | #include <iostream>
#include <string>
#include <queue>
#include <vector>
#include <algorithm>
#include <math.h>
#include <map>
#include <list>
#include <iomanip>
#include <queue>
#include <numeric>
#define repl(i, l, r) for (ll i = l; i < r; i++)
#define rep(i, n) repl(i, 0, n)
using namespace std;
using ll = long long;
template<class T>bool chmax(T& a, const T& b) { if (a < b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T& a, const T& b) { if (b < a) { a = b; return 1; } return 0; }
int main() {
ll N, Q;
cin >> N >> Q;
string S;
cin >> S;
vector<ll> F(N + 1), B(N + 1);
ll tmp = 0, total;
rep(i, N - 1) {
if (S[i] == 'A' && S[i + 1] == 'C') {
tmp++;
}
F[i + 2] = tmp;
}
total = tmp;
tmp = 0;
for (ll i = N - 1; i >= 1; i--) {
if (S[i - 1] == 'A' && S[i] == 'C') {
tmp++;
}
B[i] = tmp;
}
vector<ll> ans(Q);
ll x, y;
rep(i, Q) {
cin >> x >> y;
ans[i] = total - B[y] - F[x];
}
rep(i, Q) {
cout << ans[i] << endl;
}
return 0;
}
| 1 |
#define _USE_MATH_DEFINES
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
const ll MOD = 1e9 + 7;
const ll LINF = 1e18;
#define y0 y3487465
#define y1 y8687969
#define j0 j1347829
#define j1 j234892
#define next asdnext
#define prev asdprev
#define MP make_pair //pairのコンストラクタ
#define F first //pairの一つ目の要素
#define S second //pairの二つ目の要素
#define dump(x) cout << #x << " = " << (x) << endl; //debug
#define SZ(x) ((ll)(x).size())
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define RFOR(i, a, b) for (ll i = (a); i >= (b); i--)
#define ps(s) cout << #s << endl;
#define pv(v) cout << (v) << endl;
#define pvd(v) cout << setprecision(16) << (v) << endl;
#define ALL(a) (a).begin(),(a).end()
#define RANGE(a, start_index, num) (a).begin()+(start_index),(a).begin()+(num)
int main() {
int n, k;
cin >> n >> k;
deque<ll> d;
FOR(i, 1, n) {
int v;
cin >> v;
d.push_back(v);
}
ll res = 0;
int lim = min(k, n);
FOR(i, 0, lim) {
FOR(j, 0, i) {
deque<ll> d2 = d;
vector<ll> jw;
FOR(left, 1, j) {
jw.push_back(d2.front());
d2.pop_front();
}
FOR(right, 1, i - j) {
jw.push_back(d2.back());
d2.pop_back();
}
sort(ALL(jw));
FOR(index, 0, k - i - 1) {
if (index <= i - 1 && jw[index] < 0) {
jw[index] = 0;
}
}
ll tmp = accumulate(ALL(jw), 0LL);
res = max(res, tmp);
}
}
pv(res)
} | #include<iostream>
using namespace std;
int main(){
int N;
int A,AA;
long long ans=0;
cin>>N;
int times=N-1;
int s;
cin>>A;
for(int i=0;i<times;i++){
cin>>AA;
if(A>AA){
s=A-AA;
ans+=s;
AA+=s;
A=AA;
}else{
A=AA;
}
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
ios::sync_with_stdio(false);
cin.tie(0);
int n; cin >> n;
vector<int> p(n+1);
cin >> p[0] >> p[1];
for(int i = 0; i < n-2; i++){
int a, b; cin >> a >> b;
p[i+2] = b;
}
{
int a, b; cin >> a >> b;
p[n] = b;
}
int dp[101][101];
memset(dp, 0, sizeof(dp));
n = p.size() - 1;
for(int l = 2; l <= n; l++){
for(int i = 1; i <= n-l+1; i++){
int j = i+l-1;
dp[i][j] = INT_MAX/10;
for(int k = i; k < j; k++){
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k+1][j] + p[i-1]*p[k]*p[j]);
}
}
}
cout << dp[1][n] << endl;
return 0;
} | #include <iostream>
#include <vector>
#include <cmath>
#include <limits.h>
#include <utility>
#include <map>
#include <algorithm>
#include <set>
using namespace std;
using P = pair<int,int>;
using ll = long long;
const int MOD=1e9+7;
void modplus(int &a,int b){
a+=b;
a%=MOD;
}
ll eline(int a){
if(a<=0)return 1ll;
vector<vector<int>> dp(a,vector<int>(2,0));
dp[0][0]=1;
dp[0][1]=1;
for(int i=1;i<a;i++){
dp[i][0]=dp[i-1][0]+dp[i-1][1];
dp[i][1]=dp[i-1][0];
}
return dp[a-1][0]+dp[a-1][1];
}
int main(){
int h,w,g;
cin>>h>>w>>g;
g--;
vector<vector<int>> dp(h+1,vector<int>(w,0));
dp[0][0]=1;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
for(int l=-1;l<=1;l++){
int from=j,to=j+l;
if(from>to)swap(from,to);
if(l==0){
modplus(dp[i+1][j],dp[i][j]*(eline(from-1)*eline(w-to-2)%MOD)%MOD);
}else if(0<=j+l&&j+l<w){
modplus(dp[i+1][j+l],dp[i][j]*(eline(from-1)*eline(w-to-2)%MOD)%MOD);
}
}
}
}
cout<<dp[h][g]<<endl;
} | 0 |
#include <cstdio>
#include <cstdlib>
typedef struct node {
long v;
node *parent;
node *left;
node *right;
} Node;
typedef struct {
Node *root;
} Tree;
Tree T = {NULL};
void insertTree(Node *node) {
Node *y = NULL;
Node *x = T.root;
while (x != NULL) {
y = x;
if (node->v < x->v) {
x = x->left;
} else {
x = x->right;
}
}
node->parent = y;
if (y == NULL) {
T.root = node;
} else if (node->v < y->v) {
y->left = node;
} else {
y->right = node;
}
}
Node * find(long v) {
Node *x = T.root;
while (x != NULL) {
if (x->v == v) return x;
else if (x->v < v) x = x->right;
else x = x->left;
}
return NULL;
}
void Transplant(Node *u, Node *v) {
if (u->parent == NULL) {
T.root = v;
} else if (u == u->parent->left) {
u->parent->left = v;
} else {
u->parent->right = v;
}
if (v != NULL) {
v->parent = u->parent;
}
}
Node *TreeMinimum(Node *x) {
while (x->left != NULL) {
x = x->left;
}
return x;
}
void deleteNode(Node *z) {
if (z->left == NULL) {
Transplant(z, z->right);
} else if (z->right == NULL) {
Transplant(z, z->left);
} else {
Node *y = TreeMinimum(z->right);
if (y->parent != z) {
Transplant(y, y->right);
y->right = z->right;
y->right->parent = y;
}
Transplant(z, y);
y->left = z->left;
y->left->parent = y;
}
}
void Preorder(Node *n) {
if (n != NULL) {
printf(" %ld", n->v);
Preorder(n->left);
Preorder(n->right);
}
}
void Inorder(Node *n) {
if (n != NULL) {
Inorder(n->left);
printf(" %ld", n->v);
Inorder(n->right);
}
}
int main () {
long n;
scanf("%ld", &n);
char command[10];
long value;
for (long i=0; i<n; i++) {
scanf(" %s %ld", command, &value);
if (command[0] == 'i') {
Node *node = (Node *)malloc(sizeof(Node));
node->v = value;
node->parent = NULL;
node->left = NULL;
node->right = NULL;
insertTree(node);
} else if (command[0] == 'f') {
Node *found = find(value);
if (found != NULL) printf("yes\n");
else printf("no\n");
} else if (command[0] == 'd') {
Node *z = find(value);
deleteNode(z);
} else {
Inorder(T.root);
printf("\n");
Preorder(T.root);
printf("\n");
}
}
return 0;
} | #include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#define NIL -1
#define MAX 610005
#define REP(i,s,n) for(int i=s;i<n;i++)
#define rep(i,n) REP(i,0,n)
using namespace std;
int n;
int root;
int *p = new int[MAX]; // p---| Unit
int *left2 = new int[MAX]; // left2 --|--------> T
int *right2 = new int[MAX]; //right2---|
int *key = new int[MAX]; // key----|
void Init(){
rep(i,MAX){
p[i]=left2[i]=right2[i]=key[i]=NIL;
}
}
int TREE_MINIMUM(int x){
while(left2[x] != NIL){
x = left2[x];
}
return x;
}
int TREE_SUCCESSOR(int x){
if(right2[x] != NIL)return TREE_MINIMUM(right2[x]);
int y = p[x];
while(y != NIL && x == right2[y]){
x = y;
y = p[y];
}
return y;
}
void TREE_DELETE(int z){
int y,x;
if(left2[z] == NIL || right2[z] == NIL)y = z;
else y = TREE_SUCCESSOR(z);
if(left2[y] != NIL)x = left2[y];
else x = right2[y];
if(x != NIL)p[x]=p[y];
if(p[y] == NIL)root = x;
else if(y == left2[p[y]])left2[p[y]] = x;
else right2[p[y]] = x;
if(y != z)key[z] = key[y];
}
bool SEARCH(int x,int k){
if(k == key[x])return true;
if(x == NIL)return false;
if(k < key[x])return SEARCH(left2[x],k);
else return SEARCH(right2[x],k);
}
void TREE_INSERT(int z){
int y = NIL;
int x = root;
while(x != NIL){
y = x;
if(key[z] < key[x]){
x = left2[x];
}
else x = right2[x];
}
p[z]=y;
if(y == NIL){
root = z;
}
else if(key[z] < key[y]){
left2[y] = z;
}else{
right2[y] = z;
}
}
int IndexSearch(int x){
for(int i=0;i<MAX;i++){
if(key[i] == x)return i;
}
return -1;
}
void InorderTreeWalk(int x){
if(x != NIL){
InorderTreeWalk(left2[x]);
printf(" %d",key[x]);
InorderTreeWalk(right2[x]);
}
}
void PreorderTreeWalk(int x){
if(x != NIL){
printf(" %d",key[x]);
PreorderTreeWalk(left2[x]);
PreorderTreeWalk(right2[x]);
}
}
int main(){
int val;
string op;
long long zr;
scanf("%d",&n);
Init();
root = -1;
zr=0;
while(n-- > 0){
cin >> op;
if(op == "insert"){
scanf("%d",&val);
key[zr]=val;
TREE_INSERT(zr);
zr++;
}else if(op == "print"){
InorderTreeWalk(root);
printf("\n");
PreorderTreeWalk(root);
printf("\n");
}
else if(op == "find"){
scanf("%d",&val);
if(SEARCH(root,val)){
printf("yes\n");
}else{
printf("no\n");
}
}
else if(op == "delete"){
scanf("%d",&val);
int inthis = IndexSearch(val);
if(inthis != -1){
TREE_DELETE(inthis);
}
}
}
delete [] p;
delete [] left2;
delete [] right2;
delete [] key;
return 0;
} | 1 |
#include<iostream>
using namespace std;
typedef pair<char,int> P;
string str;
int len,size=0,cnt=1,ans=0;
P t[1000000];
int main(){
cin>>str;
str.push_back('-');
len=str.size();
for(int i=1;i<len;i++){
if(str[i-1]==str[i]){
cnt++;
}else{
t[size++]=P(str[i-1],cnt);
cnt=1;
}
}
for(int i=0;i+2<size;i++){
if(t[i].first!='J')continue;
if(t[i+1].first!='O')continue;
if(t[i+2].first!='I')continue;
if(t[i].second<t[i+1].second)continue;
if(t[i+1].second>t[i+2].second)continue;
ans=max(ans,t[i+1].second);
}
cout<<ans<<endl;
return 0;
} | #include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<set>
#include<iomanip>
#define pi 3.14159265358979323846
#define ll long long
#define rep(i, a, n) for(int i = a; i < n; i++)
using namespace std;
int main(){
int n, sm = 0;
cin >> n;
if(n >= 500){
sm += n / 500 * 1000;
n = n % 500;
}
if(n >= 5){
sm += n / 5 * 5;
}
cout << sm << "\n";
} | 0 |
#include "bits/stdc++.h"
#define rep(i, n) for(int i = 0; i < (int)n; i++)
#define all(co) co.begin(), co.end()
using namespace std;
//using P = pair<int, int>;
int main() {
int n;
while (cin >> n && n) {
int k; cin >> k;
vector<string> vec(n);
rep(i, n) cin >> vec[i];
set<string> sets;
vector<bool> used(n);
function<void(string, int)> dfs = [&](string str, int count) {
if (count == k) {
sets.insert(str);
return;
}
rep(i, n) if (!used[i]) {
used[i] = true;
dfs(str + vec[i], count + 1);
used[i] = false;
}
};
dfs("", 0);
cout << sets.size() << endl;
}
return 0;
} | #include<iostream>
#include<vector>
#include<set>
#include<string>
using namespace std;
int n,m;
vector<int> came;
string str[11];
set<string> ans;
void serch(int loop,string sans)
{
// cout << "loop:" << loop << endl;
if(loop==m)
{
// cout << "came:" ;
// for(int i=0;i<came.size();i++)
// cout << came[i] << " " ;
// cout << endl;
// cout << sans << endl;;
ans.insert(sans);
return ;
}
for(int i=0;i<n;i++)
{
for(int j=0;j<came.size();j++)
{
// cout << "j:" << j << " now:" << came[j] << " size:" << came.size() << " " << i << endl;
if(i==came[j])
{
i++;
j=-1;
}
}
if(i==n)
break;
// cout << "next:" << i << endl;
came.push_back(i);
serch(loop+1,sans+str[i]);
came.pop_back();
}
return ;
}
int main()
{
int i,j;
for(;;)
{
cin >> n >> m ;
if(n==0 && m==0)
break;
ans.clear();
for(i=0;i<n;i++)
cin >> str[i] ;
serch(0,"");
cout << ans.size() << endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using iii = pair<ii, int>;
#define vt vector
#define pq priority_queue
#define pb push_back
#define pf push_front
#define mp make_pair
#define fi first
#define se second
#define __lcm(a, b) a * b / __gcd(a, b)
// #define multicase
const int MOD = 1e9 + 7;
const int INF = 2e9;
const int N = 2e5 + 5;
int x;
void solve() {
int T = 1;
#ifdef multicase
cin >> T;
#endif
while(T--) {
cin >> x;
cout << (x < 1200 ? "ABC\n" : x < 2800 ? "ARC\n" : "AGC\n");
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
solve();
} | #define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(v) v.begin(), v.end()
typedef long long ll;
#include <bits/stdc++.h>
using namespace std;
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;
} | 1 |
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define PI 3.1415926535897932
#define MOD 1000000007;
using namespace std;
long long GCD(long long A,long long B){
if(B==0){
return A;
}
else{
return GCD(B,A%B);
}
}
long long LCM(long long A,long long B){
long long g=GCD(A,B);
return A/g*B;
}
long long num_order(long long X){
long long ans=0;
while(true){
if(X==0){
break;
}
else{
X/=10;
ans++;
}
}
return ans;
}
vector<pair<long long,long long>> prime_factorize(long long N){
vector<pair<long long,long long>> res;
for(long long i=2;i*i<=N;i++){
if(N%i!=0){
continue;
}
long long ex=0;
while(N%i==0){
ex++;
N/=i;
}
res.push_back({i,ex});
}
if(N!=1){
res.push_back({N,1});
}
return res;
}
int main() {
int N;
cin>>N;
vector<vector<int>> vec(N,vector<int>(2));
for(int i=0;i<N;i++){
cin>>vec[i][0]>>vec[i][1];
}
vector<int> root(N);
for(int i=0;i<N;i++){
root[i]=i;
}
double sum=0;
do{
double d=0;
for(int i=0;i<N-1;i++){
double a=pow((vec[root[i]][0]-vec[root[i+1]][0]),2);
double b=pow((vec[root[i]][1]-vec[root[i+1]][1]),2);
d+=pow(a+b,0.5);
}
sum+=d;
}
while(next_permutation(root.begin(),root.end()));
int x=1;
for(int i=2;i<=N;i++){
x*=i;
}
cout<<fixed<<setprecision(10)<<sum/x<<endl;
} | #include <bits/stdc++.h>
#define rep(i,l,n) for(int i=l;i<n;i++)
#define o(a) cout<<a<<endl
using namespace std;
int main(){
int a;
while(scanf("%d",&a)!=EOF){
int d[14]={},p=0,m=0;
char c;
vector<int> n(5);
n[0]=a;
d[n[0]]++;
rep(i,1,5){
cin>>c>>n[i];
d[n[i]]++;
}
sort(n.begin(),n.end());
rep(i,1,14){
m=max(m,d[i]);
if(d[i]>=2) p++;
}
if(m==4){
o("four card");
}else if(m==3 && p==2){
o("full house");
}else if(m==3){
o("three card");
}else if(p==2){
o("two pair");
}else if(p==1){
o("one pair");
}else{
bool f=1;
rep(i,0,4){
if(n[i+1]!=n[i]+1 && !(n[0]==1 && n[1]==10 && n[4]==13)){
f=0; break;
}
}
if(f) o("straight");
else o("null");
}
}
} | 0 |
#include <cstdio>
#include <cstring>
#include <string>
#include <iostream>
#include <cmath>
#include <bitset>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <algorithm>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
const int INF=1e9;
int main()
{
int n, m;
cin>>n>>m;
vector<P> g[15];
for(int i=0; i<m; i++){
int a, b, c;
cin>>a>>b>>c;
a--; b--;
g[a].push_back(P(b, c));
g[b].push_back(P(a, c));
}
int dp[14][1<<14];
for(int i=0; i<n-1; i++){
if(i==0) fill(dp[i], dp[i]+(1<<(n-1)), 0);
else fill(dp[i], dp[i]+(1<<(n-1)), INF);
}
int s[1<<15]={};
for(int i=0; i<(1<<n); i++){
for(int x=0; x<n; x++){
if((i&(1<<x))==0) continue;
for(auto pr:g[x]){
int y=pr.first;
if((i&(1<<y))==0) continue;
s[i]+=pr.second;
}
}
s[i]/=2;
}
for(int i=1; i<(1<<(n-1)); i++){
for(int j=i; j>0; j=(j-1)&i){
int sum=s[i]-s[i-j]-s[j];
for(int x=0; x<n-1; x++){
if((j&(1<<x))==0) continue;
for(auto pr:g[x]){
int y=pr.first;
if(((i-j)&(1<<y))==0) continue;
dp[y][i]=min(dp[y][i], dp[x][j]+sum-pr.second);
}
}
}
}
int ans=INF;
for(int i=1; i<(1<<(n-1)); i++){
int sum=s[(1<<n)-1]-s[i]-s[(1<<n)-1-i];
for(auto pr:g[n-1]){
int y=pr.first;
if((i&(1<<y))==0) continue;
ans=min(ans, dp[y][i]+sum-pr.second);
}
}
cout<<ans<<endl;
return 0;
} | //#include <bits/c++config.h>
#include <iostream>
#include <iomanip>
#include <math.h>
#include <cmath>
#include <algorithm>
#include <climits>
#include <cstring>
#include <string>
#include <cstdlib>
#include <ctime>
#include <cstdio>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <map>
#include <set>
#define itn int
#define nit int
#define ll long long
#define ms multiset
#define F(i,a,b) for(register int i=a,i##end=b;i<=i##end;++i)
#define UF(i,a,b) for(register int i=a,i##end=b;i>=i##end;--i)
#define openf(a) freopen(#a".in","r",stdin);freopen(#a".out","w",stdout)
#define re register
#define ri re int
#define il inline
//#pragma GCC optimize(2)
using namespace std;
int read() {
int x=0;
bool fu=0;
char ch=0;
while(ch>'9'||ch<'0') {
ch=getchar();
if(ch=='-')fu=1;
}
while(ch<='9'&&ch>='0') x=(x*10+ch-48),ch=getchar();
return fu?-x:x;
}
ll n,m,t1,t2,g[17][17],full[1<<16],dp[17][1<<16];
long long tot;
int main(){
memset(dp,-0x80,sizeof(dp));
dp[0][1]=0;
cin>>n>>m;
F(i,1,m){
cin>>t1>>t2;
t1--,t2--;
cin>>g[t2][t1];
tot+=g[t2][t1];
g[t1][t2]=g[t2][t1];
}
for(register int i=1;i<(1<<n);i++){
for(ri j=1;j<n;j++){
if(i&(1<<j)){
for(ri k=0;k<j;k++){
if(i&(1<<k)){
full[i]+=g[j][k];
}
}
}
}
}for(register int S=1;S<(1<<n);S+=2){
for(register int i=0;i<n;i++){
if(!(S&(1<<i)))continue;
for(register int j=1;j<n;j++){
if(!g[i][j]||(S&(1<<j)))continue;
dp[j][S|(1<<j)]=max(dp[j][S|(1<<j)],dp[i][S]+g[i][j]);
}
ri s2=((1<<n)-1)^S;
for(register int j=s2;j;j=(j-1)&s2){
dp[i][S|j]=max(dp[i][S|j],dp[i][S]+full[(1<<i)|j]);
}
}
}
cout<<tot-dp[n-1][(1<<n)-1];
return 0;
} | 1 |
#include <iostream>
#include <utility>
#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;
#define gcu getchar_unlocked
#define pcu putchar_unlocked
#define _il inline
#define _in _il int in
#define _sc _il bool scan
_in(int c){int n=0;bool m=false;if(c=='-')m=true,c=gcu();
do{n=10*n+(c-'0'),c=gcu();}while(c>='0');return m?-n:n;} //&&c<='9'
_in() {return in(gcu());}
_sc(int &n){int c=gcu();return c==EOF?false:(n=in(c),true);}
_sc(char &c){c=gcu();gcu();return c!=EOF;}
//_sc(string &s){int c;s="";
// for(;;){c=gcu();if(c=='\n'||c==' ')return true;else if(c==EOF)return false;s+=c;}}
template <typename H,typename... T> _sc(H &h, T&&... t){return scan(h)&&scan(t...);}
#define _vo _il void out
#define _vl _il void outl
template <typename T>
_vo(T n){static char buf[20];char *p=buf;
if(n<0)pcu('-'),n*=-1;if(!n)*p++='0';else while(n)*p++=n%10+'0',n/=10;
while (p!=buf)pcu(*--p);}
_vo(const char *s){while(*s)pcu(*s++);}
_vo(char c){pcu(c);}
//_vo(string &s){for (char c: s) pcu(c);}
template <typename H,typename... T> _vo(H&& h, T&&... t){out(h);out(move(t)...);}
//template <typename T> _vo(vector<T> &v){for(T &x:v)out(&x == &v[0]?"":" "),out(x);out('\n');}
_vl(){out('\n');}
template <typename... T> _vl(T&&... t){out(move(t)...);outl();}
template<int N>
struct sieve {
bool s[N];
constexpr sieve() : s() {
for (int i = 0; i < N; i++)
s[i] = true;
for (int i = 4; i < N; i += 2)
s[i] = false;
for (int i = 9; i < N; i += 6)
s[i] = false;
for (int i = 6, e = sqrt(N); i <= e; i += 6) {
for (int j : {i - 1, i + 1})
if (s[j])
for (int k = j * j; k < N; k += j)
s[k] = false;
}
}
};
template<int N>
struct twin {
int t[N/10], l;
constexpr twin() : t(), l(1) {
sieve<N> s;
t[0] = 5;
for (int i = 0; i < N; i++)
if (s.s[i - 2] && s.s[i])
t[l++] = i;
}
};
int main() {
enum {N = 10001};
twin<N> t;
for (int n; (n = in());) {
auto r = upper_bound(t.t, t.t + t.l, n) - 1;
outl(*r - 2, ' ', *r);
}
}
| #include <cstdio>
#include <vector>
#include <algorithm>
#include <queue>
using namespace std;
template <class T>
using gp_queue=priority_queue<T, vector<T>, less<T>>;
using Weight=int;
using DArray=vector<Weight>;
using DMatrix=vector<DArray>;
static const Weight INF=1<<29;
struct Edge {
size_t src, dst;
Weight weight;
Edge() {}
Edge(size_t src, size_t dst, Weight weight=1):
src(src), dst(dst), weight(weight)
{}
};
bool operator<(const Edge &e, const Edge &f) {
if (e.weight != f.weight) {
return e.weight > f.weight;
} else {
return e.src!=f.src? e.src<f.src : e.dst<f.dst;
}
}
using Edges=vector<Edge>;
using Vertex=vector<Edge>;
using Graph=vector<Vertex>;
void join(Graph &g, size_t s, size_t d, Weight w=1) {
// non-directed
g[s].push_back(Edge(s, d, w));
g[d].push_back(Edge(d, s, w));
}
void connect(Graph &g, size_t s, size_t d, Weight w=1) {
// directed
g[s].push_back(Edge(s, d, w));
}
pair<Weight, Edges> minimum_spanning_tree(const Graph &g, size_t s=0) {
/* Prim */
size_t V=g.size();
Edges T;
Weight total=0;
vector<bool> visited(V);
gp_queue<Edge> q; q.push(Edge(-1, s, 0));
while (!q.empty()) {
Edge e=q.top(); q.pop();
if (visited[e.dst]) continue;
T.push_back(e);
total += e.weight;
visited[e.dst] = true;
for (const Edge &f: g[e.dst])
if (!visited[f.dst])
q.push(f);
}
return make_pair(total, T);
}
int main() {
size_t n;
scanf("%zu", &n);
Graph g(n);
for (size_t i=0; i<n; ++i)
for (size_t j=0; j<n; ++j) {
Weight a;
scanf("%d", &a);
if (a > -1)
connect(g, i, j, a);
}
printf("%d\n", minimum_spanning_tree(g).first);
return 0;
} | 0 |
#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)
const string YES = "Yes";
const string NO = "No";
void solve(ll A, ll B, ll C) {
bool pred = (A-C) * (C-B) > 0;
cout << (pred ? YES : NO) << endl;
}
int main() {
ll A;
cin >> A;
ll B;
cin >> B;
ll C;
cin >> C;
solve(A, B, C);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int a,b,c;
cin>>a>>b>>c;
if(c>=a&&c<=b||c>=b&&c<=a)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return 0;
} | 1 |
#include <stdio.h>
int main(void)
{
int n;
int min, max;
double sum;
scanf("%d", &n);
int num;
int pointer=0;
scanf("%d", &num);
min=max=sum=num;
for(int i=0; i<n-1; i++){
scanf("%d", &num);
if(min>num) min=num;
if(max<num) max=num;
sum+=num;
}
printf("%d %d %.0lf\n", min, max, sum);
return 0;
} | #include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <queue>
using namespace std;
int main() {
int N, T;
cin >> N >> T;
long long X = 0;
long long preT = 0;
cin >> preT;
for (int i = 0; i < N - 1; ++i) {
int t; cin >> t;
if (preT + T < t) {
X += T;
}
else {
X += (t - preT);
}
preT = t;
}
cout << X + T << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
using P = pair<int,int>;
template< typename T >
struct BinaryIndexedTree {
vector< T > data;
BinaryIndexedTree(int sz) {
data.assign(++sz, 0);
}
T sum(int k) {
T ret = 0;
for(++k; k > 0; k -= k & -k) ret += data[k];
return (ret);
}
void add(int k, T x) {
for(++k; k < data.size(); k += k & -k) data[k] += x;
}
};
int main()
{
int n,Q;
cin >> n >> Q;
vector<int> c(n);
rep(i,n) {
cin >> c[i];
c[i]--;
}
vector<int> ql(Q),qr(Q);
vector<vector<int>> table(n);
rep(i,Q) {
cin >> ql[i] >> qr[i];
ql[i]--; qr[i]--;
table[qr[i]].push_back(ql[i]);
}
vector<int> place(n,-1);
BinaryIndexedTree<int> bit(n);
map<P,int> mp;
rep(i,n) {
if(place[c[i]] != -1) bit.add(place[c[i]], -1);
place[c[i]] = i;
bit.add(i, 1);
for(int l : table[i]) {
if(l > 0) mp[P(l,i)] = bit.sum(i) - bit.sum(l-1);
else mp[P(0,i)] = bit.sum(i);
}
}
rep(i,Q) cout << mp[P(ql[i],qr[i])] << endl;
return 0;
} | #include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
typedef long long ll;
const ll M = 4e18;
ll n, m, mn = M;
vector<ll> ve[1005];
vector<ll> ans;
vector<ll> now;
ll vv[1005];
void dfs(ll p)
{
if(now.size() != 0 && p == now[0])
{
if(mn > now.size())
{
mn = now.size();
ans = now;
}
return;
}
else if(vv[p]) return;
if(now.size() > mn) return;
vv[p] = true;
now.push_back(p);
for(ll i = 0; i < ve[p].size(); i++)
{
dfs(ve[p][i]);
}
// vv[p] = false;
now.pop_back();
}
int main()
{
scanf("%lld%lld", &n, &m);
for(ll i = 0; i < m; i++)
{
ll u, v;
scanf("%lld%lld", &u, &v);
ve[u].push_back(v);
}
for(ll i = 1; i <= n; i++)
{
for(ll i = 1; i <= n; i++) vv[i] = false;
dfs(i);
}
if(mn == M) printf("-1\n");
else
{
printf("%lld\n", mn);
for(ll i = 0; i < ans.size(); i++)
{
printf("%lld\n", ans[i]);
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,x,y) for(ll i=(x);i<(y);i++)
#define rrep(i,x,y) for(ll i=(ll)(y)-1;i>=(x);i--)
#define all(x) (x).begin(),(x).end()
#ifdef LOCAL
#define dump(x) cerr << #x << " = " << (x) << endl
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl
#define dassert(...) assert(__VA_ARGS__)
#else
#define dump(x)
#define debug(x)
#define dassert(...)
#endif
//#define int long long
typedef long long ll;
const ll MOD = 1e9 + 7;
const long double EPS = 1e-8;
signed main(){
int T;
cin >> T;
rep(ti,0,T) {
int N;
cin >> N;
vector<ll> A(N);
rep(i,0,N) cin >> A[i];
string S;
cin >> S;
// if base[i] != 0, base[i]'s ith bit is 1 and the other base's ith bit is 0.
vector<ll> base(60);
bool zero = true;
rrep(i,0,N) {
if (S[i] == '0') {
// remove 1 from A[i]'s bits where base exists.
rrep(bi,0,base.size()) {
if (base[bi] != 0 && (A[i] & (1LL << bi))) {
A[i] ^= base[bi];
}
}
// insert A[i] into base
rrep(bi, 0, base.size()) {
// found
if (A[i] & (1LL << bi)) {
base[bi] = A[i];
// remove 1 in bi'th bit from other base
rep(j,0,base.size()) {
if (j != bi && (base[j] & (1LL << bi))) {
base[j] ^= base[bi];
}
}
break;
}
}
} else {
rrep(bi, 0, base.size()) {
if (base[bi] != 0 && (A[i] & (1LL << bi))) {
A[i] ^= base[bi];
}
}
// A[i] is not included in base
if (A[i] != 0) {
zero = false;
break;
}
}
}
cout << (zero ? 0 : 1) << endl;
}
return 0;
}
| #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <string>
#include <sstream>
#include <complex>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <functional>
using namespace std;
#define mod 1000000007
#define FOR(x,to) for(int x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
#define long long long
inline int rei(){int x;cin>>x;return x;}
inline long rel(){long x;cin>>x;return x;}
inline string res(){string x;cin>>x;return x;}
//-------------------------------------------------------
int A[500000];
int acum[500001];
bool S[500001];
int zero[500001];
long DP[500001];
long DP2[500001];
vector<pair<int,int>> Data;
void Calc(){
int N = rei();
for(int i=0;i<N;i++){
A[i] = rei();
}
for(int i=0;i<N;i++){
acum[i+1] = acum[i] ^ A[i];
}
if(acum[N] == 0){
int z = 0;
for(int i=0;i<=N;i++){
if(acum[i] == 0){
z++;
}
else{
Data.push_back({acum[i],i});
}
zero[i] = z;
}
sort(Data.begin(),Data.end());
long ans = 1;
for(int i=0;i<z-2;i++){
ans <<= 1;
ans %= mod;
}
int p = 0;
while(p < Data.size()){
long c = 1;
long d = 1;
while(p+1 < Data.size() && Data[p].first == Data[p+1].first){
p++;
d += c * (zero[Data[p].second] - zero[Data[p-1].second]);
d %= mod;
c += d;
c %= mod;
}
p++;
ans += c;
ans %= mod;
}
cout << ans << endl;
}
else{
int c = 0;
for(int i=0;i<=N;i++){
if(acum[i] == 0){
S[c++] = false;
}
else if(acum[i] == acum[N]){
S[c++] = true;
}
}
DP[0] = 1;
for(int i=1;i<c;i++){
if(S[i]){
DP[i] = DP[i-1];
DP2[i] = (DP[i-1] + DP2[i-1]) % mod;
}
else{
DP[i] = (DP[i-1] + DP2[i-1]) % mod;
DP2[i] = DP2[i-1];
}
}
cout << DP[c-1] << endl;
}
}
int main(int argc,char** argv){
ios::sync_with_stdio(false), cin.tie(0);
cout.tie(0); Calc(); return 0;
} | 0 |
#include<iostream>
#include<queue>;
using namespace std;
#define MAX 1000000001
long long CNT = 0;
void merge(long long a[], int begin, int end, int mid) {
queue<long long> left;
queue<long long> right;
for (int i = begin; i < mid; i++)left.push(a[i]);
for (int i = mid; i < end; i++)right.push(a[i]);
left.push(MAX);
right.push(MAX);
int cnt = left.size() - 1;
for (int i = begin; i < end; i++) {
if (left.front() < right.front()) {
a[i] = left.front();
left.pop();
cnt--;
}
else {
a[i] = right.front();
right.pop();
CNT += cnt;
}
}
}
void m_sort(long long a[], int begin, int end) {
if (begin >= end - 1)return;
int mid = (begin + end) / 2;
m_sort(a, begin, mid);
m_sort(a, mid, end);
merge(a, begin, end, mid);
}
int main() {
long long ary[200000];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ary[i];
}
m_sort(ary, 0, n);
cout << CNT << endl;
return 0;
} | /**
* code generated by JHelper
* More info: https://github.com/AlexeyDmitriev/JHelper
* @author
*/
#include <cstdio>
#include <cstring>
#include <cmath>
#include <utility>
#include <iostream>
#include <functional>
#include <bitset>
#include <algorithm>
#include <vector>
#include <forward_list>
#include <set>
#include <map>
#include <queue>
#include <deque>
#include <stack>
#include <numeric>
#define ll long long int
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
using namespace std;
int mx4[] = {0,1,0,-1};
int my4[] = {1,0,-1,0};
int mx2[] = {1,0};
int my2[] = {0,1};
class ATravelingBudget {
public:
void solve(istream& in, ostream& out) {
int a,b,c,d;
in >> a >> b >> c >> d;
int t = min(a,b);
int v = min(c,d);
out << t + v << endl;
}
};
int main() {
ATravelingBudget solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
} | 0 |
#include <bits/stdc++.h>
#define mp make_pair
#define pb push_back
#define all(x) x.begin(),x.end()
#define cmin(a,b) (a>b?a=b:a)
#define cmax(a,b) (a<b?a=b:a)
#define mem(a,k) memset(a,k,sizeof(a))
#define lop(i,s,t) for(int i=s;i<(t);++i)
#define rep(i,s,t) for(int i=s;i<=(t);++i)
#define dec(i,s,t) for(int i=s;i>=(t);--i)
#define fore(i,v) for(int i=g[v],d=es[i].d;i;i=es[i].nxt,d=es[i].d)
using namespace std;
#ifdef CURIOUSCAT
#define Pr(f,...) fprintf(stderr,f,##__VA_ARGS__),fflush(stderr)
#else
#define Pr(f,...)
#endif
typedef long long ll;
template<typename T>
void read(T &x){
x=0;
char c;
for(c=getchar();!isdigit(c);c=getchar());
for(;isdigit(c);c=getchar())x=x*10+c-'0';
}
const int N=1e6+50;
int P;
int mul(int a,int b){ return 1ll*a*b%P; }
int add(int a,int b){ a+=b; return a>=P?a-P:a; }
void upd(int &a,int b) { a=a+b>=P?a+b-P:a+b; }
int sub(int a,int b){ a-=b; return a<0?a+P:a; }
int gcd(int a,int b){ return !b?a:gcd(b,a%b); }
int C(int n,int m) {
if(m<0||m>n)return 0;
if(m==0)return 1;
if(m==1)return n;
if(m==2)return n&1?mul(n,(n-1)/2):mul(n/2,n-1);
}
int n,dp[6005][2005],ans;
int main(int argc,char *argv[]){
#ifdef CURIOUSCAT
#endif
read(n); read(P);
dp[0][0]=1;
rep(i,0,n*3)rep(j,0,n){
upd(dp[i+1][j],dp[i][j]);
upd(dp[i+2][j+1],mul(dp[i][j],C(i+1,1)));
upd(dp[i+3][j+1],mul(dp[i][j],mul(C(i+2,2),2)));
}
rep(j,0,n)ans=add(ans,dp[n*3][j]);
cout<<ans<<endl;
return 0;
}
| #include <bits/stdc++.h>
#include <algorithm>
#define int long long
using namespace std;
#define mod 1000000007
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
bool vis[200005];
vector<int> vec[2000005], v1;
int child[2000005];
// int parent[2000005];
// //int div1[100005];
// int min_indx[200005];
// int count1 = 0;
// int height = 0;
// int max_indx[200005];
// int f[100005];
// int cost[100005];
// stack<int> stc;
// int ans[100005];
// int count2;
// int sum[100005];
// int max1 = 0;
// //int count1 = 0;
void dfs(int node)
{
vis[node] = 1;
for (int i = 0; i < vec[node].size(); i++)
{
if (!vis[vec[node][i]])
{
dfs(vec[node][i]);
child[node] += child[vec[node][i]];
}
}
// stc.pop();
}
// void dfs1(int node)
// {
// vis[node] = 1;
// // cout << node << "\n";
// for (int i = 0; i < vec[node].size(); i++)
// {
// if (!vis[vec[node][i]])
// {
// sum[vec[node][i]] += sum[node];
// // cout << sum[vec[node][i]] << " " << sum[node] << "\n";
// dfs1(vec[node][i]);
// }
// }
// }
// int MAXN = 200005;
// int LOGMAXN = (int)log2(200005) + 1;
// int M[200005][60];
// //int ans[200005];
// void fun(int a, int b, int c)
// {
// //ll val = 1;
// while (a <= b)
// {
// ans[a] += c;
// int p = -a;
// a += (a & p);
// }
// }
// int find1(int a)
// {
// int sum = 0;
// while (a != 0)
// {
// sum += ans[a];
// int p = -a;
// a -= (a & p);
// }
// return sum;
// }
// void process2(int A[], int N)
// {
// int i, j;
// for (i = 0; i < N; i++)
// M[i][0] = i;
// for (j = 1; 1 << j <= N; j++)
// for (i = 0; i + (1 << j) - 1 < N; i++)
// if (find1(M[i][j - 1]) < find1(M[i + (1 << (j - 1))][j - 1]))
// M[i][j] = M[i][j - 1];
// else
// M[i][j] = M[i + (1 << (j - 1))][j - 1];
// }
int fastexpo(int a, int b, int m)
{
int ans = 1;
while (b)
{
if (b & 1)
ans = (ans * a) % m;
b = b / 2;
a = (a * a) % m;
}
return ans % m;
}
// int arr[100005] = {0}, arr2[1000005];
//int div1[20000005];
int maxSubArraySum(int a[], int size)
{
int max_so_far = -100000000000000000, max_ending_here = 0;
// cout << max_so_far << " ";
int max_ind = 0, min_ind = 0, s = 0;
for (int i = 0; i < size; i++)
{
max_ending_here = max_ending_here + a[i];
// max_ind = i, min_ind = i;
if (max_so_far < max_ending_here)
{
max_so_far = max_ending_here;
max_ind = i;
min_ind = s;
}
if (max_ending_here < 0)
{
max_ending_here = 0;
s = i + 1;
}
}
// cout << max_so_far << "\n";
// pair<int, int> p = {min_ind, max_ind};
return max_so_far;
}
bool ch(string s1, string s2)
{
for (int i = 0; i < 7; i++)
{
if (s1[i] != s2[i])
return 0;
}
return 1;
}
int arr[100005][1010] = {0};
int32_t main()
{
int l, r;
cin >> l >> r;
int p = r - l;
if (p > 2019)
{
cout << 0 << "\n";
}
else
{
int max1 = 2020;
for (int i = l; i <= r; i++)
{
for (int j = i + 1; j <= r; j++)
{
max1 = min(max1, (i * j) % 2019);
}
}
cout << max1 << "\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for(int i = 0; i < n; i++)
#define REPR(i, n) for(int i = n; i >= 0; i--)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define INF 1e9
typedef long long ll;
int main() {
int N; cin >> N;
vector<int> X(N);
vector<int> Y(N);
vector<char> U(N);
REP(i,N) cin >> X[i] >> Y[i] >> U[i];
int ans = INF;
vector<vector<pair<int,char>>> H(1e6);//縦方向
REP(i,N){
if(U[i]=='U' || U[i]=='D'){
H[X[i]].push_back({Y[i],U[i]});
}
}
REP(i,H.size()){
if(H[i].size()==0) continue;
sort(ALL(H[i]));
REP(j,H[i].size()-1){
if(H[i][j].second=='U' && H[i][j+1].second=='D'){
ans = min(ans, 5*(H[i][j+1].first - H[i][j].first));
}
}
}
vector<vector<pair<int,char>>> V(1e6);//横方向
REP(i,N){
if(U[i]=='R' || U[i]=='L'){
V[Y[i]].push_back({X[i],U[i]});
}
}
REP(i,V.size()){
if(V[i].size()==0) continue;
sort(ALL(V[i]));
REP(j,V[i].size()-1){
if(V[i][j].second=='R' && V[i][j+1].second=='L'){
ans = min(ans, 5*(V[i][j+1].first - V[i][j].first));
}
}
}
vector<int> XX(N);
vector<int> YY(N);
REP(i,N){//45度回転
XX[i] = X[i]-Y[i]+200000;
YY[i] = X[i]+Y[i]+200000;
}
vector<vector<pair<int,char>>> V1(1e6);//横方向
REP(i,N){
if(U[i]=='R' || U[i]=='U'){
V1[YY[i]].push_back({XX[i],U[i]});
}
}
REP(i,V1.size()){
if(V1[i].size()==0) continue;
sort(ALL(V1[i]));
REP(j,V1[i].size()-1){
if(V1[i][j].second=='R' && V1[i][j+1].second=='U'){
ans = min(ans, 5*(V1[i][j+1].first - V1[i][j].first));
}
}
}
vector<vector<pair<int,char>>> V2(1e6);//横方向
REP(i,N){
if(U[i]=='D' || U[i]=='L'){
V2[YY[i]].push_back({XX[i],U[i]});
}
}
REP(i,V2.size()){
if(V2[i].size()==0) continue;
sort(ALL(V2[i]));
REP(j,V2[i].size()-1){
if(V2[i][j].second=='D' && V2[i][j+1].second=='L'){
ans = min(ans, 5*(V2[i][j+1].first - V2[i][j].first));
}
}
}
vector<vector<pair<int,char>>> H1(1e6);//横方向
REP(i,N){
if(U[i]=='R' || U[i]=='D'){
H1[XX[i]].push_back({YY[i],U[i]});
}
}
REP(i,H1.size()){
if(H1[i].size()==0) continue;
sort(ALL(H1[i]));
REP(j,H1[i].size()-1){
if(H1[i][j].second=='R' && H1[i][j+1].second=='D'){
ans = min(ans, 5*(H1[i][j+1].first - H1[i][j].first));
}
}
}
vector<vector<pair<int,char>>> H2(1e6);//横方向
REP(i,N){
if(U[i]=='U' || U[i]=='L'){
H2[XX[i]].push_back({YY[i],U[i]});
}
}
REP(i,H2.size()){
if(H2[i].size()==0) continue;
sort(ALL(H2[i]));
REP(j,H2[i].size()-1){
if(H2[i][j].second=='U' && H2[i][j+1].second=='L'){
ans = min(ans, 5*(H2[i][j+1].first - H2[i][j].first));
}
}
}
if(ans == INF) cout << "SAFE" << endl;
else cout << ans << endl;
return 0;
} | #include<bits/stdc++.h>
#define pir pair<int,int>
#define qmin(x,y) (x=min(x,y))
#define qmax(x,y) (x=max(x,y))
#define rsort(x,y) sort(x,y),reverse(x,y)
#define fr first
#define se second
using namespace std;
typedef long long ll;
const int Maxn=4100000;
const int inf=0x3f3f3f3f;
int n,x[Maxn],y[Maxn],dir[Maxn],bj[Maxn];
vector<pir> v[Maxn];
int getadir() {
char ch=getchar();
while(!isalpha(ch)) ch=getchar();
switch(ch) {
case 'U' : return 0;
case 'R' : return 1;
case 'D' : return 2;
case 'L' : return 3;
}
}
signed main() {
// freopen("test.in","r",stdin);
scanf("%d",&n);
for(int i=1;i<=n;i++) {
scanf("%d%d",&x[i],&y[i]);
dir[i]=getadir();
}
int ans=inf;
for(int i=1;i<=n;i++) if((dir[i]&1)==0) v[x[i]].push_back(make_pair(y[i],i)),bj[x[i]]=1;
for(int i=1;i<Maxn;i++) if(bj[i]) {
sort(v[i].begin(),v[i].end());
int temp=0;
for(pir j:v[i]) {
if(dir[j.se]==2) {
if(temp) qmin(ans,j.fr-y[temp]);
}
else temp=j.se;
}
}
for(int i=1;i<Maxn;i++) if(bj[i]) v[i].clear(),bj[i]=0;
for(int i=1;i<=n;i++) if(dir[i]&1) v[y[i]].push_back(make_pair(x[i],i)),bj[y[i]]=1;
for(int i=1;i<Maxn;i++) if(bj[i]) {
sort(v[i].begin(),v[i].end());
int temp=0;
for(pir j:v[i]) {
if(dir[j.se]==3) {
if(temp) qmin(ans,j.fr-x[temp]);
}
else temp=j.se;
}
}
for(int i=1;i<Maxn;i++) if(bj[i]) v[i].clear(),bj[i]=0;
for(int i=1;i<=n;i++) v[x[i]+y[i]].push_back(make_pair(x[i],i)),bj[x[i]+y[i]]=1;
for(int i=1;i<Maxn;i++) if(bj[i]) {
sort(v[i].begin(),v[i].end());
int tempx=0,tempy=0;
for(pir j:v[i]) {
if(dir[j.se]==0) {
if(tempy) qmin(ans,(j.fr-x[tempy])*2);
}
else if(dir[j.se]==1) tempy=j.se;
else if(dir[j.se]==2) tempx=j.se;
else if(tempx) qmin(ans,(j.fr-x[tempx])*2);
}
}
for(int i=1;i<Maxn;i++) if(bj[i]) v[i].clear(),bj[i]=0;
for(int i=1;i<=n;i++) v[x[i]-y[i]+2000000].push_back(make_pair(x[i],i)),bj[x[i]-y[i]+2000000]=1;
for(int i=1;i<Maxn;i++) if(bj[i]) {
sort(v[i].begin(),v[i].end());
int tempx=0,tempy=0;
for(pir j:v[i]) {
if(dir[j.se]==3) {
if(tempy) qmin(ans,(j.fr-x[tempy])*2);
}
else if(dir[j.se]==0) tempy=j.se;
else if(dir[j.se]==1) tempx=j.se;
else if(tempx) qmin(ans,(j.fr-x[tempx])*2);
}
}
for(int i=1;i<Maxn;i++) if(bj[i]) v[i].clear(),bj[i]=0;
if(ans==inf) return 0*puts("SAFE");
ans*=5;
printf("%d\n",ans);
return 0;
} | 1 |
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define rep(i, n) for(int i=0;i<n;++i)
#define rrep(i, n) for(int i=n;i>=0;--i)
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);
int DP[85][85][30000];
int main() {
int H, W;
cin>>H>>W;
int A[H][W], B[H][W];
for(int i=0;i<H;++i) {
for(int j=0;j<W;++j) {
cin>>A[i][j];
}
}
for(int i=0;i<H;++i) {
for(int j=0;j<W;++j) {
cin>>B[i][j];
}
}
for(int i=0;i<H;++i) {
for(int j=0;j<W;++j) {
A[i][j] -= B[i][j];
}
}
DP[0][0][15000+A[0][0]] = 1;
DP[0][0][15000-A[0][0]] = 1;
for(int i=0;i<H-1;++i) {
for(int j=0;j<30000;++j) {
if(DP[i][0][j]>0) {
DP[i+1][0][j+A[i+1][0]] = 1;
DP[i+1][0][j-A[i+1][0]] = 1;
}
}
}
for(int i=0;i<W-1;++i) {
for(int j=0;j<30000;++j) {
if(DP[0][i][j]>0) {
DP[0][i+1][j+A[0][i+1]] = 1;
DP[0][i+1][j-A[0][i+1]] = 1;
}
}
}
for(int i=1;i<H;++i) {
for(int j=1;j<W;++j) {
for(int k=0;k<30000;++k) {
if(DP[i-1][j][k]>0) {
DP[i][j][k+A[i][j]] = 1;
DP[i][j][k-A[i][j]] = 1;
}
if(DP[i][j-1][k]>0) {
DP[i][j][k+A[i][j]] = 1;
DP[i][j][k-A[i][j]] = 1;
}
}
}
}
int ans = inf;
for(int i=0;i<30000;++i) {
if(DP[H-1][W-1][i]>0) ans = min(ans, abs(i-15000));
}
cout<<ans<<endl;
}
| #include <bits/stdc++.h>
#define all(vec) vec.begin(), vec.end()
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
constexpr ll INF = (1LL << 30) - 1LL;
constexpr ll LINF = (1LL << 60) - 1LL;
constexpr double eps = 1e-9;
constexpr ll MOD = 1000000007LL;
template <typename T>
bool chmin(T& a, T b) {
if(a > b) {
a = b;
return true;
}
return false;
};
template <typename T>
bool chmax(T& a, T b) {
if(a < b) {
a = b;
return true;
}
return false;
};
template <typename T>
ostream& operator<<(ostream& os, vector<T> v) {
for(int i = 0; i < v.size(); i++) {
os << v[i] << (i + 1 == v.size() ? "\n" : " ");
}
return os;
}
template <typename T>
vector<T> make_v(size_t a) {
return vector<T>(a);
}
template <typename T, typename... Ts>
auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T& t, const V& v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T& t, const V& v) {
for(auto& e : t) {
fill_v(e, v);
}
};
struct UnionFind {
vector<int> par, siz;
UnionFind(int n) {
par.resize(n);
siz.resize(n, 1);
for(int i = 0; i < n; i++)
par[i] = i;
}
int find(int x) {
if(par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
bool unite(int u, int v) {
u = find(u), v = find(v);
if(u == v)
return false;
if(siz[u] < siz[v])
swap(u, v);
par[v] = u;
siz[u] += siz[v];
return true;
}
bool same(int u, int v) { return find(u) == find(v); }
};
struct edge {
ll u, v, cost;
bool operator<(const edge& e) { return cost < e.cost; }
};
ll d;
vector<ll> a;
vector<edge> es;
void calc(int l, int r) {
if(r - l <= 1) {
return;
}
int m = (l + r) / 2;
ll mi = LINF, s, t;
for(ll i = l; i < m; i++) {
ll k = -i * d + a[i];
if(mi > k) {
mi = k;
s = i;
}
}
mi = LINF;
for(ll i = m; i < r; i++) {
ll k = i * d + a[i];
if(mi > k) {
mi = k;
t = i;
}
}
for(ll i = l; i < m; i++) {
es.push_back({i, t, (t - i) * d + a[t] + a[i]});
}
for(ll i = m; i < r; i++) {
es.push_back({s, i, (i - s) * d + a[i] + a[s]});
}
calc(l, m);
calc(m, r);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n >> d;
a.resize(n + 1);
for(ll i = 1; i <= n; i++) {
cin >> a[i];
}
calc(1, n + 1);
UnionFind uf(n + 1);
sort(all(es));
ll ans = 0;
for(auto e : es) {
if(uf.unite(e.u, e.v)) {
ans += e.cost;
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
while (cin >> a) if (a > 8) return cout << ":(" << "\n", 0;
cout << "Yay!" << "\n";
} | //----------------------Shanu Garg here---------------------
//-------------Search on youtube : Shanu Garg---------------
//-Studying at National Institute of Technology Delhi(NITD)-
//---------------------From Delhi, India--------------------
#include<bits/stdc++.h>
using namespace std;
#define f(i,n) for(auto i=0;i<n;i++)
#define fr(i,n) for(auto i=n-1;i>=0;i--)
#define fs(i,a,b,c) for(auto i=a;i!=b;i+=c)
#define fl(i,x) for(auto i : x)
#define memset(a,first,last,val) fs(i,first,last,1) a[i]=val
#define nl cout<<"\n";
#define chk(x) cout<<#x<<x<<" ", nl
#define ll long long int
#define ull unsigned long long int
#define vi vector<int>
#define vvi vector<vi>
#define pr pair<ll, ll>
#define vii vector<pair<int, int>>
#define vll vector<pr>
#define vl vector<ll>
#define m(a,b) map<a, b>
#define mid(a,b) ((a+b)/2)
#define pb push_back
const int INF = 0x3f3f3f3f, mod = 1e9 + 7;
vl vb;
int N;
class triplet{ll f, s, t;};
vl in(ll n){
vl ar;
ll x;
f(i,n)
cin>>ar[i];
return ar;
}
vll in_pr(ll n){
vll ar;
ll x,y;
f(i,n)
{cin>>x>>y;
ar[i]={x,y};
}return ar;
}
void out(vl v, char ch='\0'){
fl(i,v)
cout<<i<<ch;
}
void printArray(vector<int> arr, int n)
{
ll num=0;
for (int i = 0; i < n; i++)
num*=10, num+=i;
if(n==N)
vb.pb(num);
}
int printfactorialof(int n){
if(n<=1)
return 1;
return n*printfactorialof(n-1);
}
void solve(){
ll a,b;
cin>>a>>b;
if(a+b <= 16){
if(a<=8 && b<=8)
cout<<"Yay!",nl
else
{
cout<<":(",nl
}
}
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
solve();
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
using ll = int64_t;
class StrongDisassembly{
private:
ll V;
vector<vector<ll>> E;
vector<vector<ll>> inv_E;
ll *number;
bool *used_dfs;
ll to_write_num = 0;
void dfs(ll now){
used_dfs[now] = 1;
for(ll next : E[now]){
if(used_dfs[next]){
continue;
}
dfs(next);
}
number[now] = to_write_num++;
}
void dfs(ll now, bool *used, vector<ll> &ret){
used[now] = 1;
ret.push_back(now);
for(ll next : inv_E[now]){
if(used[next]){
continue;
}
dfs(next, used, ret);
}
}
void write_num(){
for(ll i = 0; i < V; i++){
if(!used_dfs[i]){
dfs(i);
}
}
}
public:
StrongDisassembly(const vector<vector<ll>> &e){
V = e.size();
E = e;
inv_E = vector<vector<ll>>(V);
number = new ll[V];
used_dfs = new bool[V];
for(ll i = 0; i < V; i++){
used_dfs[i] = 0;
inv_E.push_back(vector<ll>(0));
}
for(ll i = 0; i < V; i++){
for(ll next : e[i]){
inv_E[next].push_back(i);
}
}
write_num();
}
map<ll, vector<ll>> disassembly(){
map<ll, vector<ll>> ret;
vector<ll> vec;
bool used[V] = {};
for(ll i = 0; i < V; i++){
vec.push_back(i);
}
sort(vec.begin(), vec.end(), [&](ll a, ll b){
return number[a] > number[b];
}
);
for(ll vertex : vec){
if(used[vertex]){
continue;
}
vector<ll> to_insert;
dfs(vertex, used, to_insert);
ret[ret.size() - 1] = to_insert;
}
return ret;
}
};
int main(){
ll V, E;
cin >> V >> E;
vector<vector<ll>> v(V);
for(ll i = 0; i < E; i++){
ll s, t;
cin >> s >> t;
v[s].push_back(t);
}
StrongDisassembly S(v);
auto ret = S.disassembly();
map<ll, ll> group;
for(auto ite = ret.begin(); ite != ret.end(); ite++){
for(ll u : ite->second) group[u] = ite->first;
}
ll Q;
cin >> Q;
for(ll i = 0; i < Q; i++){
ll u, v;
cin >> u >> v;
cout << (group[u] == group[v] ? 1 : 0) << endl;
}
return 0;
}
| #include <iostream>
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long,pair<long long,long long>>> edges;
const long long MAXN = 2e5+5;
long long par[MAXN];
long long sz[MAXN];
pair<pair<long long,long long>,long long> arr[MAXN];
pair<pair<long long,long long>,long long> arr2[MAXN];
long long getpar(long long a){
if(par[a] == a){
return a;
}
return par[a] = getpar(par[a]);
}
void merge(long long a,long long b){
a = getpar(a);
b = getpar(b);
if(a==b){
return;
}
if(sz[b]>sz[a]){
swap(a,b);
}
sz[a]+=sz[b];
par[b] = a;
}
int main(){
long long n;
cin>>n;
for(long long i=1;i<=n;i++){
cin>>arr[i].first.first>>arr[i].first.second;
arr2[i].first.first = arr[i].first.second;
arr2[i].first.second = arr[i].first.first;
arr[i].second = i;
arr2[i].second = i;
}
sort(arr+1,arr+n+1);
sort(arr2+1,arr2+n+1);
for(long long i=1;i<n;i++){
edges.push_back(make_pair(arr[i+1].first.first-arr[i].first.first,make_pair(arr[i].second,arr[i+1].second)));
edges.push_back(make_pair(arr2[i+1].first.first-arr2[i].first.first,make_pair(arr2[i].second,arr2[i+1].second)));
}
sort(edges.begin(),edges.end());
for(long long i=1;i<=n;i++){
par[i] = i;
sz[i] = 1;
}
long long ans = 0;
for(auto x:edges){
long long w = x.first;
long long from = x.second.first;
long long to = x.second.second;
if(getpar(from)== getpar(to)){
continue;
}
merge(from,to);
ans+=w;
}
cout<<ans<<endl;
}
| 0 |
#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); cout.tie(0);
}
const int N = 12;
const int S = 1e5+5501;
int dp[N][S];
int p[N], c[N];
int rek(int pos, int tot) {
if (tot <= 0) return 0;
if (pos < 0) return 1e4;
int &ret = dp[pos][tot];
if (ret != -1) return ret;
ret = rek(pos-1, tot);
for (int i = 1; i < p[pos]; ++i) {
ret = min(ret, i+rek(pos-1, tot-i*(pos+1)));
}
return ret = min(ret, p[pos]+rek(pos-1, tot-p[pos]*(pos+1)-c[pos]));
}
void solve() {
memset(dp, -1, sizeof(dp));
int d, g; scanf("%d%d", &d, &g);
g /= 100;
for (int i = 0; i < d; ++i) {
scanf("%d%d", p+i, c+i);
c[i] /= 100;
}
printf("%d", rek(d-1, g));
}
int main() {
init();
int t = 1; //scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int main()
{
int D, G, p[11], c[11];
cin >> D >> G;
for (int i = 0; i < D; ++i)
cin >> p[i] >> c[i];
int ans = 1e9;
for (int mask = 0; mask < 1 << D; ++mask)
{
int sum = 0, num = 0;
for (int i = 0; i < D; ++i)
{
if (mask & 1 << i)
{
sum += (i + 1) * 100 * p[i] + c[i];
num += p[i];
}
}
if (sum >= G)
{
ans = min(ans, num);
}
else
{
for (int i = D - 1; i >= 0; --i)
{
if (mask & 1 << i)
{
continue;
}
for (int j = 0; j < p[i]; j++)
{
if (sum >= G)
{
break;
}
sum += 100 * (i + 1);
num++;
}
}
ans = min(ans, num);
}
}
cout << ans << endl;
}
| 1 |
#include <iostream>
using namespace std;
int main(){
int a,b;
cin >> a;
b = a;
for(int i=1;i < 3;i++){
b = b * a;
}
cout << b << endl;
return 0;
} | #include <iostream>
#include <algorithm>
#include <complex>
#include <utility>
#include <vector>
#include <string>
#include <queue>
#include <tuple>
#include <cmath>
#include <bitset>
#include <cctype>
#include <set>
#include <map>
#include <numeric>
#include <functional>
#define _overload3(_1,_2,_3,name,...) name
#define _rep(i,n) repi(i,0,n)
#define repi(i,a,b) for(ll i=ll(a);i<ll(b);++i)
#define rep(...) _overload3(__VA_ARGS__,repi,_rep,)(__VA_ARGS__)
#define all(x) (x).begin(),(x).end()
#define PRINT(V) cout << V << "\n"
#define SORT(V) sort((V).begin(),(V).end())
#define RSORT(V) sort((V).rbegin(), (V).rend())
using namespace std;
using ll = long long;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
inline void Yes(bool condition){ if(condition) PRINT("Yes"); else PRINT("No"); }
template<class itr> void cins(itr first,itr last){
for (auto i = first;i != last;i++){
cin >> (*i);
}
}
template<class itr> void array_output(itr start,itr goal){
string ans = "",k = " ";
for (auto i = start;i != goal;i++) ans += to_string(*i)+k;
if (!ans.empty()) ans.pop_back();
PRINT(ans);
}
ll gcd(ll a, ll b) {
return a ? gcd(b%a,a) : b;
}
const ll INF = 1e15;
const ll MOD = 1000000007;
typedef pair<ll,ll> P;
const ll MAX = 400010;
constexpr ll nx[8] = {1,0,-1,0,-1,-1,1,1};
constexpr ll ny[8] = {0,1,0,-1,-1,1,-1,1};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
PRINT(180*(n-2));
}
| 0 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<functional>
#include<string>
#include<cmath>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<cstdio>
#include<numeric>
using namespace std;
using ll = long long;
int main(){
int a, b;
cin >> a >> b;
if(a > 8 || b > 8) {
cout << ":(\n";
} else {
cout << "Yay!\n";
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int N, K; cin >> N >> K;
if (N % K != 0) printf("%d\n", 1);
else printf("%d\n", 0);
} | 0 |
#include <iostream>
#include <algorithm>
#define N 100
#define INF 2000000000
#define WHITE 0
#define GRAY 1
#define BLACK 2
using namespace std;
int n;
int M[N][N],color[N],d[N],p[N];
//M??????????????????color????¨??????¶???(0,1,2),d????????????????°???????????¨????
//p???MST???????°???¨?????¨??????????????????????????????
void Prim() {
for (int i = 0;i < n;i++) d[i] = INF;
d[0] = 0; //?????????????????????????????§???????????§????´???????????????????????????????
/*p[0] = -1; //??????????????????????????????????????????*/
int u;
while (true) {
int min = INF;
for (int i = 0;i < n;i++) {
if(color[i]!=BLACK&&min>d[i]){
min = d[i];
u = i;
}
}
if (min == INF) break;
color[u] = BLACK;
for (int v = 0;v < n;v++)
if(color[v]!=BLACK&&M[u][v]!=-1)
if (M[u][v] < d[v]) {
d[v] = M[u][v];
/*p[v] = u;*/
/*color[v] = GRAY;*/
}
}
int sum = 0;
for (int i = 0;i < n;i++) sum += d[i];
cout << sum << endl;
}
int main() {
cin >> n;
for (int i = 0;i < n;i++)
for (int j = 0;j < n;j++) {
cin >> M[i][j];
if (M[i][j] == -1) M[i][j] = INF;
}
Prim();
} | #include <algorithm>
#include <vector>
#include <iostream>
typedef std::vector<int> TTree;
struct TPath
{
int Id1;
int Id2;
int Cost;
TPath(int AId1, int AId2, int ACost)
: Id1(AId1), Id2(AId2), Cost(ACost)
{}
};
bool Compare(const TPath& Left, const TPath& Right)
{
if(Left.Cost < 0) return false;
if(Right.Cost < 0) return true;
return Left.Cost < Right.Cost;
}
int main()
{
int n;
std::cin >> n;
std::vector<TTree*> Table(n, NULL);
for(std::size_t i = 0; i < n; ++i){
Table[i] = new std::vector<int>(1, i);
}
std::vector<TPath> PathList;
PathList.reserve(n*n);
for(int i = 0; i < n; ++i){
for(int j = 0; j < n; ++j){
int Cost;
std::cin >> Cost;
PathList.push_back(TPath(i, j, Cost));
}
}
std::sort(PathList.begin(), PathList.end(), Compare);
int Total = 0;
for(std::vector<TPath>::const_iterator It = PathList.begin();
It != PathList.end(); ++It)
{
const TPath& Path = *It;
TTree* Tree1 = Table[Path.Id1];
TTree* Tree2 = Table[Path.Id2];
if(Tree1 == Tree2){
continue;
}
Tree1->insert(Tree1->end(), Tree2->begin(), Tree2->end());
for(std::size_t j = 0; j < Tree2->size(); ++j){
int Id = (*Tree2)[j];
Table[Id] = Tree1;
}
delete Tree2;
Total += Path.Cost;
// std::cout << "[" << Path.Id1 << "]" << "[" << Path.Id2 << "] = " << Path.Cost << std::endl;
}
std::cout << Total << std::endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string s; cin >> s;
int ans = 0;
int cnt_J = 0;
int cnt_O = 0;
int cnt_I = 0;
char p = 'X';
for (int i = 0;i < s.size();i++){
if(s[i] == 'J') {
cnt_O = cnt_I = 0;
if(p != s[i]) cnt_J = 1;
else cnt_J++;
} else if(s[i] == 'O') {
if(cnt_J == 0){
cnt_J = cnt_O = cnt_I = 0;
} else {
if(p == 'I') cnt_J = cnt_O = cnt_I = 0;
else cnt_O++;
}
} else if(s[i] == 'I'){
if(cnt_O == 0){
cnt_J = cnt_O = cnt_I = 0;
} else {
cnt_I++;
if(cnt_O <= cnt_J && cnt_O <= cnt_I) ans = max(cnt_O,ans);
}
}
p = s[i];
}
cout << ans << endl;
return 0;
}
| #include <iostream>
using namespace std;
char a[1000001];
char w[] = "JOI";
int k=0, l[3];
int main() {
cin>>a;
for(char* c=a;*c!='\0';) {
for(int i=0;i<3;++i) {
l[i]=0;
while(*c!='\0'&&*c==w[i]) {
++l[i];
++c;
}
}
if(l[0]>=l[1]&&l[2]>=l[1])k=(k<l[1]?l[1]:k);
}
cout<<k<<endl;
return 0;
} | 1 |
//#include "bits/stdc++.h"
#define _USE_MATH_DEFINES
#include<cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <deque>
#include <algorithm>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#include <iterator>
using namespace std;
#define rep(i,a,b) for(int i=(a), i##_len=(b);i<i##_len;i++)
#define rrep(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define all(c) begin(c),end(c)
#define int ll
#define SZ(x) ((int)(x).size())
#define pb push_back
#define mp make_pair
//typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
typedef pair<double, double> pdd;
typedef vector< vector<int> > mat;
template<class T> bool chmax(T &a, const T &b) { if (a < b) { a = b; return true; } return false; }
template<class T> bool chmin(T &a, const T &b) { if (b < a) { a = b; return true; } return false; }
const int INF = sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)1e9 + 7;
const double EPS = 1e-9;
signed main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int N, H, W;
cin >> N >> H >> W;
int ans = 0;
cout << (N - H + 1)*(N - W + 1) << endl;
return 0;
} | #include<iostream>
#include<cstdio>
#include<string>
using namespace std;
int main()
{
string a;
cin>>a;
int tmp=a.find("ST");
while(a.length()>0&&tmp>=0)
{
a.erase(tmp,2);
int x=max(tmp-1,0);
tmp=a.find("ST",x);
if(tmp==string::npos)
tmp=-1;
}
cout<<a.length()<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b;
string s;
cin >> a >> b >> s;
string ans="Yes";
for(int i=0; i<a; i++){
if(0>s.at(i)-'0'||s.at(i)-'0'>9) ans="No";
}
if(s.at(a)!='-') ans="No";
for(int i=0; i<b; i++){
if(0>s.at(i+a+1)-'0'||s.at(i+a+1)-'0'>9) ans="No";
}
cout << ans << endl;
} | #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 a, b;
cin >> a >> b;
string s;
cin >> s;
if (s.size() != a + b + 1) {
cout << "No" << endl;
return 0;
}
for (int i = 0; i < s.size(); i++ ) {
if (i == a) {
if (s[i] != '-') {
cout << "No" << endl;
return 0;
}
} else {
if (s[i] < '0' || s[i] > '9') {
cout << "No" << endl;
return 0;
}
}
}
cout << "Yes" << endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int w[8],h[8],x1[15],x2[15],f=0;
char m[8][8],ans[8][8];
void fs(int n=0){
if(f)return;
if(n==8){
f=1;
for(int i=0;i<8;i++)
for(int j=0;j<8;j++)
ans[i][j]=m[i][j];
return;
}
if(h[n]==1)fs(n+1);
else{
for(int i=0;i<8;i++){
if(w[i]+x1[7+i-n]+x2[n+i]==0){
m[n][i]='Q';
w[i]=x1[7+i-n]=x2[n+i]=1;
fs(n+1);
m[n][i]='.';
w[i]=x1[7+i-n]=x2[n+i]=0;
}
}
}
}
int main(){
for(int i=0;i<8;i++)
for(int j=0;j<8;j++)
m[i][j]='.';
int n,a,b;
cin>>n;
for(int i=0;i<n;i++){
cin>>a>>b;
m[a][b]='Q';
h[a]=w[b]=1;
x1[7+b-a]=1;
x2[a+b]=1;
}
fs();
for(int i=0;i<8;i++){
for(int j=0;j<8;j++)
cout<<ans[i][j];
cout<<endl;
}
return 0;
} | #include <iostream>
#include <cstdio>
#include <climits>
#include <cmath>
#include <cassert>
#include <algorithm>
#include <utility>
#include <vector>
#include <string>
#include <stack>
#include <queue>
#define MAX 10000
#define INFTY 1<<30 // 2^30
#define N 8
using namespace std;
typedef long long llong;
static const int NIL = -1;
static const int WHITE = 0;
static const int GRAY = 1;
static const int BLACK = 2;
static const int NOT_FREE = 0;
static const int FREE = 1;
static const int FIXED = 2;
bool X[N][N];
vector<pair<int, int> > ans;
void init()
{
for(int i = 0; i < N; i++)
for(int j = 0; j < N; j++)
X[i][j] = false;
}
bool can_pos(int x, int y)
{
for(int i = 0; i < ans.size(); i++)
{
int tx = ans[i].first;
int ty = ans[i].second;
if(x == tx) return false;
if(y == ty) return false;
if((x-tx)*(x-tx) == (y-ty)*(y-ty)) return false;
}
return true;
}
void printBoard()
{
for(int i = 0; i < ans.size(); i++)
X[ans[i].first][ans[i].second] = true;
for(int i = 0; i < N; i++)
{
for(int j = 0; j < N; j++)
cout << (X[i][j] ? "Q" : ".");
cout << endl;
}
}
bool recursive(int p)
{
for(; p < N * N; p++)
{
int i = p%N;
int j = p/N;
if(!(can_pos(i,j))) continue;
pair<int, int>tmp = make_pair(i, j);
ans.push_back(tmp);
if(!recursive((j+1)*N)) ans.pop_back();
}
if(ans.size() == N) return true;
return false;
}
int main()
{
init();
int k, r, c; cin >> k;
for(int i = 0; i < k; i++)
{
cin >> r >> c;
pair<int, int> tmp = make_pair(r, c);
ans.push_back(tmp);
}
if(recursive(0)) printBoard();
return 0;
} | 1 |
#include<cstdio>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;
class Node{
public:
int parent, rank;
Node(int i): parent(i), rank(0){}
};
bool sortFunc(const vector<int>& A, const vector<int>& B){
return A[2] < B[2];
}
int find(vector<Node>& nodes, const int& x){
if(nodes[x].parent != x){
int p = find(nodes, nodes[x].parent);
nodes[x].parent = p;
}
return nodes[x].parent;
}
void unite(vector<Node>& nodes, const int& x, const int& y){
int xp = find(nodes, x), yp = find(nodes, y);
if(nodes[xp].rank > nodes[yp].rank){
nodes[yp].parent = xp;
}
else if(nodes[yp].rank > nodes[xp].rank){
nodes[xp].parent = yp;
}
else{
nodes[xp].rank++;
nodes[yp].parent = xp;
}
}
int main(){
int v, e, s, t, w;
vector<Node> nodes;
vector<vector<int>> edges;
scanf("%d %d", &v, &e);
for(int i = 0; i < v; i++){
nodes.push_back(Node(i));
}
for(int i = 0; i < e; i++){
scanf("%d %d %d", &s, &t, &w);
edges.push_back(vector<int>{s, t, w});
}
sort(edges.begin(), edges.end(), sortFunc);
int sum = 0;
for(vector<int> edge: edges){
if(find(nodes, edge[0]) == find(nodes, edge[1])) continue;
sum += edge[2];
unite(nodes, edge[0], edge[1]);
}
printf("%d\n", sum);
}
| #include <bits/stdc++.h>
using namespace std;
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)];
}
};
int main() {
int N,K,L;cin>>N>>K>>L;
UnionFind A(N);
UnionFind B(N);
for(int I=0;I<K;I++){
int X,Y;cin>>X>>Y;X--;Y--;
A.merge(X,Y);
}
for(int I=0;I<L;I++){
int X,Y;cin>>X>>Y;X--;Y--;
B.merge(X,Y);
}
map<pair<int,int>,int> ma;
for (int v = 0; v < N; ++v) {
pair<int,int> p(A.root(v), B.root(v));
ma[p]++;
}
for (int v = 0; v < N; ++v) {
pair<int,int> p(A.root(v), B.root(v));
cout << ma[p] << " ";
}
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define REP(i,n) for (int64_t i=0; i<(n); ++i)
#define P pair<int,int>
using ll=int64_t;
using namespace std;
#define ketasuu(n) fixed<<setprecision(n)
#define btoe(p) p.begin(),p.end()
#define etob(p) p.rbegin(),p.rend()
//UnionFind Template
struct UnionFind{ //構造体の定義
vector<int> d;
UnionFind(int n=0): d(n,-1) {} //コンストラクタ
int find(int x){
if(d[x]<0) return x;
return d[x]=find(d[x]);
}
bool unite(int x, int y){
x=find(x); y=find(y);
if(x==y) return false;
if(d[x]<d[y]) swap(x,y);//d[x] is smaller. Then, connect d[x] to d[y].
d[y]+=d[x];
d[x]=y;
return true;
}
bool same(int x, int y){
return find(x)==find(y);
}
int size(int x){
return -(d[find(x)]);
}
int rootsize(){
int cnt=0;
for(auto& v: d){
if(v<0) cnt++;
}
return cnt;
}
};
//How to use
//UnionFind uf(n); などと書けば使えるようになる.ufというobjectが生成される
//uf.unite(a,b);などで中の関数を使える
int main(){
int h,w; cin>>h>>w;
const vector<int> df={-1,1,w,-w};
vector<string> p(h);
rep(i,h) cin>>p[i];
UnionFind uf(h*w);
rep(i,h*w){
if(p[i/w][i%w]=='.') continue;
rep(j,4){
int a=i+df[j];
if(a<0 || a>=h*w || (a&w==0 && j==1) || (i%w==0 && j==0)) continue;
if(p[a/w][a%w]=='#') uf.unite(i,a);
}
}
bool ok=true;
rep(i,h*w){
if(uf.size(i)==1 && p[i/w][i%w]=='#') ok=false;
}
cout<<(ok? "Yes": "No")<<endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
ll const INF = 1LL << 60;
int main() {
ll H, W;
cin >> H >> W;
vector<string> M(H);
for (int i = 0; i < H; i++) {
cin >> M[i];
}
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (M[i][j] == '#') {
if ((i + 1 < H && M[i + 1][j] == '#') ||
(0 <= i - 1 && M[i - 1][j] == '#') ||
(j + 1 < H && M[i][j + 1] == '#') ||
(0 <= j - 1 && M[i][j - 1] == '#'))
continue;
cout << "No" << endl;
return 0;
}
}
}
cout << "Yes" << endl;
return 0;
} | 1 |
#include <stdio.h>
typedef struct _Gem{
int x;
int y;
bool hit;
} Gem;
static void
pick_gem(Gem* g, int n, int x, int y)
{
for (int i = 0; i < n; i++) {
if (!g[i].hit && g[i].x == x && g[i].y == y) {
g[i].hit = true;
return;
}
}
}
static bool
check_gem(Gem* g, int n)
{
for (int i = 0; i < n; i++) {
if (g[i].hit == false) {
return false;
}
}
return true;
}
int
main(void)
{
char line[80];
int n;
int m;
Gem g[20];
char d[30];
int l[30];
while (true) {
if (fgets(line, sizeof line, stdin) == NULL) {
return 1;
}
if (sscanf(line, "%d", &n) != 1) {
return 1;
}
if (n == 0) {
break;
}
for (int i = 0; i < n; i++) {
if (fgets(line, sizeof line, stdin) == NULL) {
return 1;
}
if (sscanf(line, "%d %d", &(g[i].x), &(g[i].y)) != 2) {
return 1;
}
g[i].hit = false;
}
if (fgets(line, sizeof line, stdin) == NULL) {
return 1;
}
if (sscanf(line, "%d", &m) != 1) {
return 1;
}
for (int i = 0; i < m; i++) {
if (fgets(line, sizeof line, stdin) == NULL) {
return 1;
}
if (sscanf(line, "%c %d", &(d[i]), &(l[i])) != 2) {
return 1;
}
}
int x = 10;
int y = 10;
for (int i = 0; i < m; i++) {
if (d[i] == 'N') {
for (int k = 1; k <= l[i]; k++) {
pick_gem(g, n, x, ++y);
}
} else if (d[i] == 'S') {
for (int k = 1; k <= l[i]; k++) {
pick_gem(g, n, x, --y);
}
} else if (d[i] == 'E') {
for (int k = 1; k <= l[i]; k++) {
pick_gem(g, n, ++x, y);
}
} else {
for (int k = 1; k <= l[i]; k++) {
pick_gem(g, n, --x, y);
}
}
}
printf("%s\n", (check_gem(g, n) ? "Yes" : "No"));
}
return 0;
} | #include <iostream>
#include <cstring>
using namespace std;
int map[50][50];
int N;
int x,y;
int main(){
while(1){
cin >> N;
if(N == 0) break;
memset(map,0,sizeof(map));
for(int i = 0; i < N ; i++){
cin >> x >> y;
map[x][y] = 1;
}
int M;
int l;
char d;
int tr = 0;
cin >> M;
int nx = 10, ny =10;
for(int i = 0; i < M ; i++){
cin >> d >> l;
if(d == 'N'){
for(int i = 0 ; i < l; i++){
ny++;
if(map[nx][ny] == 1){
tr++;
map[nx][ny] = 0;
}
}
}else if(d == 'E'){
for(int i = 0 ; i < l; i++){
nx++;
if(map[nx][ny] == 1){
tr++;
map[nx][ny] = 0;
}
}
}else if(d == 'S'){
for(int i = 0 ; i < l; i++){
ny--;
if(map[nx][ny] == 1){
tr++;
map[nx][ny] = 0;
}
}
}else if(d == 'W'){
for(int i = 0 ; i < l; i++){
nx--;
if(map[nx][ny] == 1){
tr++;
map[nx][ny] = 0;
}
}
}
}
if( tr == N ) cout << "Yes" << endl;
else cout << "No" << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef unsigned int ui;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<long long, long long> pll;
typedef long double ld;
const int inf = 1e9;
const ll inf64 = 1e18;
const int mod = 998244353;
inline int _mul(int a, int b) {
return (1ll * a * b) % mod;
}
inline int _sum(int a, int b) {
return a + b < mod ? a + b : a + b - mod;
}
inline int _sub(int a, int b) {
return a >= b ? a - b : a - b + mod;
}
inline void _inc(int &x, int y) {
if ((x += y) >= mod) {
x -= mod;
}
}
inline void _dec(int &x, int y) {
if ((x -= y) < 0) {
x += mod;
}
}
inline int _binpow(int x, int p) {
int res = 1;
int tmp = x;
while (p > 0) {
if (p & 1) {
res = _mul(res, tmp);
}
tmp = _mul(tmp, tmp);
p >>= 1;
}
return res;
}
const int N = 3e6 + 5;
int fact[N];
int rfact[N];
void precalc() {
fact[0] = 1;
for (int i = 1; i < N; i++) {
fact[i] = _mul(fact[i - 1], i);
}
rfact[N - 1] = _binpow(fact[N - 1], mod - 2);
for (int i = N - 2; i >= 0; i--) {
rfact[i] = _mul(rfact[i + 1], i + 1);
}
}
inline int CNK(int n, int k) {
if (n < k) {
return 0;
}
return _mul(fact[n], _mul(rfact[n - k], rfact[k]));
}
inline int F(int n, int k) {
return CNK(n + k - 1, k);
}
int main() {
precalc();
#ifdef debug
freopen("input.txt", "r", stdin);
#endif
int n, m;
cin >> n >> m;
int res = 0;
for (int i = m & 1; i <= m; i += 2) {
_inc(
res,
_mul(
CNK(n, i),
F(n, (3 * m - i) / 2)
)
);
}
_dec(
res,
_mul(
n,
F(n, m - 1)
)
);
cout << res << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i,m,n) for(int i=(int)(m); i<(int)(n); i++)
#define rep(i,n) REP(i,0,n)
#define RREP(i,m,n) for(int i=(int)(m); i>=(int)(n); i--)
#define rrep(i,n) RREP(i,n-1,0)
#define REPL(i,m,n) for(ll i=(ll)(m); i<(ll)(n); i++)
#define repl(i,n) REPL(i,0,n)
#define all(v) v.begin(), v.end()
const int inf = 1e9+7;
const ll longinf = 1LL<<60;
const ll mod = 1e9+7;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N;
string S;
cin >> N >> S;
int cnt = 0;
ll ans = 1;
rep(i, 2*N) {
if(S[i] == 'B') {
if(cnt%2) {
if(cnt == 0) {
ans = 0;
break;
}
(ans *= cnt) %= mod;
cnt--;
} else {
ans *= 1;
cnt++;
}
} else {
if(cnt%2) {
ans *= 1;
cnt++;
} else {
if(cnt == 0) {
ans = 0;
break;
}
(ans *= cnt) %= mod;
cnt--;
}
}
}
function<ll(ll)> fact = [&](ll n) {
if(n == 0) return 1LL;
else return (n * fact(n-1)) % mod;
};
if(cnt) cout << 0 << endl;
else cout << (ans * fact(N)) % mod << endl;
return 0;
}
| 0 |
#include <iostream>
#include <stdlib.h>
#define inf 99999
using namespace std;
bool check(int *label, int n)
{
for(int i = 1; i <= n; i++){
if(label[i] == 0){
return true;
}
}
return false;
}
void dij(int **a, int n, int s, int t)
{
int *label, current=s, num=1, next, *cost, min;
cost = (int *)calloc(n+1, sizeof(int));
label = (int *)calloc(n+1, sizeof(int));
for(int i = 1; i <= n; i++){
cost[i] = a[current][i];
}
label[current] = num++;
while(check(label, n)){
min = inf;
for(int i = 1; i <= n; i++){
if(min >= cost[i] && label[i] == 0){
min = cost[i];
next = i;
}
}
label[next] = num++;
for(int i = 1; i <= n; i++){
if(label[i] == 0 && cost[i] > (a[next][i]+cost[next])){
cost[i] = a[next][i] + cost[next];
}
}
current = next;
}
cout << cost[t] << endl;
free(cost);
free(label);
return ;
}
int main(int argc, char **argv)
{
int **t, **c, n, m, a, b, p, q;
while(1){
cin >> n >> m;
if(n == 0 && m == 0){
break;
}
t = (int **)calloc(m+1, sizeof(int));
c = (int **)calloc(m+1, sizeof(int));
for(int i = 0; i <= m; i++){
t[i] = (int *)calloc(m+1, sizeof(int));
c[i] = (int *)calloc(m+1, sizeof(int));
}
for(int i = 0; i < n; i++){
cin >> a >> b >> p >> q;
c[a][b] = c[b][a] = p;
t[a][b] = t[b][a] = q;
}
for(int i = 1; i <= m; i++){
for(int j = 1; j <= m; j++){
if(i != j && c[i][j] == 0){
c[i][j] = inf;
}
if(i != j && t[i][j] == 0){
t[i][j] = inf;
}
}
}
cin >> n;
for(int i = 0; i < n; i++){
cin >> a >> b >> p;
if(p == 0){
dij(c, m, a, b);
} else {
dij(t, m, a, b);
}
}
for(int i = 0; i <= m; i++){
free(t[i]);
free(c[i]);
}
free(t);
free(c);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define iota(i,n,b,s) for(int i=int(b);i!=int((b)+(s)*(n));i+=(s))
#define range(i,n,m) iota(i,(((n)>(m))?((n)-(m)+1):((m)-(n)+1)),(n),((n)>(m)?-1:1))
#define rep(i,n) iota(i,(n),0,1)
#define INF (1e9)
#define EPS (1e-9)
#define cons(a,b) (make_pair(a,b))
#define car(a) (a.first)
#define cdr(a) (a.second)
#define cadr(a) (car(cdr(a)))
#define cddr(a) (cdr(cdr(a)))
#define all(a) a.begin(), a.end()
#define trace(var) cerr<<">>> "<<#var<<" = "<<var<<endl;
typedef long long INTEGER;
typedef double FLOAT;
template<class S, class T>
ostream& operator<<(ostream& os, pair<S,T> p) {
os << '(' << car(p) << ", " << cdr(p) << ')';
return os;
}
template<class T>
ostream& operator<<(ostream& os, vector<T> v) {
os << v[0];
for (int i=1, len=v.size(); i<len; ++i) os << ' ' << v[i];
return os;
}
const int MM = 100;
int cost[MM][MM];
int toki[MM][MM];
int main() {
entry:;
int n, m; cin >> m >> n;
if (n + m == 0) return 0;
rep (i, n) {
rep (j, n) {
cost[i][j] = INF;
toki[i][j] = INF;
}
cost[i][i] = 0;
toki[i][i] = 0;
}
rep (i, m) {
int a, b, c, t;
cin >> a >> b >> c >> t;
--a; --b;
cost[a][b] = cost[b][a] = c;
toki[a][b] = toki[b][a] = t;
}
rep (k, n) {
rep (i, n) {
rep (j, n) {
cost[i][j] = min(cost[i][j], cost[i][k] + cost[k][j]);
toki[i][j] = min(toki[i][j], toki[i][k] + toki[k][j]);
}
}
}
//rep (i,n) { rep(j,n) { cout << cost[i][j] << ' '; } cout << endl; }
int k; cin >> k;
rep (i, k) {
int a, b, t;
cin >> a >> b >> t;
--a; --b;
if (t) {
cout << toki[a][b] << endl;
} else {
cout << cost[a][b] << endl;
}
}
goto entry;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define _GLIBCXX_DEBUG
#define rep(i, from, to) for (int i = from; i < (to); ++i)
#define mp(x,y) make_pair(x,y)
#define all(x) (x).begin(),(x).end()
#define pb push_back
using ll = long long;
using vin=vector<int>;
using vll=vector<ll>;
using vst=vector<string>;
using P = pair<int, int>;
const int inf=1e9+7;
const ll INF=1e18;
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
template<class T> inline void Yes(T condition){ if(condition) cout << "Yes" << endl; else cout << "No" << endl; }
template<class T> inline void YES(T condition){ if(condition) cout << "YES" << endl; else cout << "NO" << endl; }
const int dx[4] = { 1, 0, -1, 0 };
const int dy[4] = { 0, 1, 0, -1 };
int cnt[550][550];
ll sum[110*5][110*5];
int main(){cout<<fixed<<setprecision(10);
//O(m+nq)
int n,m,Q;
cin>>n>>m>>Q;
int r,l;
rep(i,0,m){
cin>>l>>r;
cnt[l][r]++;
}
rep(i,1,n+1){
rep(j,1,n+1){
sum[i][j]=sum[i][j-1]+cnt[i][j];
//cout<<sum[i][j]<<" ";
}
// cout<<endl;
}
int p,q;
ll ans;
rep(i,0,Q){
cin>>p>>q;
ans=0;
rep(j,p,n+1){
ans+=sum[j][q];
}
cout<<ans<<endl;
}
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define rep(i, start, n) for (int i = (int)(start); i < (int)(n); ++i)
#define all(a) a.begin(), a.end()
#define mp(a, b) make_pair(a, b)
const int MOD = 1e9+7;
const int INF = 1001001001;
const ll llINF = 1e18+9;
vector<pii> edge[100010];
int main(){
int N;
cin >> N;
rep(i, 0, N-1){
int a, b, c;
cin >> a >> b >> c;
edge[a-1].push_back(mp(b-1, c));
edge[b-1].push_back(mp(a-1, c));
}
int Q, K;
cin >> Q >> K;
K--;
vector<ll> dist(N, llINF);
dist[K] = 0;
queue<pair<int, ll>> q;
q.push(mp(K, 0));
while (!q.empty()){
int now = q.front().first;
ll nowd = q.front().second;
q.pop();
for (auto x:edge[now]){
int fol = x.first;
ll d = x.second;
ll nextd = nowd+d;
if (dist[fol] < nextd) continue;
dist[fol] = nextd;
q.push({fol, nextd});
}
}
rep(i ,0 , Q){
int x, y;
cin >> x >> y;
--x, --y;
ll ans = dist[x] + dist[y];
cout << ans << endl;
}
} | 0 |
#include<stdio.h>
#include<iostream>
#include<cmath>
#include<string>
#include<algorithm>
#include<iomanip>
#include<iterator>
#include<vector>
#include<map>
#include<utility>
#include<set>
#include<stack>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int k,x;
cin>>k>>x;
for(int i=1;i<2*k;i++)cout<<x-k+i<<" ";
return 0;
}
| #include <iostream>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <cassert>
#define int long long
#define rep(i,n) for(int i=0;i<n;i++)
#define srep(i,n,m) for(int i=n;i<m;i++)
#define elif else if
#define INF 1000000007
#define pi 3.141592653589793
using namespace std;
int sdkys(int a,int b){
if(b==0) return a;
return sdkys(b,a%b);
}
int sskbs(int a,int b){
return a*b/sdkys(a,b);
}
int sosu(int a){
if(a==2){
return 1;
}
for(int i=2;i<sqrt(a)+1;i++){
if(a%i==0){
return 0;
}
}
return 1;
}
vector<int> v;
int n,m,cnt=INF,ans=1,aa[220000],o=0;
pair<int,int> pp[220000];
string s,ss[220000];
char ch[220000];
float fl[220000],fcnt=2;
queue<int> que;
signed main(){
cin>>n>>m;
if(m-n>=2019){
cout<<0<<endl;
}else{
for(int i=n;i<m;i++){
for(int j=i+1;j<m+1;j++){
cnt=min(cnt,(i*j)%2019);
}
}
cout<<cnt<<endl;
}
} | 0 |
#include "bits/stdc++.h"
using namespace std;
#ifndef LOCAL
#define endl '\n'
#endif
#define fr(i, a, b) for(int i = a; i <= b; i++)
#define rf(i, a, b) for(int i = a; i >= b; i--)
#define pf push_front
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define sz(x) (int)x.size()
#define lb lower_bound
#define ub upper_bound
typedef long long ll;
typedef long double f80;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
int pct(int x) { return __builtin_popcount(x); }
int pct(ll x) { return __builtin_popcountll(x); }
int bt(int x) { return 31 - __builtin_clz(x); } // floor(log2(x))
int bt(ll x) { return 63 - __builtin_clzll(x); } // floor(log2(x))
int cdiv(int a, int b) { return a / b + !(a < 0 || a % b == 0); }
ll cdiv(ll a, ll b) { return a / b + !(a < 0 || a % b == 0); }
int nxt_C(int x) { int c = x & -x, r = x + c; return (((r ^ x) >> 2) / c) | r; }
ll nxt_C(ll x) { ll c = x & -x, r = x + c; return (((r ^ x) >> 2) / c) | r; }
vector<int> get_bits(int mask) {
vector<int> bb;
while(mask) { int b = bt(mask); bb.pb(b); mask ^= (1 << b); }
reverse(all(bb));
return bb;
}
int get_mask(vector<int> v) {
int mask = 0;
for(int x : v) { mask ^= (1 << x); }
return mask;
}
template<typename T>
void uniq(vector<T> &v) { sort(all(v)); v.resize(unique(all(v)) - v.begin()); }
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll rand(ll l, ll r){
uniform_int_distribution<ll> uid(l, r);
return uid(rng);
}
void sc() {}
template <typename Head, typename... Tail>
void sc(Head &H, Tail &... T) { cin >> H; sc(T...); }
#ifdef LOCAL
#define debug(...) cerr << "[L:" << __LINE__ << "][" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// #ifndef LOCAL
// string to_string(__int128 x) {
// string s = "";
// bool neg = 0;
// if(x < 0) { s += "-"; neg = 1; x = -x; }
// if(!x) s += '0';
// while(x) {
// int rem = x % 10;
// s += to_string(rem);
// x /= 10;
// }
// reverse(s.begin() + neg, s.end());
// return s;
// }
// #endif
const int mod = 1e9 + 7; // 998244353;
int pwr(int a,ll b) {
int ans = 1;
while(b) {
if(b & 1) ans = (ans * 1LL * a) % mod;
a = (a * 1LL * a) % mod;
b >>= 1;
}
return ans;
}
/*
Lookout for overflows!!
Check array sizes!!
Clear before test cases!!
Use the correct modulo!!
Check for corner cases!!
Are you forgetting something?!
Read problem statement carefully!!!
*/
const int N = 1e5 + 5;
int dsu[N], sz[N];
bool odd[N], par[N];
int root(int u) {
while(u != dsu[u]) u = dsu[u];
return u;
}
int get_par(int u) {
int p = 0;
while(u != dsu[u]) {
p ^= par[u];
u = dsu[u];
}
return p;
}
void uni(int u,int v) {
int uu = root(u), vv = root(v);
if(uu == vv) {
if(get_par(u) == get_par(v))
odd[uu] = 1;
return;
}
if(sz[uu] > sz[vv]) {
swap(uu, vv), swap(u, v);
}
dsu[uu] = vv;
sz[vv] += sz[uu];
odd[vv] |= odd[uu];
par[uu] = get_par(u) ^ get_par(v) ^ 1;
}
void solve() {
int n, m;
sc(n, m);
fr(i, 1, n) {
sz[i] = 1;
dsu[i] = i;
odd[i] = 0;
par[i] = 0;
}
fr(i, 1, m) {
int u, v;
sc(u, v);
uni(u, v);
}
int c1 = 0, c2 = 0, c3 = 0;
fr(i, 1, n) {
if(i == dsu[i]) {
if(sz[i] == 1) {
c1++;
}
else if(odd[i]) {
c2++;
}
else {
c3++;
}
}
}
ll ans = 0;
while(c1) {
ans += 2 * n - 1;
n--;
c1--;
}
while(c2) {
ans += 2 * (c2 + c3) - 1;
c2--;
}
ans += (c3 * 1LL * (c3 - 1)) * 2 + 2LL * c3;
cout << ans;
}
int main() {
ios :: sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
// cin >> t;
for(int tt = 1; tt <= t; tt++) {
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
struct UnionFind{
int num;//連結成分の数
vector<int> r,p;//そのグループのサイズ,自分の親っぽいやつ
UnionFind(){}
UnionFind(int n):num(n),r(n,1),p(n,0){iota(p.begin(),p.end(),0);}
int find(int x){//どのグループに所属するか
return (x==p[x]?x:p[x]=find(p[x]));//xがグループの名前と一致するまでxを親にする
}
bool same(int x,int y){//同じグループかどうか
return find(x)==find(y);
}
void unite(int x,int y){//xとyを同じグループにする
x=find(x);y=find(y);//xとyのグループの名前をどっちかが変える
if(x==y) return;
if(r[x]<r[y]) swap(x,y);//サイズが大きい方をxとする
r[x]+=r[y];//yの親をxにする（今までyだったグループ名がxになる）
p[y]=x;
num--;
}
int size(int x){//グループの大きさ
return r[find(x)];
}
int count() const{//グループの数
return num;
}
};
signed main(){
int n,m;cin>>n>>m;
vector<int> edge[n];
UnionFind uf(n);
while(m--){
int u,v;cin>>u>>v;u--;v--;
uf.unite(u,v);
edge[u].push_back(v);
edge[v].push_back(u);
}
vector<int> arr(n,-1);
vector<int> ni,no,si;
for(int i=0;i<n;i++){
if(uf.size(i)==1){
si.push_back(i);
continue;
}
if(~arr[i])continue;
arr[i]=0;
bool out=false;
queue<int> que;
que.push(i);
while(que.size()){
int p=que.front();que.pop();
for(int q:edge[p]){
if(~arr[q]){
if(arr[q]==arr[p])out=1;
}
else{
arr[q]=arr[p]^1;
que.push(q);
}
}
}
if(out)no.push_back(uf.size(i));
else ni.push_back(uf.size(i));
}
int ans=0;
int a=ni.size(),c=no.size(),e=si.size();
ans=2*a*a+2*a*c+c*c+2*e*n-e*e;
cout<<ans<<endl;
}
/*
解説AC
連結成分なのでどう言う時に繋がっていくかを考える必要があって、それを元のグラフでの連結成分と結びつける問題
実験コードでひらめく感じはしなくて、でも手を動かすのも相当大変
解説記事も全然なくて考察フローがしっかり考えることしかなさそう？えーちょっとまだ分からんな
自分で解説記事書くしかないかなぁ
FA13分ってなんだよ
*/
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
const int INF = (1<<30) - 1;
const ll LINF = (1LL<<60) - 1;
int main(){
int n;
cin >> n;
for (int i = 0; i < 3; ++i) {
if (n % 10 == 7){
cout << "Yes" << endl;
return 0;
}
n /= 10;
}
cout << "No" << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
string str = to_string(N);
string res;
if(str.find("7") != string::npos){
res = "Yes";
} else {
res = "No";
}
cout << res << endl;
return 0;
} | 1 |
#include<iostream>
#include<vector>
#include<algorithm>
int main() {
std::cin.tie(0); std::ios::sync_with_stdio(false);
int N; std::cin >> N;
char buf[1002];
buf[N] = '\n';
buf[N+1] = 0;
if(N >= 4 && N%2 == 0) {
char const* p[2] = {"abcc",
"abdd"};
for(int i = 0; i < N; ++i) {
int x = (i/2)*2, y = i%2;
std::fill_n(buf, N, '.');
for(int j = 0; j < 4; ++j) buf[(x+j)%N] = p[y][j];
std::cout << buf;
}
} else if(N%3 == 0) {
char const* p[3] = {"aab",
"b.b",
"baa"};
for(int i = 0; i < N; ++i) {
int x = (i/3)*3, y = i%3;
std::fill_n(buf, N, '.');
for(int j = 0; j < 3; ++j) buf[(x+j)%N] = p[y][j];
std::cout << buf;
}
} else if(N >= 9 || N==5) {
char const* p[2] = {"abcc",
"abdd"};
int n = N-5;
for(int i = 0; i < n; ++i) {
int x = (i/2)*2, y = i%2;
std::fill_n(buf, N, '.');
for(int j = 0; j < 4; ++j) buf[(x+j)%n] = p[y][j];
std::cout << buf;
}
std::fill_n(buf, N, '.');
char const *q[5] = {"aabba",
"cca.a",
"bbabb",
"..bca",
"..bca"};
for(int i = 0; i < 5; ++i) {
for(int j = 0; j < 5; ++j) buf[n+j] = q[i][j];
std::cout << buf;
}
} else if(N==7) {
std::cout << "aa.ab..\n"
"...aba.\n"
"a....ac\n"
"a.aa..c\n"
"bb..aab\n"
".aa.b.b\n"
"..ccbaa\n";
} else {
std::cout << "-1\n";
}
return 0;
}
| #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int n;
bool no[10001] = {true,true};
for(int i = 4;i <= 10000;i += 2) no[i] = true;
for(int i = 3;i * i <= 10000;i += 2){
for(int j = i * 2;j <= 10000;j += i) no[j] = true;
}
vector<int> twin;
for(int i = 2;i <= 10000;i++){
if(!no[i] && !no[i - 2]) twin.push_back(i);
}
while(cin >> n,n){
int pos = upper_bound(twin.begin(),twin.end(),n) - twin.begin() - 1;
cout << twin[pos] - 2 << " " << twin[pos] << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void input(int& rnTrgSu, int& rnTrgKin)
{
cin >> rnTrgSu >> rnTrgKin;
}
void searchCntl(int nTrgSu, int nTrgKin)
{
for (int n10000 = 0; n10000 <= nTrgSu; ++n10000)
for (int n5000 = 0; n5000 <= (nTrgSu - n10000); ++n5000)
{
int n1000 = nTrgSu - n10000 - n5000;
if (nTrgKin == 10000 * n10000 + 5000 * n5000 + 1000 * n1000)
{
cout << n10000 << " " << n5000 << " " << n1000 << endl;
return;
}
}
cout << -1 << " " << -1 << " " << -1 << endl;
}
int main()
{
int nTrgSu, nTrgKin;
input(nTrgSu, nTrgKin);
searchCntl(nTrgSu, nTrgKin);
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>;
using Graph = vector<vector<int>>;
int main(int argc, const char * argv[]) {
cin.tie(0);
ios::sync_with_stdio(false);
int a,b;
cin>>a>>b;
int ans=-1e9;
ans=max(ans,a+b);
ans=max(ans,a-b);
ans=max(ans,a*b);
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#include <type_traits>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define ddrep(i, n) for (int i = n; i > 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
#define ssrep(i, s, t) for (int i = s; i <= t; ++i)
#define rng(a) a.begin(), a.end()
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define chmax(x, y) (x = max(x, y))
#define chmin(x, y) (x = min(x, y))
using pi = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
using ld = long double;
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
rep(i, (int)v.size()) {
if (i)
os << ",";
os << v[i];
}
os << "}";
return os;
}
template <typename T, size_t S> void printArray(const T (&array)[S]) {
for (auto val : array)
std::cout << val << ", ";
std::cout << "\n";
}
const int mod = 1e9 + 7;
const int inf = 1e9 + 5;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << std::setprecision(10);
int a, b, k; std::cin >> a >> b >> k;
bool t = true;
auto process = [](int &x, int &y) {
if (x & 1)
x--;
y += x / 2;
x /= 2;
};
rep(i, k) {
if (t) {
process(a, b);
} else {
process(b, a);
}
t ^= 1;
}
std::cout << a << ' ' << b << "\n";
}
| #include "bits/stdc++.h"
#define MOD 1000000007
#define rep(i, n) for(ll i=0; i < (n); i++)
#define rrep(i, n) for(ll i=(n)-1; i >=0; i--)
#define ALL(v) v.begin(),v.end()
#define rALL(v) v.rbegin(),v.rend()
#define FOR(i, j, k) for(ll i=j;i<k;i++)
#define debug_print(var) cerr << #var << "=" << var <<endl;
#define DUMP(i, v)for(ll i=0;i<v.size();i++)cerr<<v[i]<<" "
#define fi first
#define se second
using namespace std;
typedef long long int ll;
typedef vector<ll> llvec;
typedef vector<double> dvec;
typedef pair<ll, ll> P;
typedef long double ld;
struct edge{ll x, c;};
ll mod(ll a, ll mod){
ll res = a%mod;
if(res<0)res=res + mod;
return res;
}
ll modpow(ll a, ll n, ll mod){
ll res=1;
while(n>0){
if(n&1) res=res*a%mod;
a=a*a%mod;
n>>=1;
}
return res;
}
ll modinv(ll a, ll mod){
ll b=mod, u=1, v=0;
while(b){
ll t=a/b;
a-=t*b; swap(a, b);
u-=t*v; swap(u, v);
}
u%=mod;
if(u<0)u+=mod;
return u;
}
ll gcd(ll a, ll b){
ll r = a%b;
if(r==0) return b;
else return gcd(b, a%b);
}
bool is_prime(ll n){
ll i = 2;
if(n==1)return false;
if(n==2)return true;
bool res = true;
while(i*i <n){
if(n%i==0){
res = false;
}
i = i+1;
}
//if(i==1)res = false;
if(n%i==0)res=false;
return res;
}
struct UnionFind{
ll N;
llvec p;
llvec cnt;
UnionFind(ll n){
N = n;
p=llvec(N);
cnt=llvec(N, 0);
rep(i, N){
p[i] = i;
cnt[i] = 1;
}
}
void con(ll a, ll b){
P at = root(a);
P bt = root(b);
if(at.second!=bt.second){
if(at.first>bt.first){
swap(at, bt);
swap(a, b);
}
p[at.second] = bt.second;
cnt[bt.second]+=cnt[at.second];
p[a]=bt.second;
}
}
P root(ll a){
ll atmp = a;
ll c=0;
while(atmp!=p[atmp]){
atmp = p[atmp];
c++;
}
p[a] = atmp;
return {c, atmp};
}
bool is_con(ll a, ll b){
P at=root(a);
P bt=root(b);
return at.second == bt.second;
}
};
struct dijkstra{
ll N;
llvec d;
vector<vector<edge>> e;
dijkstra(ll n){
N = n;
//d = llvec(N, 1e18);
e = vector<vector<edge>>(N);
}
void add_edge(ll from, ll to, ll cost){
e[from].push_back({to, cost});
}
void run(ll start){
priority_queue<P, vector<P>, greater<P>> que;
que.push({0, start});
d = llvec(N, 1e18);
d[start]=0;
while(!que.empty()){
P q = que.top();que.pop();
ll dc = q.first;
ll x = q.second;
if(dc>d[x]){
continue;
}else{
for(auto ip: e[x]){
if(d[ip.x]<=d[x]+ip.c){
continue;
}else{
d[ip.x]= d[x]+ip.c;
que.push({d[ip.x], ip.x});
}
}
}
}
}
};
/**************************************
** A main function starts from here **
***************************************/
int main(){
ll a, b;
cin >> a >> b;
ll k;
cin >> k;
for(ll i=0;i<k;i++){
if(a%2==1)a-=1;
b += a/2;
a/=2;
i++;
if(i==k)break;
if(b%2==1)b-=1;
a += b/2;
b/=2;
}
cout << a << " " << b << endl;
return 0;
}
| 1 |
Subsets and Splits