code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <algorithm>
#include <climits>
#include <cmath>
#include <deque>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <unordered_map>
#include <vector>
const int mod = 1e9 + 7;
const int kmax = 510000;
const int last_days[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
long long fact[kmax], fact_inv[kmax], inv[kmax];
void init_comb()
{
fact[0] = fact[1] = 1;
fact_inv[0] = fact_inv[1] = 1;
inv[1] = 1;
for (int i = 2; i < kmax; i++) {
fact[i] = fact[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
fact_inv[i] = fact_inv[i - 1] * inv[i] % mod;
}
}
long long comb(int n, int r)
{
if (n < r) {
return 0;
}
if (n < 0 || r < 0) {
return 0;
}
return fact[n] * (fact_inv[r] * fact_inv[n - r] % mod) % mod;
}
template <typename T, T N>
class UnionFind {
T parent_[N];
T rank_[N];
T size_[N];
public:
UnionFind();
T Root(T idx);
bool IsSame(T x, T y);
void Unite(T x, T y);
T GetSize(T idx);
};
template <typename T, T N>
UnionFind<T, N>::UnionFind()
{
for (T i = 0; i < N; i++) {
parent_[i] = i;
rank_[i] = 0;
size_[i] = 1;
}
}
template <typename T, T N>
T UnionFind<T, N>::Root(T idx)
{
return parent_[idx] == idx ? idx : parent_[idx] = Root(parent_[idx]);
}
template <typename T, T N>
bool UnionFind<T, N>::IsSame(T x, T y)
{
return Root(x) == Root(y);
}
template <typename T, T N>
void UnionFind<T, N>::Unite(T x, T y)
{
x = Root(x);
y = Root(y);
if (x == y) {
return;
}
if (rank_[x] < rank_[y]) {
parent_[x] = y;
size_[y] += size_[x];
} else {
parent_[y] = x;
size_[x] += size_[y];
if (rank_[x] == rank_[y]) {
rank_[x]++;
}
}
}
template <typename T, T N>
T UnionFind<T, N>::GetSize(T idx)
{
return size_[Root(idx)];
}
long long pow_mod(long long n, long long p, long long m)
{
if (p == 0) {
return 1;
}
if (p % 2 == 0) {
long long t = pow_mod(n, p / 2, m);
return t * t % m;
}
return n * pow_mod(n, p - 1, m) % mod;
}
long long nCr_mod(long long n, long long r)
{
long long x = 1;
for (long long i = n - r + 1; i <= n; i++) {
x *= i;
x %= mod;
}
long long a = 1;
for (long long i = 1; i <= r; i++) {
a *= i;
a %= mod;
}
long long y = pow_mod(a, mod - 2, mod) % mod;
return x * y % mod;
}
bool is_prime(long long n)
{
if (n == 1) {
return false;
}
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
bool is_leap(long long y)
{
return (y % 4 == 0 && y % 100 != 0) || y % 400 == 0;
}
void next_day(long long& y, long long& m, long long& d)
{
d++;
if (d > last_days[m - 1] + (m == 2 && is_leap(y) ? 1 : 0)) {
d = 1;
m++;
}
if (m > 12) {
y++;
m = 1;
}
}
long long fib(long long n)
{
long long a = 0, b = 1;
for (int i = 0; i < n; i++) {
long long t = a;
a = b;
b = a + t;
}
return a;
}
int main()
{
long long x, y;
std::cin >> x >> y;
if (x < y) {
if (x * y < 0) {
std::cout << std::min(y - x, 1 + std::abs(std::abs(y) - std::abs(x))) << std::endl;
return 0;
}
std::cout << y - x << std::endl;
} else if (x * y <= 0) {
std::cout << std::abs(std::abs(x) - std::abs(y)) + 1 << std::endl;
} else {
std::cout << std::abs(x - y) + 2 << std::endl;
}
}
| #include<bits/stdc++.h>
using namespace std;
using lli = long long;
#define rep(i,n) for(int i=0;i<n;i++)
lli x, y;
int main(void){
cin >> x >> y;
lli ans = 1e18;
rep(i, 2){
rep(j, 2){
lli xc, yc;
xc = x;
yc = y;
lli c = 0;
if(i == 1) xc*=-1, c++;
if(j == 1) yc*=-1, c++;
if(xc <= yc) c+=yc-xc;
else c+=1e18;
ans = min(ans, c);
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define endl "\n"
#define int long long
const int N = 1e5 + 5;
struct Gauss
{
static const int bits = 60;
int table[bits];
Gauss()
{
for(int i = 0; i < bits; i++)
table[i] = 0;
}
int size()
{
int ans = 0;
for(int i = 0; i < bits; i++)
{
if(table[i])
ans++;
}
return ans;
}
bool can(int x)
{
for(int i = bits-1; i >= 0; i--)
x = min(x, x ^ table[i]);
return x == 0;
}
void add(int x)
{
for(int i = bits-1; i >= 0 && x; i--)
{
if(table[i] == 0)
{
table[i] = x;
x = 0;
}
else
x = min(x, x ^ table[i]);
}
}
int getBest()
{
int x = 0;
for(int i = bits-1; i >= 0; i--)
x = max(x, x ^ table[i]);
return x;
}
void merge(Gauss &other)
{
for(int i = bits-1; i >= 0; i--)
add(other.table[i]);
}
};
int n;
int a[N];
Gauss g;
int32_t main()
{
IOS;
cin >> n;
int curXor = 0;
for(int i = 1; i <= n; i++)
{
cin >> a[i];
curXor ^= a[i];
}
for(int i = 1; i <= n; i++)
{
a[i] = a[i] & (((1LL << 60) - 1) ^ curXor);
g.add(a[i]);
}
cout << curXor + g.getBest() * 2;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
const int N = 15;
void cmax(int& x, int y) {
if (x < y) {
x = y;
}
}
int n, m, dist[N][N], value[1 << N], dp[1 << N][N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
int sum = 0;
for (int i = 0, a, b, c; i < m; ++i) {
cin >> a >> b >> c;
--a;
--b;
dist[a][b] = dist[b][a] = c;
sum += c;
}
int all = 1 << n;
for (int i = 1; i < all; ++i) {
int p = 0;
while (!(i >> p & 1)) {
++p;
}
value[i] = value[i ^ (1 << p)];
for (int j = 0; j < n; ++j) {
if (j != p && (i >> j & 1)) {
value[i] += dist[p][j];
}
}
}
memset(dp, 0xc0, sizeof dp);
for (int i = 1; i < all; ++i) {
if ((i & 1) && !(i >> n - 1 & 1)) {
dp[i][0] = value[i];
}
}
for (int i = 1; i < all; ++i) {
for (int j = 1; j < n; ++j) {
if (i >> j & 1) {
for (int k = (i - 1) & i; k; k = (k - 1) & i) {
if ((k & 1) && !(k >> j & 1)) {
for (int l = 0; l < n; ++l) {
if ((k >> l & 1) && dist[j][l]) {
cmax(dp[i][j], dp[k][l] + value[i ^ k] + dist[j][l]);
}
}
}
}
}
}
}
int answer = 0;
for (int i = 1; i < all; ++i) {
cmax(answer, dp[i][n - 1]);
}
cout << sum - answer << '\n';
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
int main() {
long long int n, k; cin >> n >> k;
vector<long long> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long ans = k;
for (int i = 1; i < n; i++) {
if (a[i] - a[i - 1] < k) {
ans += a[i] - a[i - 1];
} else {
ans += k;
}
}
cout << ans;
}
| #include<iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<queue>
#include<cmath>
#include<cstdio>
#include<tuple>
#include<bitset>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<n;++i)
#define rep1(i,n) for(int i=1;i<=n;++i)
#define ALL(x) x.begin(),x.end()
#define ll long long
const int inf=1000000007;
const int MOD=1000000007;
int n,m;
struct Map{
vector<vector<int>> map;
void mkmap(vector<int> const& a,vector<int> const& b,vector<int>& num){
//num.resize(n*m+1,0);
rep(i,n){
map.push_back(vector<int> (m,inf));
}
rep(i,n){
rep(j,m){
map[i][j]=min(a[i],b[j]);
if(a[i]==b[j])map[i][j]=999;
}
}
}
void show_map(){
rep(i,n){
rep(j,m){
cout<<map[i][j]<<" ";
}
cout<<endl;
}
}
};
signed main(){
cin>>n>>m;
vector<int> a(n);
vector<int> b(m);
vector<int> sum;
vector<int> memo(n*m+1,0);
vector<int> num(n*m+1,0);
vector<int> list;
rep(i,n)cin>>a[i];
rep(i,m)cin>>b[i];
//Map grid;
//grid.mkmap(a,b,num);
rep(i,n){
rep(j,m){
if(a[i]==b[j]){
sum.push_back(inf);
++num[a[i]];
list.push_back(a[i]);
}
else{
sum.push_back(min(a[i],b[j]));
}
}
}
sort(ALL(sum));
rep1(i,n*m){
memo[i]=memo[i-1];
if(num[i]==1)++memo[i];
else if(num[i]>1){
cout<<0<<endl;
return 0;
}
}
int cur=1;
int res=1;
sum.push_back(inf);
sum.push_back(inf);
int last=sum[0];
rep1(i,n*m){
if(last==sum[i]){
cur++;
continue;
}
else{
if(num[last]==1){
rep1(k,cur){
res*=last-1-memo[last]-i+k+1;
res%=MOD;
}
}
else{
res*=cur;
rep1(k,cur-1){
res*=last-1-memo[last]-i+k+1;
res%=MOD;
}
}
cur=1;
}
//cout<<sum[i]-memo[sum[i]]-i<<endl;
if(res<0)res=0;
res%=MOD;
last=sum[i];
if(sum[i]==inf){
break;
}
}
cout<<res<<endl;
//grid.show_map();
/*rep(i,list.size()){
cout<<list[i]<<endl;
}*/
//cout<<memo[182]<<endl;
return 0;
}
| 0 |
// <------------- Template -----------------------> //
#include<bits/stdc++.h>
using namespace std;
#define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0); cout<<fixed; cout<<setprecision(0);
#define randomINT mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
#define newl cout<<"\n"
#define DISP(as) for(auto it : as) cout<<it<<" ";newl;
#define all(x) (x).begin(),(x).end()
#define mset(x,val) memset(x,val,sizeof(x))
#define newl cout<<"\n"
#define pb push_back
#define mp make_pair
#define f first
#define s second
#define dline cerr<<"///REACHED///\n";
#define deb1(x) cerr<<#x<<" = "<<x<<'\n';
#define deb2(x,y) cerr<<'['<<#x<<','<<#y<<"] = "<<'['<<x<<','<<y<<']'<<'\n';
#define deb3(x,y,z) cerr<<'['<<#x<<','<<#y<<','<<#z<<"] = "<<'['<<x<<','<<y<<','<<z<<']'<<'\n';
#define N 1000000007 // prime modulo value
typedef long long ll;
typedef long double ld;
typedef vector<ll> vll;
typedef pair<ll , ll> pll;
typedef pair<ld, ld> pld;
typedef unordered_map<ll, ll> um;
typedef vector<pll> vpll;
const ll MAX5 = 1e+5 + 7;
const ll MAX7 = 1e+7 + 7;
const ll MAXN = 2 * 1e18;
const ll INF = 0x7f7f7f7f7f7f7f7f;
const int INFi = 0x7f7f7f7f;
const ll MOD = 1e+9 + 7;
vll adj[MAX5];
// <------------- Declare Variables Here ------------> //
ll T = 1;
ll n, x, y, q, m, k;
string s, t, d;
ll sum = 0;
ll cou = 0;
// <------------- Implement Functions Here ----------> //
// <------------- Start of main() -------------------> //
void MAIN() {
cin >> n >> x;
vll a(n);
for(ll i=0;i<n;i++) cin>>a[i];
sort(all(a));
reverse(all(a));
ll sum = 0;
for(ll i=0;i<x;i++) sum+=a[i];
cout<<sum;
}
int main() {
fastio; randomINT;
//cin>>T;
while (T--) {
MAIN();
}
return 0;
}
|
/*
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;
}
| 0 |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long int
#define ld long double
#define pb push_back
#define pll pair<ll, ll>
#define vl vector<ll>
#define vvl vector< vector<ll> >
#define vlp vector< pair<ll, ll> >
#define vllp vector<pair<pll, ll> >
#define mll map<ll, ll>
#define rep(i,a) for(ll i=0; i< a; i++)
#define rep1(i,a) for(ll i = 1; i< a; i++)
#define foi(i, a, b) for(ll i = a; i<b ; i++)
#define fod(i, a, b) for(ll i = a; i>=b ; i--)
#define mp make_pair
#define all(v) (v).begin(), (v).end()
#define fst first
#define sec second
#define ff first.first
#define fs first.second
#define max3(a, b, c) max(max(a, b), c)
#define min3(a, b, c) min(min(a, b), c)
#define MAX 1000001
#define MOD 1000000007
// #define MOD 998244353
#define endl "\n"
#define INF (ll)1e18
#define s(v) (ll)v.size()
#define e(v) v.empty()
#define bscount(x) __builtin_popcountll(x)
// #define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
using namespace std;
// using namespace __gnu_pbds;
ll gcd(ll a, ll b){if(b==0)return a;return gcd(b, a%b);}
ll fexp(ll a, ll b){ll ans = 1;while(b){if(b&1) ans = ans*a%MOD; b/=2;a=a*a%MOD;}return ans;}
ll inverse(ll a, ll p){return fexp(a, p-2);}
void ingraph(vvl& graph, ll m){ll x, y;rep(i, m){cin>>x>>y;x--, y--;graph[x].pb(y);graph[y].pb(x);}}
ll modify(ll n){ll res = n;res%=MOD;res+=MOD;res%=MOD;return res;}
int main(){
// #ifndef ONLINE_JUDGE
// freopen("../input.txt", "r", stdin);
// freopen("../output.txt", "w", stdout);
// #endif
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
ll t;
// cin>>t;
t = 1;
while(t--){
ll n, m, v, p;
cin>>n>>m>>v>>p;
vl vec(n);
rep(i, n) cin>>vec[i];
sort(all(vec));
vl pref(n);
ll cur = 0;
rep(i, n){
cur += vec[i];
pref[i] = cur;
}
ll ans = 0;
rep(i, n){
ll nv = v;
nv -= (i+1);
bool poss = false;
ll j = upper_bound(all(vec), vec[i] + m) - vec.begin();
if(n - j >= p) continue;
else{
nv -= (n - j);
if(v <= 0) {ans++;poss = true;}
else{
ll np = p - (n - j) - 1;
if(j - i - 1 <= np) ans++;
else{
nv -= np;
ll del = (j - np - 1 - i)*(vec[i] + m) - (pref[j-np-1] - pref[i]);
if(del >= nv*m) ans++;
}
}
}
}
cout<<ans;
}
} | #include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#define N 100010
#define int long long
using namespace std;
int num[N];
signed main()
{
int n,m,v,p;
scanf("%lld%lld%lld%lld",&n,&m,&v,&p);
for(int i=1;i<=n;i++) scanf("%d",&num[i]);
sort(num+1,num+n+1);
reverse(num+1,num+n+1);
int sum=0,ans=p;
for(int i=p+1;i<=n && num[i]+m>=num[p];i++)
{
int d=n-(i-p);
if(v<=d) ++ans;
else
{
int res=(1ll*(v-d)*m-sum-1)/(i-p)+1;
if(num[p]+res<=num[i]+m) ++ans;
}
sum+=num[p]-num[i];
}
printf("%lld\n",ans);
return 0;
}
| 1 |
#include<iostream>
#include<cmath>
using namespace std;
int main(){
int h,w;
while(cin>>h>>w,h||w){
int a=h*h+w*w;
bool hantei=false;
while(1){
while(1){
h++;
double s=sqrt(a-h*h);
if(s-(int)s==0&&h*h<(a-h*h)){hantei=true;break;}
if(a-h*h<1)break;
}
//cout<<a<<endl;
if(hantei){cout<<h<<" "<<sqrt(a-h*h)<<endl;break;}
a++;
h=0;
}
}
} | #include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<algorithm>
#include<cmath>
#include<climits>
#include<string>
#include<set>
#include<map>
using namespace std;
#define rep(i,n) for(int i=0;i<((int)(n));i++)
#define reg(i,a,b) for(int i=((int)(a));i<=((int)(b));i++)
#define irep(i,n) for(int i=((int)(n))-1;i>=0;i--)
#define ireg(i,a,b) for(int i=((int)(b));i>=((int)(a));i--)
typedef long long int lli;
typedef pair<int,int> mp;
#define fir first
#define sec second
#define IINF INT_MAX
#define LINF LLONG_MAX
int n;
bool isbig(mp pa,mp pb){
int da = pa.fir*pa.fir+pa.sec*pa.sec;
int db = pb.fir*pb.fir+pb.sec*pb.sec;
if(da!=db)return (da>db);
return (pa.fir>pb.fir);
}
int main(void){
for(;;){
int w,h;
scanf("%d%d",&h,&w);
if(h==0)break;
mp cp(h,w);
mp pa(1000,1000);
reg(y,1,150){
reg(x,y+1,150){
mp np(y,x);
if(!isbig(np,cp))continue;
if(isbig(pa,np))pa=np;
}
}
printf("%d %d\n",pa.fir,pa.sec);
}
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int a[4], b[2], sum;
sum = 0;
for (int i = 0; i < 4; i++){
cin >> a[i];
}
cin >> b[0] >> b[1];
if (b[0] <= b[1]){
sum += b[1];
}
else {
sum += b[0];
}
sort(a, a + 4);
sum += a[1] + a[2] + a[3];
cout << sum << endl;
} | //Author: Fuadul Hasan([email protected])
//BSMRSTU,Gopalganj
#include<bits/stdc++.h>
using namespace std;
//int input........
template <typename T> inline void readline(T &n) {n = 0; int f = 1; register int ch = getchar();
for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;for (; isdigit(ch);
ch = getchar()) n = (n << 3) + (n << 1) + ch - '0';n = n * f;}
template <typename T, typename TT> inline void readline(T &n, TT &m) { readline(n); readline(m); }
template <typename T, typename TT, typename TTT> inline void readline(T &n, TT &m, TTT &l) { readline(n, m); readline(l);}
// long long input........
template <typename T> inline void readlinel(T &n) {n = 0; long long f = 1; register long long ch = getchar();
for (; !isdigit(ch); ch = getchar()) if (ch == '-') f = -1;for (; isdigit(ch);
ch = getchar()) n = (n << 3) + (n << 1) + ch - '0';n = n * f;}
template <typename T, typename TT> inline void readlinel(T &n, TT &m) { readlinel(n); readlinel(m); }
template <typename T, typename TT, typename TTT> inline void readlinel(T &n, TT &m, TTT &l) { readlinel(n, m); readlinel(l);}
//debug..........
#define error(args...) {vector<string>_v=split(#args,',');err(_v.begin(),args);cout<<endl;}
vector<string> split(const string &s, char c) {vector<string>v; stringstream ss(s); string x;
while (getline(ss, x, c))v.emplace_back(x); return move(v);} void err(vector<string>::iterator it) {}
template<typename T, typename... Args>void err(vector<string>::iterator it, T a, Args...args) {
cout << it->substr((*it)[0] == ' ', it->length()) << " = " << a << " "; err(++it, args...);}
//............ignore it..................//
int dx[8]= {1,0,-1,0,-1,-1,1,1};int dy[8]= {0,1,0,-1,-1,1,-1,1}; int tc = 1;
#define F first
#define S second
#define pb push_back
#define mp make_pair
#define Pi atan(1)*4
#define ll long long int
#define happy cin.tie(0);
#define point(x) setprecision(x)
#define coding ios::sync_with_stdio(false);
#define Test printf("Case %d: ",tc++);
#define Unique(c) (c).resize(unique(all(c))-(c).begin())
#define vout(v) for (auto z: v) cout << z << " "; cout << endl;
void print(int n){printf("%d ", n);}
void print(int n,int m){printf("%d ",n);printf("%d ",m);}
void print(int n,int m,int k){printf("%d ",n);printf("%d ",m);printf("%d ",k);}
void print(ll n){printf("%I64d ", n);}
void print(ll n,ll m){printf("%I64d ",n);printf("%I64d ",m);}
void print(ll n,ll m,ll k){printf("%I64d ",n);printf("%I64d ",m);printf("%I64d ",k);}
int length(long long x){int l = 0;for(long long i=x;i;i/=10)l++;return l;}
int length(string s){return s.size();}
#define pr pair<int, int>
#define vpr vector<pr>
#define vi std::vector<int>
#define vll std::vector<ll>
#define all(n) n.begin(),n.end()
const int M = 1e9 + 7;
const int Inf = (int)2e9 + 5;
const ll Lnf = (ll)2e18 + 5;
const int N = 4e5 + 5;
const int N1 = 1e5 + 5;
double vip(int x1,int y1,int x2,int y2){
double x = (x1 - x2);
double y = (y1 - y2);
double ans = x*x + y*y;
return sqrt(ans);
}
double fact(int n){
double ans = 1.0;
for(int i=1;i<=n;i++){
ans *= (double)i;
}
return ans;
}
int solve()
{
//happy coding
int n;
cin>>n;
vector<pair<int,int>>v;
for(int i=0;i<n;i++){
int x,y;
cin>>x>>y;
v.pb({x,y});
}
sort(all(v));
double dis = 0;
do{
for(int i=0;i<n-1;i++){
//cout<<v[i].F<<" "<<v[i].S<<endl;
dis += (vip(v[i].F,v[i].S,v[i+1].F,v[i+1].S));
}
}while(next_permutation(all(v)));
double z = fact(n);
//error(dis);
cout<<point(10)<<dis/z<<endl;
return 0;
//error();
}
int main(){
int test = 1;
//readline(test);//(void)getchar();
while (test--)solve();return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int z;
cin>>z;
if(z<1200) cout<<"ABC"<<endl;
else if(z<2800) cout<<"ARC"<<endl;
else cout<<"AGC"<<endl;
} | #include <iostream>
//#include <vector>
#include <string>
//#include <algorithm>
//#include <math.h>
//#include <queue>
//#include <stack>
//#include <iomanip>
// sometimes used
//#include <set>
//#include <map>
//#include <numeric>
//#include <list>
//#include <deque>
//#include <unordered_map>
typedef long long LL;
//typedef long double LD;
using namespace std;
//#define MOD 1000000007
//#define MAX 100100
//#define NIL -1
//#define INFTY 1000000000000000000
int main(){
string s;
cin >> s;
s[3]='8';
cout << s << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
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;
vi a(n+1);
rep1(i, n) cin >> a[i];
vi b(n+1);
rep1r(i, n) {
int sum = 0;
for (int j=i*2; j<=n; j+=i) sum ^= b[j];
b[i] = sum ^ a[i];
}
vi ans;
rep1(i, n) if (b[i] == 1) ans.pb(i);
int m = sz(ans);
cout << m << endl;
rep(i, m) printf("%d%c", ans[i], (i<m-1?' ':'\n'));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int MAXN = 1E5;
bool isSheep[MAXN];
bool o[MAXN];
bool options[2] = {true, false};
bool isValid(int n)
{
bool firstSheep = isSheep[0];
for (int i = 1; i < n; i++)
{
if (isSheep[i] && o[i] || !isSheep[i] && !o[i])
{
isSheep[(i + 1) % n] = isSheep[i - 1];
}
else if (isSheep[i] && !o[i] || !isSheep[i] && o[i])
{
isSheep[(i + 1) % n] = !isSheep[i - 1];
}
}
if (isSheep[0] != firstSheep)
return false;
if (firstSheep && o[0] || !firstSheep && !o[0])
{
return isSheep[n - 1] == isSheep[1];
}
else
{
return isSheep[n - 1] != isSheep[1];
}
}
int main()
{
int n;
cin >> n;
for (int i = 0; i < n; i++)
{
char c;
cin >> c;
o[i] = c == 'o';
}
bool valid = false;
for (bool s1 : options)
{
for (bool s2 : options)
{
isSheep[0] = s1;
isSheep[1] = s2;
if (isValid(n))
{
valid = true;
break;
}
}
if (valid)
break;
}
if (valid)
{
stringstream ss;
for (int i = 0; i < n; i++)
{
if (isSheep[i])
ss << "S";
else
ss << "W";
}
cout << ss.str() << endl;
}
else
cout << -1 << endl;
return 0;
}
| 0 |
#include "bits/stdc++.h"
using namespace std;
int main() {
int H, W;
cin >> H >> W;
vector<string> S(H);
for (int i = 0; i < H; i++) cin >> S[i];
vector<vector<int> > A(H, vector<int>(W));
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
if (S[i][j] == '.') A[i][j] = 0;
else A[i][j] = 1;
}
}
vector<vector<int> > B(H, vector<int>(W - 1));
for (int i = 0; i < H; i++) {
for (int j = 0; j < W - 1; j++) {
B[i][j] = A[i][j] ^ A[i][j + 1];
}
}
vector<vector<int> > C(H, vector<int>(W - 1));
for (int i = 0; i < W - 1; i++) {
C[H - 1][i] = 1;
for (int j = H - 2; j >= 0; j--) {
if (B[j + 1][i] == B[j][i]) C[j][i] = C[j + 1][i] + 1;
else C[j][i] = 1;
}
}
int ANS = 0;
for (int i = 0; i < H; i++) {
stack<pair<int, int> > ST;
ST.push({ C[i][0], 0 });
for (int j = 1; j < W - 1; j++) {
int X = j;
while (!ST.empty() && ST.top().first > C[i][j]) {
ANS = max(ANS, ST.top().first * (j - ST.top().second + 1));
X = ST.top().second;
ST.pop();
}
ST.push({ C[i][j], X });
}
while (!ST.empty()) {
ANS = max(ANS, ST.top().first * (W - ST.top().second));
ST.pop();
}
}
cout << max(ANS, max(H, W)) << endl;
} | # include <iostream>
# include <string>
# include <algorithm>
# include <vector>
# include <cstring>
# include <stdio.h>
# include <map>
# include <queue>
# define ll long long
# define pii pair<int,int>
# define FOR(a,b) for(int a=1; a<=b; a++)
# define REP(a,b) for(int a=0; a<b; a++)
# define FORU(a,b,c) for(int a=b; a<=c; a++)
# define FORD(a,b,c) for(int a=b; a>=c; a--)
using namespace std;
char grid[2005][2005];
int tok[2005][2005];
int h[2005], w[2005];
int R, C;
int main(){
ios :: sync_with_stdio(false);
cin >> R >> C;
FOR(i,R) FOR(j,C){
cin >> grid[i][j];
}
int ans = max(R,C);
FOR(i,R-1){
FOR(j,C-1){
int black = (grid[i][j] == '#') + (grid[i][j+1] == '#') + (grid[i+1][j] == '#') + (grid[i+1][j+1] == '#');
tok[i][j] = black&1;
}
}
FOR(i,R){
FOR(j,C-1){
if(tok[i-1][j]) h[j] = 1;
else h[j]++;
}
int k = 0;
FOR(j,C-1){
while(h[j] <= h[w[k]]){
ans = max(ans, h[w[k]]*(j - w[k-1]));
k--;
}
w[++k] = j;
}
while(k > 0){
ans = max(ans, h[w[k]] * (C - w[k-1]));
k--;
}
}
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
#define REP(i,n) for (int i = 0; i <(n); ++i)
#define REP2(i,x,n) for (int i = x; i <(n); ++i)
#define ALL(v) v.begin(), v.end()
#define RALL(v) v.rbegin(), v.rend()
using namespace std;
using ll = long long;
using P = pair<int,int>;
static const double PI = acos(-1);
static const int INF = 1e9+7;
#define REP(i,n) for (int i = 0; i <(n); ++i)
//debug
#ifdef _DEBUG
#define debug(var) do{cout << #var << " :";view(var);}while(0)
#else
#define debug(...)
#endif
template<typename T> void view(T e){cout << e << endl;}
template<typename T> void view(const vector<T>& v){for(const auto& e : v){ cout << e << " "; } cout << endl;}
template<typename T> void view(const vector<vector<T> >& vv){ for(const auto& v : vv){ view(v); } }
int main(){
string s;
cin >> s;
map<char, bool> mp;
for(char alp = 'a'; alp <='z'; alp++){
mp[alp] = false;
}
REP(i,s.size()){
mp[s[i]] = true;
}
for(char alp = 'a'; alp <='z'; alp++){
if(mp[alp] == false) {
cout << alp << endl;
return 0;
}
}
cout << "None" << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
string S , T;
while(getline(cin , S))for(size_t i = 0; i < 26; i++)
{
for(auto &x : S)if('a' <= x&&x <= 'z')if(++x > 'z')x -= 26;
stringstream SS;
SS << S;
vector<string>VS;
while(SS >> T)if(T == "the" || T == "this" || T == "that" || T == "ths." || T == "this." || T == "that.")
{
cout << S << endl;
break;
}
}
} | 0 |
#include<bits/stdc++.h>
#define reg register int
#define il inline
#define fi first
#define se second
#define mk(a,b) make_pair(a,b)
#define numb (ch^'0')
#define pb push_back
#define solid const auto &
#define enter cout<<endl
#define pii pair<int,int>
using namespace std;
typedef long long ll;
template<class T>il void rd(T &x){
char ch;x=0;bool fl=false;while(!isdigit(ch=getchar()))(ch=='-')&&(fl=true);
for(x=numb;isdigit(ch=getchar());x=x*10+numb);(fl==true)&&(x=-x);}
template<class T>il void output(T x){if(x/10)output(x/10);putchar(x%10+'0');}
template<class T>il void ot(T x){if(x<0) putchar('-'),x=-x;output(x);putchar(' ');}
template<class T>il void prt(T a[],int st,int nd){for(reg i=st;i<=nd;++i) ot(a[i]);putchar('\n');}
namespace Modulo{
const int mod=1e9+7;
int ad(int x,int y){return (x+y)>=mod?x+y-mod:x+y;}
void inc(int &x,int y){x=ad(x,y);}
int mul(int x,int y){return (ll)x*y%mod;}
void inc2(int &x,int y){x=mul(x,y);}
int qm(int x,int y=mod-2){int ret=1;while(y){if(y&1) ret=mul(x,ret);x=mul(x,x);y>>=1;}return ret;}
}
using namespace Modulo;
namespace Miracle{
const int N=2002;
const int M=4000000+5+N+N;
int n,k;
int f[2][N];
int jie[M],inv[M];
int C(int n,int m){
if(n<0||m<0||n<m) return 0;
return mul(jie[n],mul(inv[m],inv[n-m]));
}
int main(){
rd(n);rd(k);
if(k==1){
puts("1");return 0;
}
int lim=n*k+n+n;
jie[0]=1;
for(reg i=1;i<=lim;++i) jie[i]=mul(jie[i-1],i);
inv[lim]=qm(jie[lim]);
for(reg i=lim-1;i>=0;--i) inv[i]=mul(inv[i+1],i+1);
int tmp=0;
f[0][0]=1;
for(reg i=2*n;i>=1;--i){
tmp^=1;
memset(f[tmp],0,sizeof f[tmp]);
int re=2*n-i;
for(reg j=0;j<=min(re,n);++j){
if(!f[tmp^1][j]) continue;
int le=re-j;
if(le+1<=j) f[tmp][j]=ad(f[tmp][j],f[tmp^1][j]);
if(j!=n){
f[tmp][j+1]=ad(f[tmp][j+1],mul(f[tmp^1][j],C(k-2+le+j*(k-1),le+j*(k-1))));
}
}
}
ll ans=mul(f[tmp][n],jie[n]);
ot(ans);
return 0;
}
}
signed main(){
Miracle::main();
return 0;
}
/*
Author: *Miracle*
*/ | #include<bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=2000+10,mod=1e9+7;
ll f[maxn][maxn];
ll s[maxn*maxn+10],invs[maxn*maxn+10];
int n,m;
inline void read(int &x){
char c=getchar();
int f=1;
x=0;
while(c<'0' || c>'9'){if(c=='-')f=-1;c=getchar();}
while(c>='0' && c<='9'){x=x*10+c-'0';c=getchar();}
x*=f;
}
inline long long ksm(ll x,int y){
ll sum=1;
while(y){
if(y&1){sum=(sum*x)%mod;}
y/=2;
x=(x*x)%mod;
}
return sum%mod;
}
inline ll cal(int x,int y){
//cout<<s[x]<<" "<<s[y]<<endl;
ll sum2=1,sum1=1,sum=0;
//for(register int i=1;i<=y;i++)sum1=(sum1*i)%mod;
//for(register int i=x-y+1;i<=x;i++)sum2=(sum2*i)%mod;
//sum2=s[x];sum1=(s[x-y]*s[y])%mod;
//sum=(sum2*ksm(sum1,mod-2))%mod;
sum=((s[x]*invs[y])%mod*invs[x-y])%mod;
//cout<<sum<<endl;
return sum%mod;
}
int main(){
int i,j,k;
read(n);read(m);
//cout<<n<<" "<<m<<endl;
if(m==1){cout<<1<<endl;return 0;}
f[0][0]=1;
s[0]=1;
//for(register int i=1;i<=n;i++)f[i][0]=1;
for(register int i=1;i<=maxn*maxn;i++){s[i]=(s[i-1]*i)%mod;}
invs[maxn*maxn]=ksm(s[maxn*maxn],mod-2);
for(register int i=maxn*maxn-1;i>=0;i--)invs[i]=(invs[i+1]*(i+1))%mod;
for(register int i=1;i<=n;i++)
for(register int j=0;j<=i;j++){
if(!j)f[i][j]=f[i-1][j]%mod;
else f[i][j]=(f[i-1][j]+((f[i][j-1]*(n-j+1))%mod*cal(n*m-(j-1)*(m-1)-i-1,m-2)))%mod;
}
cout<<f[n][n]<<endl;
return 0;
} | 1 |
#include <cstdio>
#include <vector>
using namespace std;
class Edge{
public:
int from,to,cost;
Edge(int f,int t,int c){
from = f;
to = t;
cost = c;
}
void swap(){
int a = from;
from = to;
to = a;
}
};
vector<Edge> edge;
int n,m;
const int INF = 999999999;
int solve(int s){
int* d = new int[n + 1];
for(int i=0;i<=n;i++){
d[i] = INF;
}
d[s] = 0;
while(1){
bool f = true;
vector<Edge>::iterator it;
for(it = edge.begin();it<edge.end();it++){
if(d[it->from] != INF){
if(d[it->to] > d[it->from] + it->cost){
d[it->to] = d[it->from] + it->cost;
f = false;
}
}
}
if(f){
break;
}
}
int ans = 0;
for(int i=2;i<=n;i++){
if(d[i] <= 2){
ans += 1;
}
}
delete[] d;
return ans;
}
int main(){
int a,b;
while(scanf("%d %d",&n,&m) && (n || m)){
edge.clear();
for(int i=0;i<m;i++){
scanf("%d %d",&a,&b);
edge.push_back( Edge(a,b,1) );
edge.push_back( Edge(b,a,1) );
}
printf("%d\n",solve(1));
}
} | #include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
int need[10] = {0, 2, 5, 5, 4, 5, 6, 3, 7, 6};
int compare(string s, string t) {
if (s.length() > t.length()) {
return -1;
} else if (s.length() < t.length()) {
return 1;
} else {
if (s < t) {
return 1;
} else if (s == t) {
return 0;
} else {
return -1;
}
}
}
string add(string s, char a) {
if (s.length() == 0) {
return string(1, a);
}
if (s[0] <= a) {
return a + s;
} else if (s.back() >= a) {
return s + a;
}
for (int i = 0; i < (int)s.length(); i++) {
if (s[i] < a) {
return s.substr(0, i) + a + s.substr(i + 1);
}
}
return "";
}
int main() {
int N, M;
cin >> N >> M;
vector<int> A(M);
for (int i = 0; i < M; i++) {
cin >> A[i];
}
vector<string> dp(N + 1, "");
for (int a : A) {
if (need[a] > N)
continue;
if (dp[need[a]] == "") {
dp[need[a]] = to_string(a);
} else if (compare(dp[need[a]], to_string(a)) == 1) {
dp[need[a]] = to_string(a);
}
}
for (int i = 0; i <= N; i++) {
if (dp[i] == "")
continue;
for (int a : A) {
int nxt = i + need[a];
if (nxt > N)
continue;
string added = add(dp[i], ('0' + a));
if (dp[nxt] == "") {
dp[nxt] = added;
} else if (compare(dp[nxt], added) == 1) {
dp[nxt] = added;
}
}
}
cout << dp[N] << endl;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define irep(i, n) for (int i = (n); i >= 0; i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1 << 30;
int main() {
vector<queue<char>> s(3);
rep(i,3) {
string t; cin >> t;
rep(j,t.size()) s[i].push(t[j]);
}
int turn = 0;
//!s[0].empty()&&!s[1].empty()&&!s[2].empty()
while (true)
{
if (s[turn].empty()) break;
char c = s[turn].front(); s[turn].pop();
if (c == 'a') turn = 0;
else if (c=='b') turn = 1;
else turn = 2;
}
if (turn==0) cout << 'A' << endl;
else if (turn==1) cout << 'B' << endl;
else cout << 'C' << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int H,W; cin>>H>>W;
vector<vector<char>>A(H+2,vector<char>(W+2,'.'));
for(int i=1;i<=H;i++){
string S; cin>>S;
for(int j=1;j<=W;j++){
A[i][j]=S.at(j-1);
}
}
for(int i=1;i<=H;i++){
for(int j=1;j<=W;j++){
if(A[i][j]=='.')continue;
if(A[i+1][j]=='#')continue;
if(A[i-1][j]=='#')continue;
if(A[i][j+1]=='#')continue;
if(A[i][j-1]=='#')continue;
cout<<"No"<<endl;
return 0;
}
}
cout<<"Yes"<<endl;
} | 0 |
#include <bits/stdc++.h>
#define ios ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define debug freopen("in.txt","r",stdin),freopen("out.txt","w",stdout);
#define pb push_back
#define all(x) x.begin(),x.end()
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int maxn = 5e5+10;
const int maxM = 1e6+10;
const int inf = 0x3f3f3f3f;
int N,Q;
int c[maxn];
int last[maxn],nx[maxn];
int root[maxn];
struct Tree
{
struct node{
int l,r;
int sum;
}tr[maxn*4 + maxn*19];
int tail = 0;
int build(int l,int r){
int cur = ++tail;
if(l == r) return cur;
int mid = (l+r)>>1;
tr[cur].l = build(l,mid);
tr[cur].r = build(mid+1,r);
return cur;
}
int insert(int pre,int l,int r,int x){
int cur = ++tail;
tr[cur] = tr[pre];
if(l == r){
tr[cur].sum++;
return cur;
}else{
int mid = (l+r)>>1;
if(x <= mid) tr[cur].l = insert(tr[pre].l,l,mid,x);
else tr[cur].r = insert(tr[pre].r,mid+1,r,x);
tr[cur].sum = tr[tr[cur].l].sum + tr[tr[cur].r].sum;
return cur;
}
}
int query(int cur,int pre,int l,int r,int R){
if(l == r){
if(R>l) return tr[cur].sum - tr[pre].sum;
else return 0;
}else{
int mid = (l+r)>>1;
if(R<=mid) return query(tr[cur].l,tr[pre].l,l,mid,R) + tr[tr[cur].r].sum - tr[tr[pre].r].sum;
else return query(tr[cur].r,tr[pre].r,mid+1,r,R);
}
}
}tree;
void init(){
for(int i = 1;i<=N;i++){
if(last[c[i]]){
nx[last[c[i]]] = i;
}
last[c[i]] = i;
}
for(int i = 1;i<=N;i++) if(nx[i] == 0) nx[i] = N+1;
}
void solve(){
root[0] = tree.build(1,N+1);
for(int i = 1;i<=N;i++){
root[i] = tree.insert(root[i-1],1,N+1,nx[i]);
}
while(Q--){
int l,r;cin>>l>>r;
int ans = tree.query(root[r],root[l-1],1,N+1,r);
cout<<ans<<'\n';
}
}
int main(){
// debug;
ios;
cin>>N>>Q;
for(int i =1;i<=N;i++) cin>>c[i];
init();
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int c[500005];
int d[500005];
int e[500005];
int a[500005];
int bit[500005];
vector<pair<int, int>> v[500005];
int n, q;
// 1 is true
// 0 is false
int esum(int l, int r) {
int sum = 0;
for (int i = l; i <= r; i++) {
sum += e[i];
}
return sum;
}
void update(int i, int value) {
for (; i <= n; i += i & -i) {
bit[i] += value;
}
}
int sum(int i) {
int s = 0;
for (; i > 0; i -= i & -i) {
s += bit[i];
}
return s;
}
int main() {
cin >> n >> q;
for (int i = 1; i <= n; i++) {
cin >> c[i];
}
for (int i = 1; i <= q; i++) {
int l, r;
cin >> l >> r;
v[r].push_back({i, l});
}
for (int i = 1; i <= n; i++) {
if (d[c[i]] != 0) {
update(d[c[i]], -1);
}
d[c[i]] = i;
update(i, 1);
for (auto x : v[i]) {
a[x.first] = sum(i) - sum(x.second - 1);
}
// for (int r = 1; r <= n; r++) {
// cout << c[r] << ' ';
// }
// cout << endl;
// for (int r = 1; r <= n; r++) {
// cout << d[r] << ' ';
// }
// cout << endl;
// for (int r = 1; r <= n; r++) {
// cout << e[r] << ' ';
// }
// cout << endl << "--------------------------------" << endl;
}
for (int i = 1; i <= q; i++) {
cout << a[i] << endl;
}
}
| 1 |
#include <iostream>
#include <algorithm>
#include <string>
#define N 50
using namespace std;
struct data{
string l;
int p,a,b,c,d,e,f,s,m;
double cal;
};
int main(){
int n,i,j,time;
struct data d[N];
while(1){
cin >> n;
if(n==0) break;
for(i=0;i<n;i++){
cin >> d[i].l >> d[i].p >> d[i].a >> d[i].b >> d[i].c;
cin >> d[i].d >> d[i].e >> d[i].f >> d[i].s >> d[i].m;
time=(d[i].a+d[i].b+d[i].c+d[i].d+d[i].e);
d[i].m--;
time+=(d[i].d+d[i].e)*d[i].m;
d[i].cal=((double)d[i].f*d[i].s*(d[i].m+1)-d[i].p)/time;
}
for(i=0;i<n;i++){
for(j=1;j<n;j++){
if(d[j].l<d[j-1].l) swap(d[j],d[j-1]);
}
}
for(i=0;i<n;i++){
for(j=1;j<n;j++){
if(d[j].cal>d[j-1].cal) swap(d[j],d[j-1]);
}
}
for(i=0;i<n;i++) cout << d[i].l << endl;
cout << '#' << endl;
}
return 0;
} | # define _CRT_SECURE_NO_WARNINGS 1
# define _USE_MATH_DEFINES
# include <iostream>
# include <numeric>
# include <string>
# include <bitset>
# include <vector>
# include <algorithm>
# include <cstdlib>
# include <cstdio>
# include <cstring>
# include <cstdlib>
# include <iomanip>
# include <queue>
# include <sstream>
# include <unordered_set>
# include <unordered_map>
# include <climits>
# include <complex>
# include <cmath>
# include <list>
# include <functional>
# include <string>
# include <ctime>
# include <set>
# include <forward_list>
# include <map>
# include <stack>
using namespace std;
# define INF ((int)(1<<25))
# define REP(i,n) for(int i=0;i<(int)n;i++)
# define FOR(i,n) REP(i,n)
# define FORI(i,k,n) for(int i=k;i<(int)n;i++)
# define TORAD 2.0*M_PI/360.0
# define INT(x) int x;cin>>x;
# define STR(x) string x;cin>>x;
# define ALL(x) begin(x),end(x)
# define RALL(x) (x).rbegin(),(x).rend()
# define DEBUG(x) cout<<#x<<":"<<x<<endl;
# define EPS 1e-12
#ifdef _MSC_VER
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
typedef long long lint;
typedef vector<bool> vb;
typedef vector<char> vc;
typedef vector<int> vi;
typedef vector<lint> vl;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef pair<int, pii> piii;
//const int dx[4] = { 0, 1, 0, -1 }, dy[4] = { -1, 0, 1, 0 };
const int dx[4] = {1,0,-1,0}, dy[4] = {0,1,0,-1};
template<class T> void debug(T a) { for (auto i : a)cout << i << endl; }
int main()
{
while (true)
{
int w, h;
pii start, goal;
int n;
int a[200][200] = {};
bool flag[200][200] = {};
bool ok = false;
cin >> w >> h;if (!w)break;
cin >> start.first >> start.second;
cin >> goal.first >> goal.second;
cin >> n;
FOR(i, n)
{
int c, d, x, y;
cin >> c >> d >> x >> y;
for (int X = x; X <= x+1+(d?0:2); X++)
{
for (int Y = y; Y <= y + 1 + (d ? 2 : 0); Y++)
{
a[X][Y] = c;
}
}
}
flag[start.first][start.second] = true;
queue<pii> que;
if(a[start.first][start.second]!=0)que.push(start);
while (!que.empty())
{
pii now = que.front(); que.pop();
if (now == goal)
{
cout << "OK" << endl;
ok = true;
}
FOR(i, 4)
{
pii next=now;
next.first += dx[i]; next.second += dy[i];
if (a[next.first][next.second] == a[now.first][now.second] && !flag[next.first][next.second])
{
flag[next.first][next.second] = true;
que.push(next);
}
}
}
if (!ok)cout << "NG" << endl;
}
} | 0 |
#include <iostream>
#include <vector>
using namespace std;
const int MOD = 1000000007;
const int N_MAX = 100000;
long long mod(long long a) {
a %= MOD;
return a >= 0 ? a : a+MOD;
}
long long inverse[N_MAX+1+64];
long long factorial[N_MAX+1+64];
long long factorial_inverse[N_MAX+1+64];
void calc(int n) {
inverse[1] = 1;
factorial[0] = factorial[1] = 1;
factorial_inverse[0] = factorial_inverse[1] = 1;
for (int i = 2; i <= n; i++) {
inverse[i] = MOD - inverse[MOD%i] * (MOD/i) % MOD;
factorial[i] = i * factorial[i-1] % MOD;
factorial_inverse[i] = inverse[i] * factorial_inverse[i-1] % MOD;
}
}
long long comb(long long n, long long k) {
return factorial[n] * (factorial_inverse[k] * factorial_inverse[n-k] % MOD) % MOD;
}
long long rep_comb(long long n, long long k) {
return comb(n + k - 1, k);
}
vector<pair<long long, int>> prime_factorization(long long n) {
vector<pair<long long, int>> v;
for (long long i = 2; i * i <= n; ++i) {
int e = 0;
while (n % i == 0) {
++e;
n /= i;
}
if (e != 0) v.emplace_back(i, e);
}
if (n != 1) v.emplace_back(n, 1);
return v;
}
int main() {
calc(N_MAX+65);
long long n, m;
cin >> n >> m;
long long ans = 1;
auto v = prime_factorization(m);
for (auto el : v) {
long long e = el.second;
ans = mod(ans * rep_comb(n, e));
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
#include <math.h>
#include <set>
#include <map>
#include <string>
#include <stack>
#include <queue>
#include <iomanip>
#include <numeric>
#include <tuple>
#include <bitset>
#include <complex>
#include <unistd.h>
#include <cassert>
#include <cctype>
#include <random>
#include <time.h>
#include <functional>
#define _USE_MATH_DEFINES
#define _GLIBCXX_DEBUG
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> plglg;
typedef pair<double, ll> pdlg;
typedef tuple<int, int, int> tiii;
typedef tuple<ll, ll, ll> tlglglg;
typedef tuple<ll, ll, ll, ll> tlglglglg;
typedef tuple<double, double, double> tddd;
typedef complex<double> xy_t;
typedef vector<ll> vll;
typedef vector< vector<ll> > matrix;
typedef unsigned int uint;
typedef unsigned long long ull;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
template <class T> using VVV = V<VV<T>>;
#define REP(i, x, y) for(ll i = (ll)x; i < (ll)y; i++)
#define DREP(i, x, y, d) for(ll i = (ll)x; i < (ll)y; i += (ll)d)
#define PER(i, x, y) for(ll i = (ll)x; i > (ll)y; i--)
#define DPER(i, x, y, d) for(ll i = (ll)x; i > (ll)y; i -= (ll)d)
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
double pi = 3.141592653589793;
ll mod = 1000000007;
int intmax = 2147483647;
int intmin = -2147483648;
ll llmax = 9223372036854775807;
ll llmin = -9223372036854775807;
int iinf = intmax / 8;
ll inf = llmax / 8;
double eps = 1e-12;
void yesno(bool ok, string yes = "Yes", string no = "No") {
if (ok) {
cout << yes << endl;
} else {
cout << no << endl;
}
}
ll dp[310][310][310];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
string S;
cin >> S;
ll len = S.size();
ll K;
cin >> K;
dp[0][0][0] = 0;
REP(i, 0, len) {
REP(k, 0, K + 1) {
dp[i][i + 1][k] = 1;
}
}
REP(j, 2, len + 1) {
REP(i, 0, len) {
if (i + j > len) {
continue;
}
REP(k, 0, K + 1) {
dp[i][i + j][k] = max(dp[i][i + j - 1][k], dp[i + 1][i + j][k]);
if (k > 0) {
dp[i][i + j][k] = max(dp[i][i + j][k], dp[i + 1][i + j - 1][k - 1] + 2);
}
if (S[i] == S[i + j - 1]) {
dp[i][i + j][k] = max(dp[i][i + j][k], dp[i + 1][i + j - 1][k] + 2);
}
}
}
}
// REP(i, 0, len + 1) {
// REP(j, 0, len + 1) {
// REP(k, 0, K + 1) {
// cout << dp[i][j][k] << " ";
// }
// cout << "aaa ";
// }
// cout << endl;
// }
ll ans = 0;
REP(i, 0, K + 1) {
ans = max(ans, dp[0][len][i]);
}
cout << ans << endl;
}
| 0 |
#include <iostream>
#include <cmath>
using namespace std;
int main(){
int e;
while(cin >> e && e > 0){
unsigned int m = e;
for(int z=0;z*z*z<=e;z++){
for(int y=0;y*y+z*z*z<=e;y++){
int x = e - y * y - z * z * z;
if(x >= 0){
unsigned int sum = x + y + z;
m = min(m,sum);
}
}
}
cout << m << endl;
}
} | #include<iostream>
#include<string>
#include<vector>
#include<set>
using namespace std;
int main(void){
int a,b,c,d;
int n,k;
while(1){
cin >> n;
cin >> k;
if(n==0 && k==0)break;
vector<string> num;
set<string> str;
for(a=0;a<n;a++){
string s;
cin >> s;
num.push_back(s);
}
if(k==2){
for(a=0;a<n;a++){
for(b=0;b<n;b++){
if(a!=b)str.insert(num[a]+num[b]);
}
}
}
if(k==3){
for(a=0;a<n;a++){
for(b=0;b<n;b++){
if(a!=b)for(c=0;c<n;c++){
if(a!=c && b!=c)str.insert(num[a]+num[b]+num[c]);
}
}
}
}
if(k==4){
for(a=0;a<n;a++){
for(b=0;b<n;b++){
if(a!=b)for(c=0;c<n;c++){
if(a!=c && b!=c)for(d=0;d<n;d++){
if(a!=d && b!=d && c!=d)str.insert(num[a]+num[b]+num[c]+num[d]);
}
}
}
}
}
cout << str.size() << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#include<cstdlib>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
typedef long long ll;
int main(){
ll n;
cin >> n;
vector<ll> p(5);
rep(i,5) cin >> p.at(i);
ll mi = p.at(0);
rep(i,5) mi = min(mi, p.at(i));
ll ans = ceil(double(n/double(mi))) + 4;
cout << ans;
} | #include <bits/stdc++.h>
int n, a[205];
int main()
{
scanf("%d", &n);
for(int i=1; i<=2*n; i++) scanf("%d", a+i);
std::sort(a+1, a+2*n+1);
int ans = 0;
for(int i=1; i<=2*n; i+=2) ans += a[i];
printf("%d\n", ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int solve () {
int n;
cin >> n;
vector<long long> a(n);
for (auto &e : a) cin >> e;
string s;
cin >> s;
vector<long long> b;
for (int i = n; i--> 0;) {
long long e = a[i];
for (const auto &c : b) e = min(e, e^c);
if (e > 0) {
if (s[i] == '1') return 1;
b.push_back(e);
}
}
return 0;
}
int main() {
int t;
cin >> t;
while (t--) cout << solve() << '\n';
return 0;
} | #include <iostream>
#include <vector>
#include <algorithm>
#define INPUT_FROM_FILE (0)
#if INPUT_FROM_FILE
#include <fstream>
#endif
int calc_gcd(int n, int m){
if(n == m){ return n; }
if(n > m){
std::swap(n, m);
}
return calc_gcd(n, m - n);
}
int main(int argc, char **argv){
#if INPUT_FROM_FILE
std::ifstream ifs("test.txt");
#endif
int n = 0;
std::vector<int> vec;
int gcd = 1;
#if INPUT_FROM_FILE
ifs >> n;
#else
std::cin >> n;
#endif
vec.resize(n);
for(int i = 0; i < n; i++){
#if INPUT_FROM_FILE
ifs >> vec[i];
#else
std::cin >> vec[i];
#endif
}
std::sort(vec.begin(), vec.end());
gcd = calc_gcd(vec[0], vec[1]);
std::cout << "1" << std::endl;
for(int i = 2; i <= gcd; i++){
if(gcd % i == 0){
if(n == 3){
if(vec[2] % i == 0){
std::cout << i << std::endl;
}
}
else{
std::cout << i << std::endl;
}
}
}
return 0;
}
| 0 |
/*
This Submission is to determine how many 120/240 min const. delivery point there are.
//info
120 req. steps <= 5
*/
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <algorithm>
#include <utility>
#include <functional>
#include <cstring>
#include <queue>
#include <stack>
#include <math.h>
#include <iterator>
#include <vector>
#include <string>
#include <set>
#include <math.h>
#include <iostream>
#include <random>
#include<map>
#include <iomanip>
#include <time.h>
#include <stdlib.h>
#include <list>
#include <typeinfo>
#include <list>
#include <set>
#include <cassert>
#include<fstream>
#include <unordered_map>
#include <cstdlib>
#include <complex>
#include <cctype>
#include <bitset>
using namespace std;
typedef string::const_iterator State;
#define Ma_PI 3.141592653589793
#define eps 1e-5
#define LONG_INF 1e18
#define GOLD 1.61803398874989484820458
#define MAX_MOD 1000000007
#define MOD 1000000007
#define seg_size 262144
#define REP(a,b) for(long long a = 0;a < b;++a)
unsigned long xor128() {
static unsigned long x = time(NULL), y = 362436069, z = 521288629, w = 88675123;
unsigned long t = (x ^ (x << 11));
x = y; y = z; z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
//do gift-wrapping method
#define double long double
double dot(complex<double> a, complex<double> b) {
return a.real() * b.real() + a.imag() * b.imag();
}
double gyaku_dot(complex<double> a, complex<double> b) {
return a.real() * b.imag() - a.imag() * b.real();
}
double leng(complex<double> a) {
return sqrt(a.real() * a.real() + a.imag() * a.imag());
}
double angles(complex<double> a, complex<double> b) {
double cosine = dot(a, b) / (leng(a) * leng(b));
double sine = gyaku_dot(a, b) / (leng(a) * leng(b));
double kaku = acos(min((double)1.0, max((double)-1.0, cosine)));
if (sine <= 0) {
kaku = 2 * Ma_PI - kaku;
}
return kaku;
}
vector<int> convex_hull(vector<complex<double>> a) {
vector<int> ans;
double now_minnest = a[0].real();
int now_itr = 0;
REP(i, a.size()) {
if (now_minnest > a[i].real()) {
now_minnest = a[i].real();
now_itr = i;
}
}
ans.push_back(now_itr);
complex<double> ba(0, 1);
while (true) {
int now_go = 0;
double now_min = 0;
double now_length = 0;
int starter = ans[ans.size() - 1];
for (int i = 0; i < a.size(); ++i) {
if (i != starter) {
double goa = angles(ba, a[i] - a[starter]);
if (goa - now_min >= eps||(abs(goa - now_min) <= eps&&(abs(a[i] - a[starter]) - now_length) >= eps)) {
now_min = goa;
now_go = i;
now_length = abs(a[i] - a[starter]);
}
}
}
if (now_go == ans[0]) break;
ans.push_back(now_go);
ba = complex<double>(a[now_go] - a[starter]);
}
return ans;
}
double ans[2000] = {};
#undef double
int main() {
#define double long double
int n;
cin >> n;
vector<complex<double>> inputs;
REP(i, n) {
double x, y;
cin >> x >> y;
inputs.push_back(complex<double>(x, y));
}
vector<int> hoge;
if (n == 2) {
hoge.push_back(0);
hoge.push_back(1);
}
else {
hoge = convex_hull(inputs);
}
hoge.push_back(hoge[0]);
hoge.push_back(hoge[1]);
for (int i = 1; i < hoge.size() - 1; ++i) {
complex<double> A = inputs[hoge[i]] - inputs[hoge[i - 1]];
complex<double> B = inputs[hoge[i + 1]] - inputs[hoge[i]];
complex<double> C = complex<double>(A.imag() * -1.0, A.real());
complex<double> D = complex<double>(B.imag() * -1.0, B.real());
ans[hoge[i]] = angles(D,C) / (2.0 * Ma_PI);
}
cout << fixed << setprecision(50);
REP(i, n) {
cout << ans[i] << endl;
}
} | #include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int p[500];
int sakurako(int a, int b, int c){
bool f1, f2, f3;
f1 = (p[a] == 1 ? true : false);
f2 = (p[b] == 1 ? true : false);
f3 = (p[c] == 1 ? true : false);
if (f1 && f2 && !f3) return c;
if (f1 && !f2 && f3) return b;
if (!f1 && f2 && f3) return a;
return -1;
}
int main(void)
{
int a, b, c, n;
int ni[1200], nj[1200], nk[1200], nr[1200];
while(cin >> a >> b >> c){
if (a == 0) break;
cin >> n;
fill(p, p + 500, 2);
for (int i = 0; i < n; i++){
scanf("%d %d %d %d", &ni[i], &nj[i], &nk[i], &nr[i]);
if (nr[i] == 1){
p[ni[i]] = 1;
p[nj[i]] = 1;
p[nk[i]] = 1;
}
}
for (int i = 0; i < n; i++){
if (nr[i] == 0){
int re = sakurako(ni[i], nj[i], nk[i]);
if (re == -1) continue;
p[re] = 0;
}
}
for (int i = 1; i <= a + b + c; i++){
printf("%d\n", p[i]);
}
}
return 0;
} | 0 |
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int A, B;
cin >> A >> B;
cout << max({ 2 * A - 1, 2 * B - 1, A + B }) << endl;
return 0;
} | #include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
using namespace std;
struct node{
int a;
int b;
}x[100005];
int main()
{
int n,m;
scanf("%d%d",&n,&m);
for(int i=0;i<m;i++)
{
scanf("%d%d",&x[i].a,&x[i].b);
}
int start=x[0].a;
int end=x[0].b;
for(int i=1;i<m;i++)
{
start=max(x[i].a,start);
end=min(x[i].b,end);
}
int sum=end-start+1;
if(sum<0)
sum=0;
printf("%d\n",sum);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using pp=pair<int,char>;
using ll=long long;
int main() {
int N, Y;
cin >> N >> Y;
string ans="No";
int fin=0;
for (int i=0; i<=Y/10000; i++) {
for (int j=0; j<=(Y-10000*i)/5000; j++) {
if (Y-10000*i-5000*j==(N-i-j)*1000) {
cout << i << " " << j << " " << N-i-j << endl;
fin =1;
break;
}
}
if (fin==1) {break;}
}
if (fin==0) {
cout << -1 << " " << -1 << " " << -1 << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); ++i)
#define all(a) (a).begin(), (a).end()
#define all2(a, b) (a).begin(), (a).begin() + (b)
#define debug(vari) cerr << #vari << " = " << (vari) << endl;
const int MOD = 1e9 + 7;
int main()
{
int n, y;
cin >> n >> y;
rep(i, n + 1)
{
rep(j, n + 1)
{
if (i + j + (y / 1000 - 10 * i - 5 * j) == n && (y / 1000 - 10 * i - 5 * j) >= 0)
{
printf("%d %d %d\n", i, j, y / 1000 - 10 * i - 5 * j);
return (0);
}
}
}
printf("-1 -1 -1\n");
return (0);
}
| 1 |
#include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a), i##_max = (b); i < i##_max; ++i)
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define ALL(obj) (obj).begin(), (obj).end()
using namespace std;
using vi = vector<int>;
using i64 = int64_t;
constexpr int INF = 1 << 30;
constexpr int MOD = 1000000007;
i64 cnt = 0;
template <typename T>
void print(vector<T> v) {
REP(i, v.size()) {
if (i) cout << " ";
cout << v[i];
}
cout << endl;
}
void merge(vi &A, int left, int mid, int right) {
auto n1 = mid - left;
auto n2 = right - mid;
vi L(n1 + 1), R(n2 + 1);
copy(A.begin() + left, A.begin() + mid, L.begin());
copy(A.begin() + mid, A.begin() + right, R.begin());
L[n1] = INF;
R[n2] = INF;
int i = 0, j = 0;
FOR(k, left, right) {
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
cnt += n1 - i;
}
}
}
void merge_sort(vi &A, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
merge_sort(A, left, mid);
merge_sort(A, mid, right);
merge(A, left, mid, right);
}
}
int main() {
int n;
cin >> n;
vi S(n);
REP(i, n) cin >> S[i];
merge_sort(S, 0, n);
cout << cnt << endl;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
#define U(v) cerr << #v << ": " << (v) << endl
template <class T>
struct BIT {
vector<T> a;
BIT(int size) : a(size, 0) {}
T sum(int r) const {
T sm = 0;
for (--r; r >= 0; r = (r & r + 1) - 1)
sm += a[r];
return sm;
}
T sum(int l, int r) const {
return sum(r) - sum(l);
}
T at(int i) const {
return sum(i, i + 1);
}
void add(int i, T v) {
for (; i < (int)a.size(); i |= i + 1)
a[i] += v;
}
void set(int i, T v) {
add(i, v - at(i));
}
};
int main() {
int n;
cin >> n;
vector<int> a(n);
vector<pair<int, int>> b(n);
for (int i = 0; i < n; ++i) {
cin >> b[i].first;
b[i].second = i;
}
sort(b.begin(), b.end());
for (int i = 0; i < n; ++i)
a[b[i].second] = i;
BIT<int> bit(n);
long long sm = 0;
for (int i = n - 1; i >= 0; --i) {
sm += bit.sum(a[i]);
bit.add(a[i], 1);
}
cout << sm << endl;
return 0;
} | 1 |
#include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<queue>
#include<algorithm>
#define ll long long
#define rg register
#define go(i,x,a) for(rg int i=a;i<x;i++)
#define inf 0x3f3f3f3f
#define mod 1000000007
using namespace std;
const int maxn=5e5+5;
int n,a[maxn],b[maxn],hx[maxn],tl,s0[maxn],q[maxn],tt;
ll ans,f[maxn][2];
vector<int>g[maxn];
inline int rd(){
int ret=0,af=1; char gc=getchar();
while(gc < '0' || gc > '9'){ if(gc == '-') af=-af; gc=getchar(); }
while(gc >= '0' && gc <= '9') ret=ret*10+gc-'0',gc=getchar();
return ret*af;
}
inline void add(ll &a,ll b){ a=a+b; if(a >= mod) a-=mod; return; }
inline void dec(ll &a,ll b){ a=a-b; if(a < 0) a+=mod; return ; }
inline void cal(int x){
tt=0;
go(i,g[x].size(),0) q[++tt]=g[x][i];
ll sa=1,sb=0;
go(i,tt+1,1){
ll ss=s0[q[i]]-s0[q[i-1]];
add(sa,sb*ss%mod);
add(sb,sa);
}
if(q[tt] != n){
ll ss=s0[n]-s0[q[tt]];
add(sa,sb*ss%mod);
}
add(ans,b[n] == 0 ? sb : sa);
}
inline ll qpow(int x,int k){
ll ss=1,tmp=x;
while(k > 0){
if(k & 1) ss=ss*tmp%mod;
tmp=tmp*tmp%mod;
k>>=1;
}
return ss;
}
int main(){
n=rd();
go(i,n+1,1){
a[i]=rd(); b[i]=b[i-1]^a[i];
if(b[i]) hx[++tl]=b[i];
}
// go(i,n+1,1) printf("%d ",b[i]); puts("");
go(i,n+1,1) s0[i]=s0[i-1]+(b[i] == 0);
sort(hx+1,hx+tl+1); tl=unique(hx+1,hx+tl+1)-hx-1;
// go(i,tl+1,1) printf("%d ",hx[i]); puts("");
go(i,n+1,1)
if(b[i]) b[i]=lower_bound(hx+1,hx+tl+1,b[i])-hx;
go(i,n+1,1) g[b[i]].push_back(i);
if(b[n] == 0){
go(i,tl+1,1) cal(i);//,printf("%d: %lld\n",hx[i],ans);
add(ans,qpow(2,s0[n]-1));
}else cal(b[n]);
printf("%lld",ans);
return 0;
} | #include<cstdio>
using namespace std;
#define N 1050000
#define mod 1000000007
int dp[N][2],n,s[N],las[N],k=20,sn;
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)scanf("%d",&s[i]);
for(int i=0;i<1<<k;i++)dp[i][0]=1;
for(int i=1;i<n;i++)
{
s[i]^=s[i-1];
dp[s[i]][0]=(dp[s[i]][0]+1ll*dp[s[i]][1]*(sn-las[s[i]]))%mod;
dp[s[i]][1]=(dp[s[i]][1]+dp[s[i]][0])%mod;
las[s[i]]=sn;
if(s[i]==0)sn++;
}
s[n]^=s[n-1];
if(s[n])
{
int ans=0;
dp[s[n]][0]=(dp[s[n]][0]+1ll*dp[s[n]][1]*(sn-las[s[n]]))%mod;
printf("%d\n",dp[s[n]][0]);
}
else
{
int ans=0;
for(int i=1;i<1<<k;i++)
ans=(ans+dp[i][1])%mod;
int tp=1;
for(int i=1;i<=sn;i++)tp=tp*2%mod;
printf("%d\n",(ans+tp)%mod);
}
} | 1 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define rrep(ri,n) for(int ri = (int)(n-1); ri >= 0; ri--)
#define rep2(i,x,n) for(int i = (int)(x); i < (int)(n); i++)
#define rrep2(ri,x,n) for(int ri = (int)(n-1); ri >= (int)(x); ri--)
#define repit(itr,x) for(auto itr = x.begin(); itr != x.end(); itr++)
#define rrepit(ritr,x) for(auto ritr = x.rbegin(); ritr != x.rend(); ritr++)
#define ALL(x) x.begin(), x.end()
using ll = long long;
using namespace std;
int main(){
int n, m;
cin >> n >> m;
ll ans = 1001001001;
for(ll i = 1; i*i <= m; i++){
if(m % i != 0) continue;
ll j = m / i;
if(i >= n){
ans = min(ans, i);
}
if(j >= n){
ans = min(ans, j);
}
}
if(ans == 1001001001) ans = m;
ans = m/ans;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int R,G;
cin >> R >> G;
cout << G + G - R;
} | 0 |
#include<iostream>
#include<iomanip>
using namespace std;
int main(void){
int x;
cin >> x;
cout << x*x*x <<"\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int x;
cin >> x;
int ans = 1;
for (int i = 0; i < 3; i++) {
ans *= x;
}
cout << ans << endl;
}
| 1 |
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <assert.h>
#include <memory.h>
#include <queue>
#include <string.h>
#include <map>
using namespace std;
#define N 40
#define BIT (1<<17)
#define mod 1000000007
int add(int x,int y) {
int ret = x+y;
if(ret<0) {
ret += mod;
} else if(ret>=mod) {
ret -= mod;
}
return ret;
}
int n,x[3],maxi;
int dp[N][BIT][2];
map<int,int> failure;
int ar[1000],tot = 0;
int failureCall(int bit) {
if(bit==0) {
return 0;
}
int nbit;
if(failure.count(bit)) {
return failure[bit];
}
for(int i=0;;++i) {
if(bit&(1<<i)) {
nbit = bit>>(i+1);
break;
}
}
if(nbit==0) {
return 0;
}
if(nbit>=BIT) {
return failure[bit] = failureCall(nbit);
}
int ret = 0;
int sum = 0,cur = 0;
int lastBit = -1;
bool isGood = true;
for(int i=0;;++i) {
if((1<<i) >nbit) {
break;
}
if(nbit&(1<<i)) {
int a = i-lastBit;
lastBit = i;
sum += a;
if(sum==x[cur]) {
++cur;
sum = 0;
}else if (sum>x[cur]) {
isGood = false;
break;
}
}
}
if(isGood) {
return failure[bit] = nbit;
} else {
return failure[bit] = failureCall(nbit);
}
}
map<int,pair<int,int> > BB;
pair<int,int> newBit(int bit,int num) {
tot = 0;
int lastBit = -1;
int pos = 0;
for(int i=0;i<17;++i) {
if(bit&(1<<i)) {
ar[pos++] = i-lastBit;
lastBit = i;
}
}
if(num!=-1) {
ar[pos++] = num;
bit |= (1<<(lastBit + num));
}
if(bit>=BIT) {
return newBit(failureCall(bit),-1);
}
int cur = 0,sum = 0;
for(int i=0;i<pos;++i) {
sum += ar[i];
tot += ar[i];
if(sum==x[cur]) {
++cur;
sum = 0;
} else if(sum>x[cur]) {
return newBit(failureCall(bit),-1);
}
}
if( cur!=3) {
return make_pair(0, bit);
} else {
//success but need failure
return make_pair(1 , failureCall(bit));
}
}
int solveDp(int ind,int bit,int isSatisfy) {
if(ind==n) {
if(isSatisfy) {
return 1;
} else {
return 0;
}
}
int &ret = dp[ind][bit][isSatisfy];
if(ret!=-1) {
return ret;
}
ret = 0;
for(int num=1;num<=10;++num) {
pair<int,int> nBit;
if(num>maxi) {
nBit = make_pair(0,0);
} else {
nBit = newBit(bit,num);
}
ret = add(ret, solveDp(ind+1,nBit.second, isSatisfy | nBit.first));
}
return ret;
}
void solve() {
scanf("%d ", &n);
for(int i=0;i<3;++i) {
scanf("%d ", &x[i]);
maxi = max(maxi,x[i]);
}
memset(dp,-1,sizeof(dp));
printf("%d\n", solveDp(0,0,0));
}
int main() {
//freopen("input.txt","r",stdin);
solve();
return 0;
}
| #include<algorithm>
#include<cstring>
#include<cstdio>
#define ll long long
#define qwq
const int mod=1e9+7;
int dp[50][(1<<17)+7];
int n,x,y,z;
ll all_ans=1;
int main(){
scanf("%d%d%d%d",&n,&x,&y,&z);
int gdans=(1<<(x+y+z-1))|(1<<(y+z-1))|(1<<(z-1));
int limit=(1<<(x+y+z))-1;
dp[0][0]=1;
for(int i=1;i<=n;++i){
all_ans*=10;
all_ans%=mod;
for(int s=0;s<=limit;++s){
if((s&gdans)==gdans)continue;
for(int c=1;c<=10;++c){
int k=((s<<c)|(1<<(c-1)))&limit;
if((k&gdans)==gdans)continue;
dp[i][k]+=dp[i-1][s];
dp[i][k]%=mod;
}
}
}
ll ans=0;
for(int s=0;s<=limit;++s){
ans+=dp[n][s];ans%=mod;
}
printf("%lld\n",(all_ans-ans+mod)%mod);
return 0;
} | 1 |
#include <bits/stdc++.h>
#define reg register
#define ll long long
#define ull unsigned long long
using namespace std;
const int MAXN = 110;
int n;
ll a[MAXN];
void work() {
scanf("%d", &n);
for(reg int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
int ans = 0;
for(reg int i = 1; i <= n; ++i) {
for(reg int j = i + 1; j <= n; ++j) {
for(reg int k = j + 1; k <= n; ++k) {
if(a[i] != a[j] && a[j] != a[k] && a[i] != a[k]) {
if(a[i] + a[j] > a[k] && a[i] + a[k] > a[j] && a[j] + a[k] > a[i]) ++ans;
}
}
}
}
printf("%d\n", ans);
}
signed main() {
int _ = 1;
// scanf("%d", &_);
while(_--) {
work();
}
return 0;
}
| #include<iostream>
#include<algorithm>
#include<map>
#include<vector>
#include<cstdint>
#include<cstdlib>
template<typename T>
void fin(T const& t){ std::cout << t << std::endl; exit(0); }
int64_t const INF = 1e18;
int main() {
std::cin.tie(0); std::ios::sync_with_stdio(false);
int N; std::cin >> N;
std::vector<int64_t> A(N), S(N+1, 0);
for(int i = 0; i < N; ++i) std::cin >> A[i];
for(int i = 0; i < N; ++i) S[i+1] = S[i] + A[i];
auto split = [&](auto b, auto e)-> std::pair<int64_t,int64_t> {
int64_t V = (*e + *b)/2;
auto m = std::upper_bound(b, e, V);
int64_t mi = INF;
std::pair<int64_t, int64_t> res;
for(auto i: {m-1, m, m+1}) if(b < i && i < e) {
int64_t cur = std::abs((*i-*b) - (*e-*i));
if(cur < mi) { mi = cur; res = std::make_pair(*i-*b, *e-*i); }
}
return res;
};
auto isOK = [&](int64_t k)->bool {
int64_t vmi = (S[N]+1)/2 - k, vma = S[N]/2 + k;
auto lb = std::lower_bound(S.begin()+2, S.end()-3, vmi);
auto ub = std::upper_bound(S.begin()+2, S.end()-2, vma);
for(auto it = lb; it != ub; ++it) {
auto L = split(S.begin(), it);
auto R = split(it, S.end()-1);
int64_t P[4] = {L.first, L.second, R.first, R.second};
if(*std::max_element(P, P+4) - *std::min_element(P, P+4) <= k) return true;
}
return false;
};
int64_t ng = -1;
// rough try
auto split2 = [&](auto b, auto e) {
int64_t V = (*e + *b)/2;
auto m = std::upper_bound(b, e, V);
int64_t mi = INF;
auto res = e+1;
for(auto i: {m-1, m, m+1}) if(b < i && i < e) {
int64_t cur = std::abs((*i-*b) - (*e-*i));
if(cur < mi) { mi = cur; res = i; }
}
return res;
};
auto M = split2(S.begin(), S.end()-1);
while((M-S.begin()) < 2) ++M;
while((M-S.begin()) > S.size()-3) --M;
auto L = split(S.begin(), M);
auto R = split(M, S.end()-1);
int64_t P[4] = {L.first, L.second, R.first, R.second};
int64_t ok = *std::max_element(P, P+4) - *std::min_element(P, P+4);
while(ok - ng > 1) {
int64_t mid = (ok+ng)/2;
if(isOK(mid)) ok = mid; else ng = mid;
}
fin(ok);
return 0;
}
| 0 |
#include <iostream>
#include <vector>
#define INF (int)1e9
int bellman_ford(int m, int p, int q, std::vector<std::vector<std::pair<int, int> > > v) {
std::vector<int> rvec(m, INF);
bool flag;
rvec[p] = 0;
int value;
int target;
do{
flag = false;
for (int i = 0; i < m; i++) {
for (int j = 0; j < v[i].size(); j++) {
value = v[i][j].first;
target = v[i][j].second;
if (rvec[target] > rvec[i] + value) {
rvec[target] = rvec[i] + value;
flag = true;
}
}
}
} while(flag);
return rvec[q];
}
int main(void) {
int n;
int m;
int a;
int b;
int cost;
int time;
int k;
int p;
int q;
int r;
int res;
while (true) {
std::cin >> n >> m;
if (n == 0 && m == 0) {
break;
}
std::vector<std::vector<std::pair<int, int> > > vcost(m);
std::vector<std::vector<std::pair<int, int> > > vtime(m);
for (int i = 0; i < n; i++) {
std::cin >> a >> b >> cost >> time;
--a;
--b;
vcost[a].push_back(std::make_pair(cost, b));
vcost[b].push_back(std::make_pair(cost, a));
vtime[a].push_back(std::make_pair(time, b));
vtime[b].push_back(std::make_pair(time, a));
}
std::cin >> k;
for (int i = 0; i < k; i++) {
std::cin >> p >> q >> r;
--p;
--q;
// ????????????????????????
if (r == 0) {
res = bellman_ford(m, p, q, vcost);
} else {
res = bellman_ford(m, p, q, vtime);
}
std::cout << res << std::endl;
}
}
return 0;
} | #include<cstdio>
#include<algorithm>
#include<queue>
#include<string>
#include<cstring>
#include<cstdlib>
#include<sstream>
#include<set>
using namespace std;
class P{
public:
int num;
int cnt;
bool used[10];
P(){}
P(int num,int cnt,bool a[10]):num(num),cnt(cnt){
for(int i = 0; i < 10; i++){
used[i] = a[i];
}
}
};
int bond(int x,int y){
stringstream ss1;
ss1 << x;
stringstream ss2;
ss2 << y;
string ans = ss1.str() + ss2.str();
stringstream Ans;
Ans << ans;
int res;
Ans >> res;
return res;
}
int main(){
int n;
int m;
while(scanf("%d%d",&n,&m),(n|m)){
int card[10];
set<int> S;
queue<P> Q;
for(short i = 0; i < n; i++){
bool x[10]={0};
x[i] = 1;
scanf("%d",&card[i]);
Q.push(P(card[i],1,x));
}
short ans = 0;
while( Q.size() ){
P p = Q.front();Q.pop();
if(p.cnt == m){
if(S.find(p.num) == S.end())ans++,S.insert(p.num);
}
else{
for(int i = 0; i < n; i++){
if(p.used[i] == 0){
p.used[i] = 1;
Q.push(P(bond(p.num,card[i]),p.cnt+1,p.used));
p.used[i] = 0;
}
}
}
}
printf("%d\n",ans);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int e;
while(1) {
cin >> e;
if(e == 0) {
break;
}
int tmpx, tmpy, tmpz, tmpe;
tmpe = e;
for(tmpz = 0; pow(tmpz, 3) <= tmpe; tmpz++){}
tmpz--;
tmpe = tmpe - pow(tmpz, 3);
if(tmpe == 0){
tmpy = 0; tmpx = 0;
}else{
for(tmpy = 0; pow(tmpy, 2) <= tmpe; tmpy++){}
tmpy--;
tmpe = tmpe - pow(tmpy, 2);
if(tmpe == 0){
tmpx = 0;
}else{
tmpx = tmpe;
}
}
int tmpm = tmpx + tmpy + tmpz;
//cout << tmpz << " ! " << endl;
int tmp;
for(int z = 0; z <= tmpz + 1; z++) {
for(int y = tmpy; y <= min(tmpm - z, int(pow(e - pow(z, 3), 1.0 / 2.0))); y++) {
int x = e - pow(y, 2) - pow(z, 3);
tmp = x + y + z;
if(tmp < tmpm) {
tmpm = tmp;
}
}
}
cout << tmpm << endl;
}
return 0;
} | #include<iostream>
#include<vector>
#include<algorithm>
#include<cstring>
#include<string>
#include<cctype>
#include<cmath>
using namespace std;
string str="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
char encode(char a,int k){
int b;
if(isupper(a))b=a-'A';
else b=a-'a'+26;
if(b-k>=0)return str[b-k];
return str[52-abs(b-k)];
}
int main(void){
int n;
while(cin >> n,n){
vector<int>k(n);
for(int i=0;i<n;i++){
cin >> k[i];
}
string s;
cin >> s;
for(int i=0;i<s.size();i++)s[i]=encode(s[i],k[i%n]);
cout << s << endl;
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define LL long long
#define DD double
#define Pb push_back
#define Bp pop_back
#define Pf push_front
#define Fp pop_front
#define Ub upper_bound
#define Lb lower_bound
#define In insert
#define All(x) x.begin(), x.end()
#define mem(a, b) memset(a, b, sizeof(a))
#define fast ios_base::sync_with_stdio(0);cin.tie(0)
#define X first
#define Y second
#define mx1 10
#define mx2 110
#define mx3 1010
#define mx4 10010
#define mx5 100010
#define mx6 1000010
typedef vector<LL> Vl;
typedef vector<DD> Vd;
typedef vector<bool> Vb;
typedef vector<Vl> VVl;
typedef pair<LL, LL> Pll;
typedef pair<DD, DD> Pdd;
typedef vector<Pll> Vpl;
typedef vector<Pdd> Vpd;
typedef queue<LL> Ql;
typedef stack<LL> Sl;
typedef deque<LL> Dl;
LL _set(LL N, LL pos) {return N = N | (1 << pos);}
LL _reset(LL N, LL pos) {return N = N & ~(1 << pos);}
bool _check(LL N, LL pos) {return (bool)(N & (1 << pos));}
bool _upper(char a) {return a >= 'A' && a <= 'Z';}
bool _lower(char a) {return a >= 'a' && a <= 'z';}
bool _digit(char a) {return a >= '0' && a <= '9';}
LL dx[] = {1, -1, 0, 0, -1, -1, 1, 1};
LL dy[] = {0, 0, 1, -1, -1, 1, -1, 1};
///**************************DONE****************************///
int x[] = {111, 222, 333, 444, 555, 666, 777, 888, 999};
int main()
{
int n;
cin >> n;
for(int i = 0; i < 9; i++){
if(x[i] >= n)
return cout << x[i] << '\n', 0;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main()
{
string s;
cin >> s;
bool flag = true;
int n = s.size();
int ok = 0;
if(s[0] != 'A'){
cout << "WA" << endl;
return 0;
}
for(int i = 2; i <= n-2; i++){
if(s[i] == 'C'){
ok++;
}
}
if(ok != 1){
cout << "WA" << endl;
return 0;
}
for(int i = 0; i < n; i++){
if(s[i] != 'A' && s[i] != 'C' && isupper(s[i])){
cout << "WA" << endl;
return 0;
}
}
cout << "AC" << endl;
} | 0 |
#include<bits/stdc++.h>
#include<iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <set>
#include <queue>
#include <deque>
#include <map>
#include <stack>
#include<bitset>
#include<list>
#include<cassert>
#include<numeric>
using namespace std;
const long long N = 1000 * 100 + 5;
long long c[N], n, cnt = 0, is, bi, nbi;
vector < long long > graph[N];
bool mark[N], b;
void dfs(long long v)
{
mark[v] = 1;
for (auto u : graph[v])
{
if (c[u] == c[v])
{
b = 0;
}
if (!mark[u])
{
c[u] = 1 - c[v];
dfs(u);
}
}
return;
}
void dfs2()
{
memset(c , -1 , sizeof c);
for(long long i = 0; i < n; i++)
{
if(!mark[i])
{
cnt++;
b = 1;
c[i] = 1;
if(graph[i].size())
{
dfs(i);
if(b)
{
bi++;
}
else
{
nbi++;
}
}
else
{
is++;
}
}
}
return;
}
int main()
{
long long m;
cin >> n >> m;
for (long long i = 0; i < m; i++)
{
long long u, v;
cin >> u >> v;
graph[u - 1].push_back(v - 1);
graph[v - 1].push_back(u - 1);
}
dfs2();
cout << (bi + nbi) * (bi + nbi) + bi * bi + 2 * n * is - is * is << endl;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long s64;
s64 C2(int n)
{
return (s64)n*(n-1)/2;
}
#define rep(i,l,r) for(int i=l;i<=r;++i)
const int N=1e5+5;
int fa[N],sz[N];bool d[N],have[N];
int find(int x)
{
if(fa[x]==x)return x;
find(fa[x]);
d[x]^=d[fa[x]];
return fa[x]=fa[fa[x]];
}
int main()
{
//freopen("1.in","r",stdin);
int n,m;
cin>>n>>m;
rep(i,1,n){fa[i]=i;sz[i]=1;}
while(m--)
{
int x,y;
scanf("%d%d",&x,&y);
int fx=find(x),fy=find(y);
if(fx==fy)
{
have[fx]|=d[x]==d[y];
continue;
}
fa[fy]=fx;d[fy]=d[x]^1^d[y];
sz[fx]+=sz[fy];
have[fx]|=have[fy];
}
int cnt1=0,cnt[2]={};
rep(x,1,n)
if(fa[x]==x)
if(sz[x]==1)++cnt1;
else ++cnt[have[x]];
cout<<(s64)cnt[1]*cnt[0]*2+(s64)cnt1*(n-cnt1)*2
+(s64)cnt[1]*cnt[1]+(s64)cnt[0]*cnt[0]*2+(s64)cnt1*cnt1;
} | 1 |
#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <vector>
#include <assert.h>
#include <map>
#include <set>
#include <unordered_set>
#include <unordered_map>
#include <math.h>
#include <string>
#include <string.h>
#include <queue>
#include <complex>
#include <iomanip>
#include <stack>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
ll mod=1e9+7;
double eps=1e-7;
ll exp(ll x,ll y){if(y<0) return 0; ll ret=1;for(;y;y>>=1,x=(x*x)%mod){if(y&1)ret=(ret*x)%mod;}return ret;}
ull pexp(ull x,ull y){if(y<0) return 0; ull ret=1; for(;y;y>>=1,x=(x*x)){if(y&1)ret=(ret*x);}return ret;}
ll gcd(ll x,ll y){if(!x||!y) return x+y; return x%y==0?y:gcd(y,x%y);}
ll lcm(ll x,ll y){return x*(y/gcd(x,y));}
ll bsum(ll u,ll b){ll ret=0;if(u<b)return u;while(u){ret+=u%b;u/=b;}return ret;}
ll prival(ll u,ll p){ll cn=0;while(u%p==0){cn++;u=u/p;}return cn;}
ll minv(ll a,ll b){return 1<a?b-minv(b%a,a)*b/a:1;}
ll extm(ll a,ll b){ll ret=0;while(a!=0){if(a%2==1){ret+=b;ret%=mod;}a>>=1;b=(2*b)%mod;}return ret;}
ll eaphi(ll x){ll t=x,ret=x,i;for(i=2;i*i<=x;i++){if(t%i==0){ret-=ret/i;while(t%i==0) t/=i;}}if(t!=1) ret-=ret/t;return ret;}
ll eadivc(ll x){ll ret=0;ll i;for(i=1;i*i<=x;i++){if(x%i==0 && i*i!=x) ret+=2;if(x%i==0 && i*i==x) ret+=1;}return ret;}
ll eadivs(ll x){ll ret=0;ll i;for(i=1;i*i<=x;i++){if(x%i==0 && i*i!=x) ret+=i+x/i;if(x%i==0 && i*i==x) ret+=i;}return ret;}
ll ndig(ll x, ll b){ll ret=0;while(x){x/=b; ret++;}return ret;}
ll rev(ll n, ll b){ll ret=0;while(n){ret=b*ret+n%b; n/=b;}return ret;}
ll sq(ll x){ll t=(ll)sqrt(x); for(ll i=t-2 ; i<=t+2 ; i++) if(i*i==x) return abs(i); return -1;}
ll extexp(ll x,ll y){if(y<0) return 0; ll ret=1;for(;y;y>>=1,x=extm(x,x)){if(y&1)ret=extm(ret,x);}return ret;}
bool isprime(ll x){if(x<=1) return false; for(ll i=2;i*i<=x;i++){if(x%i==0){return false;}}return true;}
pair<ll, int> x[111111];
pair<ll, int> y[111111];
vector< pair< ll, pair<int, int> > > edge;
int par[111111]; ll ans, n;
int find(int x)
{
if(par[x]==x) return x;
return par[x]=find(par[x]);
}
void unite(int u, int v)
{
if(find(u)==find(v)) return;
par[find(u)]=v;
}
int main(void)
{
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin>>n; int i, j;
for(i=1 ; i<=n ; i++) par[i]=i;
for(i=1 ; i<=n ; i++) cin>>x[i].first>>y[i].first;
for(i=1 ; i<=n ; i++) x[i].second=y[i].second=i;
sort(x+1,x+n+1); sort(y+1,y+n+1);
for(i=1 ; i<=n-1 ; i++) edge.push_back(make_pair(x[i+1].first-x[i].first,make_pair(x[i].second,x[i+1].second)));
for(i=1 ; i<=n-1 ; i++) edge.push_back(make_pair(y[i+1].first-y[i].first,make_pair(y[i].second,y[i+1].second)));
sort(edge.begin(),edge.end());
for(i=0 ; i<edge.size() ; i++)
{
int u=edge[i].second.first;
int v=edge[i].second.second;
if(find(u)==find(v)) continue;
unite(u,v); ans+=edge[i].first;
}
cout<<ans; return 0;
}
// 제출하기 전에 생각햇나요?
// it may be easier/harder than you think
// ios::sync_with_stdio(false); cin.tie(0); cout.tie(0); | #include <bits/stdc++.h>
using ll = long long;
using Pii = std::pair<int, int>;
using Pll = std::pair<ll, ll>;
const ll INF = (ll)1e11;
const ll MOD = 998244353;
using namespace std;
int main() {
ios::sync_with_stdio(false);
int N;
cin >> N;
vector<int> A;
ll S = 0;
for (int i = 0, a; i < N; ++i) {
cin >> a;
A.push_back(a);
S += a;
}
ll cnt = 1;
for (int i = 0; i < N; ++i) {
cnt *= 3; // all ways to paint stones
cnt %= MOD;
}
// subtract the numbers of ways to paint such that R,G,B cannot construct a triangle from all.
{ // reduce the number of ways to paint such that R >= G + B, G >= B + R, B >= R + G
vector<ll> dp(S + 10, 0);
dp[0] = 1; // assume that R = max(R,G,B) here
for (auto a : A) {
for (ll s = S; s > a - 1; --s) {
dp[s] += 2 * dp[s-a]; // select a_i in G or B
dp[s] %= MOD;
}
}
for (ll s = 0; s < S / 2 + 1; ++s) {
cerr << "----" << endl;
cnt -= 3 * dp[s]; // subtract sum of R, G, B = max(R,G,B)
while (cnt < 0) cnt += 3 * MOD;
cnt %= MOD;
cerr << cnt << endl;
}
}
cerr << cnt << endl;
if (S % 2 == 0) { // add the number of ways to paint such that R == G && B == 0, G == B && R == 0, B == R && G == 0
vector<ll> dp(S + 10, 0);
dp[0] = 1; // assume that R == G && B == 0 here
for (auto&& a : A) {
for (ll s = S; s > a - 1; --s) {
dp[s] = (dp[s] + dp[s-a]) % MOD; // select a_i in R (G)
dp[s] %= MOD;
}
}
cnt += 3ll * dp[S/2]; // add sum of R,G,B == 0
cnt %= MOD;
}
cout << cnt << endl;
return 0;
}
| 0 |
#include<iostream>
using namespace std;
int func(int x);
int main() {
int x;
while (true) {
cin >> x;
if (x == 0) { break; }
cout << func(x) / 3650 + 1 << endl;
}
return 0;
}
int func(int x) {
if (x == 1) {
return 1;
}
else if (x == 2) {
return 2;
}
else if (x == 3) {
return 4;
}
else {
return func(x - 1) + func(x - 2) + func(x - 3);
}
} | #include <iostream>
#include <stdio.h>
#include <string>
#include <vector>
#include <queue>
#include <stdlib.h>
using namespace std;
int main(void){
int n;
cin >> n;
for( int i = 0; i < n; i++ ) {
int outs = 0, runner = 0, pts = 0;
while( outs < 3 ) {
string evt;
cin >> evt;
if( evt == "HIT" ) {
if( runner < 3 ) {
runner ++;
} else {
pts ++;
}
} else if( evt == "OUT" ) {
outs ++;
} else {
pts += runner + 1;
runner = 0;
}
}
cout << pts << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
#define ll long long int
#define ull unsigned long long
#define si set <ll>
#define vi vector <ll>
#define popcount(x) __builtin_popcountll(x)
#define mii map <ll,ll>
#define vpi vector <pair <ll,ll> >
#define sz(c) (ll)c.size()
#define fr first
#define fastio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define sc second
#define pb push_back
#define mp make_pair
#define all(a) (a).begin(),(a).end()
#define mem0(a) memset(a,0,sizeof(a))
#define rep(i,a,n) for(ll i=a ; i<n ; i++)
#define ld long double
const ll INF = __LONG_LONG_MAX__;
#define rall(a) (a).rbegin(),(a).rend()
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("unroll-loops")
ll power(ll b,ll e,ll m)
{
if(b==0) return 0;
if(e==0) return 1;
if(e&1) return b*power(b*b%m,e/2,m)%m;
return power(b*b%m,e/2,m);
}
ll power( ll b, ll e)
{
if(b==0) return 0;
if(e==0) return 1;
if(e&1) return b*power(b*b,e/2);
return power(b*b,e/2);
}
bool isPowerOfTwo(ll x)
{
// x will check if x == 0 and !(x & (x - 1)) will check if x is a power of 2 or not
return (x && !(x & (x - 1)));
}
ll ans(ll a[],ll n)
{
ll sum=0;
for(ll i=0;i<64;i++)
{
ll zero=0,one=0;
for(ll j=0;j<n;j++)
{
if(a[j]&1) zero++;
else one++;
a[j]/=2;
}
ll x=(zero%MOD*one%MOD*power(2,i,MOD))%MOD;
sum=(sum%MOD+x%MOD)%MOD;
}
return sum;
}
void solve()
{
ll n;
cin>>n;
ll a[n];
rep(i,0,n) cin>>a[i];
cout<<ans(a,n);
}
int main()
{
fastio
ll tt=1;
// cin>>tt;
while(tt--)
{
solve();
cout<<"\n";
}
} | #include <bits/stdc++.h>
#define l(i) (n / 2 - (n - i + 1) / 2)
#define r(i) ((i + 1) / 2)
#define st(i) (i / 2 - 1)
using namespace std;
typedef long long ll;
int n, a[200005];
ll dp[200005][3], ans = -1e16; // j�ķ�Χ��i/2-1��(i+1)/2�����3��
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++)
for (int j = 0; j < 3; j++) dp[i][j] = -1e16;
dp[1][1 - st(1)] = a[1], dp[1][0 - st(1)] = 0;
for (int i = 2; i <= n; i++) {
for (int j = l(i); j <= r(i); j++) {
if (j == 0)
dp[i][j - st(i)] = 0;
else {
for (int k = i - 2; l(k) <= j - 1 && r(k) >= j - 1 && k >= 0;
k--)
dp[i][j - st(i)] =
max(dp[i][j - st(i)], dp[k][j - 1 - st(k)] + a[i]);
}
}
}
for (int i = n / 2; i <= n; i++)
for (int j = l(i); j <= r(i); j++)
if (j == n / 2) ans = max(ans, dp[i][j - st(i)]);
cout << ans;
return 0;
}
| 0 |
#include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <list>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <array>
#include <queue>
#include <stack>
#include <algorithm>
#include <tuple>
#include <numeric>
#include <type_traits>
#define MOD 998244353
int main()
{
long dp0[300*300+1]={}, dp1[300*300+1]={};
long sub0[300*300+1]={}, sub1[300*300+1]={};
long N;
std::vector<int> A;
std::cin >> N;
A.resize(N);
for (auto& a : A) {
std::cin >> a;
}
long sum = 0;
for (auto a : A) {
sum += a;
}
dp0[0] = 1;
sub0[0] = 1;
long* prevdp = dp0;
long* dp = dp1;
long* prevsub = sub0;
long* sub = sub1;
for (auto a : A) {
for (int i = 0; i < a; ++i) {
dp[i] = prevdp[i]*2 % MOD;
sub[i] = prevsub[i];
}
for (int i = a; i <= 300*300; ++i) {
dp[i] = (prevdp[i-a] + prevdp[i]*2) % MOD;
sub[i] = (prevsub[i-a] + prevsub[i]) % MOD;
}
std::swap(dp, prevdp);
std::swap(sub, prevsub);
}
long ret = 1;
for (long i = 0; i < N ; ++i)
ret = (ret * 3) % MOD;
for (long i = (sum+1)/2; i <= 300*300; ++i) {
ret = (ret + (MOD - prevdp[i])*3) % MOD;
}
if (sum%2 == 0) {
ret = (ret + prevsub[sum/2]*3) % MOD;
}
std::cout << ret << "\n";
}
| #include <iostream>
using namespace std;
typedef long long ll;
const ll mod = 998244353;
int n;
int a[305];
ll dp[305][90005];
ll dp2[305][90005];
ll p(ll a, ll x) {
ll res = 1;
while(x > 0) {
if(x & 1) res = res * a % mod;
a = a * a % mod;
x >>= 1;
}
return res;
}
int main() {
cin >> n;
int sum = 0;
int maxa = 0;
for(int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
maxa = max(maxa,a[i]);
}
dp[0][0] = 1;
for(int i = 0; i < n; i++) {
for(int j = 0; j <= i * maxa; j++) {
if(dp[i][j] == 0) continue;
dp[i+1][j] = (dp[i+1][j] + dp[i][j] * 2) % mod;
dp[i+1][j+a[i]] = (dp[i+1][j+a[i]] + dp[i][j]) % mod;
}
}
dp2[0][0] = 1;
for(int i = 0; i < n; i++) {
for(int j = 0; j <= i * maxa; j++) {
if(dp2[i][j] == 0) continue;
dp2[i+1][j] = (dp2[i+1][j] + dp2[i][j]) % mod;
dp2[i+1][j+a[i]] = (dp2[i+1][j+a[i]] + dp2[i][j]) % mod;
}
}
ll ans = p(3,n);
for(int i = 0; i <= n * maxa; i++) {
if(i >= sum - i) {
ans = (ans + mod - dp[n][i] * 3 % mod) % mod;
}
if(i == sum - i) {
ans = (ans + dp2[n][i] * 3 % mod) % mod;
}
}
if(ans < 0 ) cout << ans + mod << endl;
else
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define rep1(i,n) for(int i=1;i<=(int)n;i++)
#define sp(n) cout << fixed << setprecision(n)
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; }
typedef long long ll;
using namespace std;
int main(void){
int n;cin>>n;
vector<ll> a(n);
rep(i,n) cin>>a[i];
if(a[0]!=0){
cout<<-1<<endl;
return 0;
}
ll res=0;
reverse(a.begin(),a.end());
ll maxi=0;
rep(i,n){
if(a[i]<maxi){
cout<<-1<<endl;
return 0;
}
if(chmax(maxi,a[i]))res+=a[i];
maxi--;
}
cout<<res<<endl;
} | #include<iostream>
#include<cstdio>
using namespace std;
#define N 200012
int n,a[N],las=0;bool vis[N];long long ans=0;
int main(){
scanf("%d",&n);int i,l,r,lef;bool fl=true;
for(i=1;i<=n;i++)scanf("%d",&a[i]);
for(i=1;i<=n;i=r+1)
{
l=r=i;while((r<n)&&(a[r+1]==(a[r]+1)))++r;
lef=l-a[l];if(lef<=las){printf("-1");fl=false;break;}
ans+=r-lef;las=lef;
}if(fl)printf("%lld",ans);return 0;
} | 1 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define _USE_MATH_DEFINES
#include <math.h>
#define rep(i,n) for(int i = 0;i < n;i++)
#define NIL = -1;
#define all(x) x.begin(),x.end()
const ll INF = 1e9;
const ll mod = 1e9 + 7;
int digit(ll x) {
if (x / 10 == 0) return 1;
return digit(x / 10) + 1;
}
ll gcd(long long a,long long b) {
if (a < b) swap(a,b);
if (b == 0) return a;
return gcd(b,a%b);
}
bool is_prime(long long N){
if (N == 1) return false;
for (long long i = 2;i * i <= N;i++){
if (N % i == 0) return false;
}
return true;
}
ll lcm(ll a,ll b){
return ((a * b == 0)) ? 0 : (a / gcd(a,b) * b);
}
double DegreeToRadian(double degree){
return degree * M_PI / 180.0;
}
int dx[4] = {0,1,0,-1};
int dy[4] = {1,0,-1,0};
///////////////////////////////////////////////////////////////////////////////////
char s[4010];
int main(){
int n;
cin >> n;
long long r = 0, g = 0, b = 0;
for (int i = 1;i <= n;i++){
cin >> s[i];
if (s[i] == 'R') r++;
else if (s[i] == 'G') g++;
else b++;
}
ll ans = r*g*b;
for (int i = 1;i <= n;i++){
for (int j = i + 1;j <= n;j++){
if (s[i] != s[j]){
int k = j + j - i;
if (k > n) continue;
if (s[i] != s[k] && s[j] != s[k]){
ans--;
}
}
}
}
cout << ans << endl;
return 0;
}
| #include <iostream>
#include <string>
#include <set>
using namespace std;
void input(int& N, set<int>& R_INDEX, set<int>& G_INDEX, set<int>& B_INDEX)
{
char c;
for (int i= 0; i < N; i++){
cin >> c;
switch(c){
case 'R':
R_INDEX.insert(i);
break;
case 'G':
G_INDEX.insert(i);
break;
case 'B':
B_INDEX.insert(i);
break;
}
}
}
long long int findsetnum(set<int>& R_INDEX, set<int>& G_INDEX, set<int>& B_INDEX)
{
long long int sum = 0;
int a, b, c;
set<int>::iterator R_iter, G_iter;
for (R_iter = R_INDEX.begin(); R_iter != R_INDEX.end(); R_iter++)
for (G_iter = G_INDEX.begin(); G_iter != G_INDEX.end(); G_iter++){
a = (B_INDEX.find(2 * (*G_iter) - *R_iter) == B_INDEX.end())? 0 : 1;
b = (B_INDEX.find(2 * (*R_iter) - *G_iter) == B_INDEX.end())? 0 : 1;
c = (B_INDEX.find((*G_iter + *R_iter) / 2) == B_INDEX.end() || (*G_iter + *R_iter) % 2 != 0)? 0 : 1;
sum += (B_INDEX.size() - a - b - c);
}
return sum;
}
int main(void)
{
ios::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
set<int> R_INDEX, G_INDEX, B_INDEX;
input(N, R_INDEX, G_INDEX, B_INDEX);
cout << findsetnum(R_INDEX, G_INDEX, B_INDEX) << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define fastio ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
#define endl "\n"
#define ALL(a) (a).begin(),(a).end()
using namespace std;
using ll = long long;
const double PI = 3.14159265358979;
void solve()
{
int n, k;
cin >> n >> k;
vector<int> a(n + 1, 0);
for(int i = 0; i < n; ++i)
{
cin >> a[i];
}
for(int i = 0; i < k; ++i)
{
vector<int> next_a(n + 1, 0);
for(int j = 0; j < n; ++j)
{
next_a[ max(0, j - a[j]) ]++;
next_a[ min(n, j + a[j] + 1) ]--;
}
int max_cd_num = 0;
for(int j = 0; j < n; ++j)
{
next_a[j + 1] += next_a[j];
max_cd_num += (next_a[j] == n);
}
a = next_a;
if (max_cd_num >= n) break;
}
for(int i = 0; i < n; ++i) cout << a[i] << " ";
}
int main()
{
fastio;
solve();
return 0;
} | #include<bits/stdc++.h>
#define maxn 105
using namespace std;
int xe,ye;
short n,m,ans,a[maxn][maxn],p=0,np=1,dp[2][maxn][maxn][maxn];
char c[maxn][maxn];
void inline upd(short& x,short y){
if(x<y){x=y;if(y>ans)ans=y;}
}
int inline z(int i,int j,int k,int l){
return a[k][l]-a[i-1][l]-a[k][j-1]+a[i-1][j-1];
}
int inline cal1(int w,int h,int x,int l,int r){
int ret=0,_w=n-w,_h=m-h;
if(ye>1+_h)return 0;
else return z(max(l,xe-_w+l-1),x,min(r,xe+l-1),x);
}
int inline cal2(int w,int h,int y,int l,int r){
int ret=0,_w=n-w,_h=m-h;
if(xe>1+_w)return 0;
else return z(y,max(l,ye+l-_h-1),y,min(r,ye+l-1));
}
int inline cal3(int w,int h,int x,int l,int r){
int ret=0,_w=n-w,_h=m-h;
if(ye<h)return 0;
else return z(max(l,xe-_w+l-1),x,min(r,xe+l-1),x);
}
int inline cal4(int w,int h,int y,int l,int r){
int ret=0,_w=n-w,_h=m-h;
if(xe<w)return 0;
else return z(y,max(l,ye-_h+l-1),y,min(r,ye+l-1));
}
int main(){
// freopen("in.txt","r",stdin);
cin>>n>>m;
for(int i=1;i<=n;++i)
scanf("%s",c[i]+1);
for(int i=1;i<=n;++i)
for(int j=1;j<=m;++j){
a[i][j]=(c[i][j]=='o')+a[i-1][j]+a[i][j-1]-a[i-1][j-1];
if(c[i][j]=='E')xe=i,ye=j;
}
dp[np][1][1][m]=ans=1;
for(int k=n;k>=1;--k,swap(p,np))for(int l=m;l>=1;--l)
for(int i=1;i<=n-k+1;++i)for(int j=1;j<=m-l+1;++j)if(dp[np][i][j][l]){
int x=dp[np][i][j][l];
// printf("{%d,%d,%d,%d,%d}\n",i,j,k,l,x);
upd(dp[np][i][j+1][l-1],x+cal1(k,l,j,i,i+k-1));
upd(dp[p][i+1][j][l],x+cal2(k,l,i,j,j+l-1));
upd(dp[np][i][j][l-1],x+cal3(k,l,j+l-1,i,i+k-1));
upd(dp[p][i][j][l],x+cal4(k,l,i+k-1,j,j+l-1));
dp[np][i][j][l]=0;
}
printf("%d",ans-1);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main()
{
int n; cin >> n;
int a,b;
switch (n)
{
case 1:
cout << "Hello World\n";
break;
case 2:
cin >> a >> b; cout << a+b << endl;
break;
}
return (0);
}
| #include <bits/stdc++.h>
#define rep(i,n) for (int (i) = 0; (i) < (n); i++)
#define ll long long
using namespace std;
int main() {
ll N = 0, A,B;;
cin >> N >> A >> B;
if(N == 1){
cout << "Hello World";
}
else{
cout << A + B;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
//#define int long long
typedef long long ll;
typedef unsigned long long ul;
typedef unsigned int ui;
const ll mod = 1000000007;
const ll INF = mod * mod;
const int INF_N = 1e+9;
typedef pair<int, int> P;
#define stop char nyaa;cin>>nyaa;
#define rep(i,n) for(int i=0;i<n;i++)
#define per(i,n) for(int i=n-1;i>=0;i--)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)
#define rep1(i,n) for(int i=1;i<=n;i++)
#define per1(i,n) for(int i=n;i>=1;i--)
#define Rep1(i,sta,n) for(int i=sta;i<=n;i++)
#define all(v) (v).begin(),(v).end()
typedef pair<ll, ll> LP;
typedef long double ld;
typedef pair<ld, ld> LDP;
const ld eps = 1e-12;
const ld pi = acos(-1.0);
//typedef vector<vector<ll>> mat;
typedef vector<int> vec;
//繰り返し二乗法
ll mod_pow(ll a, ll n, ll m) {
ll res = 1;
while (n) {
if (n & 1)res = res * a%m;
a = a * a%m; n >>= 1;
}
return res;
}
struct modint {
ll n;
modint() :n(0) { ; }
modint(ll m) :n(m) {
if (n >= mod)n %= mod;
else if (n < 0)n = (n%mod + mod) % mod;
}
operator int() { return n; }
};
bool operator==(modint a, modint b) { return a.n == b.n; }
modint operator+=(modint &a, modint b) { a.n += b.n; if (a.n >= mod)a.n -= mod; return a; }
modint operator-=(modint &a, modint b) { a.n -= b.n; if (a.n < 0)a.n += mod; return a; }
modint operator*=(modint &a, modint b) { a.n = ((ll)a.n*b.n) % mod; return a; }
modint operator+(modint a, modint b) { return a += b; }
modint operator-(modint a, modint b) { return a -= b; }
modint operator*(modint a, modint b) { return a *= b; }
modint operator^(modint a, int n) {
if (n == 0)return modint(1);
modint res = (a*a) ^ (n / 2);
if (n % 2)res = res * a;
return res;
}
//逆元(Eucledean algorithm)
ll inv(ll a, ll p) {
return (a == 1 ? 1 : (1 - p * inv(p%a, a)) / a + p);
}
modint operator/(modint a, modint b) { return a * modint(inv(b, mod)); }
const int max_n = 1 << 18;
modint fact[max_n], factinv[max_n];
void init_f() {
fact[0] = modint(1);
for (int i = 0; i < max_n - 1; i++) {
fact[i + 1] = fact[i] * modint(i + 1);
}
factinv[max_n - 1] = modint(1) / fact[max_n - 1];
for (int i = max_n - 2; i >= 0; i--) {
factinv[i] = factinv[i + 1] * modint(i + 1);
}
}
modint comb(int a, int b) {
if (a < 0 || b < 0 || a < b)return 0;
return fact[a] * factinv[b] * factinv[a - b];
}
using mP = pair<modint, modint>;
int dx[4] = { 0,1,0,-1 };
int dy[4] = { 1,0,-1,0 };
// 素因数が何乗かをmapで返却する
map< ll, int > prime_factor(ll n) {
map< ll, int > ret;
for(ll i = 2; i * i <= n; i++) {
while(n % i == 0) {
ret[i]++;
n /= i;
}
}
if(n != 1) ret[n] = 1;
return ret;
}
void solve() {
ll N, M; cin >> N >> M;
auto pf = prime_factor(M);
ll res = 1;
for(auto a: pf){
res = modint(modint(res) * comb(a.second + N - 1, a.second));
}
cout << res << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
//cout << fixed << setprecision(10);
init_f();
//init();
//int t; cin >> t; rep(i, t)solve();
solve();
// stop
return 0;
}
| #define _CRT_SECURE_NO_WARNINGS
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef double db;
typedef vector<ll> VLL;
typedef vector<VLL> VVLL;
typedef pair<ll,ll> PLL;
#define REP(x,l,u) for(ll x = l; x < u; x++)
#define RREP(x,l,u) for(ll x = l; x >= u; x--)
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define mst(x,v) memset(x, v, sizeof(x))
#define sz(x) (ll)x.size()
string to_string(string s) {return s;}
string to_string(char c) {string s = string(1, c);return s;}
template <typename A, typename B> string to_string(pair<A,B> p) { return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }
template <typename A> string to_string(vector<A> v) { string s = "("; int first = 1; for (A a : v) { if (!first) { s += ", "; } first = 0; s += to_string(a); } s += ")"; return s; }
template <typename A> string to_string(set<A> v) { string s = "("; int first = 1; for (A a : v) { if (!first) { s += ", "; } first = 0; s += to_string(a); } s += ")"; return s; }
void debug_out() {cerr << endl;}
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) { cerr << " " << to_string(H); debug_out(T...); }
void in() {}
template <typename A> void in(A & x) { cin >> x; }
template <typename A, typename B> void in(pair<A,B> & x) { in(x.first); in(x.second); }
template <typename A> void in(vector<A> & x) { REP(i,0,(ll)x.size()) in(x[i]); }
template <typename Head, typename... Tail> void in(Head & H, Tail & ... T) {in(H); in(T...); }
#ifndef ONLINE_JUDGE
#define debug(...) do { cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__); } while (false)
#else
#define debug(...) do { } while (false)
#endif
const ll inf = (ll)1e18 + 5;
const ll mod = 1e9+7;
const ll nax = 100500;
ll F[nax], INVF[nax];
ll pow(ll a, ll b) {
if (b == 0) return 1;
ll h = pow(a, b/2);
ll ans = b % 2 ? h * h % mod * a : h * h;
ans %= mod;
return ans;
}
ll ncr(ll n, ll r) {
// n! / r! / (n-r)!
ll ans = F[n];
ans *= INVF[r];
ans %= mod;
ans *= INVF[n-r];
ans %= mod;
return ans;
}
void solve() {
ll n, m;
in(n, m);
F[0] = 1;
REP(i,1,nax) F[i] = (F[i-1] * i) % mod;
REP(i,0,nax) INVF[i] = pow(F[i], mod-2);
map<ll,ll> factors;
ll f = 2;
while (m != 1 && f*f <= m) {
while (m % f == 0) {
factors[f]++;
m /= f;
}
f++;
}
if (m != 1) factors[m]++;
ll ans = 1;
for (PLL a : factors) {
ans *= ncr(a.second + n - 1, a.second) % mod;
ans %= mod;
}
cout << ans << endl;
}
signed main() {
ll t = 1;
REP(i,0,t) solve();
return 0;
} | 1 |
#include <bits/stdc++.h>
#define For(i, a, b) for(int (i)=(a); (i)<(b); ++(i))
#define rFor(i, a, b) for(int (i)=(a)-1; (i)>=(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef unsigned long long ulint;
typedef pair<int, int> pii;
typedef complex<double> xy_t;
typedef vector<lint> poly;
template<class T>bool chmax(T &a, const T &b){if(a<b){a=b; return true;} return false;}
template<class T>bool chmin(T &a, const T &b){if(a>b){a=b; return true;} return false;}
const lint mod = 1e9+7;
const lint INF = mod*mod;
const int MAX = 1<<20;
lint powmod(lint x, lint n){
lint ret = 1;
while(n > 0){
if(n&1) ret *= x, ret %= mod, n -= 1;
else x *= x, x %= mod, n >>= 1;
}
return ret;
}
lint dp[MAX], zero[MAX], cnt[MAX], now;
int main(){
int n;
scanf("%d", &n);
int a[n], s[n+1];
s[0]=0;
rep(i, n){
scanf("%d", &a[i]);
s[i+1]=s[i]^a[i];
}
rep(i, MAX){
zero[i]=cnt[i]=0;
dp[i]=1;
}
now=0;
rep(i, n+1){
if(s[i]==0) ++now;
else{
(dp[s[i]]+=zero[s[i]]*(now-cnt[s[i]])%mod)%=mod;
(zero[s[i]]+=dp[s[i]])%=mod;
cnt[s[i]]=now;
}
}
if(s[n]!=0){
printf("%lld\n", dp[s[n]]);
return 0;
}
lint ans=0;
rep(i, MAX)if(cnt[i]) (ans+=zero[i])%=mod;
(ans+=powmod(2, now-2))%=mod;
printf("%lld\n", ans);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const int maxn=2e5+5;
const int mod=1e9+7;
ll fac[maxn]={1},ifac[maxn];
inline ll fastpow(ll a,ll b) {
ll ans=1;
for(;b;b>>=1,a=a*a%mod) if(b&1) ans=ans*a%mod;
return ans;
}
inline void init() {
for(int i=1;i<maxn;i++) fac[i]=fac[i-1]*i%mod;
ifac[maxn-1]=fastpow(fac[maxn-1],mod-2);
for(int i=maxn-2;~i;i--) ifac[i]=ifac[i+1]*(i+1)%mod;
}
inline ll C(ll n,ll m) {
return fac[n]*ifac[m]%mod*ifac[n-m]%mod;
}
int main() {
init();
ll h,w,a,b;cin>>h>>w>>a>>b;
ll ans=0;
for(int i=b+1;i<=w;i++) {
ans=(ans+C(h-1-a+i-1,i-1)*C(w-i+a-1,a-1)%mod)%mod;
}
cout<<ans<<endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
string s;
cin>>s;
if(s[0]=='R'&& s[1]=='R'&&s[2]=='R'){
cout<<"3"<<endl;
}
else if(s[0]!='R'&& s[1]!='R'&&s[2]!='R'){
cout<<"0"<<endl;
}
else if(s[0]=='R'&& s[1]=='R' || s[1]=='R'&&s[2]=='R'){
cout<<"2"<<endl;
}
else{
cout<<"1"<<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() {
string s;
cin >> s;
if (s[0] > s[1]) {
cout << s[0] << s[0] << s[0] << endl;
} else if (s[0] < s[1]) {
cout << s[0] - '0' + 1 << s[0] - '0' + 1 << s[0] - '0' + 1 << endl;
} else if (s[0] > s[2]) {
cout << s[0] << s[0] << s[0] << endl;
} else if (s[0] < s[2]) {
cout << s[0] - '0' + 1 << s[0] - '0' + 1 << s[0] - '0' + 1 << endl;
} else {
cout << s << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
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;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
sort(all(a));
for (int i = 1; i < n; ++i) {
if (a[i] == a[i-1]){
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define ff first
#define ss second
#define ll long long
#define int long long
#define inf ((ll)1e18)
#define mod 1000000007
#define double long double
#define ull unsigned long long
#define vi vector<ll>
#define ppi pair<int,int>
#define pii pair<pair<int,int>,int>
#define pb push_back
#define pi 2*acos(0.0)
#define rev greater<int>()
#define pr(a,x,y) for(int i=x;i<y;i++){cout<<a[i]<<" ";}
#define ps(s) for(auto i:s){cout<<i<<" ";}
#define sp(x,y) fixed<<setprecision(y)<<x
#define w(x) ll x; cin>>x; while(x--)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define test cout<<"This is test"<<endl;
#define str string
#define endl '\n'
#define e cout<<'\n';
void kehsihba(){
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
/*#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif*/
}
void solve(){
ll n;cin>>n;
ll x;
set<int>s;
for(int i=0;i<n;i++){
cin>>x;s.insert(x);
}
cout<<(((int)s.size()==n)?"YES":"NO");
}
int32_t main(){
kehsihba();
//init();
ll t=1;
//cin>>t;
for(int k=1;k<=t;k++){
//cout<<"Case "<<k<<": ";
solve();
//e;
}
}
| 1 |
#include <bits/stdc++.h>
#define int long long
typedef long long ll;
using namespace std;
const ll MAXN = 200000;
const ll INF = 1001001001;
const ll MOD = 1000000007;
ll N, ans=0, tmp=0;
vector<vector<ll>> A;
string S;
signed main(){
cin >> S;
A.resize(26);
for(int i=0;i<S.size();i++) {
ll abc = S[i]-'a';
//cout << abc << endl;
A[abc].push_back(i);
}
for(int i=0;i<26;i++) {
for(int j=0;j<A[i].size();j++) {
tmp = S.size()-A[i][j]-A[i].size()+j;
ans += max(tmp, 0LL);
//cout << ans << endl;
}
}
cout << ans+1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
string A;
cin >> A;
int N = A.size();
vector<vector<long long>> v( N, vector<long long>( 26 ) );
for( int i = 0; i < N; i++ ) {
int j = A[N - 1 - i] - 'a';
v[N - 1 - i][j]++;
}
for( int i = 0; i < N - 1; i++ ) {
for( int j = 0; j < 26; j++ ) {
v[N - 2 - i][j] += v[N - 1 - i][j];
}
}
long long ans = 1;
for( int i = 0; i < N; i++ ) {
long long n = 0;
int k = A[i] - 'a';
for( int j = 0; j < 26; j++ ) {
if( j == k ) continue;
n += v[i][j];
}
ans += n;
}
cout << ans << endl;
}
| 1 |
//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define pp pair<int,int>
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define ld long double
#define al(a) (a).begin(),(a).end()
#define mk make_pair
#define check cout<<"?"<<endl;
ll MOD=1000000007;
ll mod=998244353;
int inf=1000001000;
ll INF=1e18+5;
int main(){
int h,w,n,ans=inf; cin>>h>>w>>n;
rep(i,h+1)rep(j,w+1){
if(h*w-(h-i)*(w-j)>=n) ans=min(ans,i+j);
}
cout<<ans<<endl;
}
| #include <bits/stdc++.h>
#define P pair<long long, long long>
using namespace std;
const int INF=1e5;
int main(){
int h, w, n;
cin >> h >> w >> n;
int mx = max(h, w);
cout << (n-1)/mx + 1 << endl;
}
| 1 |
#include<bits/stdc++.h>
int n,m,a[101],c[101],b[201],e,sum,now;
int main()
{
scanf("%d%d",&n,&m);
if(m==1)
{
printf("%d\n",n);
if(n==1)puts("1"),puts("1");
else puts("2"),printf("%d %d\n",n-1,1);
return 0;
}
for(int i=1;i<=m;++i)
scanf("%d",&a[i]),sum+=a[i],now+=a[i]/2;
now+=sum/2;
if(now<sum-1)puts("Impossible");
else
{
for(int i=1;i<=m;++i)
if(a[i]&1)
{
if(c[1])c[m]=a[i];
else c[1]=a[i];
a[i]=0;
}
for(int i=1,j=c[1]?1:0;i<=m;++i)
if(a[i])
c[++j]=a[i];
for(int i=1;i<=m;++i)
b[i]=c[i];
++b[1];
e=m;
--b[m];
if(c[m]==1)--e;
for(int i=1;i<=m;++i)
printf("%d ",c[i]);
puts("");
printf("%d\n",e);
for(int i=1;i<=e;++i)
printf("%d ",b[i]);
puts("");
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcount
#define INF 1e16
#define mod 1000000007
ll N,M;
vector<int> A;
int main(){
cin>>N>>M;
A.resize(M);
rep(i,M)cin>>A[i];
if(M==1){
cout<<A[0]<<endl;
if(A[0]>1){
cout<<2<<endl;
cout<<A[0]-1<<" "<<1<<endl;
}else{
cout<<1<<endl;
cout<<1<<endl;
}
return 0;
}
vector<int> os;
rep(i,M){
if(A[i]%2==1)os.push_back(i);
}
if(os.size()>2){
cout<<"Impossible"<<endl;
return 0;
}
if(os.size()==1){
swap(A[0],A[os[0]]);
}else if(os.size()==2){
swap(A[0],A[os[0]]);
swap(A[M-1],A[os[1]]);
}
rep(i,M)cout<<A[i]<<" ";
cout<<endl;
if(A[0]-1>0){
cout<<M<<endl;
cout<<A[0]-1<<" ";
}else{
cout<<M-1<<endl;
}
repl(i,1,M-1)cout<<A[i]<<" ";
cout<<A[M-1]+1<<endl;
return 0;
}
| 1 |
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
#define rep1(i,n) for(int i=1;i<=n;i++)
struct rec{int di,h;};
vector<rec> vc;
bool comp(rec const &l,rec const &r){
return l.di!=r.di ? l.di<r.di : l.h<r.h;
}
int main(){
rep1(i,150) rep1(j,i-1) vc.push_back({i*i+j*j,j});
sort(vc.begin(),vc.end(),comp);
while(true){
int n,m;
scanf("%d%d",&n,&m);
if(n==0) break;
rec e={n*n+m*m,n};
rec rc=*upper_bound(vc.begin(),vc.end(),e,comp);
printf("%d %d\n",rc.h,(int)((1e-9)+sqrt(rc.di-rc.h*rc.h)));
}
return 0;
} | #include<iostream>
using namespace std;
int main(){
int h,w;
while(1){
cin>>h>>w;
if(h==0)break;
int d=h*h+w*w,ah=100,aw=100;
for(int i=1;i<=150;i++)
for(int j=i+1;j<=150;j++){
int k=i*i+j*j;
if(((k==d&&i>h)||k>d)&&(ah*ah+aw*aw>k||(k==ah*ah+aw*aw&&ah>i)))ah=i,aw=j;
}
cout<<ah<<' '<<aw<<endl;
}
return 0;
} | 1 |
#include<iostream>
using namespace std;
int main() {
int n;
int a[10000];
int b[10000];
while(cin >> n) {
if(n == 0) {
break;
}
for(int i = 0; i < n; i++ ){
cin >> a[i] >> b[i];
}
int ans_a = 0;
int ans_b = 0;
for(int i = 0; i < n; i++) {
if(a[i] < b[i]) {
ans_b += a[i] + b[i];
}else if(a[i] > b[i]) {
ans_a += a[i] + b[i];
}else {
ans_a += a[i];
ans_b += b[i];
}
}
cout << ans_a << " " << ans_b << endl;
}
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main(){
int num_battle;
int a, b;
int point_a = 0;
int point_b = 0;
string cards;
cin >> num_battle;
for(; num_battle != 0;){
while(num_battle > 0){
cin >> a >> b;
if(a == b){
point_a += a;
point_b += b;
}else if(a > b){
point_a += a + b;
}else{
point_b += a + b;
}
num_battle--;
}
cout << point_a << " " << point_b << endl;
// initialize
point_a = 0;
point_b = 0;
cin >> num_battle;
}
return 0;
} | 1 |
#include <iostream>
#include <cstdio>
#include <cmath>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <queue>
#include <cstring>
using namespace std;
typedef long long int ll;
const int INF = 1000000000;
#define rep(i,n) for(int i=0;i<(int)(n);i++)
int main(){
string s;
while(getline(cin, s)){
rep(i, 26){
for(char& c : s){
if(isalpha(c)){
if(c != 'z') ++c;else c = 'a';
}
}
if(s.find("that") != string::npos || s.find("this") != string::npos || s.find("the") != string::npos){
cout << s << endl;
}
}
}
return 0;
} | #include <cstdio>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <string.h>
#include <queue>
#include <stack>
#include <utility>
#include <queue>
#include <cmath>
#define mp make_pair
#define pii pair<int,int>
#define ff first
#define ss second
using namespace std;
int month[20]={0,31,29,31,30,31,30,31,31,30,31,30,31};
string days[10]={"Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"};
int a,b,c,d;
int main()
{
while(1)
{
scanf("%d %d",&a,&b);
c=0;
if(a==0&&b==0)
{
break;
}
for(int i=1;i<a;i++)
{
c+=month[i];
}
c+=b+2;
d=c%7;
//printf("%d\n",c);
cout<<days[d]<<endl;
}
return 0;
} | 0 |
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
using namespace std;
typedef long long ll;
typedef pair < int, int > pii;
const int N = 16;
const int M = (1 << N);
const int INF = 0x3f3f3f3f;
int dp[N][M], g[N][N], n, m, rv[M];
int f(int st, int msk){
if(st == n - 1) return 0;
if(dp[st][msk] != -1) return dp[st][msk];
int sol = INF;
for(int msk1 = (msk - 1) & msk; msk1 ; msk1 = (msk1 - 1) & msk){
int msk2 = msk ^ msk1;
if(msk1 & (1 << (n - 1))) continue;
if(msk2 & (1 << st)) continue;
int sum = 0;
for(int t1 = msk1; t1 ; t1 -= t1 & (-t1)){
for(int t2 = msk2 ; t2 ; t2 -= t2 & (-t2)){
sum += g[rv[t1 & (-t1)]][rv[t2 & (-t2)]];
}
}
for(int t2 = msk2 ; t2 ; t2 -= t2 & (-t2)){
if(g[st][rv[t2 & (-t2)]]){
sol = min(sol, f(rv[t2 & (-t2)], msk2) + sum - g[st][rv[t2 & (-t2)]]);
}
}
}
return dp[st][msk] = sol;
}
int main(){
memset(dp, -1, sizeof(dp));
for(int i = 0;i<N;i++) rv[(1 << i)] = i;
memset(dp, -1, sizeof(dp));
scanf("%d%d", &n, &m);
for(int i = 0;i<m;i++){
int x, y;scanf("%d%d", &x, &y);x--;y--;
scanf("%d", &g[x][y]);
g[y][x] = g[x][y];
}
printf("%d\n", f(0, (1 << n) - 1));
}
| #include <bits/stdc++.h>
using namespace std;
const int N = 16;
const int inf = 1e9;
int n, m;
int e[N][1 << N];
int c[N][N];
int dp[N][1 << N];
void minimize(int &x, int y) { x = (x > y) ? y : x; }
void prep() {
for (int mask = 0; mask < (1 << n); ++mask) {
for (int i = 0; i < n; ++i) if (!(mask >> i & 1)) {
for (int j = 0; j < n; ++j) if (mask >> j & 1) e[i][mask] += c[i][j];
}
}
}
void brute(int pos, int cmask, int cost, int &u, int &mask) {
// dp[u][mask] is the current state
// cmask is the next mask
if (pos == n) {
minimize(dp[u][cmask], dp[u][mask] + cost);
return;
}
if (mask >> pos & 1) {
return brute(pos + 1, cmask | (1 << pos), cost, u, mask);
}
brute(pos + 1, cmask, cost, u, mask);
brute(pos + 1, cmask | (1 << pos), cost + e[pos][mask ^ (1 << u)], u, mask);
}
int main() {
scanf("%d %d", &n, &m);
while(m--) {
int u, v, w; scanf("%d %d %d", &u, &v, &w);
--u; --v;
c[u][v] = c[v][u] = w;
}
prep();
for (int mask = 0; mask < (1 << n); ++mask) {
for (int i = 0; i < n; ++i) dp[i][mask] = inf;
}
dp[0][1] = 0;
for (int mask = 0; mask < (1 << n); ++mask) {
for (int u = 0; u < n; ++u) if (dp[u][mask] != inf) {
for (int v = 0; v < n; ++v) if (!(mask >> v & 1)) {
if (c[u][v] == 0) continue;
minimize(dp[v][mask ^ (1 << v)], dp[u][mask] + e[v][mask ^ (1 << u)]);
}
brute(0, 0, 0, u, mask);
}
}
printf("%d\n", dp[n - 1][(1 << n) - 1]);
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x;
cin >> x;
long long ans=0;
ans+=x/11*2;
if (x%11>6)
{
ans+=2;
}
else {
if (x%11) {
ans++;
}
}
cout << ans << endl;
} | /** Created by: Marcos Portales
Codeforces User: marcosportales
Country: Cuba
Copyright */
#include<bits/stdc++.h>
using namespace std;
/// Pragmas:
#pragma GCC optimize("Ofast","unroll-loops","omit-frame-pointer","inline") //Optimization flags
#pragma GCC option("arch=native","tune=native","no-zero-upper") //Enable AVX
#pragma GCC target("avx2") //Enable AVX
/// Macros:
#define int long long
#define f first
#define s second
#define db(x) cerr << #x << ": " << (x) << '\n';
#define pb push_back
#define lb lower_bound
#define up upper_bound
#define all(x) x.begin() , x.end()
#define rall(x) x.rbegin() , x.rend()
#define enl '\n'
#define vi vector<int>
#define sz(a) int((a).size())
#define rep(i,x,y) for(int i=x;i<y;i++)
typedef pair<int,int> ii;
typedef long double ld;
typedef unsigned long long ull;
/// Constraints:
const int maxn = 400010;
const int mod = 1000000007;
const ld eps = 1e-9;
const int inf = ((1ll<<31ll)-1ll);
const int INF = 2000000000000000000ll;
const ld pi = acos(-1);
/// Prime Numbers:
// 2, 173, 179, 181, 197, 311, 331, 737, 1009, 2011, 2027, 3079, 4001, 10037, 10079, 20011, 20089;
// 100003, 100019, 100043, 200003, 200017, 1000003, 1000033, 1000037, 1000081;
// 2000003, 2000029, 2000039, 1000000007, 1000000021, 2000000099;
/// Functions:
#define lg2(x) 31 - __builtin_clz(x)
#define lgx(x,b) ( log(x) / log(b) )
/// Red-Black Tree Template ---------------------------------
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;
//typedef tree < long long , null_type , less<long long> , rb_tree_tag , tree_order_statistics_node_update > ordered_set;
/// Quick Pow------------------------------------------------
int qpow(int b,int e){
if( !e ) return 1;
if( e & 1 ) return qpow(b,e-1) * b % mod;
int pwur = qpow(b,e>>1);
return (pwur * pwur) % mod;
}
int modinv(int x){
return qpow(x,mod-2);
}
/// My Code -------------------------------------------------
int32_t main(){
ios_base::sync_with_stdio(0); cin.tie(0);
cout.setf(ios::fixed); cout.precision(0);
srand(time(NULL));
//freopen("a.in","r",stdin);
//freopen("a.in","w",stdout);
int x;
cin >> x;
int p=x/11;
int r=x-p*11;
int ans;
if(r==0) {
ans=2*p;
}else if(r<=6) {
ans=2*p+1;
}else{
ans=2*p+2;
}
cout << ans << "\n";
return 0;
}
| 1 |
#include<iostream>
#include<string>
#include<cstdio>
#include<algorithm>
#include<stack>
#include<queue>
#include<vector>
#include<cmath>
#include<utility>
#include<set>
#include<complex>
#include<map>
#define vi vector<int>
#define vvi vector<vector<int> >
#define ll long long int
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vb vector<bool>
#define vc vector<char>
#define vs vector<string>
#define ld long double
#define INF 1e9
#define EPS 0.0000000001
#define rep(i,n) for(int i=0;i<n;i++)
#define loop(i,s,n) for(int i=s;i<n;i++)
#define CC puts("-------ok--------");
#define all(in) in.begin(), in.end()
using namespace std;
typedef pair<int, int> pii;
#define MAX 99999999
int main(){
int n;
cin>>n;
vi v(n+1,0);
rep(i,n*(n-1)/2){
pii a,b;
cin>>a.first>>b.first;cin>>a.second>>b.second;
if(a.second==b.second){v[a.first]++; v[b.first]++;}
else{
a.second>b.second ? v[a.first]+=3:v[b.first]+=3;
}
}
vi hoge;
rep(i,n)hoge.push_back(v[i+1]);
sort(hoge.begin(),hoge.end(),greater<int>());
rep(i,n){
for(int j=0;j<n;j++){
if(hoge[j]==v[i+1]){cout<<j+1<<endl; break;}
}
}
} | #include <bits/stdc++.h>
// #undef DEBUG // Uncomment this line to forcefully disable debug print.
#if DEBUG
template <typename T>
void debug(T value) {
std::cerr << value;
}
template <typename T, typename... Ts>
void debug(T value, Ts... args) {
std::cerr << value << ", ";
debug(args...);
}
#define dbg(...) \
do { \
cerr << #__VA_ARGS__ << ": "; \
debug(__VA_ARGS__); \
cerr << " (L" << __LINE__ << ")" << endl; \
} while (0)
#else
#define dbg(...)
#endif
void read_from_cin() {}
template <typename T, typename... Ts>
void read_from_cin(T& value, Ts&... args) {
std::cin >> value;
read_from_cin(args...);
}
#define in(type, ...) \
type __VA_ARGS__; \
read_from_cin(__VA_ARGS__);
template <typename T>
void write_to_cout(const T& value) {
std::cout << value << std::endl;
}
template <typename T, typename... Ts>
void write_to_cout(const T& value, const Ts&... args) {
std::cout << value << ' ';
write_to_cout(args...);
}
#define out(...) write_to_cout(__VA_ARGS__);
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
using ll = long long;
using namespace std;
int main() {
in(int, n);
for (;; ++n) {
string s = to_string(n);
bool ok = true;
for (char c : s)
if (c != s[0]) ok = false;
if (ok) {
out(n);
return 0;
}
}
}
| 0 |
#include<iostream>
using namespace std;
int main(){
while(1){
int INF=100000100;
int n,k,ans[105][105],t,a,b,c;
scanf("%d%d",&n,&k);
if(n==0&&k==0)break;
for(int i=1;i<=n+2;i++){
for(int j=1;j<=n+2;j++){
ans[i][j]=INF;
if(i==j)ans[i][j]=0;
}
}
for(int i=0;i<k;i++){
scanf("%d",&t);
if(t==0){
scanf("%d%d",&a,&b);
if(ans[a][b]==INF)printf("%d\n",-1);
else printf("%d\n",ans[a][b]);
}
if(t==1){
scanf("%d%d%d",&a,&b,&c);
if(ans[a][b]>c){
ans[a][b]=c;
ans[b][a]=c;
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if(ans[i][j]>ans[i][a]+ans[a][b]+ans[b][j])ans[i][j]=ans[i][a]+ans[a][b]+ans[b][j];
if(ans[i][j]>ans[i][b]+ans[b][a]+ans[a][j])ans[i][j]=ans[i][b]+ans[b][a]+ans[a][j];
}
}
}
}
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef tuple<int, int> duo;
#define TT template<typename T>
#define TTF template<typename T, typename F>
#define ET(T) typename T::value_type
TT inline T sq(T x){return x*x;}
TT inline T In(){T x;cin>>x;return x;}
TT inline void Out(T&x){cout<<x;}
TT inline void sort(T&v){sort(begin(v),end(v));}
TT inline void revs(T&v){reverse(begin(v),end(v));}
TT inline void uniq(T&v){sort(v);v.erase(unique(begin(v),end(v)),end(v));}
TT inline int ubnd(T&v,ET(T)&x){return upper_bound(begin(v),end(v),x)-begin(v);}
TT inline int lbnd(T&v,ET(T)&x){return lower_bound(begin(v),end(v),x)-begin(v);}
TTF inline void inpt(T&v,int n,F f){for(v.reserve(n);n--;v.emplace_back(f()));}
TTF inline void show(T&v,F f,string d=" ",string e="\n"){int i=0;for(auto&x:v)i++&&(cout<<d),f(x);cout<<e;}
#undef TT
#undef TTF
#undef ET
inline void fast_io(){ios::sync_with_stdio(0);cin.tie(0);}
inline int in(){int x;scanf("%d",&x);return x;}
inline ll pow_mod(ll a,ll k,ll m){ll r=1;for(;k>0;a=a*a%m,k>>=1)if(k&1)r=r*a%m;return r;}
inline ll mod_inv(ll a,ll p){return pow_mod(a,p-2,p);}
const int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
const int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
const int Mod = 1000000000;
struct Edge {
int f, t, c;
Edge(int f, int t, int c) : f(f), t(t), c(c) {}
bool operator<(const Edge& e) const { return c != e.c ? c > e.c : (f != e.f ? f < e.f : t < e.t); }
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
int dijkstra(const Graph& g, int s, int t){
int vis[128];
fill(begin(vis), end(vis), 0);
priority_queue<Edge> pq;
for (pq.push(Edge(-2, s, 0)); !pq.empty(); pq.pop()){
Edge e = pq.top();
if (vis[e.t]++) continue;
if (e.t == t) return e.c;
for (const auto& ee : g[e.t]){
pq.push(Edge(e.f, ee.t, e.c + ee.c));
}
}
return -1;
}
int main()
{
int n, k;
while (cin >> n >> k, n || k){
Graph g(n + 1);
for (int i = 0; i < k; i++){
int t = in();
if (t){
int a, b, c;
cin >> a >> b >> c;
g[a].push_back(Edge(a, b, c));
g[b].push_back(Edge(b, a, c));
}
else {
int a, b;
cin >> a >> b;
cout << dijkstra(g, a, b) << endl;
}
}
}
return (0);
}
// priority_queue queue deque front stringstream max_element min_element insert count make_tuple | 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
const ll INF=1001001001001001;
struct Sieve {
int n;
vector<int> f, primes;
Sieve(int n=1):n(n), f(n+1) {
f[0] = f[1] = -1;
for (ll i = 2; i <= n; ++i) {
if (f[i]) continue;
primes.push_back(i);
f[i] = i;
for (ll j = i*i; j <= n; j += i) {
if (!f[j]) f[j] = i;
}
}
}
bool isPrime(int x) { return f[x] == x;}
vector<int> factorList(int x) {
vector<int> res;
while (x != 1) {
res.push_back(f[x]);
x /= f[x];
}
return res;
}
vector<P> factor(int x) {
vector<int> fl = factorList(x);
if (fl.size() == 0) return {};
vector<P> res(1, P(fl[0], 0));
for (int p : fl) {
if (res.back().first == p) {
res.back().second++;
} else {
res.emplace_back(p, 1);
}
}
return res;
}
};
int main() {
ll n;
cin>>n;
Sieve sv(55555);
vector<int> v;
v=sv.primes;
ll now=0;
vector<ll>A;
rep(i,v.size()){
if (v[i]%10==1) {
now++;
A.push_back(v[i]);
}
}
rep(i,n){
cout<<A[i]<<' ';
}
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define repr(i,n) for(int i = (int)(n); i >= 0; i--)
#define all(v) v.begin(),v.end()
typedef long long ll;
int main(){
int N;
cin >> N;
vector<bool> vec(55555);
vec[1] = false;
for (int i = 2; i <= 55554; i++){
vec[i] = true;
}
for(int i = 2; i <= 55554; i++){
if (vec[i]){
for (int j = 2; j * i <= 55554; j++){
vec[i * j] = false;
}
}
}
vector<int> ans(0);
for (int i = 1; i <= 55551; i += 5){
if (vec[i]) ans.push_back(i);
}
rep(i,N){
cout << ans[i] << " ";
}
cout << endl;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#include "debug.h"
#else
#define dump(...)
#endif
#define endl "\n"
#define ll long long
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define INF 2147483647
#define LLINF 9223372036854775807LL
#define vi vector<int>
#define vvi vector<vector<int>>
#define pi pair<int, int>
#define ALL(a) (a).begin(), (a).end()
#define BIT(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end()) //sortしてからつかうこと
constexpr ll MOD = 1e9 + 7;
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1};
int dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
ll A, B, C, D, E, F, G, H, N, M, L, K, P, Q, R, W, X, Y, Z;
string S, T;
ll ans = 0;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
signed main() {
string a, b, c;
cin >> a >> b >> c;
if (a.back() == b.front() && b.back() == c.front()) {
cout << "YES" << endl;
} else
cout << "NO" << endl;
} | #include <stdio.h>
int main () {
char a[12];
char b[12];
char c[12];
int lenA = 0, lenB = 0;
scanf("%s", a);
scanf("%s", b);
scanf("%s", c);
for(int i = 0; a[i] != '\0'; i++) {
lenA++;
}
for(int i = 0; b[i] != '\0'; i++) {
lenB++;
}
if (a[lenA-1] == b [0] && b[lenB-1] == c[0]) {
printf("YES\n");
}
else {
printf("NO\n");
}
return 0;
} | 1 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;
#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define BW(a,x,b) ((a)<=(x)&&(x)<=(b))
#define ALL(v) (v).begin(), (v).end()
#define LENGTHOF(x) (sizeof(x) / sizeof(*(x)))
#define AFILL(a, b) fill((int*)a, (int*)(a + LENGTHOF(a)), b)
#define MP make_pair
#define PB push_back
#define F first
#define S second
#define INF 1 << 30
#define EPS 1e-10
#define MAX_N 100
typedef pair<int, int> P;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;
struct edge{ int to, cost; };
vector<vector<edge> >G(MAX_N);
int n;
int d[MAX_N];
void dijkstra(int s){
priority_queue<P, vector<P>, greater<P> >q;
fill(d, d + n, INF);
d[s] = 0;
q.push(P(0, s));
while(!q.empty()){
P p = q.top(); q.pop();
int v = p.S;
if(d[v] < p.F) continue;
rep(i, G[v].size()){
edge e = G[v][i];
if(d[e.to] > d[v] + e.cost){
d[e.to] = d[v] + e.cost;
q.push(P(d[e.to], e.to));
}
}
}
}
int main(){
int k;
while(scanf("%d%d", &n, &k) && n+k){
rep(i, MAX_N) G[i].clear();
int a, b, c;
rep(i, k){
scanf("%d", &a);
if(a){
scanf("%d%d%d", &a, &b, &c); b--; a--;
edge e;
e.to = b; e.cost = c;
G[a].PB(e);
e.to = a;
G[b].PB(e);
}else{
scanf("%d%d", &a, &b); a--; b--;
dijkstra(a);
printf("%d\n", d[b]==INF?-1:d[b]);
}
}
}
return 0;
} | #include <bits/stdc++.h>
using ll = long long int;
using P = std::pair<int, int>;
#define rep(i, n) for (int i = 1; i <= (n); ++i)
#define rag(con) std::begin(con), std::end(con)
constexpr int MAX = 1010;
std::vector<int> to[MAX];
int main()
{
int n, m;
std::cin >> n >> m;
rep(i, m)
{
int a, b;
std::cin >> a >> b;
to[a].push_back(b);
}
std::vector<int> ans(n + 1);
constexpr int INF = 1e9;
rep(i, n)
{
std::queue<int> que;
std::vector<int> dis(n + 1, INF);
std::vector<int> par(n + 1);
que.push(i);
dis[i] = 0;
while (!que.empty())
{
int x = que.front();
que.pop();
for (auto u : to[x])
{
if (dis[u] > dis[x] + 1)
{
dis[u] = dis[x] + 1;
par[u] = x;
que.push(u);
}
else if (dis[u] == 0)
par[u] = x;
}
}
if (!par[i])
continue;
int v = par[i];
std::vector<int> vec;
while (v != i)
{
vec.push_back(v);
v = par[v];
}
vec.push_back(i);
if (ans.size() > vec.size())
ans = vec;
}
if (ans.size() == n + 1)
std::cout << -1 << std::endl;
else
{
std::cout << ans.size() << std::endl;
for (auto x : ans)
std::cout << x << std::endl;
}
return 0;
} | 0 |
#include <cstdio>
typedef long long ll;
template<class T> inline T Abs(const T x){return x>=0?x:-x;}
template<class T> inline T Min(const T a,const T b){return a<b?a:b;}
int n,m,x,y;
ll AT,f[200005],f1[200005],f2[200005],Ans;
const ll Inf=1e18;
void Add1(int x,ll k){for(;x<=n&&k<f1[x];x+=x&-x)f1[x]=k;}
ll Query1(int x,ll k=Inf){for(;x;x^=x&-x)k=Min(k,f1[x]);return k;}
void Add2(int x,ll k){for(;x&&k<f2[x];x^=x&-x)f2[x]=k;}
ll Query2(int x,ll k=Inf){for(;x<=n;x+=x&-x)k=Min(k,f2[x]);return k;}
int main()
{
scanf("%d%d%d%d",&n,&m,&x,&y),Ans=Inf;
for(int i=1;i<=n;++i)f[i]=f1[i]=f2[i]=Inf;
for(f[y]=0,Add1(y,-y),Add2(y,y);m--;)
{
y=x,scanf("%d",&x);
ll v=Min(Query1(x)+x,Query2(x)-x)+AT;
AT+=Abs(x-y);
if(v-AT<f[y])f[y]=v-AT,Add1(y,f[y]-y),Add2(y,f[y]+y);
}
for(int i=1;i<=n;++i)Ans=Min(Ans,f[i]);
return printf("%lld\n",Ans+AT),0;
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <sstream>
#include <functional>
#include <map>
#include <string>
#include <cstring>
#include <vector>
#include <queue>
#include <stack>
#include <deque>
#include <set>
#include <list>
#include <numeric>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll,ll> P;
const double PI = 3.14159265358979323846;
const double EPS = 1e-12;
const ll INF = 1LL<<29;
const ll mod = 1e9+7;
#define rep(i,n) for(int (i)=0;(i)<(ll)(n);++(i))
#define repd(i,n,d) for(ll (i)=0;(i)<(ll)(n);(i)+=(d))
#define all(v) (v).begin(), (v).end()
#define pb(x) push_back(x)
#define mp(x,y) make_pair((x),(y))
#define mset(m,v) memset((m),(v),sizeof(m))
#define chmin(x,y) (x=min(x,y))
#define chmax(x,y) (x=max(x,y))
#define fst first
#define snd second
#define UNIQUE(x) (x).erase(unique(all(x)),(x).end())
template<class T> ostream &operator<<(ostream &os, const vector<T> &v){int n=v.size();rep(i,n)os<<v[i]<<(i==n-1?"":" ");return os;}
#define N 200010
ll n, q, c, x[N];
set<P> dp[2];
int main(){
cin>>n>>q>>x[0]>>c;
rep(i, q) cin>>x[i+1];
dp[0].insert(P(c, 0));
for(int i = 1; i <= q; i++){
int t = i%2;
dp[t].clear();
for(auto p: dp[!t]){
dp[t].insert(P(x[i-1], p.snd+abs(x[i]-p.fst)));
dp[t].insert(P(p.fst, p.snd+abs(x[i]-x[i-1])));
}
{
auto it = dp[t].begin(), it2 = it; ++it2;
while(it2!=dp[t].end()){
while(it2!=dp[t].end() && it->snd+abs(it->fst-it2->fst)<=it2->snd){
dp[t].erase(it2);
it2 = it;
++it2;
}
++it;
if(it2!=dp[t].end()) ++it2;
}
}
{
auto it = dp[t].end();
if(it!=dp[t].begin()) --it;
auto it2 = it;
if(it!=dp[t].begin()) --it2;
while(it!=dp[t].begin()){
while(it!=dp[t].begin() && it->snd+abs(it->fst-it2->fst)<=it2->snd){
dp[t].erase(it2);
it2 = it;
if(it2!=dp[t].begin()) --it2;
}
if(it!=dp[t].begin()){
--it;
if(it2!=dp[t].begin()) --it2;
}
}
}
}
ll res = 1e17;
for(auto p: dp[q%2]) res = min(res, p.snd);
cout<<res<<endl;
return 0;
}
| 1 |
#include<iostream>
#include<iomanip>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<string>
#include<utility>
#include<numeric>
#include<algorithm>
#include<cmath>
#include<climits>
using namespace std;
using ll = long long;
class Stream{
public:
Stream(){
}
//配列以外の入力を受け取る
void read(){
}
template<typename First, typename... Rest>
void read(First& first, Rest&... rest){
cin >> first;
read(rest...);
}
//配列を区切って出力する
template<typename T>
void write_vec(vector<T>& v, char divider){
for(size_t i = 0; i < v.size(); i++){
cout << v[i] << divider;
}
}
};
int main(){
Stream io;
string S;
io.read(S);
string ans = "AC";
if(S[0] != 'A') ans = "WA";
int c = 0;
for(int i = 1; i < S.size(); i++){
if(!(S[i] <= 'z' && S[i] >= 'a')){
if(i <= S.size() - 2 && i >= 2){
c++;
}
else ans = "WA";
}
}
if(c != 1) ans = "WA";
cout << ans;
return 0;
} | #include<cstdio>
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(void) {
string S;
cin >> S;
int alfabet[26] = {0};
for (int i = 0; i < S.length(); i++) {
alfabet[S[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (alfabet[i] == 0) {
printf("%c\n", 'a' + i);
return 0;
}
}
printf("None\n");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
static const ll MOD = 998244353;
static const int MAX = 500000+100;
ll fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll COM(ll n, ll k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
ll ModPow(ll a, ll cur=MOD-2) {
ll r=1;
while(cur) r=r*((cur%2)?a:1)%MOD,a=a*a%MOD,cur>>=1;
return r;
}
int main(){
ll N,M,K;
cin>>N>>M>>K;
/*
先頭の選び方がM
iが[0,K]で、
先頭と同じ色のブロックの選び方はcomb(N-1,i)
残りのブロックの色の選び方はM^(N-1-i);
*/
ll ans = 0;
COMinit();
for(int i=0; i<=K; i++){
ans += M*COM(N-1,i)%MOD*ModPow(M-1,N-1-i)%MOD;
}
cout<<ans%MOD<<endl;
return 0;
} |
#include <bitset>
#include <tuple>
#include <string>
#include <array>
#include <deque>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
#include <cstdio>
#include <cmath>
#ifdef LOCAL
#include <iostream>
#endif
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
typedef long long ll;
#ifdef LOCAL
#define debug_echo(e) cout << "L" << __LINE__ << ": " << e << "\n"
#define debug_repr(e) cout << "L" << __LINE__ << ": " << #e << " -> " << e << "\n"
#else
#define debug_echo(e)
#define debug_repr(e)
#endif
#define defread(T, fmt) \
inline T read_ ## T() { \
T result; \
scanf(fmt, &result); \
return result; \
}
defread(int, "%d")
defread(ll, "%lld")
defread(float, "%f")
defread(double, "%lf")
int gcd(int m, int n) {
if ((0 == m) || (0 == n)) return 0;
while (m != n) {
if (m > n) m -= n;
else n -= m;
}
return m;
}
int lcm(int m, int n) {
if ((0 == m) || (0 == n)) return 0;
return (m / gcd(m, n)) * n;
}
int main() {
vector<int> a(4);
vector<int> b(2);
a[0] = read_int();
a[1] = read_int();
a[2] = read_int();
a[3] = read_int();
b[0] = read_int();
b[1] = read_int();
sort(all(a));
sort(all(b));
printf("%d\n", a[1] + a[2] + a[3] + b[1]);
} | 0 |
#include<iostream>
#include<cmath>
using namespace std;
typedef long long int LL;
LL base[25];
LL check(LL a,int n,int k){
if(n==0){
if(a==0)return 10;
else return 0;
}
if(n<0){
if(a==0)return 1;
else return 0;
}
LL b,c,d;
LL t;
t=base[n];
for(int i=0;i<k;i++)t*=10;
b=(a+t*15)/t-15;
c=0;
if(-9<=b && b<=9){
d=10-abs(b);
if(k==0 && b>=0)d--;
c=check(a-b*t,n-2,k+1)*d;
}
if(-9<=b+1 && b+1<=9){
d=10-abs(b+1);
if(k==0 && b+1>=0)d--;
c+=check(a-(b+1)*t,n-2,k+1)*d;
}
return c;
}
int main(){
LL a,b,c;
LL s=0;
int i,j,k;
for(i=1,a=1;i<=20;i++){
a*=10;
base[i]=a-1;
}
cin>>a;
for(i=20;i>0;i--){
s+=check(a,i,0);
}
cout<<s<<endl;
}
| #include <bits/stdc++.h>
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 = (ll)(n)-1; i >= 0; i--)
#define FOR(i, a, b) for (ll i = (a); i <= (b); i++)
#define FORD(i, a, b) for (ll i = (a); i >= (b); i--)
#define ALL(x) (x).begin(), (x).end()
#define SIZE(x) ((ll)(x).size())
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define INF 1000000000000
#define MOD 1000000007
#define PB push_back
#define MP make_pair
#define F first
#define S second
void solve() {
ll N, A, B, dist = 0;
cin >> N >> A >> B;
vector<ll> X(N);
REP(i, N) { cin >> X[i]; }
sort(ALL(X));
FOR(i, 0, N - 1 - 1) {
if ((X[i + 1] - X[i]) * A < B) {
dist += (X[i + 1] - X[i]) * A;
} else {
dist += B;
}
}
cout << dist << endl;
}
signed main() {
solve();
return 0;
} | 0 |
#include<iostream>
using namespace std;
int main(){
int n, x, y, pt1, pt2;
while(cin >> n){
pt1 = 0;
pt2 = 0;
if(n == 0) break;
for(int i=0; i<n; i++){
cin >> x >> y;
if(x > y) pt1 += x + y;
else if(x < y) pt2 += x + y;
else {
pt1 += x;
pt2 += y;
}
}
cout << pt1 << " " << pt2 << endl;
}
return 0;
} | #include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <complex>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)n;++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
int ba[12][12];
int dx[] = {1,0,-1,0};
int dy[] = {0,-1,0,1};
void dfs(int x,int y) {
REP(i,4) {
int xx = x+dx[i];
int yy = y+dy[i];
if (xx<0||xx>=12||yy<0||yy>=12) continue;
if (ba[xx][yy]) {
ba[xx][yy] = 0;
dfs(xx,yy);
}
}
}
int main() {
char b;
while(cin >> b) {
ba[0][0] = b-'0';
REP(i,12) {
REP(j,12) {
if (i==0&&j==0)continue;
char a;
cin >> a;
ba[j][i] = a-'0';
}
}
int ans = 0;
REP(i,12) {
REP(j,12) {
if (ba[i][j]) {
ans++;
dfs(i,j);
}
}
}
cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
#include <climits>
#include <cmath>
#include <iomanip>
#include <math.h>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
//#define local
#ifdef local
#include "dbg-macro/dbg.h"
#endif
//#define hacks
#ifdef hacks
#include <boost/multiprecision/cpp_int.hpp>
#endif
#define p std::pair
#define ll long long
#define ld long double
#define ull unsigned long long
#define pi std::pair<int, int>
#define stdabs std::abs
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (unsigned long long i = 0; i < (unsigned long long)(n); ++i)
#define vec std::vector
#define oreq |=
#define npm next_permutation
using namespace std;
std::vector<unsigned ll> genprimevec(const unsigned ll N);
ll extgcd(ll a, ll b, ll& x, ll& y);
ll nCr(ll n, ll r);
void stat();
template <typename T> T fact(T num);
constexpr ll mod = 1000000000 + 7;
int main()
{
stat();
ll n, k;
cin >> n >> k;
vec<ll> v(n);
rep(i, n) { cin >> v[i]; }
vec< double> kitai(n);
rep(i, n) { kitai[i] = (double)((v[i]+1.0) / 2.0); }
#ifdef local
dbg(kitai);
#endif
double ans = 0.0, t=0.0;
rep(i, k) { t += kitai[i]; }
ans=t;
#ifdef local
dbg(ans);
#endif
rep(i, n - k + 1)
{
if (i == 0) { continue; }
t = (double)(t+ kitai[i + k-1] - kitai[i - 1]);
#ifdef local
dbg(t);
dbg(i,kitai[i+k-1],kitai[i-1]);
#endif
ans = max(ans, t);
}
cout <<std::fixed<<std::setprecision(10)<< ans << endl;
return 0;
}
ll extgcd(ll a, ll b, ll& x, ll& y)
{
if (b == 0) {
x = 1, y = 0;
return a;
}
ll d = extgcd(b, a % b, y, x);
y -= a / b * x;
return d;
}
std::vector<unsigned ll> genprimevec(const unsigned ll N)
{
std::vector<bool> is_prime(N + 1);
for (unsigned ll i = 0; i <= N; i++) {
is_prime[i] = true;
}
std::vector<unsigned ll> P;
for (unsigned ll i = 2; i <= N; i++) {
if (is_prime[i]) {
for (unsigned ll j = 2 * i; j <= N; j += i) {
is_prime[j] = false;
}
P.emplace_back(i);
}
}
return P;
}
void stat(){
#ifdef local
rep(i, 2){std::cout << "local enable" << std::endl;
}
#endif
#ifdef hacks
rep(i, 2) { std::cout << "boost enable" << std::endl; }
#endif
}
ll nCr(ll n, ll r)
{
ll num = 1;
for (ll i = 1; i <= r; i++) {
num = num * (n - i + 1) / i;
}
return num;
}
template <typename T> T fact(T num)
{
if (num == 1) { return 1; }
return num * fact(num - 1);
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < int(n); i++)
using namespace std;
using ll = long long;
const int INF = (1<<30)-1;
const long long LINF = (1LL<<62)-1;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
rep(i, n) cin >> a[i];
for (int i = 0; i < k && i*i < n; i++) {
vector<int> imos(n+1);
rep(j, n) {
imos[max(j-a[j], 0)]++;
imos[min(j+a[j]+1, n)]--;
}
rep(j, n)
imos[j+1] += imos[j];
a = imos;
}
rep(i, n) {
if (i)
cout << ' ';
cout << a[i];
}
cout << endl;
return 0;
} | 0 |
#include<iostream>
#include<algorithm>
#include<math.h>
#include<vector>
#include<map>
#include<set>
#include<iomanip>
using namespace std;
using ll = long long;
const int MOD = 1e9 + 7;
const int INF = numeric_limits<int>::max();
const ll LLINF = numeric_limits<ll>::max();
const double PI = acos(-1.0);
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, a, n) for (int i = a; i <= (n); ++i)
int main() {
int A, B; cin >> A >> B;
if (A > 8 || B > 8) cout << ":(" << endl;
else cout << "Yay!" << endl;
return 0;
}
| #include <iostream>
#include <vector>
#include <algorithm>
#include <stack>
#include <map>
#include <tuple>
#include <cmath>
#include <cstdio>
#include <cassert>
#include <functional>
#define _LIBCPP_DEBUG 0
using namespace std;
int main(void){
int l,r;
cin >> l >> r;
int mi=2018*2018;
for (int i = l; i<r; i++)
{
int L=i%2019;
for (int j = i+1; j <= r; j++)
{
int R=j%2019;
int ama=(L*R)%2019;
if (ama<mi)
{
mi=ama;
if (mi==0)
{
cout << 0 << endl;
return 0;
}
}
}
}
cout << mi << endl;
}
| 0 |
#include <string>
#include <math.h>
#include <iostream>
using namespace std;
int main()
{
int n;
cin >> n;
int x = n - 2;
cout << 180 * x;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for(ll i=0; i<n; i++)
#define repr(i, s, e) for(ll i=s; i>=e; i--)
#define reps(i, s, e) for(ll i=s; i<=e; i++)
#define inf 1e18
#define all(v) v.begin(),v.end()
#define ceil(a, b) (a+b-1)/b
#define ok cout << "ok" << endl;
#define sp << " " <<
template<typename T> inline bool chmax(T &a, T b){ if(a<b) a=b; return a<b; }
template<typename T> inline bool chmin(T &a, T b){ if(b<a) a=b; return b<a; }
template<typename T> void vdeb(T v){
cout << "#vector set debug" << endl;
for(auto vv : v) cout << vv << " ";
cout << endl;
}
template<typename T1, typename T2> void adeb(T1 arr[], T2 n){
cout << "#adebug" << endl;
for(int i=0; i<=n; i++) cout << arr[i] << " ";
cout << endl;
}
template<typename T1> void mdeb(T1 mp){
cout << "#map pair debug" << endl;
for(auto const& m : mp) cout << m.first sp m.second << endl;
}
template<typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val){ fill((T*)array, (T*)(array+N), val); }
void ans(bool b){ cout << (b ? "Yes" : "No") << endl; }
void ans2(bool b){ cout << (b ? "YES" : "NO") << endl; }
int dx[] = {1, 0, -1, 0, 1, -1, 1, -1};
int dy[] = {0, 1, 0, -1, 1, -1, -1, 1};
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
cout << (n-3)*180 + 180 << endl;
return 0;
}
| 1 |
#include <iostream>
using namespace std;
void MySwap(int &a, int &b){
int tmp = a;
a = b;
b = tmp;
}
int partition(int *A, int p, int r){
int x = A[r];
int i = p - 1;
for(int j = p; j < r; j++){
if(A[j] <= x){
MySwap(A[++i], A[j]);
}
}
MySwap(A[++i], A[r]);
return i;
}
int main(){
int A[100000], n, place;
cin >> n;
for(int i = 0; i < n; i++) cin >> A[i];
place = partition(A, 0, n-1);
for(int i = 0; i < n; i++)
cout << (i==place?"[":"") << A[i] << (i==place?"]":"") << (i==n-1?'\n':' ');
return 0;
}
| #include<vector>
#include<list>
#include<algorithm>
#include<iostream>
#include<string>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
using namespace std;
int main(){
int h,i;
int a[10],b[10];
for(i=0;i<10;i++)
cin>>a[i];
for(i=0;i<10;i++)
cin>>b[i];
do{
h=0;
for(i=1;i<10;i++){
if(a[i-1]<a[i]){
swap(a[i-1],a[i]);
h=1;
}
}
}while(h);
do{
h=0;
for(i=1;i<10;i++){
if(b[i-1]<b[i]){
swap(b[i-1],b[i]);
h=1;
}
}
}while(h);
cout<<a[0]+a[1]+a[2]<<" "<<b[0]+b[1]+b[2]<<endl;
return 0;
} | 0 |
#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
//C++11
#if __cplusplus == 201103L
#include <tuple>
#endif
using namespace std;
#define FOR(i,k,n) for(int i=(k); i<(int)n; ++i)
#define REP(i,n) FOR(i,0,n)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
template<class T> void debug(T begin, T end){ for(T i = begin; i != end; ++i) cout<<*i<<" "; cout<<endl; }
typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
int main(){
string s;
map<char, int> m;
m['J'] = 0;
m['O'] = 1;
m['I'] = 2;
while(cin>>s){
s = "I" + s;
int N = s.size();
int cnt[3]={};
int ans = 0;
for(int i = 1; i < N; i++){
int n = m[s[i]];
int b = m[s[i-1]];
if(n < b){
REP(i, 3) cnt[i] = 0;
if(n == 0) cnt[0]++;
}else{
cnt[n]++;
if(cnt[0]>=cnt[1]&&cnt[1]==cnt[2]) ans = max(ans, cnt[1]);
}
}
cout<<ans<<endl;
}
return 0;
} | #include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class T>
using Table = vector<vector<T>>;
const ld eps=1e-9;
//// < "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Download\Visual Studio 2015\Projects\programing_contest_c++\Debug\b.answer"
int main() {
string st; cin >> st;
int ans = 0;
for (int l = 0; l < st.size(); ++l) {
if (st[l] == 'O') {
int r = l;
while (r!=st.size()&&st[r] == 'O') {
r++;
}
int len = r - l;
if (l - len >= 0 && r + len <= st.size()) {
bool ok = true;
for (int t = 0; t < len; ++t) {
if (st[l - t - 1] != 'J')ok = false;
if (st[r + t] != 'I')ok = false;
}
if (ok)ans = max(ans, len);
}
l += len - 1;
}
}
cout << ans << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
vector<pair<int,pair<int,int>>>v;
for(int i=1;i<150;++i){
for(int j=i+1;j<=150;++j){
v.push_back(make_pair(i*i+j*j,make_pair(i,j)));
}
}
sort(v.begin(),v.end());
int h,w;
while(cin>>h>>w,h){
int a=h*h+w*w;
bool flag=0;
for(auto x:v){
if(flag){
cout<<x.second.first<<" "<<x.second.second<<endl;
break;
}
if(x.first==a && x.second.first==h){
flag=1;
}
}
}
} | #include <iostream>
#include <iomanip>
#include <cassert>
#include <algorithm>
#include <functional>
#include <vector>
#include <string>
#include <cstring>
#include <stack>
#include <queue>
#include <map>
#include <bitset>
#include <sstream>
#include <istream>
#include <cmath>
#include <cstdio>
using namespace std;
#define vci vector<int>
#define vcs vector<string>
#define pb push_back
#define sz size()
#define mapii map<int, int>
#define mapci map<char, int>
#define mapsi map<string, int>
#define all(x) x.begin(), x.end()
#define minit(a, i) memset(a, i, sizeof(a));
#define for_(i, a, b) for (int i=(int)a; i<(int)b; i++)
#define for_d(i, a, b) for (int i=(int)a-1; i>=b; i--)
#define for_r(i, a, b, c) for (int i=(int)a; i<(int)b; i += c)
#define for_dr(i, a, b, c) for (int i=(int)a-1; i>=b; i -= c)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
typedef long long ll;
const int iINF = 2147483647;
const ll lINF = 9223372036854775807;
template <class T> inline void dbg(T t) { cout << t << endl; }
string ret[7] = {"null", "one pair", "two pair", "three card", "straight", "full house", "four card"};
int main() {
vci t(5); char c;
while (cin>>t[0]>>c>>t[1]>>c>>t[2]>>c>>t[3]>>c>>t[4]) {
int ans = 0;
vci v(13, 0);
for_(i, 0, (int)t.sz) v[t[i]-1]++;
int cnt = 0;
// 0, 1, 2
for_(i, 0, 13) if (v[i]==2) cnt++;
ans = cnt;
// 3
cnt = 0;
for_(i, 0, 13) if (v[i]==3) cnt++;
if (cnt) ans = 3;
// 4
for_(i, 0, 10) {
cnt = 0;
for_(j, 0, 5) {
if (v[(i+j)%13]==1) cnt++;
}
if (cnt==5) ans = 4;
}
// 5
cnt = 0; int cnt2 = 0;
for_(i, 0, 13) {
if (v[i]==2) cnt++;
if (v[i]==3) cnt2++;
}
if (cnt2==1 && cnt==1) ans = 5;
cnt = 0;
for_(i, 0, 13) if (v[i]==4) cnt++;
if (cnt) ans = 6;
cout << ret[ans] << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,N) for(int i=0;i<int(N);++i)
#define rep1(i,N) for(int i=1;i<int(N);++i)
#define all(a) (a).begin(),(a).end()
#define print(v) { cerr<<#v<<": [ "; for(auto _ : v) cerr<<_<<", "; cerr<<"]"<<endl; }
#define printpair(v) { cerr<<#v<<": [ "; for(auto _ : v) cerr<<"{"<<_.first<<","<<_.second<<"}"<<", "; cerr<<"]"<<endl; }
#define dump(x) cerr<<#x<<": "<<x<<endl;
#define bit(k) (1LL<<(k))
#define Yes "Yes"
#define No "No"
#define YES "YES"
#define NO "NO"
typedef long long ll;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vec<T>>;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
const int INF = (ll)1e9;
const ll INFLL = (ll)1e18+1;
const ll MOD = (ll)1e9+7;
const double PI = acos(-1.0);
/*
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const string dir = "DRUL";
*/
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
int M;
cin >> M;
vec<ll> d(M), c(M);
rep(i,M){
cin >> d[i] >> c[i];
}
ll sumdc = 0;
ll sumc = 0;
ll ans = 0;
rep(i,M){
sumdc += d[i] * c[i];
sumc += c[i];
}
ans = sumc - 1 + (sumdc - 1)/9;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
using ll = long long;
using P = pair<int,int>;
using graph = vector<vector<int>>;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const ll INF = 1LL<<60;
const ll mod = 1000000007LL;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main(){
vector<vector<P>> v(10);
rep(i,10){
v[i].push_back(make_pair(0,0));
v[i].push_back(make_pair(0,i));
}
rep(i,10){
while(true){
P p = *v[i].rbegin();
int t = i*10 + p.second;
int cnt = 0;
while(t>=10){
t = t/10+t%10;
cnt++;
}
v[i].push_back(make_pair(p.first+cnt,t));
if(t==i) break;
}
}
v[0][2].first = 1;
ll M;
cin>>M;
vector<ll> d(M),c(M);
rep(i,M) cin>>d[i]>>c[i];
ll ans = 0;
vector<ll> rest(M);
rep(i,M){
ll t = d[i],s=c[i];
ll l = v[t].size();
ans+=v[t][l-1].first*((s-1)/(l-2));
s = s - ((s-1)/(l-2))*(l-2);
ans += v[t][s].first;
rest[i]=v[t][s].second;
}
ll cnt = 0;
while(cnt!=M-1){
while(rest[cnt]!=0){
ll a = rest[cnt],b=rest[cnt+1];
rest[cnt] = (a+b)/10;
rest[cnt+1] = (a+b)%10;
ans++;
}
cnt++;
}
cout<<ans<<endl;
} | 1 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); i++)
using namespace std;
using ll = long long;
int main(){
int a,b,c;
cin >>a >>b >>c;
int M = max(a,b);
int m = min(a,b);
if(M>=c && m<=c) cout << "Yes" << endl;
else cout << "No" << endl;
return 0;
} | #include <algorithm>
#include <functional>
#include <iostream>
#include <string>
using namespace std;
int main()
{
int A, B;
string S;
cin >> A >> B;
cin >> S;
// 文字列の長さがA+B+1か判定
if (S.size() != A + B + 1) {
// cout << "文字列の長さが" << S.size() << "です。\n";
cout << "No\n";
return 0;
}
// -がA番目にあるか判定(文字列は0からスタート)
if (S.find('-') != A) {
// cout << "-(ハイフン)は" << S.find('-') << "番目にあります。\n";
cout << "No\n";
return 0;
}
// A+1番目の文字以外が0から9であるか判定
for (int i = 0; i < S.size(); i++) {
// cout << "S[" << i << "]は" << S[i] << "です。\n";
if (i == A) {
continue;
}
if (S[i] > '9' || S[i] < '0') {
// cout << "0-9以外の文字が含まれています。\n";
cout << "No\n";
return 0;
}
}
cout << "Yes\n";
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
void computeLPSArray(string pattern, int m, int lps[]){
int len=0;
lps[0]=0; //lps[0] is always 0
int i=1;
while(i<m){
if(pattern[i]==pattern[len]){
len++;
lps[i]=len;
i++;
}else{
if(len!=0)
len=lps[len-1];
else{
lps[i]=0;
i++;
}
}
}
}
void kmpSearch(string str,string pattern){
int m=pattern.length();
int n=str.length();
int lps[m]; //longest prefix suffix array
computeLPSArray(pattern,m,lps);
int i=0; //text
int j=0; //pattern
bool found=0;
while(i<n){
if(pattern[j]==str[i]){
i++;
j++;
}
if(j==m){
j=lps[j-1];
found=1;
break;
}else if(i<n && pattern[j]!=str[i]){
if(j!=0) j=lps[j-1];
else i=i+1;
}
}
if(!found)cout<<"No"<<endl;
else cout<<"Yes"<<endl;
}
int main(){
//freopen("input.txt","r",stdin);
//freopen("output.txt","w",stdout);
string str,pattern;
while(cin>>str){
pattern="AC";
kmpSearch(str,pattern);
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
string s; cin >> s;
cout << ((s.find("AC") != string::npos) ? "Yes" : "No") << endl;
}
| 1 |
#define task "test"
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair <int, int> ii;
typedef pair <ll, ll> pll;
#define pb push_back
#define mp make_pair
#define X first
#define Y second
const ll LINF = 1E18;
const int INF = 1E9;
const int MOD = 1E9 + 7;
const int N = 2E5 + 5;
int t = 1;
int n, m, nump[N], pa[N];
bool avail[N];
vector <int> A[N];
set <ii> S[N];
void Input()
{
cin >> n >> m;
for (int i = 1; i <= n + m - 1; i++) {
int u, v;
scanf("%d%d", &u, &v);
A[u].pb(v);
nump[v]++;
}
}
void Prepare()
{
/*for (int u = 1; u <= n; u++) {
for (int v : A[u]) S[u].insert({nump[v], v});
}*/
}
void DFS(int u, int p)
{
pa[u] = p;
avail[u] = 0;
for (int v : A[u]) if (v != p) {
nump[v]--;
}
for (int v : A[u]) if (v != p && avail[v] && !nump[v]) DFS(v, u);
}
void Solve()
{
int root = 0;
for (int i = 1; i <= n; i++) if (!nump[i]) root = i;
memset(avail, 1, sizeof(avail));
DFS(root, 0);
for (int i = 1; i <= n; i++) printf("%d\n", pa[i]);
}
int main()
{
if (fopen(task ".inp","r")){
freopen(task ".inp","r",stdin);
freopen(task ".out","w",stdout);
}
// cin >> t;
while (t--) {
Input();
Prepare();
Solve();
}
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, N) for (int i = 0; i < (int)N; i++)
#define FOR(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define INF (1 << 30)
#define LLINF (1LL << 62)
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
constexpr int MOD = 1000000007;
using ll = long long;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;
template <class T>
string to_string(T s);
template <class S, class T>
string to_string(pair<S, T> p);
string to_string(string s);
template <class T>
string to_string(T v) {
if (v.empty()) return "{}";
string ret = "{";
auto itr = v.begin(), next = ++v.begin();
for (; next != v.end(); ++itr, ++next) ret += to_string(*itr) + ",";
ret += to_string(*itr) + "}";
return ret;
}
template <class S, class T>
string to_string(pair<S, T> p) {
return "{" + to_string(p.first) + "," + to_string(p.second) + "}";
}
string to_string(string s) { return s; }
void debug() { cerr << endl; }
template <class Head, class... Tail>
void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
void print() { cout << endl; }
template <class Head, class... Tail>
void print(Head head, Tail... tail) {
cout << to_string(head) << " ";
print(tail...);
}
struct IO {
#ifdef _WIN32
inline char getchar_unlocked() { return getchar(); }
inline void putchar_unlocked(char c) { putchar(c); }
#endif
string separator = " ";
template <class T>
inline void read(T &x) {
char c;
do {
c = getchar_unlocked();
} while (c != '-' && (c < '0' || '9' < c));
bool minus = 0;
if (c == '-') {
minus = 1;
c = getchar_unlocked();
}
x = 0;
while ('0' <= c && c <= '9') {
x *= 10;
x += c - '0';
c = getchar_unlocked();
}
if (minus) x = -x;
}
inline void read(string &x) {
char c;
do {
c = getchar_unlocked();
} while (c == ' ' || c == '\n');
x.clear();
do {
x += c;
c = getchar_unlocked();
} while (c != ' ' && c != '\n' && c != EOF);
}
template <class T>
inline void read(vector<T> &v) {
for (auto &x : v) read(x);
}
template <class Head, class... Tail>
inline void read(Head &head, Tail &... tail) {
read(head);
read(tail...);
}
template <class T>
inline void write(T x) {
char buf[32];
int p = 0;
if (x < 0) {
x = -x;
putchar_unlocked('-');
}
if (x == 0) putchar_unlocked('0');
while (x > 0) {
buf[p++] = (x % 10) + '0';
x /= 10;
}
while (p) {
putchar_unlocked(buf[--p]);
}
}
inline void write(string x) {
for (char c : x) putchar_unlocked(c);
}
inline void write(const char s[]) {
for (int i = 0; s[i] != 0; ++i) putchar_unlocked(s[i]);
}
template <class T>
inline void write(vector<T> v) {
for (auto itr = v.begin(); itr + 1 != v.end(); ++itr) {
write(*itr);
write(separator);
}
write(v.back());
}
template <class Head, class... Tail>
inline void write(Head head, Tail... tail) {
write(head);
write(separator);
write(tail...);
}
void set_separator(string s) { separator = s; }
} io;
int main() {
int N, M;
io.read(N, M);
vector<vector<int>> G(N), RG(N);
REP(i, N + M - 1) {
int a, b;
io.read(a, b);
G[a - 1].push_back(b - 1);
RG[b - 1].push_back(a - 1);
}
int root = -1;
REP(i, N) if (RG[i].empty()) root = i;
vector<int> ans(N, -1);
function<void(int)> dfs = [&](int u) {
for (auto v : G[u]) {
if (ans[v] == -1) {
bool f = 1;
for (int k : RG[v])
if (ans[k] == -1 && k != root) f = 0;
if (f) {
ans[v] = u;
dfs(v);
}
}
}
};
dfs(root);
REP(i, N) {
io.write(ans[i] + 1);
io.write("\n");
}
return 0;
} | 1 |
//Name: Twin Prime
//Level: 2
//Category: 数学,素数
//Note:
/**
* 10000以下の双子素数を列挙しておけば、あとは線形探索でよい。
*
* オーダーは O(M log log M)。
* ただしMは求める必要がある最大の素数で、M=10000。
*/
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
vector<bool> eratosthenes(int N) {
vector<bool> is_prime(N+1, true);
is_prime[0] = is_prime[1] = false;
const int LIM = static_cast<int>(sqrt(N));
for(long long i = 2; i <= LIM; ++i) {
if(is_prime[i]) {
for(long long j = i*i; j <= N; j += i) {
is_prime[j] = false;
}
}
}
return is_prime;
}
bool solve(bool first) {
const static auto is_prime = eratosthenes(10000);
int N;
if(!(cin >> N)) return false;
if(!N) return false;
for(int i = N; i >= 0; --i) {
if(is_prime[i] && is_prime[i-2]) {
cout << i-2 << ' ' << i << endl;
break;
}
}
return true;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout.setf(ios::fixed);
cout.precision(10);
bool first = true;
while(solve(first)) {
first = false;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define rg register
#define rep(i,a,b) for (rg int i=(a);i<=(b);i++)
#define per(i,a,b) for (rg int i=(b);i>=(a);i--)
#define pb push_back
#define lowbit(x) (x&(-x))
#define replow(i,a,b) for(rg int i = (a);i<=(b);i+=lowbit(i))
#define perlow(i,a,b) for(rg int i = (b);i>=(a);i-=lowbit(i))
#define mk make_pair
#define VI vector<int>
#define pii pair<int,int>
#define pLL pair<long long,long long>
#define fi first
#define se second
#define il inline
#define ll long long
#define ull unsigned long long
#define db double
#define ld long double
#define inf 0x3f3f3f3f
#define getc() (p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<15,stdin),p1==p2)?EOF:*p1++)
char buf[1<<15],*p1 = buf,*p2 = buf;
inline ll read(){
#define num ch-'0'
char ch;bool flag=0;ll res;
while(!isdigit(ch=getc()))
(ch=='-')&&(flag=true);
for(res=num;isdigit(ch=getc());res=res*10ll+num);
(flag)&&(res=-res);
#undef num
return res;
}
inline void write(ll x){
if (x < 0) x = ~x + 1ll, putchar('-');
if (x > 9) write(x / 10ll);
putchar(x % 10ll + '0');
}
#define mid ((l + r)>>1)
#define ls (x<<1)
#define rs ((x<<1)|1)
#undef mid
#undef ls
#undef rs
multiset<int> s;
void solve()
{
int n = read();
int mn = 1e9 + 10;
int cnt = 0;
rep(i,1,n)
{
int x = read();
if(s.empty())
{
s.insert(x);
}
else
{
auto it = s.lower_bound(x);
if(it == s.begin())
{
s.insert(x);
}
else
{
it--;
s.erase(it);
s.insert(x);
}
}
}
printf("%d",s.size());
}
int main()
{
#ifndef ONLINE_JUDGE
freopen("data.txt","r",stdin);
#endif
// int T = read();
// while(T--)
solve();
} | 0 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
#define REP(i,n) for (int i = 1; i < (int)(n); i++)
#define all(x) x.begin(),x.end()
#define rall(x) x.rbegin(),x.rend()
#define debug(var) do{cout << #var << " : "; view(var);}while(0)
template<class T> bool chmin(T &a, T b) {if(a>b) {a=b;return 1;}return 0;}
template<class T> bool chmax(T &a, T b) {if(a<b) {a=b;return 1;}return 0;}
using namespace std;
template<class T> void view(T e) {cout << e << endl;}
template<class T> void view(const vector<T> &v) {for(const auto &e : v){cout << e << " ";} cout << endl;}
template<class T> void view(const vector<vector<T>> &vv) {for(const auto &v : vv){view(v);}}
using vint = vector<int>;
using vvint = vector<vector<int>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using P = pair<int,int>;
const int inf = 1e9;
const ll inf_l = 1e18;
const int MAX = 1e5;
vint dx = {1,0,-1,0};
vint dy = {0,1,0,-1};
int main() {
int h, w; cin >> h >> w;
vector<string> field(h);
rep(i,h) cin >> field[i];
queue<P> q;
rep(i,h)rep(j,w) if (field[i][j] == '#') q.push(P(i,j));
int ans = 0;
while (true) {
if (q.empty()) {ans--; break;}
queue<P> tmp_q;
while (!q.empty()) {
int x = q.front().second;
int y = q.front().first;
q.pop();
rep(i,4) {
int n_x = x + dx[i];
int n_y = y + dy[i];
if (n_x >= 0 && n_x < w && n_y >= 0 && n_y < h && field[n_y][n_x] != '#') {
field[n_y][n_x] = '#';
tmp_q.push(P(n_y,n_x));
}
}
}
swap(q,tmp_q);
ans++;
}
cout << ans << endl;
} | #include <iostream>
#include <vector>
#include <string>
using namespace std;
class edge;
class vertex{
public:
vector<edge*> edges;
int color;
vertex(int _color){
color = _color;
}
};
class edge{
public:
vertex *to;
edge(vertex *_to){
to = _to;
}
};
class list_node{
public:
list_node *prev,*next;
vertex *data;
list_node(list_node *_prev,list_node *_next,vertex *_data){
prev = _prev;
next = _next;
data = _data;
}
};
class list{
public:
list_node *back,*front;
list(){
back = new list_node(0,0,0);
front = new list_node(0,back,0);
back->prev = front;
}
list_node *get_first(){
return front->next;
}
list_node *get_last(){
return back->prev;
}
void push_back(vertex *data){
list_node *node = back->prev;
node->next = new list_node(node,back,data);
back->prev = node->next;
}
bool isEmpty(){
if(front->next == back) return true;
return false;
}
};
int bfs(list l){
int count = 0;
list *L = new list[10000];
L[0] = l;
while(true){
for(list_node *j = L[count].get_first(); j != L[count].back; j = j->next){
vertex *v = j->data;
for(int k = 0; k < v->edges.size(); k++){
vertex *to = v->edges[k]->to;
if(to->color) continue;
to->color = 1;
L[count+1].push_back(to);
}
}
if(L[count+1].isEmpty()) break;
count++;
}
return count;
}
int main(){
int H,W,color;
string str;
cin >> H >> W;
list l;
vertex *A[H+2][W+2];
for(int i = 0; i <= H+1; i++){
if(i != 0 && i != H+1) cin >> str;
for(int j = 0; j <= W+1; j++){
if(i == 0 || j == 0 || i == H+1|| j == W+1){
A[i][j] = new vertex(1);
}else{
if(str[j-1] == '.') color = 0;
else color = 1;
A[i][j] = new vertex(color);
}
}
}
for(int i = 1; i <= H; i++){
for(int j = 1; j <= W; j++){
if(A[i][j]->color) l.push_back(A[i][j]);
A[i][j]->edges.push_back(new edge(A[i-1][j]));
A[i][j]->edges.push_back(new edge(A[i][j+1]));
A[i][j]->edges.push_back(new edge(A[i+1][j]));
A[i][j]->edges.push_back(new edge(A[i][j-1]));
}
}
cout << bfs(l) << endl;
} | 1 |
#include <bits/stdc++.h>
#include <array>
using namespace std;
using ULL = unsigned long long;
using UL = unsigned;
using LL = long long;
#define rep(i, n) for(UL i = 0; i < (n); i++)
struct Problem {
void Solve() {
UL N; cin >> N;
string S; cin >> S;
string rS = S; reverse(rS.begin(), rS.end());
ULL ans = 0;
rep(i, (1 << N)) {
string R, B;
rep(j, N) { if (i & (1 << j)) R.push_back(S[j]); else B.push_back(S[j]); }
R.push_back(' '); B.push_back(' ');
UL dp[19][19] = {};
dp[0][0] = 1;
rep(b, B.size()) {
rep(r, R.size()) {
if (B[b] == rS[r + b]) dp[r][b + 1] += dp[r][b];
if (R[r] == rS[r + b]) dp[r + 1][b] += dp[r][b];
}
}
ans += dp[R.size() - 1][B.size() - 1];
}
cout << ans << endl;
}
Problem();
};
int main() {
unique_ptr<Problem> p(new Problem());
p->Solve();
return 0;
}
Problem::Problem() {
cout << fixed << setprecision(10);
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef set<int> si;
typedef pair<int,int> pii;
#define rep(i,a,b) for(int i=(a); i<(b); ++i)
#define per(i,a,b) for(int i=(b)-1; i>=(a); --i)
#define all(x) (x).begin(),(x).end()
#define sz(x) (int)(x).size()
#define mp make_pair
#define pb push_back
#define F first
#define S second
void cal(string s, string x, string y, map<pair<string, string>, ll>& a) {
if(sz(s) == 0) {
a[mp(x,y)]++;
return;
}
cal(s.substr(1), x + s.substr(0,1), y, a);
cal(s.substr(1), x, y + s.substr(0,1), a);
}
ll solve(string s, string t) {
map<pair<string, string>, ll> a, b;
string x,y;
x = y = "";
cal(s,x,y,a);
cal(t,x,y,b);
ll ret = 0;
for(auto e : a) {
auto key = e.F;
if(b.find(key) != b.end()) {
ret += e.S * b[key];
}
}
return ret;
}
int main(void) {
ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
//freopen("in.txt", "r", stdin);
int n;
string s;
cin >> n >> s;
string t = s.substr(n);
reverse(all(t));
cout << solve(s.substr(0,n), t) << '\n';
} | 1 |
#include<iostream>
#include<cstdio>
#include<cstring>
#include<ctime>
#define re register
const int MAXN=2e5+10;
int n,K,s[MAXN],a[MAXN],timee;
char fin[10010],*p1=fin,*p2=fin;
char getc()
{
return p1==p2&&(p2=(p1=fin)+fread(fin,1,10000,stdin),p1==p2)?EOF:*p1++;
}
int read()
{
re int x=0;
re char ch=0;
while(ch<'0'||ch>'9') ch=getc();
while('0'<=ch&&ch<='9') x=(x<<3)+(x<<1)+(ch^48),ch=getc();
return x;
}
inline void insert(int x,int w)
{
for(;x<=n;x+=x&-x) s[x]+=w;
}
inline int query(int x)
{
re int res=0;
for(;x;x-=x&-x) res+=s[x];
return res;
}
int main()
{
//freopen("t2.out","w",stdout);
n=read();
K=read();
for(re int i=1;i<=n;i++) a[i]=read();
if(K>=41)
{
for(re int i=1;i<=n;i++) printf("%d ",n);
return 0;
}
while(K--)
{
re bool flag=1;
memset(s,0,(n+5)*sizeof(int));
for(re int i=1;i<=n;i++) insert(std::max(1,i-a[i]),1),insert(std::min(n,i+a[i])+1,-1);
for(re int i=1;i<=n;i++) a[i]=query(i),flag&=(a[i]==n);
if(flag) break;
}
for(re int i=1;i<=n;i++) printf("%d ",a[i]);
printf("\n");
return 0;
}
/*
5 1
1 0 0 1 0
*/ | #include <iostream>
#include <vector>
#include <stack>
#include <bitset>
#include <utility>
#include <algorithm>
using namespace std;
const int kNil = -1;
const int kMaxV = 100010;
enum class Color {
kWhite,
kGrey,
kBlack,
};
template <class T>
struct Edge {
using w_type = T;
Edge(int u, int v, w_type w): u(u), v(v), w(w) { }
int u, v;
w_type w;
bool operator<(const Edge<T> & rhs) const {
if (w != rhs.w) { return w < rhs.w; }
if (u != rhs.u) { return u < rhs.u; }
return v < rhs.v;
}
};
template <class Edge>
void ArticulationPointsVisit(
const typename vector<Edge>::size_type node_now,
typename vector<Edge>::size_type & time,
const vector<vector<Edge>> & adjacency_list,
vector<int> & d,
vector<int> & low,
vector<Color> & color,
vector<int> & parent,
bitset<kMaxV> & bs_aps) {
color[node_now] = Color::kGrey;
d[node_now] = time;
low[node_now] = time++;
unsigned child_num = 0;
for (const auto & e: adjacency_list[node_now]) {
if (color[e.v] == Color::kWhite) {
++child_num;
parent[e.v] = e.u;
ArticulationPointsVisit(e.v, time, adjacency_list, d, low, color, parent, bs_aps);
low[e.u] = min(low[e.u], low[e.v]);
if (parent[e.u] == kNil && child_num >= 2) {
bs_aps.set(e.u);
}
if (parent[e.u] != kNil && d[e.u] <= low[e.v]) {
bs_aps.set(e.u);
}
} else if (parent[e.u] != e.v) {
low[e.u] = min(low[e.u], d[e.v]);
}
}
color[node_now] = Color::kBlack;
}
template <class Edge>
bitset<kMaxV> ArticulationPoints(const vector<Edge> & edges,
typename vector<Edge>::size_type node_num) {
using size_type = typename vector<Edge>::size_type;
vector<vector<Edge>> adjacency_list(node_num, vector<Edge>());
for (const auto & e: edges) {
adjacency_list[e.u].push_back(e);
adjacency_list[e.v].emplace_back(e.v, e.u, e.w);
}
size_type time = 0;
vector<int> d(node_num);
vector<int> low(node_num);
vector<Color> color(node_num, Color::kWhite);
vector<int> parent(node_num, kNil);
bitset<kMaxV> bs_aps;
for (unsigned i = 0; i < node_num; ++i) {
if (color[i] == Color::kWhite) {
ArticulationPointsVisit(i, time, adjacency_list, d, low, color, parent, bs_aps);
}
}
return bs_aps;
}
int main(int argc, char const *argv[]) {
using w_type = unsigned;
vector<Edge<w_type>> edges;
unsigned V, E;
cin >> V >> E;
for (unsigned i = 0; i < E; ++i) {
unsigned u, v;
w_type w;
cin >> u >> v;
edges.emplace_back(u, v, 1);
}
auto bs_aps = ArticulationPoints(edges, V);
for (unsigned i = 0; i < V; ++i) {
if (bs_aps.test(i)) {
cout << i << endl;
}
}
return 0;
} | 0 |
#include <stdio.h>
#include <stdbool.h>
char dividing(int pm, int pe, int pj);
int main(void)
{
int ninnzuu;
int point[3];
while(true) {
scanf("%d", &ninnzuu);
if(ninnzuu == 0) {
break;
}
for(int i = 0; i < ninnzuu; i++) {
scanf("%d %d %d", &point[0], &point[1], &point[2]);
printf("%c\n", dividing(point[0], point[1], point[2]));
}
}
return 0;
}
char dividing(int pm, int pe, int pj)
{
if(pm == 100 || pe == 100 || pj == 100) {
return 'A';
}else if(pm + pe >= 180) {
return 'A';
}else if(pm + pe + pj >= 240) {
return 'A';
}else if(pm + pe + pj >= 210) {
return 'B';
}else if(pm + pe + pj >= 150 && (pm >= 80 || pe >= 80)) {
return 'B';
}else{
return 'C';
}
} | #define _USE_MATH_DEFIMES
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <clocale>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
const int MOD = 1'000'000'007;
const int INF = 1'000'000'000; //1e9
const int NIL = -1;
const long long LINF = 1'000'000'000'000'000'000; // 1e18
const long double EPS = 1E-10;
template<class T, class S> inline bool chmax(T &a, const S &b){
if(a < b){
a = b; return true;
}
return false;
}
template<class T, class S> inline bool chmin(T &a, const S &b){
if(b < a){
a = b; return true;
}
return false;
}
template<class T> class SegmentTreeSum{
int n = 0;
std::vector<T> dat;
T fill = 0;
public:
SegmentTreeSum(){}
SegmentTreeSum(int m, T fil = 0){
fill = fil;
int i = 1;
while(i < m) i *= 2;
n = i;
dat.resize(2*i - 1);
for(int j(0), j_len(2*i-1); j < j_len; ++j)
dat[j] = fill;
}
void update(int k, T a){
k += n - 1;
T moto = dat[k];
dat[k] = a;
while(k){
k = (k - 1) / 2;
dat[k] += a - moto;
}
}
void updateIncrease(int k, T a){
update(k, dat[k+n-1] + a);
}
void updateIncrease(int k){
updateIncrease(k, 1);
}
void updateDecrease(int k, T a){
update(k, dat[k+n-1] - a);
}
void updateDecrease(int k){
updateDecrease(k, 1);
}
T getSum(int a, int b, int k=0, int l=0, int r=-1){
//[a, b[であることに注意
if(r < 0) r = n;
if(r <= a || b <= l) return fill;
if(a <= l && r <= b) return dat[k];
T vl = getSum(a, b, 2*k+1, l, (l+r)/2);
T vr = getSum(a, b, 2*k+2, (l+r)/2, r);
return vl + vr;
}
T getvalue(int k){
return dat[k+n-1];
}
bool getExist(int l, int r){//全て非負と仮定
//[l, r]
return (getSum(l, r+1) > fill);
}
};
int main(){
int N, Q; std::cin >> N >> Q;
SegmentTreeSum<long long> st(N);
{
int a;
for(int i(0); i < N; ++i){
std::cin >> a;
st.update(i, a);
}
}
{
int op, l, r;
for(int i(0); i < Q; ++i){
std::cin >> op >> l >> r;
if(op) std::cout << st.getSum(l, r) << "\n";
else st.updateIncrease(l, r);
}
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pi;
typedef pair<ll,ll> pl;
typedef vector<int> vi;
typedef vector<ll> vl;
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define all(x) x.begin(), x.end()
#define ins insert
#define pi 3.14159265359
#define mod 1000000007
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n,m;
cin>>n>>m;
char val[5+1]={'a','a','a','a','a'};
bool t=false;
for(int i=1;i<=m;i++)
{
int x;char y;
cin>>x>>y;
if(val[x]=='a'){
val[x]=y;
}else{
if(val[x]!=y){
t=true;
}
}
}
if(t){
cout<<-1;
}else if(val[1]=='0'&&n>=2){
cout<<-1;
}else{
if(val[1]=='a'){
if(n>=2)
val[1]='1';
else
val[1]='0';
}
for(int i=1;i<=n;i++)
{
if(val[i]!='a') cout<<val[i];
else cout<<0;
}
}
}
| #include <bits/stdc++.h>
int solve() {
int N, M; std::cin >> N >> M;
std::vector<int> s(M);
std::vector<int> c(M);
for (int i = 0; i < M; ++i) std::cin >> s[i] >> c[i];
/* 全探索 */
for (int n = 0; n < std::pow(10,N); ++n) {
int digit = 1; // 0は1桁
std::vector<int> each_num(1, n%10); // 一の位
int x = n/10;
while (x) {
digit++;
each_num.push_back(x%10);
x /= 10;
}
if (digit != N) continue; // 桁数の条件を満たさない
std::reverse(each_num.begin(), each_num.end());
bool ok = true; // 条件を満たす整数が存在するかどうか
for (int i = 0; i < M; ++i)
if (each_num[s[i]-1] != c[i]) ok = false; // 一つでも条件を満たさないものがあれば
if (ok) return n; // 桁数とそれぞれの桁の数字が条件を満たす
}
return -1;
}
int main() {
std::cout << solve() << std::endl;
return 0;
}
| 1 |
// Next Mayor
// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=1159&lang=jp
#include<iostream>
#include<vector>
using namespace std;
const int NONE = -1;
int N, P;
vector<int> player;
int bowl;
int winner;
bool is_win(int i) {
for (int nth = 0; nth < N; ++nth) {
if (nth == i) continue;
if (player[nth] != 0) return false;
}
return true;
}
void pick_up(int i) {
if (bowl == 0) {
bowl += player[i];
player[i] = 0;
return;
}
else if (bowl == 1) {
bowl--;
player[i]++;
if (is_win(i)) winner = i;
return;
}
bowl--;
player[i]++;
return;
}
int main() {
while(cin >> N >> P && N) {
player.assign(N, 0);
bowl = P;
winner = NONE;
int i = 0;
while (true) {
if (winner != NONE) break;
pick_up(i);
i = (i + 1) % N;
}
cout << winner << endl;
}
return 0;
} | #include<iostream>
using namespace std;
int main(){
int n,p;
while(cin>>n>>p){
bool f=true;
int d[55]={};
int cn=p;
if(n==0)break;
while(f){
for(int i=0;i<n;i++){
if(cn>0){
d[i]++;
cn--;
}
else if(cn==0){
cn=d[i];
d[i]=0;
}
if(d[i]==p){
cout<<i<<endl;
f=false;
break;
}
}
}
}
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
#include <array>
#include <set>
#include <vector>
#include <climits>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int>> graph[n];
array<int, 3> points[n];
int cost[n];
for (int i = 0; cin >> points[i][0] >> points[i][1]; i++) {
points[i][2] = i;
cost[i] = INT_MAX;
}
sort(points, points + n, [](const array<int, 3>& left, const array<int, 3>& right) {
return left[0] < right[0];
});
for (int i = 1; i < n; i++) {
auto dist = min(abs(points[i - 1][0] - points[i][0]), abs(points[i - 1][1] - points[i][1]));
graph[points[i - 1][2]].emplace_back(points[i][2], dist);
graph[points[i][2]].emplace_back(points[i - 1][2], dist);
}
sort(points, points + n, [](const array<int, 3>& left, const array<int, 3>& right) {
return left[1] < right[1];
});
for (int i = 1; i < n; i++) {
auto dist = min(abs(points[i - 1][0] - points[i][0]), abs(points[i - 1][1] - points[i][1]));
graph[points[i - 1][2]].emplace_back(points[i][2], dist);
graph[points[i][2]].emplace_back(points[i - 1][2], dist);
}
long long result = 0;
set<int> mst = {0};
set<pair<int, int>> set;
auto update = [&](const vector<pair<int, int>>& nodes) {
for (auto& p : nodes) {
if (mst.find(p.first) != end(mst)) {
continue;
}
if (cost[p.first] > p.second) {
set.erase({cost[p.first], p.first});
cost[p.first] = p.second;
set.emplace(p.second, p.first);
}
}
};
update(graph[0]);
do {
auto current = set.begin()->second;
auto weight = set.begin()->first;
set.erase(set.begin());
mst.emplace(current);
result += weight;
update(graph[current]);
} while (!set.empty());
cout << result;
return 0;
}
|
#include <stdio.h>
#include <math.h>
#include <algorithm>
using namespace std;
int main() {
int sum = 0;
int small = 114514;
for (int i = 0; i < 4; i++) {
int t;
scanf("%d", &t);
sum += t;
small = min(small, t);
}
sum -= small;
int t,u;
scanf("%d", &t);
scanf("%d", &u);
printf("%d\n", sum + max(t, u));
return 0;
} | 0 |
#include<iostream>
#include<string.h>
using namespace std;
int kingaku(void);
int saitan(void);
#define WHITE 0
#define GLAY 1
#define BLACK 2
#define INF 9999
int n; // ??????????????±?????°
int m; // ?§??????°
int p; // ????????°
int q; // ??°?????°
int minv;
int cost[101][101];
int Time[101][101];
int dd[101];
int main()
{
int a,b,c,t,k,r;
while(1){
memset(cost,INF,sizeof(cost));
memset(Time,INF,sizeof(Time));
cin >> n >> m;
if(n == 0 && m == 0) break;
for(int i=0;i<n;i++){
cin >> a >> b >> c >>t;
cost[a][b] = cost[b][a] = c;
Time[a][b] = Time[b][a] = t;
}
cin >> k;
for(int i=0;i<k;i++){
cin >> p >> q >> r;
if(r == 0)
cout << kingaku() << endl;
else if(r == 1)
cout << saitan() << endl;
//for(int i=1;i<=m;i++)
// cout << i << " " << dd[i] << endl;
}
}
return 0;
}
int kingaku()
{
int u;
int color[101];
memset(dd,INF,sizeof(dd));
memset(color,WHITE,sizeof(color));
dd[p] = 0;
color[p] = GLAY;
while(1){
u = -1;
minv = INF;
for(int i=1;i<=m;i++){
if(minv > dd[i] && color[i] != BLACK){
minv = dd[i];
u = i;
}
}
if(u==-1) break;
color[u] = BLACK;
for(int i=1;i<=m;i++){
if(cost[u][i] != INF && color[i] != BLACK){
if(dd[i] > dd[u] + cost[u][i]) //
//1?§? 1?§???¨??\?????????????§?
dd[i] = dd[u] + cost[u][i];
}
}
}
return dd[q];
}
int saitan()
{
int u;
int color[101];
memset(dd,INF,sizeof(dd));
memset(color,WHITE,sizeof(color));
dd[p] = 0;
color[p] = GLAY;
while(1){
u = -1;
minv = INF;
for(int i=1;i<=m;i++){
if(minv > dd[i] && color[i] != BLACK){
minv = dd[i];
u = i;
}
}
if(u==-1) break;
color[u] = BLACK;
for(int i=1;i<=m;i++){
if(Time[u][i] != INF && color[i] != BLACK){
if(dd[i] > dd[u] + Time[u][i])
dd[i] = dd[u] + Time[u][i];
}
}
}
return dd[q];
} | #include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main () {
// input
string str;
cin >> str;
int q;
cin >> q;
string result = str;
int res_len = result.length();
for (int i=0; i<q; i++) {
string order;
int a, b;
cin >> order >> a >> b;
if (order == "print") {
// output
cout << result.substr(a, b-a+1) << endl;
} else if (order == "reverse") {
string reversed = "";
for (int j=0; j<a; j++) {
reversed += result[j];
}
for (int jj=b; jj>a-1; jj--) {
reversed += result[jj];
}
for (int jjj=b+1; jjj<res_len; jjj++) {
reversed += result[jjj];
}
result = reversed;
//cout << reversed << endl;
} else if (order == "replace") {
string p;
cin >> p;
string replaced = "";
for (int k=0; k<a; k++) {
replaced += result[k];
}
for (int kk=a; kk<b+1; kk++) {
replaced += p[kk-a];
}
for (int kkk=b+1; kkk<res_len; kkk++) {
replaced += result[kkk];
}
result = replaced;
//cout << result << endl;
}
}
}
| 0 |
#include <iostream>
#include <iomanip>
using namespace std;
int main(){
int data[11][11];
int n;
cin >> n;
while (n){
for (int i = 0; i < n; i++){
for (int j = 0; j < n; j++){
cin >> data[i][j];
}
}
int sum_col[10] = { 0 };
int sum_low[10] = { 0 };
for (int i = 0; i < n; i++){
for (int j = 0; j < n; j++){
sum_col[i] += data[i][j];
sum_low[i] += data[j][i];
}
data[i][n] = sum_col[i];
data[n][i] = sum_low[i];
}
int sum = 0;
for (int i = 0; i < n; i++){
sum += data[i][n];
}
data[n][n] = sum;
for (int i = 0; i < n + 1; i++){
for (int j = 0; j < n + 1; j++){
cout << setw(5) << right << data[i][j];
}
cout<<"\n";
}
cin >> n;
}
return 0;
} | #include <iostream>
using namespace std;
#include <algorithm>
int main() {
int n;
while (1) {
cin >> n;
if (n==0) break;
int p1=0, p2=0;
int c1, c2;
for (int i=0; i<n; i++) {
cin >> c1 >> c2;
if (c1==c2) p1+=c1, p2+=c2;
if (c1>c2) p1+=c1+c2;
if (c1<c2) p2+=c1+c2;
}
cout << p1 << " " << p2 << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
#define m0(x) memset(x, 0, sizeof(x))
#define all(x) x.begin(), x.end()
#define rep(i, n) for(int i = 0; i < (n); i++)
#define asort(x) sort(all(x));
#define dsort(x, t) sort(x.begin(), x.end(), greater<t>());
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define MINS(m, s) m.insert(make_pair(s, 1));
#define MFIN(m, s) m.find(s) != m.end()
const int mod = 1000000007;
vector<ll> divisor(ll n) {
vector<ll> res;
for(ll i = 1; i * i <= n; i++) {
if(n % i == 0) {
res.push_back(i);
if(i * i != n) {
res.push_back(n / i);
}
}
}
sort(begin(res), end(res));
return res;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
bool isPrime(ll x) {
ll i;
if(x < 2)
return 0;
else if(x == 2)
return 1;
if(x % 2 == 0)
return 0;
for(i = 3; i * i <= x; i += 2)
if(x % i == 0)
return 0;
return 1;
}
int main() {
ll A, B;
cin >> A >> B;
ll ab_gcd = gcd(A, B);
vector<ll> ab_divisor;
ab_divisor = divisor(ab_gcd);
ll cnt = 1;
for(ll i = 0; i < ab_divisor.size(); i++) {
if(isPrime(ab_divisor[i])) {
cnt++;
}
}
cout << cnt << endl;
return 0;
} | #include <iostream>
using namespace std;
int main(){
int a, b, x;
cin >> a >> b;
x = (b - a) * 2;
cout << a + x << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
// #define int long long
/* short */
#define pb push_back
#define print(Target) cout << Target << '\n'
/* REPmacro */
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REPS(i, a, n) for (int i = (a); i < (n); i++)
/* typedef */
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vector<int> > vii;
typedef pair<int, int> pii;
/* func */
inline bool is_uruu(int y) {return (y % 4 == 0 && (y % 100 != 0 || y % 400 == 0));}
/* const */
const int INF = INT_MAX;
int dp[31];
int shinobu(int n)
{
if (dp[n] != -1){
return (dp[n]);
}
if (n == 1) return (1);
if (n == 2) return (2);
if (n == 3) return (4);
return (shinobu(n - 1) + shinobu(n - 2) + shinobu(n - 3));
}
signed main()
{
ios::sync_with_stdio(false);
int n;
while (cin >> n, n){
fill(dp, dp + 31, -1);
print(shinobu(n) / 3650 + 1);
}
return (0);
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
string N;
cin >> N;
for(int i = 0; i < 8; i++) {
string ans;
ans += N.at(0);
int sum = N.at(0) - '0';
for(int j = 0; j < 3; j++) {
//cout << (i >> (j + 1)) << endl;
if(i >> j & 1) {
sum += N.at(j + 1) - '0';
ans += '+';
ans += N.at(j + 1);
} else {
sum -= N.at(j + 1) - '0';
ans += '-';
ans += N.at(j + 1);
}
}
//˜cout << sum << endl;
if(sum == 7) {
cout << ans << "=7" << endl;
break;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
typedef long double ld;
const int inf=1e9+7;
const ll longinf=1LL<<60;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
#define F first
#define S second
const int mx=100010;
const ll mod=1e9+7;
vector<int> edges[2100];
struct UnionFind {
vector<int> par,sizes; // par[i]:iの親の番号(ex)par[3]=2 : 3の親が2
UnionFind(int n) : par(n),sizes(n,1) { //最初は全てが根であるとして初期化
for(int i=0; i<n; i++){ par[i]=i; }
}
int root(int x) { //xが属する木の根を再帰で得る:root(x)={xの木の根}
if(par[x]==x){ return x; }
return par[x] = root(par[x]);
}
void unite(int x, int y) { // xとyの木を併合
int rx = root(x); //xの根をrx
int ry = root(y); //yの根をry
if(rx == ry){ return; } //xとyの根が同じ(=同じ木にある)時はそのまま
if(sizes[rx]<sizes[ry]){ swap(rx, ry); } //xの木をおおきくする
par[ry] = rx;
sizes[rx] += sizes[ry]; //sizes[ry]はもう使わない
}
bool check(int x, int y) { // x,yが属する木が同じならtrueを返す
return root(x) == root(y);
}
int size(int x){ //xが含まれる木の大きさを返す
return sizes[root(x)];
}
};
bool dfs(int p, set<int> &a){
for(auto to:edges[p]){
if(a.find(to)!=a.end()){ return true; }
a.insert(to);
if(dfs(to,a)){ return true; } else { a.erase(to); }
}
return false;
}
int main(){
int n,m;
cin >> n >> m;
UnionFind uf(n);
vector<P> aded;
for(int i=0; i<m; i++){
int x,y; cin >> x >> y; x--; y--;
if(uf.check(x,y)){
aded.emplace_back(x,y);
} else {
uf.unite(x,y);
edges[x].emplace_back(y);
}
}
set<int> shortest;
int cnt=inf;
for(auto tmp:aded){
set<int> ans;
ans.insert(tmp.F);
ans.insert(tmp.S);
if(dfs(tmp.S,ans)){
if(ans.size()<cnt){
cnt=ans.size();
shortest = ans;
}
}
}
if(cnt!=inf){
cout << shortest.size() << endl;
for(auto anno:shortest){cout << anno+1 << endl;}
return 0;
}
cout << -1 << endl;
return 0;
}
| #include<bits/stdc++.h>
#define MN 100000
#define ll long long
using namespace std;
inline int read()
{
int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
ll res,v[MN+5],V[MN+5],ans,g[MN+5],G[MN+5];
int n,X,L[MN+5],R[MN+5],b[MN+5],rk[MN+5];
bool cmp(int x,int y){return v[x]+g[x]>v[y]+g[y];}
ll GetV(ll*s,int l,int r,int x){return s[r]-s[l-1]-((x>=l&&x<=r)?s[x]-s[x-1]:0);}
inline int Div(ll x,int y){return (x+y-1)/y;}
int main()
{
n=read();X=read();
for(int i=1;i<=n;++i)
{
b[i]=read();L[i]=read();R[i]=read();
v[i]=1LL*(X-b[i])*R[i];g[i]=1LL*b[i]*L[i];
rk[i]=i;ans+=b[i];
}
sort(rk+1,rk+n+1,cmp);
for(int i=1;i<=n;++i) V[i]=V[i-1]+v[rk[i]],G[i]=G[i-1]+g[rk[i]];
for(int i=1;i<=n;++i)
{
int l=0,r=n-1,mid,res=n;
while(l<=r)
{
mid=l+r>>1;
ll Val=GetV(V,1,mid,i)-GetV(G,mid+1,n,i)+v[rk[i]];
if(Val>=0) res=mid,r=mid-1; else l=mid+1;
}
ll Val=GetV(V,1,res,i)-GetV(G,res+1,n,i);
if(Val>=0) ans=min(ans,1LL*(res-(res>=i))*X+max(0,Div(g[rk[i]]-Val,L[rk[i]])));
else ans=min(ans,1LL*(res-(res>=i))*X+b[rk[i]]+Div(-Val,R[rk[i]]));
}
cout<<ans;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin>>N;
vector<vector<int>> Q(N, vector<int>(2));
for(int i=0;i<N;i++){
int l,r;
cin>>l>>r;
Q[i][0]=l;
Q[i][1]=r;
}
// 左側の順にソート
sort(Q.begin(),Q.end());
vector<int> A(N), B(N);
// A→１回目のコンテストの右側
// A[i]→i個目まで１回目のコンテストで出題
A[0] = Q[0][1];
for(int i=1;i<N;i++){
A[i]= min(A[i-1],Q[i][1]);
}
// B→２回目のコンテストの右側
// B[i]→i個目まで１回目のコンテストで出題
B[N-1]=Q[N-1][1];
for(int i=N-2;i>=0;i--){
B[i]= min(B[i+1],Q[i][1]);
}
int ans=0;
for(int i=0;i<N-1;i++){
//cout<<A[i]<<" "<<Q[i][0]<<" "<<B[i+1]<<" "<<Q[N-1][0]<<endl;;
ans = max(ans, max(0,A[i]-Q[i][0]+1)+max(0,B[i+1]-Q[N-1][0]+1));
ans = max(ans, max(0,A[N-1]-Q[N-1][0]+1)+max(0,Q[i][1]-Q[i][0]+1));
//cout<<ans<<endl;
}
cout<<ans<<endl;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<vector<vector<ll>>> vvvll;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
typedef vector<vector<vector<bool>>> vvvb;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<vpll> vvpll;
typedef vector<double> vd;
typedef vector<vd> vdd;
typedef pair<double, double> pd;
typedef vector<pd> vpd;
#define FOR(i,x,y) for(ll i=(ll)x; i<(ll)y; ++i)
#define REP(i,y) FOR(i, 0, y)
#define RFOR(i,x,y) for(ll i=(ll)x; i>=(ll)y; --i)
#define RREP(i,x) RFOR(i, x, 0)
#define ALL(a) a.begin(), a.end()
#define pb push_back
#define debug_print(x...) cerr << "line " << __LINE__ << " : "; debug_print_in(x);
template <typename First>
void debug_print_in(First first){
cerr << first << endl;
return;
}
template <typename First, typename... Rest>
void debug_print_in(First first, Rest... rest){
cerr << first << " ";
debug_print_in(rest...);
return;
}
void IN(void){
return;
}
template <typename First, typename... Rest>
void IN(First& first, Rest&... rest){
cin >> first;
IN(rest...);
return;
}
template <typename First>
void OUT(First first){
cout << first << endl;
return;
}
template <typename First, typename... Rest>
void OUT(First first, Rest... rest){
cout << first << " ";
OUT(rest...);
return;
}
template<class t, class u> t chmax(t&a,u b){if(a<b)a=b; return a;};
template<class t, class u> t chmin(t&a,u b){if(a>b)a=b; return a;};
int popcount(int t){return __builtin_popcount(t);} //GCC
int popcount(ll t){return __builtin_popcountll(t);} //GCC
template <typename T>
void vec_print(vector<T> VEC){
REP(i, VEC.size()){
cerr << VEC[i] << " ";
}
cerr << endl;
};
template <typename T>
void mat_print(vector<vector<T> > MAT){
REP(i,MAT.size()){
REP(j,MAT[i].size()){
cerr << MAT[i][j] << " ";
}
cerr << endl;
}
};
constexpr int INF = (1<<30);
constexpr ll INFLL = 1LL<<62;
constexpr long double EPS = 1e-12;
constexpr ll MOD = (ll)((1E+9)+7);
int main(){
cin.tie(0); // cut the cin and cout (default, std::flush is performed after std::cin)
ios::sync_with_stdio(false); // cut the iostream and stdio (DON'T endl; BUT "\n";)
ll N;
IN(N);
vpll RL(N);
REP(i,N){
IN(RL[i].second, RL[i].first);
}
sort(ALL(RL));
vll Lmax(N, RL[0].second);
REP(i,N-1){
Lmax[i+1] = max(Lmax[i], RL[i+1].second);
}
/*
REP(i,N){
debug_print(RL[i].second, RL[i].first);
}
*/
ll ans = max(RL[0].first-Lmax[N-2]+1, (ll)0)+(RL[N-1].first-RL[N-1].second)+1;
ll Lmax_after = RL[N-1].second;
for(ll i=N-2; i>0; --i){
ll Lmax1 = Lmax[i-1];
ll Rmin1 = RL[0].first;
ll Lmax2 = RL[i].second;
ll Rmin2 = RL[i].first;
ll LR1 = max(Rmin1-Lmax1+1, (ll)0);
ll LR2 = max(Rmin2-Lmax2+1, (ll)0);
ll LR1_1 = max(Rmin1-max(Lmax_after, Lmax1)+1, (ll)0);
ll LR2_1 = max(Rmin2-max(Lmax_after, Lmax2)+1, (ll)0);
ll ans_tmp = max(LR1+LR2_1, LR1_1+LR2);
chmax(ans, ans_tmp);
chmax(Lmax_after, Lmax2);
}
OUT(ans);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define MAXN 16
#define MAXM 32768
#define MAXS 14348907
#define INF 1e9
template <typename T> void read(T &x) {
x = 0; int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
int mp[MAXN][MAXN], bit[MAXN];
int ups[MAXM], upt[MAXM];
int sum[MAXN][MAXM], cost[MAXS];
int dp[MAXN][MAXM];
int n, m, goal;
void init() {
goal = (1 << n) - 1;
bit[1] = 1;
for (int i = 2; i <= n; i++)
bit[i] = bit[i - 1] << 1;
for (int i = 1; i <= n; i++)
for (int s = 0; s <= goal; s++) {
if (s & bit[i]) continue;
for (int j = 1; j <= n; j++)
if (s & bit[j]) sum[i][s] += mp[i][j];
}
for (int s = 0; s <= goal; s++) {
int tmp = s, sv = 0, tv = 0, now = 1;
while (tmp) {
if (tmp & 1) sv += 2 * now;
if (tmp & 1) tv += now;
now *= 3; tmp >>= 1;
}
ups[s] = sv; upt[s] = tv;
}
for (int s = 0; s <= goal; s++)
for (int tmp = goal ^ s, t = goal ^ s; t; t = (t - 1) & tmp)
for (int i = 1; i <= n; i++)
if (s & bit[i]) cost[ups[s] + upt[t]] += sum[i][t];
}
void update(int &x, int y) {
x = min(x, y);
}
int main() {
read(n), read(m);
for (int i = 1; i <= m; i++) {
int x, y, z;
read(x), read(y), read(z);
mp[x][y] = mp[y][x] = z;
}
init();
for (int i = 1; i <= n; i++)
for (int j = 0; j <= goal; j++)
dp[i][j] = INF;
dp[1][bit[1]] = 0;
for (int s = 0; s <= goal; s++)
for (int i = 1; i <= n; i++) {
if ((bit[i] & s) == 0 || dp[i][s] == INF) continue;
int ts = s ^ bit[i];
for (int j = 1; j <= n; j++) {
if ((bit[j] & s) || mp[i][j] == 0) continue;
update(dp[j][s ^ bit[j]], dp[i][s] + sum[j][ts]);
}
for (int tmp = goal ^ s, t = goal ^ s; t; t = (t - 1) & tmp)
update(dp[i][s ^ t], dp[i][s] + cost[ups[ts] + upt[t]]);
}
cout << dp[n][goal] << endl;
return 0;
} | //by yjz
#include<bits/stdc++.h>
using namespace std;
#define FF first
#define SS second
#define PB push_back
#define MP make_pair
#define bged(v) (v).begin(),(v).end()
#define foreach(it,s) for(__typeof((s).begin()) it=(s).begin();it!=(s).end();it++)
typedef long long ll;
const int Imx=2147483647;
const ll Lbig=2e18;
const int mod=1e9+7;
//My i/o stream
struct fastio
{
char s[100000];
int it,len;
fastio(){it=len=0;}
inline char get()
{
if(it<len)return s[it++];it=0;
len=fread(s,1,100000,stdin);
if(len==0)return EOF;else return s[it++];
}
bool notend()
{
char c=get();
while(c==' '||c=='\n')c=get();
if(it>0)it--;
return c!=EOF;
}
}_buff;
#define geti(x) x=getnum()
#define getii(x,y) geti(x),geti(y)
#define getiii(x,y,z) getii(x,y),geti(z)
#define puti(x) putnum(x),putchar(' ')
#define putii(x,y) puti(x),puti(y)
#define putiii(x,y,z) putii(x,y),puti(z)
#define putsi(x) putnum(x),putchar('\n')
#define putsii(x,y) puti(x),putsi(y)
#define putsiii(x,y,z) putii(x,y),putsi(z)
inline ll getnum()
{
ll r=0;bool ng=0;char c;c=_buff.get();
while(c!='-'&&(c<'0'||c>'9'))c=_buff.get();
if(c=='-')ng=1,c=_buff.get();
while(c>='0'&&c<='9')r=r*10+c-'0',c=_buff.get();
return ng?-r:r;
}
template<class T> inline void putnum(T x)
{
if(x<0)putchar('-'),x=-x;
register short a[20]={},sz=0;
while(x)a[sz++]=x%10,x/=10;
if(sz==0)putchar('0');
for(int i=sz-1;i>=0;i--)putchar('0'+a[i]);
}
inline char getreal(){char c=_buff.get();while(c<=32)c=_buff.get();return c;}
ll qpow(ll x,ll k){return k==0?1:1ll*qpow(1ll*x*x%mod,k>>1)*(k&1?x:1)%mod;}
char s[311];
int n,k;
int dp[305][305][305];
void upd(int &x,int v){x=max(x,v);}
int main()
{
scanf("%s",s+1);
n=strlen(s+1);
cin>>k;
int ans=0;
for(int i=1;i<=n;i++)
{
for(int j=n;j>=i;j--)
{
for(int t=0;t<=k;t++)
{
int cur=dp[i][j][t];
upd(ans,cur+(s[i]==s[j])*2-(i==j));
if(t<k)upd(ans,cur+2-(i==j));
if(i<j)
{
upd(dp[i+1][j][t],cur);
upd(dp[i][j-1][t],cur);
upd(dp[i+1][j-1][t],cur+(s[i]==s[j])*2-(i==j));
if(t<k)upd(dp[i+1][j-1][t+1],cur+2-(i==j));
}
}
}
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include<cstdio>
#include<algorithm>
using namespace std;
int n,a[605][605];
void work()
{
int d,l=1;
scanf("%d",&d);
for(; d%4==0; d>>=2)
l<<=1;
if(~d&1)
{
for(int i=1; i<=n; i+=l)
if(!(i/l&1))
for(int k=i; k<=min(n,i+l-1); ++k)
for(int j=1; j<=n; j++)
a[k][j]++;
}
else if(d%4==1)
{
for(int i=1; i<=n; i+=l)
for(int j=1; j<=n; j+=l)
if((i/l&1)^(j/l&1)^1)
for(int k=i; k<=min(n,i+l-1); ++k)
for(int p=j; p<=min(n,j+l-1); ++p)
a[k][p]++;
}
else
{
for(int i=1; i<=n; i++)
for(int j=1; j<=n; j++)
a[i][j]++;
}
}
int main()
{
scanf("%d",&n);
n<<=1;
work(); work();
/* for(int i=1; i<=n; i++)
{
for(int j=1; j<=n; j++)
printf("%d ",a[i][j]);
puts("");
}*/
for(int s=0,i=1; i<=n; i++)
for(int j=1; j<=n; j++)
if(a[i][j]==2)
{
++s;
printf("%d %d\n",i-1,j-1);
if(s*4==n*n)
return 0;
}
return 0;
} | #include<bits/stdc++.h>
#define eps 1e-7
using namespace std;
int n,d1,d2,cnt=0;
bool f[1005][1005];
inline void solve(int d){
int b=0;
while(!(d%4))d>>=2,++b;
if(d&1){
for(int i=0;i<(n<<1);++i)
for(int j=0;j<(n<<1);++j)
if(((i>>b)+(j>>b))&1)f[i][j]=true;
return;
}
for(int i=0;i<(n<<1);++i)
for(int j=0;j<(n<<1);++j)
if((i>>b)&1)f[i][j]=true;
}
int main(){
scanf("%d%d%d",&n,&d1,&d2);
solve(d1),solve(d2);
for(int i=0;i<(n<<1);++i)
for(int j=0;j<(n<<1);++j)
if(cnt<n*n&&!f[i][j])printf("%d %d\n",i,j),++cnt;
return 0;
} | 1 |
#include <iostream>
#include <vector>
constexpr bool divisible(const std::size_t n, const std::size_t m)
{
return (0 == n % m);
}
constexpr bool help_prime(const std::size_t n, const std::size_t m)
{
return (m * m <= n) ?
!divisible(n, m) && help_prime(n, m + 1) :
true;
}
constexpr bool prime(const std::size_t n)
{
return (n <= 1) ?
false :
help_prime(n, 2);
}
std::pair<std::size_t, std::size_t> find_twin_prime(const std::size_t limit, const bool next_skip = false)
{
return prime(limit) ?
prime(limit - 2) ?
std::make_pair(limit - 2, limit) :
find_twin_prime(limit - (next_skip ? 3 : 1), true) :
find_twin_prime(limit - (next_skip ? 2 : 1), false);
}
int main()
{
std::vector<std::size_t> ns;
std::size_t n;
while(std::cin >> n, n != 0)
{
ns.push_back(n);
}
for(const auto a : ns)
{
const auto&& t = find_twin_prime(a);
std::cout << t.first << " " << t.second << std::endl;
}
} | #include <iostream>
#include <utility>
#include <vector>
#include <algorithm>
using namespace std;
bool furui[10010];
vector<int> prime;
vector<int> twin;
void mkprime() {
for(int i = 0; i < 10010; i++) furui[i] = true;
furui[0] = furui[1] = false;
for(int i = 0; i < 10010; i++) {
if(furui[i]) {
prime.push_back(i);
for(int j = i * 2; j < 10010; j += i) {
furui[j] = false;
}
}
}
for(int i = 0; i < prime.size() - 1; i++) {
if(prime[i + 1] - prime[i] == 2)
twin.push_back(prime[i + 1]);
}
sort(twin.begin(), twin.end());
}
int main() {
int n;
mkprime();
while(cin >> n, n) {
vector<int>::iterator iter;
iter = upper_bound(twin.begin(), twin.end(), n);
cout << *(iter-1) - 2 << " " << *(iter-1) << endl;
}
} | 1 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define repr(i, n) for (int i = (n); i >= 0; --i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define FORR(i, m, n) for (int i = (m); i >= (n); --i)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
const ll mod = 1000000007;
//const ll mod = 998244353;
const int inf = 1e9 + 10;
const ll INF = 1e18;
const ld EPS = 1e-10;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
template<class T> bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T> bool chmin(T &a, const T &b) { if (a>b) { a=b; return 1; } return 0; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(25);
ld n, m, d;
cin >> n >> m >> d;
ld ans = (n - d) * 2 * (m - 1) / n / n;
if (d == 0) ans /= 2;
cout << ans << '\n';
return 0;
} | #include<iostream>
using namespace std;
int main(){
int a,b,c;
cin>>a>>b>>c;
if(a==b&&b!=c||a==c&&b!=c||b==c&&a!=b){
cout<<"Yes";
}else{
cout<<"No";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin>>n;
int arr[n];
for(int i=0; i<n; i++){
cin>>arr[i];
}
multiset<int>s;
s.insert(arr[0]);
for(int i=1; i<n; i++){
int val=arr[i];
auto it=s.begin();
int vals=(*it);
if(val<=vals){
s.insert(val);
continue;
}
it=s.end();
it--;
vals=(*it);
if(vals<val){
s.erase(s.find(vals));
s.insert(val);
continue;
}
it=s.lower_bound(val);
it--;
s.erase(s.find((*it)));
s.insert(val);
}
cout<<s.size();
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main(){
int n;
cin>>n;
int a[n+2];
a[0]=0;
a[n+1]=0;
for(int i=1;i<=n;i++)
cin>>a[i];
int b[n+1]; //b[i]=cost of i->i+1
int sum=0;
for(int i=0;i<=n;i++){
b[i]=abs(a[i+1]-a[i]);
sum+=b[i];
}
for(int i=1;i<=n;i++)
cout<<sum-b[i-1]-b[i]+abs(a[i+1]-a[i-1])<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#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 ll long long
static const int MAX = 10000;
static const ll INFTY = 1e12;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }
int main() {
int N; cin >> N;
cout << N / 3 << endl;
}
/*
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\ = /O
____/`---'\____
.' \\| |// `.
/ \\||| : |||// \
/ _||||| -:- |||||- \
| | \\\ - /// | |
| \_| ''\---/'' | |
\ .-\__ `-` ___/-. /
___`. .' /--.--\ `. . __
."" '< `.___\_<|>_/___.' >'"".
| | : `- \`.;`\ _ /`;.`/ - ` : | |
\ \ `-. \_ __\ /__ _/ .-` / /
======`-.____`-.___\_____/___.-`____.-'======
`=---='
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
pass System Test!
*/ | #include <bits/stdc++.h>
using namespace std;
#define INF 1e9
#define LLINF 1e18
#define pi 3.14159265358979323
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
int gcd(int a, int b) {
if(a % b == 0) {
return b;
}
else {
return(gcd(b, a % b));
}
}
int main() {
string s;
cin >> s;
if (s.size() % 2 != 0) {
cout << "No" << endl;
return 0;
}
rep(i, s.size()) {
if (i % 2 == 0 && s.at(i) != 'h') {
cout << "No" << endl;
return 0;
}
else if (i % 2 == 1 && s.at(i) != 'i') {
cout << "No" << endl;
return 0;
}
}
cout << "Yes" << endl;
} | 0 |
#include <bits/stdc++.h>
#define FOR(i, begin, end) for(int i=(begin);i<(end);i++)
#define REP(i, n) FOR(i,0,n)
#define IFOR(i, begin, end) for(int i=(end)-1;i>=(begin);i--)
#define IREP(i, n) IFOR(i,0,n)
#define SORT(a) sort(a.begin(), a.end())
#define REVERSE(a) reverse(a.begin(), a.end())
#define Lower_bound(v, x) distance(v.begin(), lower_bound(v.begin(), v.end(), x))
#define Upper_bound(v, x) distance(v.begin(), upper_bound(v.begin(), v.end(), x))
#define int long long
#define INF 1000000000000000000
using namespace std;
#define ANS(f) if(f) cout << "YES" << endl; else cout << "NO" << endl;
typedef vector<int> vec;
typedef vector<vec> mat;
typedef pair<int, int> Pii;
template<typename T>
void readv(vector<T> &a){ REP(i, a.size()) cin >> a[i]; }
void readi(vector<int> &a){ REP(i, a.size()){cin >> a[i]; a[i]--;} }
void debug(mat m){REP(i, m.size()){ REP(j, m[i].size()){ cout << m[i][j] << ","; } cout << endl; }}
int modpow(int x, int n, int m){
int a = 1;
IREP(i, 64){
a = (a * a) % m;
if(((n >> i) & 1) == 1) a = (a * x) % m;
}
return a;
}
class Combination
{
public:
vec fact, invfact;
int MAX_N, mod;
Combination(int MAX_N, int mod): MAX_N(MAX_N), mod(mod) {
initialize();
}
void initialize(){
fact = vec(MAX_N + 1);
invfact = vec(MAX_N + 1);
fact[0] = 1;
FOR(i, 1, MAX_N + 1){
fact[i] = (fact[i - 1] * i) % mod;
}
invfact[MAX_N] = modpow(fact[MAX_N], mod - 2, mod);
IREP(i, MAX_N){
invfact[i] = (invfact[i + 1] * (i + 1)) % mod;
}
}
int nCr(int n, int r){
if(r > n || r < 0 || n < 0) return 0;
if(n > MAX_N){
MAX_N = n;
initialize();
}
int a = fact[n];
a = (a * invfact[r]) % mod;
a = (a * invfact[n - r]) % mod;
return a;
}
};
signed main(){
int K, N; cin >> K >> N;
int mod = 998244353;
Combination comb(N + K, mod);
FOR(i, 2, 2 * K + 1){
if(i % 2 == 1){
int p = min(i, 2 * K + 2 - i) / 2;
int ans = 0;
REP(j, p + 1){
int k = K - 2 * p + j;
int n = N - j;
ans += ((comb.nCr(n + k - 1, n) * modpow(2, j, mod)) % mod) * comb.nCr(p, j);
ans %= mod;
}
cout << ans << endl;
}else{
int p = min(i, 2 * K + 2 - i) / 2 - 1;
int ans = 0;
REP(j, p + 1){
int k = K - 1 - 2 * p + j;
int n = N - j;
ans += ((comb.nCr(n + k - 1, n) * modpow(2, j, mod)) % mod) * comb.nCr(p, j);
ans %= mod;
n = N - j - 1;
ans += ((comb.nCr(n + k - 1, n) * modpow(2, j, mod)) % mod) * comb.nCr(p, j);
ans %= mod;
}
cout << ans << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const ll N = 2e5 + 5, mod = 1e9 + 7;
ll x[N], y[N], sumY;
int main()
{
ll n, m;
scanf("%lld%lld", &n, &m);
ll ans = 0, temp;
for(ll i = 0 ; i < n ; i++) scanf("%lld", x + i);
for(ll i = 0 ; i < m ; i++) scanf("%lld", y + i);
for(ll i = 1 ; i < m ; i++)
{
sumY += (((i * (m - i)) % mod) * ((y[i] - y[i - 1]) % mod)) % mod;
sumY %= mod;
}
for(ll i = 1 ; i < n ; i++)
{
temp = (((i * (n - i)) % mod) * ((x[i] - x[i - 1]) % mod)) % mod;
ans += (temp * sumY) % mod;
ans %= mod;
}
printf("%lld\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
int main() {
int N, K;
cin >> N >> K;
vector<int> vec(N);
rep(i, N) {
cin >> vec.at(i);
}
sort(vec.begin(), vec.end());
reverse(vec.begin(), vec.end());
int sum = 0;
rep(i, K) {
sum += vec.at(i);
}
cout << sum << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int A,B;
cin>>A>>B;
int count_ana=1,count_ans=0;
while(count_ana<B){
count_ana+=A-1;
count_ans++;
}
cout<<count_ans<<endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define FAST ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define mp make_pair
#define pb push_back
#define lp(i,s,f) for(ll i = s; i < ll(f); i++)
#define inF freopen("input.in", "r", stdin);
#define outF freopen("output.in", "w", stdout);
#define endl '\n'
#define MOD 1000000007
#define mm(arr) memset(arr, 0, sizeof(arr))
int main(){
FAST
int arr[3];
for(int i = 0; i < 3; i++){
cin >> arr[i];
}
sort(arr, arr + 3);
cout << arr[0] + arr[1];
return 0;
}
| #include <iostream>
#include <algorithm>
int main()
{
int n;
int64_t a, b;
std::cin >> n >> a >> b;
int x;
std::cin >> x;
int64_t sum = 0;
for (int i = 1; i < n; ++i)
{
int y;
std::cin >> y;
sum += std::min((y - x) * a, b);
x = y;
}
std::cout << sum << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
#define chmax(x,y) x = max(x,y);
#define chmin(x,y) x = min(x,y);
const int di[] = {-1, 0, 1, 0};
const int dj[] = {0, -1, 0, 1};
const int INF = 1001001001;
int main() {
int n;
cin >> n;
vector<int> a(n+1);
rep(i,n) cin >> a[i+1];
vector<int> ans(n+1);
for (int i = n; i >= 1; i--) {
int cnt = 0;
for (int j = i; j <= n; j += i) {
cnt += ans[j];
}
ans[i] = a[i]^(cnt%2);
}
int b = 0;
for (int i = 1; i <= n; i++) {
if (ans[i]) b++;
}
cout << b << endl;
for (int i = 1; i <= n; i++) {
if (ans[i]) cout << i << endl;
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n, m;
scanf("%d%d", &n, &m);
int l = 1, r = (n - 1) / 2;
int ll = r + 1, rr = ll + r;
int cnt = 0;
for (int i = 0; i < 2; i++) {
while (l < r && cnt < m) {
printf("%d %d\n", l, r);
cnt++;
l++, r--;
}
l = ll, r = rr;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
#define ar array
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
template <typename T> using oset = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define vt vector
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define sz(x) (int)(x).size()
#define F_OR(i, a, b, s) for (int i=(a); (s)>0?i<(b):i>(b); i+=(s))
#define F_OR1(e) F_OR(i, 0, e, 1)
#define F_OR2(i, e) F_OR(i, 0, e, 1)
#define F_OR3(i, b, e) F_OR(i, b, e, 1)
#define F_OR4(i, b, e, s) F_OR(i, b, e, s)
#define GET5(a, b, c, d, e, ...) e
#define F_ORC(...) GET5(__VA_ARGS__, F_OR4, F_OR3, F_OR2, F_OR1)
#define FOR(...) F_ORC(__VA_ARGS__)(__VA_ARGS__)
#define EACH(x, a) for (auto& x: a)
template<class A> void read(vt<A>& v);
template<class A, size_t S> void read(ar<A, S>& a);
template<class T> void read(T& x) {
cin >> x;
}
void read(double& d) {
string t;
read(t);
d=stod(t);
}
void read(long double& d) {
string t;
read(t);
d=stold(t);
}
template<class H, class... T> void read(H& h, T&... t) {
read(h);
read(t...);
}
template<class A> void read(vt<A>& x) {
EACH(a, x)
read(a);
}
template<class A, size_t S> void read(array<A, S>& x) {
EACH(a, x)
read(a);
}
string to_string(char c) {
return string(1, c);
}
string to_string(bool b) {
return b?"true":"false";
}
string to_string(const char* s) {
return string(s);
}
string to_string(string s) {
return s;
}
string to_string(vt<bool> v) {
string res;
FOR(sz(v))
res+=char('0'+v[i]);
return res;
}
template<size_t S> string to_string(bitset<S> b) {
string res;
FOR(S)
res+=char('0'+b[i]);
return res;
}
template<class T> string to_string(T v) {
bool f=1;
string res;
EACH(x, v) {
if(!f)
res+=' ';
f=0;
res+=to_string(x);
}
return res;
}
template<class A> void write(A x) {
cout << to_string(x);
}
template<class H, class... T> void write(const H& h, const T&... t) {
write(h);
write(t...);
}
void print() {
write("\n");
}
template<class H, class... T> void print(const H& h, const T&... t) {
write(h);
if(sizeof...(t))
write(' ');
print(t...);
}
void DBG() {
cerr << "]" << endl;
}
template<class H, class... T> void DBG(H h, T... t) {
cerr << to_string(h);
if(sizeof...(t))
cerr << ", ";
DBG(t...);
}
#ifdef _DEBUG
#define dbg(...) cerr << "LINE(" << __LINE__ << ") -> [" << #__VA_ARGS__ << "]: [", DBG(__VA_ARGS__)
#else
#define dbg(...) 0
#endif
template<class T> void offset(ll o, T& x) {
x+=o;
}
template<class T> void offset(ll o, vt<T>& x) {
EACH(a, x)
offset(o, a);
}
template<class T, size_t S> void offset(ll o, ar<T, S>& x) {
EACH(a, x)
offset(o, a);
}
mt19937 mt_rng(chrono::steady_clock::now().time_since_epoch().count());
ll randint(ll a, ll b) {
return uniform_int_distribution<ll>(a, b)(mt_rng);
}
const int d4i[4]={-1, 0, 1, 0}, d4j[4]={0, 1, 0, -1};
const int d8i[8]={-1, -1, 0, 1, 1, 1, 0, -1}, d8j[8]={0, 1, 1, 1, 0, -1, -1, -1};
ll mod=1e9+7;
const int N=1e6+5;
const ld PI=2*acos(0.0);
ll modpow(ll a, ll b){
ll res=1; a%=mod;
while(b){
if(b&1){ res=(res*a)%mod;}
a=(a*a)%mod;
b>>=1;
}
return res;
}
#define lcm(a,b) ((a)*(b))/(__gcd(a,b))
bool compare(array<int,2> a,array<int,2> b){
return a[0]<b[0];
}
void solve() {
int n,t; read(n,t);
vt<array<int,2> > td(n+1);
FOR(i,1,n+1) read(td[i][0],td[i][1]);
sort(++td.begin(),td.end(),compare);
int siz=(*--td.end())[0]+t+5;
vt<int> dp(siz,0);
vt<int> pre(siz,0);
FOR(i,1,n+1){
FOR(j,1,siz){
if(j-td[i][0]<0||j-td[i][0]>=t) { dp[j]=pre[j];}
else{ dp[j]=max(pre[j],pre[j-td[i][0]]+td[i][1]);}
}
FOR(j,1,siz){ pre[j]=dp[j]; dp[j]=0; }
//dbg(i,pre);
}
print(*max_element(all(pre)));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
solve();
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (long long i = 0; i < (n); ++i)
#define repr(i, a, b) for (auto i = (a); i < (b); ++i)
#define itr(x) for (auto&& v : (x))
#define updatemax(t, v) ((t) = std::max((t), (v)))
#define updatemin(t, v) ((t) = std::min((t), (v)))
ll dp[3010][3010];
pair<ll, ll> a[3010];
int main() {
ll n, t;
cin >> n >> t;
rep(i, n) cin >> a[i].first >> a[i].second;
sort(a, a + n);
rep(i, n) {
rep(j, t) {
updatemax(dp[i + 1][j], dp[i][j]);
updatemax(dp[i + 1][min(j + a[i].first, t)], dp[i][j] + a[i].second);
}
updatemax(dp[i + 1][t], dp[i][t]);
}
cout << dp[n][t] << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll MOD = 1000000007;
#define REP(i, n) for (ll i = 0; i < (n); i++)
#define REP2(i, x, n) for (ll i = x; i < (n); i++)
const long long INF = numeric_limits<long long>::max();
template <class T>
inline bool chmin(T &a, T b)
{
if (a > b)
{
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T &a, T b)
{
if (a < b)
{
a = b;
return true;
}
return false;
}
string func(ll N, ll Y)
{
for (ll i = 0; i <= N; ++i)
{
ll iAmount = 10000 * i;
for (ll j = 0; j <= (N-i); ++j)
{
ll jAmount = 5000 * j;
ll k = N - (i + j);
if ( k < 0 ) continue;
if (iAmount + jAmount + 1000 * k == Y)
{
#ifdef SOURCE_TEST
cout << N << " " << Y << endl;
cout << i + j + k << endl;
cout << i * 10000 + j * 5000 + k * 1000 << endl;
#endif
return to_string(i) + " " + to_string(j) + " " + to_string(k);
}
}
}
return "-1 -1 -1";
}
int main()
{
ll N, Y;
cin >> N >> Y;
cout << func(N, Y) << endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
// syntax sugar: `for (int i = 0; i < N; ++i)`
#define rep(i, N) for (int i = 0; i < (int)(N); ++i)
#define rep2(i, startValue, N) for (int i = (int)(startValue); i < (int)(N); ++i)
// syntax sugar: `for (int i = 0; i < N; ++i)`
#define REP(type, name, beginValue, endCondValue) \
for (type name = beginValue; name < endCondValue; ++name)
// syntax sugar: 多次元vector
#define VECTOR_DIM3(T, name, d1, d2, d3, initValue) \
std::vector<std::vector<std::vector<T>>> name(d1, std::vector<std::vector<T>>(d2, std::vector<int>(d3, initValue)));
#define VECTOR_DIM2(T, name, d1, d2, initValue) \
std::vector<std::vector<T>> name(d1, std::vector<T>(d2, initValue));
#define VECTOR_DIM1(T, name, d1, initValue) \
std::vector<T> name(d1, initValue);
#define ll long long
#define ld long double
// ABC085C - Otoshidama
int main(){
int n, y; // 1 <= n <= 2000
cin >> n >> y;
for (int a = 0; a <= n; ++a) {
const int total = a * 10000;
if (y < total) {
break;
}
for (int b = 0; b <= n-a; ++b) {
const int total2 = total + b * 5000;
if (y < total2) {
break;
}
const int c = (n-a-b);
if (total2 + c * 1000 == y) {
cout << a << " " << b << " " << c << endl;
return 0;
}
}
}
cout << "-1 -1 -1" << endl;
return 0;
}
| 1 |
const int LG = 21;
const int FN = 400005;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
#define forn(i, n) for (int (i) = 0; (i) != (n); (i)++)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define popcount(x) __builtin_popcount(x)
#define popcountll(x) __builtin_popcountll(x)
#define fi first
#define se second
#define re return
#define pb push_back
#define uniq(x) sort(all(x)); (x).resize(unique(all(x)) - (x).begin())
#ifdef LOCAL
#define dbg(x) cerr << __LINE__ << " " << #x << " " << x << endl
#define ln cerr << __LINE__ << endl
#else
#define dbg(x) void(0)
#define ln void(0)
#endif // LOCAL
int cx[4] = {-1, 0, 1, 0};
int cy[4] = {0, -1, 0, 1};
string Ans[2] = {"No", "Yes"};
string ANS[2] = {"NO", "YES"};
ll inq(ll x, ll y)
{
if (!y) re 1 % MOD;
ll l = inq(x, y / 2);
if (y % 2) re l * l % MOD * x % MOD;
re l * l % MOD;
}
ll rev(ll x)
{
return inq(x, MOD - 2);
}
bool __precomputed_combinatorics = 0;
vector<ll> __fact, __ufact, __rev;
void __precompute_combinatorics()
{
__precomputed_combinatorics = 1;
__fact.resize(FN);
__ufact.resize(FN);
__rev.resize(FN);
__rev[1] = 1;
for (int i = 2; i < FN; i++) __rev[i] = MOD - __rev[MOD % i] * (MOD / i) % MOD;
__fact[0] = 1, __ufact[0] = 1;
for (int i = 1; i < FN; i++) __fact[i] = __fact[i - 1] * i % MOD, __ufact[i] = __ufact[i - 1] * __rev[i] % MOD;
}
ll fact(int x)
{
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[x];
}
ll cnk(int n, int k)
{
if (k < 0 || k > n) return 0;
if (!__precomputed_combinatorics) __precompute_combinatorics();
return __fact[n] * __ufact[n - k] % MOD * __ufact[k] % MOD;
}
int Root(int x, vector<int> &root)
{
if (x == root[x]) return x;
return root[x] = Root(root[x], root);
}
void Merge(int v, int u, vector<int> &root, vector<int> &sz)
{
v = Root(v, root), u = Root(u, root);
if (v == u) return;
if (sz[v] < sz[u])
{
sz[u] += sz[v];
root[v] = u;
}
else
{
sz[v] += sz[u];
root[u] = v;
}
}
int ok(int x, int n)
{
return 0 <= x && x < n;
}
void bfs(int v, vi &dist, vector<vi> &graph)
{
fill(all(dist), -1);
dist[v] = 0;
vi q = {v};
for (int i = 0; i < q.size(); i++)
{
for (auto u : graph[q[i]])
{
if (dist[u] == -1)
{
dist[u] = dist[q[i]] + 1;
q.push_back(u);
}
}
}
}
int A[505][505];
signed main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, q;
cin >> n >> m >> q;
forn(i, m)
{
int l, r;
cin >> l >> r;
for (int k = r; k <= n; k++) A[l][k]++;
}
while (q--)
{
int a, b;
cin >> a >> b;
int ans = 0;
for (int i = a; i <= b; i++) ans += A[i][b];
cout << ans << "\n";
}
}
/* Note:
Check constants at the beginning of the code.
N is set to 4e5 but be careful in problems with large constant factor.
Setting N in every problem is more effective.
Check corner cases.
N = 1
No def int long long for now.
Add something here.
*/
| #include <bits/stdc++.h>
// #undef DEBUG // Uncomment this line to forcefully disable debug print.
#if DEBUG
template <typename T>
void debug(T value) {
std::cerr << value;
}
template <typename T, typename... Ts>
void debug(T value, Ts... args) {
std::cerr << value << ", ";
debug(args...);
}
#define dbg(...) \
do { \
cerr << #__VA_ARGS__ << ": "; \
debug(__VA_ARGS__); \
cerr << " (L" << __LINE__ << ")" << endl; \
} while (0)
#else
#define dbg(...)
#endif
void read_from_cin() {}
template <typename T, typename... Ts>
void read_from_cin(T& value, Ts&... args) {
std::cin >> value;
read_from_cin(args...);
}
#define in(type, ...) \
type __VA_ARGS__; \
read_from_cin(__VA_ARGS__);
template <typename T>
void write_to_cout(const T& value) {
std::cout << value << std::endl;
}
template <typename T, typename... Ts>
void write_to_cout(const T& value, const Ts&... args) {
std::cout << value << ' ';
write_to_cout(args...);
}
#define out(...) write_to_cout(__VA_ARGS__);
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
using ll = long long;
using namespace std;
int main() {
in(int, N, M, Q);
vector<int> l(N + 2), r(N + 2);
vector<vector<int>> train(N + 1);
while (M--) {
in(int, L, R);
++l[L];
++r[R];
train[L].push_back(R);
}
vector<int> ls(N + 2), rs(N + 2);
rep(i, N) {
ls[i + 1] = ls[i] + l[i + 1];
rs[i + 1] = rs[i] + r[i + 1];
// rs[N - i] = rs[N - i + 1] + r[N - i];
}
vector outside(N + 1, vector(N + 1, 0));
priority_queue<int> que;
for (int i = 1; i <= N; ++i) {
for (int t : train[i - 1]) {
que.push(-t);
}
while (!que.empty() && -que.top() <= i) {
que.pop();
}
priority_queue<int> que2 = que;
for (int j = i; j <= N; ++j) {
while (!que2.empty() && -que2.top() <= j) {
que2.pop();
}
outside[i][j] = que2.size();
}
}
while (Q--) {
in(int, p, q);
out(rs[q] - ls[p - 1] + outside[p][q]);
// out(M - (ls[p - 1] + rs[q + 1]));
}
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.