code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <bits/stdc++.h>
#define Inf 0x3f3f3f3f
#define rg register
using std::cin;
using std::cout;
const int Maxn = 2e7 + 5, Mod = 998244353;
typedef long long ll;
typedef ll arr[Maxn];
ll Add(ll x, ll y) { return (x += y) >= Mod ? x - Mod : (x < 0 ? x + Mod : x); }
ll min(ll x, ll y) { return x < y ? x : y; }
ll max(ll x, ll y) { return x > y ? x : y; }
inline ll read()
{
rg ll res = 0, sign = 1;
rg char ch = getchar();
while (!isdigit(ch))
{
if (ch == '-')
sign = -1;
ch = getchar();
}
do
{
res = (res << 3) + (res << 1) + (ch ^ 48);
ch = getchar();
} while (isdigit(ch));
return res * sign;
}
int n, m;
arr fac, inv, invfac;
ll ans;
ll qp(ll x, int y)
{
ll res = 1;
while (y)
{
if (y & 1)
res = res * x % Mod;
x = x * x % Mod;
res >>= 1;
}
return res;
}
ll C(int x, int y) { return fac[x] * invfac[y] % Mod * invfac[x - y] % Mod; }
int main()
{
fac[0] = inv[1] = invfac[0] = 1;
for (rg int i = 1; i <= 20000000; i++)
{
fac[i] = fac[i - 1] * i % Mod;
if (i > 1)
inv[i] = (Mod - Mod / i) * inv[Mod % i] % Mod;
invfac[i] = invfac[i - 1] * inv[i] % Mod;
}
rg int tmp;
cin >> n >> m;
ans = 1;
for (rg int i = 1; i < n; i++)
ans = ans * (3 * m + i) % Mod;
ans = ans * invfac[n - 1] % Mod;
ans = Add(ans, -(n * C(m - 1 + n - 1, n - 1) % Mod));
if (n > m)
{
tmp = min(3 * m, n);
for (rg int i = m + 2; i <= tmp; i += 2)
ans = Add(ans, -(C(n, i) * C((3 * m - i) / 2 + n - 1, n - 1) % Mod));
}
cout << ans << '\n';
return 0;
} | #include<bits/stdc++.h>
using namespace std;
// (POLICY BASED DS)
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// using namespace __gnu_pbds;
// template<typename T>
// using ordered_set=tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
// template<typename T>
// using ordered_multiset=tree<T,null_type,less_equal<T>,rb_tree_tag,tree_order_statistics_node_update>;
// ( find_by_order( ) , order_of_key( ) )
typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<long long> vll;
typedef pair<ll,ll> pll;
const ll mod = 1e9 + 7;
const ld PI = 3.1415926535897932384626;
const ld eps = 1e-9;
#define boost ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define sidha(i,a,b) for(ll i=(ll)(a);i<(ll)(b);++i)
#define ulta(i,a,b) for(ll i=(ll)(a);i>=(ll)(b);--i)
#define stl(container,itr) \
for(auto itr = container.begin(); itr != container.end(); itr++)
#define sab(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define test ll t;cin>>t;while(t--)
#define sz size()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
#define LOG2(X) (63ll - __builtin_clzll(X))
#define endl '\n'
#define modinv(x) power(x, mod-2)
#define ncr(n,r) ( n >= r ? ((((fact[n]*modinv(fact[r]))%mod)*modinv(fact[n-r]))%mod) : (ll)0)
#define MAX 100005
ll power(ll x, ll y) {
ll ans=1;
x=x%mod;
while(y>0) {
if (y&1)
ans=(ans*x)%mod;
y=y>>1;
x=(x*x)%mod;
}
return ans;
}
// vector<ll> adj[MAX];
// ll visit[MAX];
// void dfs(ll node){
// visit[node]=1;
// for(auto i : adj[node]){
// if(!visit[i]) dfs(i);
// }
// }
// ll spf[MAX];
// void sieve(){
// sidha(i,1,MAX) spf[i]=i;
// for(ll i=4;i<MAX;i+=2) spf[i]=2;
// for(ll i=3;i*i<=MAX;i++){
// if(spf[i]==i){
// for(ll j=i*i;j<MAX;j+=i){
// if(spf[j]==j) spf[j]=i;
// }
// }
// }
// }
int main()
{
boost;
ll n,count=0,ans=0;
cin>>n;
ll arr[n],suff[n];
sidha(i,0,n) cin>>arr[i];
ulta(i,n-1,0){
suff[i]=count;
count=((count+arr[i])%mod);
}
sidha(i,0,n){
ans=((ans+((arr[i]*suff[i])%mod))%mod);
}
cout<<ans;
return 0;
}
| 0 |
#pragma region header
#include <bitset>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <cctype>
#include <assert.h>
#include <stdlib.h>
#include <stdio.h>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <limits>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <math.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define rev(i, n) for(int i = (int)(n - 1); i >= 0; i--)
#define rev1(i, n) for(int i = (int)(n); i > 0; i--)
#define pb push_back
#define all(v) (v).begin(), (v).end()
#define resort(v) sort((v).rbegin(), (v).rend())
#define vi vector<int>
#define vvi vector<vector<int>>
#define vs vector<string>
#define vvs vector<vector<string>>
#define vc vector<char>
#define vvc vector<vector<char>>
#define vb vector<bool>
#define vvb vector<vector<bool>>
using ll = long long;
using P = pair<int, int>;
/* ----------------よく使う数字や配列----------------- */
int dx[] = { 1,0,-1,0 };
int dy[] = { 0,1,0,-1 };
constexpr ll mod = 1e9 + 7;
constexpr ll inf = INT32_MAX / 2;
constexpr ll INF = LLONG_MAX / 2;
constexpr long double eps = DBL_EPSILON;
constexpr long double pi = 3.141592653589793238462643383279;
signed main() {
string S;
cin >> S;
int size = S.size();
vector<int> date;
rep(i, S.size() - 2) {
string suuji=(S.substr(i, 3));
int a=stoi(suuji);
int b = abs(753 - a);
date.push_back(b);
}
sort(date.begin(), date.end());
cout << abs(date.at(0)) << endl;
} | #include<bits/stdc++.h>
using namespace std;
int main(){
string s;
cin >> s;
bool flg = true;
int c_cnt = 0;
for(int i=0; i<s.length(); i++){
if(i==0){
if(s.at(i)!= 'A'){
flg = false; break;
}
}else if(isupper(s.at(i))){
if(i==1 || i==s.length()-1 || s.at(i) != 'C'){
flg = false; break;
}
c_cnt++;
}
}
if(c_cnt != 1)
flg = false;
if(flg) cout << "AC" << endl;
else cout << "WA" << endl;
return 0;
} | 0 |
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#include<vector>
#include<string>
#include<sstream>
#include<iomanip>
#include<utility>
#include<cmath>
#include<set>
#include<list>
#include<queue>
#include<stack>
#include<map>
#include<set>
using namespace std;
typedef long long int ll;
const int MAX=100000;
const int INFTY=1<<30;
int n,col[MAX],d[MAX];
vector<pair<int,int>> Q[MAX];//target,weight
void dijkstra(int s)
{
priority_queue<pair<int,int>> PQ;//weight,id
for(int i=0;i<n;i++)
{
d[i]=INFTY;
col[i]=0;
}
d[s]=0;
PQ.push(make_pair(0,s));
col[s]=1;
while(!PQ.empty())
{
pair<int,int> f=PQ.top();PQ.pop();
int u=f.second;
col[u]=2;
if(d[u]<f.first*(-1))continue;
for(int j=0;j<Q[u].size();j++)
{
int v=Q[u][j].first;
if(col[v]==2)continue;
if(d[u]+Q[u][j].second<d[v])
{
d[v]=d[u]+Q[u][j].second;
PQ.push(make_pair(d[v]*(-1),v));
col[v]=1;
}
}
}
for(int i=0;i<n;i++)
{
if(d[i]==INFTY)cout<<"INF"<<endl;
else cout<<d[i]<<endl;
}
return;
}
int main()
{
cin>>n;
int u;int m;cin>>m>>u;
int s,t,w;
for(int i=0;i<m;i++)
{
cin>>s>>t>>w;
Q[s].push_back(make_pair(t,w));
}
dijkstra(u);
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
// #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define all(c) begin(c), end(c)
#define range(i,a,b) for(int i = a; i < (int)(b); i++)
#define rep(i,b) range(i,0,b)
#define eb emplace_back
typedef long long ll;
#define int ll
auto const inf = numeric_limits<int>::max()/4;
using Weight = int;
using Capacity = int;
struct Edge {
int src, dst; Weight weight;
Edge(int s, int d, int w) : src(s), dst(d), weight(w) {}
};
using Edges = vector<Edge>;
using Graph = vector<Edges>;
using Array = vector<Weight>;
using Matrix = vector<Array>;
pair<vector<Weight>, bool> spfa(const Graph &g, int s){
const Weight inf = numeric_limits<Weight>::max()/4;
const int n = g.size(); priority_queue<int> q;
vector<Weight> dist(n, inf); vector<int> inQ(n);
vector<int> count(n);
dist[s] = 0; q.emplace(s); inQ[s] = true; ++count[s];
bool negCycle = false;
for(int i = 0; q.size(); i++){
int v = q.top(); q.pop(); inQ[v] = false;
for(auto &e : g[v]){
if(dist[v] != inf && dist[e.dst] > dist[v] + e.weight){
dist[e.dst] = dist[v] + e.weight;
if(!inQ[e.dst]){
q.emplace(e.dst); inQ[e.dst] = true; ++count[e.dst];
if(count[e.dst] >= n){ negCycle = true; goto END; }
}
}
}
}
END:;
return make_pair(dist, !negCycle);
}
signed main(){
int V,E,r;
while(cin >> V >> E >> r){
Graph g(V);
rep(i,E){
int a,b,c;
cin >> a >> b >> c;
g[a].eb(a,b,c);
}
bool ok;
vector<Weight> dist;
tie(dist, ok) = spfa(g,r);
if(ok){
for(int i = 0; i < (int)dist.size(); i++){
if(dist[i] == inf) cout << "INF";
else cout << dist[i];
cout << endl;
}
} else {
cout << "NEGATIVE CYCLE" << endl;
}
}
} | 1 |
#include <iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<set>
#include<map>
#define debug(a) cout << "*" << a << "*" << endl
using namespace std;
typedef long long ll;
char mp[50][101];
int m, n;
void fill_mp(int num, int x, char ch)
{
for (int i = x; ; i += 2)
{
for (int j = 0; j < 100; j += 2)
{
if (num == 0) return;
mp[i][j] = ch;
num--;
}
}
}
int main()
{
while (~scanf("%d%d", &m, &n))
{
for (int i = 0; i < 25; i++)
{
memset(mp[i], '#', sizeof(mp[i]));
}
for (int i = 25; i < 50; i++)
{
memset(mp[i], '.', sizeof(mp[i]));
}
for (int i = 0; i < 50; i++) mp[i][100] = 0;
m--, n--;
fill_mp(m, 0, '.'), fill_mp(n, 26, '#');
printf("50 100\n");
for (int i = 0; i < 50; i++) printf("%s\n", mp[i]);
}
}
| #include<bits/stdc++.h>
#define rep(i,n) for (int i=0; i<n; i++)
#define REP(i,x,n) for (int i=x; i<n; i++)
using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using ll = long long;
int main(){
int n;
cin >> n;
string s;
cin >> s;
vi v1(n);
rep(i,n){
if (i == 0){
v1.at(i) = 0;
continue;
}
v1.at(i) += v1.at(i-1) ;
if (s.at(i-1) == 'W') v1.at(i)++;
}
vi v2(n);
rep(i,n){
if (i == 0){
v2.at(i) = 0;
continue;
}
v2.at(i) += v2.at(i-1);
if (s.at(n-i) == 'E') v2.at(i)++;
}
vi v3(n);
rep(i,n){
v3.at(i) = v1.at(i) + v2.at(n-1-i);
}
sort(v3.begin(),v3.end());
cout << v3.at(0) << endl;
return 0;
}
| 0 |
#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
#include <string>
#include <cmath>
#include <iomanip>
#include <map>
#include <set>
#include <numeric>
#include <queue>
using namespace std;
#define loop(i,N) for(ll (i)=0; (i)<(N);++(i))
struct TEMP_OMAZINAI_ { TEMP_OMAZINAI_() { std::ios::sync_with_stdio(false); std::cin.tie(0); } } TEMP__omazinai_instance__;
#define INF ((1LL<<61) + (1<<29))
#define YesNo(x) {std::cout << ((x)?"Yes":"No") << std::endl;}
#define YESNO(x) {std::cout << ((x)?"YES":"NO") << std::endl;}
#define OddEven(x) {std::cout << ((x)%2?"Odd":"Even") << std::endl;}
#define ODDEVEN(x) {std::cout << ((x)%2?"ODD":"EVEN") << std::endl;}
typedef long long int ll;
ll my_gcd(ll a, ll b) { return b ? my_gcd(b, a%b) : a; };
void TEMP_INPUT_IMPL_() {};
template <class T, class... Args> void TEMP_INPUT_IMPL_(T& dest, Args&... args) { cin >> dest; TEMP_INPUT_IMPL_(args...); }
void TEMP_OUTPUT_IMPL_() {};
template <class T, class... Args> void TEMP_OUTPUT_IMPL_(T dest, Args... args) { cout << dest << (sizeof...(Args) ? " " : ""); TEMP_OUTPUT_IMPL_(args...); }
#define in(type, ...) type __VA_ARGS__; TEMP_INPUT_IMPL_(__VA_ARGS__)
#define in_v(type, name, cnt) vector<type> name(cnt); loop(i, cnt) cin >> name[i];
#define sort_v(v) std::sort(v.begin(), v.end())
#define rsort_v(v) std::sort(v.rbegin(), v.rend())
#define unique_v(v) v.erase(std::unique(v.begin(), v.end()), v.end()) //必ずソート後に実行
#define out(...) (TEMP_OUTPUT_IMPL_(__VA_ARGS__), std::cout<<std::endl)
#define set_fix(x) ((std::cerr<<std::fixed<<std::setprecision(x)),(std::cout<<std::fixed<<std::setprecision(x)))
//小さい方に寄る
#define space_op(x, y, a, b, c) ([](auto x_, auto y_, auto a_, auto b_, auto c_){if(x_<y_)return a_;if(x_>y_)return c_;return b_;}(x,y,a,b,c))
#define space_out(x, y, a, b, c) out(space_op(x, y, a, b, c))
// ^^^ Template ^^^ //
struct UnionFind{
vector<ll> parent;
vector<ll> size;
UnionFind() = delete;
UnionFind(ll n) : parent(n), size(n, 1){
loop(i, n)
parent[i] = i;
}
int find(ll x) {
if(parent[x] == x) return x;
return parent[x] = find(parent[x]);
}
void unite(ll x_, ll y_){
ll x = find(x_);
ll y = find(y_);
if(x==y) return ;
if(size[x] < size[y]) swap(x, y);
parent[y] = x;
size[x] += size[y];
}
bool same(ll x, ll y){
return find(x) == find(y);
}
};
int main() {
in(ll, N);
vector<pair<ll, ll>> xv(N), yv(N);
vector<pair<ll, pair<ll, ll>>> ev;
ev.reserve(N*3);
//set<ll> u;
ll ans = 0;
loop(i, N){
in(ll, x, y);
xv[i] = {x, i};
yv[i] = {y, i};
}
sort_v(xv);
sort_v(yv);
loop(i, N-1){
// x
ev.push_back({
xv[i+1].first - xv[i].first,
make_pair(xv[i].second, xv[i+1].second)
});
ev.push_back({
xv[i+1].first - xv[i].first,
make_pair(xv[i+1].second, xv[i].second)
});
// y
ev.push_back({
yv[i+1].first - yv[i].first,
make_pair(yv[i].second, yv[i+1].second)
});
ev.push_back({
yv[i+1].first - yv[i].first,
make_pair(yv[i+1].second, yv[i].second)
});
}
sort_v(ev);
UnionFind uf(N);
for(auto e : ev){
if(!uf.same(e.second.first, e.second.second)){
ans += e.first;
uf.unite(e.second.first, e.second.second);
}
}
out(ans);
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll N;
typedef tuple<ll, ll, ll> Point;
vector<Point> Points[2];
typedef tuple<ll, ll, ll> Edge;
vector<Edge> Edges;
vector<ll> Parent, Rank;
ll R;
void init() {
Parent.resize(N, -1);
Rank.resize(N, 0);
}
ll root(ll v) {
if (Parent[v] == -1) return v;
return Parent[v] = root(Parent[v]);
}
bool same(ll u, ll v) { return root(u) == root(v); }
void unite(ll u, ll v) {
u = root(u);
v = root(v);
if (u == v) return;
if (Rank[u] < Rank[v]) swap(u, v);
Parent[v] = u;
if (Rank[u] == Rank[v]) ++Rank[u];
}
int main() {
cin >> N;
for (ll v = 0; v < N; ++v) {
ll x, y;
cin >> x >> y;
Points[0].push_back(Point(x, y, v));
Points[1].push_back(Point(y, x, v));
}
for (ll k : {0, 1}) sort(Points[k].begin(), Points[k].end());
for (ll k : {0, 1})
for (ll i = 0; i < N - 1; ++i) {
ll x, y, u, x2, y2, v;
tie(x, y, u) = Points[k][i];
tie(x2, y2, v) = Points[k][i + 1];
Edges.push_back(Edge(min(abs(x2 - x), abs(y2 - y)), u, v));
}
sort(Edges.begin(), Edges.end());
init();
for (Edge edge : Edges) {
ll d, u, v;
tie(d, u, v) = edge;
if (!same(u, v)) {
unite(u, v);
R += d;
}
}
cout << R << endl;
return 0;
}
| 1 |
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
int main()
{
for(;;){
vector<int> card(5);
if(!(cin >> card[0]))
return 0;
for(int i=1; i<5; ++i){
char c;
cin >> c >> card[i];
}
sort(card.begin(), card.end());
vector<int> num(5, 0);
for(int i=0; i<5; ++i){
int j = i+1;
while(j < 5 && card[j] == card[i])
++ j;
++ num[j-i];
i = j-1;
}
if(num[4] == 1)
cout << "four card" << endl;
else if(num[3] == 1 && num[2] == 1)
cout << "full house" << endl;
else if(num[3] == 1)
cout << "three card" << endl;
else if(num[2] == 2)
cout << "two pair" << endl;
else if(num[2] == 1)
cout << "one pair" << endl;
else if(card[0] == 1 && card[1] + 3 == card[4])
cout << "straight" << endl;
else if(card[0] + 4 == card[4])
cout << "straight" << endl;
else
cout << "null" << endl;
}
} | #include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define inf 0x3f3f3f3f
#define MAX(x,y) x=max(x,y)
using namespace std;
const int N=18;
const int M=32775;
int n,m,bin[N],num[M],ma[N][M],sum[M],f[N][M],g[M];
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;
}
int lowbit(int x)
{
return x&(-x);
}
int main()
{
n=read();m=read();
bin[0]=1;
for (int i=1;i<=n;i++) bin[i]=bin[i-1]*2,num[bin[i]]=i;
int tot=0;
for (int i=1;i<=m;i++)
{
int x=read()-1,y=read()-1,z=read();tot+=z;
ma[x][bin[y]]=ma[y][bin[x]]=z;
}
for (int i=0;i<n;i++)
for (int j=1;j<bin[n];j++)
ma[i][j]=ma[i][j-lowbit(j)]+ma[i][lowbit(j)];
for (int i=1;i<bin[n];i++) sum[i]=sum[i-lowbit(i)]+ma[num[lowbit(i)]][i-lowbit(i)];
for (int i=0;i<n;i++)
for (int j=0;j<bin[n];j++)
f[i][j]=-inf;
f[0][1]=0;
for (int j=0;j<bin[n];j++)
for (int i=0;i<n-1;i++)
{
if (f[i][j]<0) continue;
for (int k=0;k<n;k++)
if (!(j&bin[k])&&ma[i][bin[k]]) MAX(f[k][j+bin[k]],f[i][j]+ma[i][bin[k]]);
}
for (int i=0;i<bin[n];i++) g[i]=f[n-1][i];
for (int i=1;i<bin[n];i++)
{
if (g[i]<0) continue;
int r=i^(bin[n]-1);
for (int s=r;s;s=(s-1)&r)
{
int mxv=0;
for (int j=i;j;j-=lowbit(j)) mxv=max(mxv,sum[s+lowbit(j)]);
MAX(g[i+s],g[i]+mxv);
}
}
printf("%d",tot-g[bin[n]-1]);
return 0;
} | 0 |
#include <bits/stdc++.h>
#define MAX 100005
#define bit(x) (1ll << x)
using namespace std;
int n;
int cnt[64];
long long a[MAX], ans;
inline long long Rd() {
long long x = 0; char ch = getchar();
while(!isdigit(ch)) ch = getchar();
while(isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x;
}
struct linear_base {
long long u[60];
inline void insert(long long val) {
for(int i = 59; i >= 0; --i) {
if(val & bit(i)) {
if(u[i]) val ^= u[i];
else {
u[i] = val;
return;
}
}
}
}
inline long long query() {
long long res = 0;
for(int i = 59; i >= 0; --i)
if((res ^ u[i]) > res) res ^= u[i];
return res;
}
}lsk;
int main() {
n = Rd();
for(int i = 1; i <= n; ++i) {
a[i] = Rd();
for(int j = 59; j >= 0; --j)
if(a[i] & bit(j)) ++cnt[j];
}
for(int i = 59; i >= 0; --i) {
if(cnt[i] & 1) {
ans += bit(i);
for(int j = 1; j <= n; ++j) {
if(a[j] & bit(i)) {
a[j] ^= bit(i);
}
}
}
}
for(int i = 1; i <= n; ++i) lsk.insert(a[i]);
cout << ans + 2ll * lsk.query() << endl;
return 0;
} | #include "bits/stdc++.h"
#define rep(i,n) for(int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
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(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> a(n);
rep(i,n) cin >> a[i];
ll ans = 0, cnt = 0;
if(a[0] != 0){
cout << -1 << endl;
return 0;
}
vector<int> b(n, 0);
for(int i = n-1; i >= 0; i--){
if(b[i] > a[i]){
cout << -1 << endl;
return 0;
}
if(i > 0) b[i-1] = max(0, a[i] - 1);
if(a[i] == b[i]) continue;
ans += a[i];
}
cout << ans << 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 <string>
#include <algorithm>
using namespace std;
int main(){
int n;
while(cin>>n){
if(n==0)
break;
int da[22][22]={};
int x,y;
for(int i=0;i<n;i++){
cin>>x>>y;
da[y][x]=1;
}
int m;
cin>>m;
char v;
int l;
int nx=10,ny=10;
for(int i=0;i<m;i++){
cin>>v;
cin>>l;
if(v=='N'){
for(int j=1;j<=l;j++)
da[ny+j][nx]=0;
ny+=l;
}
if(v=='E'){
for(int j=1;j<=l;j++)
da[ny][nx+j]=0;
nx+=l;
}
if(v=='S'){
for(int j=1;j<=l;j++)
da[ny-j][nx]=0;
ny-=l;
}
if(v=='W'){
for(int j=1;j<=l;j++)
da[ny][nx-j]=0;
nx-=l;
}
}
for(int i=0;i<22;i++){
for(int j=0;j<22;j++){
if(da[i][j]==1){
cout<<"No"<<endl;
j=30;
i=30;
break;
}
}
if(i==21)
cout<<"Yes"<<endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5000500;
const int mod = 1e9 + 7;
int a[maxn], pref[maxn], cntzer[maxn];
long long dp[maxn];
vector < int > v[maxn];
long long add(long long a, long long b){
a += b;
if(a >= mod) a -= mod;
return a;
}
long long mul(long long a, long long b){
return (a * b) % mod;
}
long long solve_fixed(int n, int X){
dp[pref[n - 1]] = 1;
long long ans = (pref[n - 1] == X ? 1:0);
for(int i = n - 2 ; i >= 0 ; --i){
if(pref[i] == X) ans = add(ans, dp[0]);
dp[pref[i]] = add(dp[pref[i]],dp[X ^ pref[i]]);
}
return ans;
}
int main(){
ios::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int n;
cin >> n;
long long xr = 0;
for(int i = 0 ; i < n ; ++i)
cin >> a[i];
pref[0] = a[0];
cntzer[0] = (a[0] ? 0:1);
v[a[0]].push_back(0);
for(int i = 1 ; i < n ; ++i){
pref[i] = a[i] ^ pref[i - 1];
cntzer[i] = !pref[i] + cntzer[i - 1];
v[pref[i]].push_back(i);
}
long long ans = solve_fixed(n, 0);
for(int i = 1 ; i < maxn ; ++i){
if((int)v[i].size() == 0 || (v[i][(int)v[i].size() - 1] != n - 1 && pref[n - 1])) continue;
long long smx = 1, sm0 = !pref[n - 1];
ans = add(ans, smx);
for(int j = (int)v[i].size() - 2 ; j >= 0 ; --j){
sm0 = add(sm0, mul(cntzer[v[i][j + 1]] - cntzer[v[i][j]], smx));
ans = add(ans, sm0);
smx = add(smx, sm0);
}
}
cout << ans << '\n';
return 0;
} | #include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace __gnu_pbds;
using namespace std;
typedef long long int ll;
#define int long long
#define pb push_back
#define fi first
#define se second
#define fr(i, a, b) for(int i = a; i <= b; i++)
#define all(x) x.begin(), x.end()
#define IO ios :: sync_with_stdio(0), cin.tie(0), cout.tie(0)
#define pii pair<int,int>
#define sz(x) (int)x.size()
const int mod = 1e9 + 7;
const int mod1 = 998244353;
typedef long double f80;
#ifndef LOCAL
#pragma GCC optimize ("O2")
#define endl '\n'
#endif
template<typename T>
using ordered_set = tree<T,null_type,less<T>,rb_tree_tag,tree_order_statistics_node_update>;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int rand(int l, int r){
uniform_int_distribution<int> uid(l, r);
return uid(rng);
}
ll pwr(ll a,ll b, ll mod){
a %= mod;
int ans = 1;
while(b){
if(b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
string to_string(string s) {
return '"' + s + '"';
}
string to_string(const char* s) {
return to_string((string) s);
}
string to_string(bool b) {
return (b ? "true" : "false");
}
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(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
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
const int N = 5e5 + 5;
int a[N], pre[N];
int dp[N];
map<int,int> m, m1;
void solve(){
int n;
cin >> n;
fr(i, 1, n){
cin >> a[i];
pre[i] = pre[i - 1] ^ a[i];
}
int ans = 0;
if(pre[n] != 0){ // xor != 0 and odd partitions ...
int s0 = 1, s1 = 0;
int val = pre[n];
fr(i, 1, n){
if(pre[i] == val){
dp[i] = s0;
s1 += dp[i];
s1 %= mod;
}
else if(pre[i] == 0){
dp[i] = s1;
s0 += dp[i];
s0 %= mod;
}
}
cout << dp[n] << endl;
return;
}
// xor = 0
int c = 0;
fr(i, 1, n - 1){
if(pre[i] == 0)
c++;
}
ans = pwr(2, c, mod);
// xor != 0
int c0 = 1;
m[0] = 1;
dp[0] = 1;
fr(i, 1, n){
if(pre[i] == 0){
c0++;
}
else{
dp[i] = (m1[pre[i]] * c0 - m[pre[i]] + mod + 1) % mod;
ans += dp[i];
ans %= mod;
m[pre[i]] += c0 * dp[i];
m[pre[i]] %= mod;
m1[pre[i]] += dp[i];
m1[pre[i]] %= mod;
}
}
cout << ans;
}
signed main(){
IO;
#ifdef LOCAL
freopen("inp.txt","r", stdin);
freopen("out.txt", "w", stdout);
#endif
cout << setprecision(10) << fixed;
int t = 1;
// cin >> t;
fr(tt, 1, t){
solve();
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#define ll long long
#define str string
#define pii pair<int, int>
#define pll pair<ll, ll>
#define fi first
#define se second
#define vc vector<char>
#define vvc vector<vc>
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define vvll vector<vll>
#define vvvll vector<vvll>
#define vs vector<str>
#define vvs vector<vs>
#define vpii vector<pii>
#define vvpii vector<vpii>
#define vpll vector<pll>
#define vvpll vector<vpll>
#define vb vector<bool>
#define vvb vector<vb>
#define rep(i, a, b) for (int i = (a); i < int(b); i++)
#define repi(i, a, b) for (int i = (a); i <= int(b); i++)
using namespace std;
ll INF = LONG_LONG_MAX;
ll mod = 1000000000 + 7;
template <typename T, typename L>
void read(vector<T> & _data, L & _size, bool _shift) {
_data.resize(_size + (ll)_shift);
for (ll i = (ll)_shift; i < _size + (ll)_shift; i++)
cin >> _data[i];
}
template <typename T, typename L>
void read(vector<vector<T>> & _data, L & _rows, L & _cols, bool _shiftRows, bool _shiftCols) {
_data.resize(_rows + (ll)_shiftRows);
for (ll i = 0; i < _rows + (ll)_shiftRows; i++)
_data[i].resize(_cols + (ll)_shiftCols);
for (ll i = (ll)_shiftRows; i < _rows + (ll)_shiftRows; i++)
for (ll j = (ll)_shiftCols; j < _cols + (ll)_shiftCols; j++)
cin >> _data[i][j];
}
template <typename T>
void write(vector<T> & _data, bool _shift) {
for (ll i = (ll)_shift; i < _data.size(); i++)
cout << _data[i] << " ";
cout << endl;
}
//TODO: SOLUTION
ll h, w;
vll l, r;
void solve() {
cin >> h >> w;
l.resize(h + 1);
r.resize(h + 1);
repi(i, 1, h) {
cin >> l[i] >> r[i];
}
set<pll> s;
map<ll, ll> m;
m[0] = 0;
repi(i, 1, w) {
s.insert({i, i});
m[0]++;
}
ll x = 1;
while (x != h + 1) {
auto it = s.lower_bound({l[x], 0});
ll ans = INF;
vpll todel;
vpll toins;
while (it != s.end() && it->first <= r[x]) {
//cout << it->fi << " "<< it->se << ", ";
toins.push_back({r[x] + 1, it->second});
todel.push_back({it->first, it->second});
it++;
}
for (auto p : todel) {
m[p.first - p.second]--;
if (m[p.first - p.second] == 0)
m.erase(p.first - p.second);
s.erase(p);
//cout << "delete " << p.second << ":" << p.first << endl;
}
if (!toins.empty()) {
auto p = toins[toins.size() - 1];
//cout << "insert " << p.se << ":" << p.fi << endl;
if (m.count(p.first - p.second) && p.first <= w)
m[p.first - p.second]++;
else if (p.first <= w)
m[p.first - p.second] = 1;
if (p.first <= w)
s.insert(p);
}
if (m.empty()) {
cout << -1 << endl;
}
else {
cout << x + m.begin()->fi << endl;
}
x++;
}
}
int main() {
// TODO: Set value of this variable manually
bool _multipleTestCases = false;
if (_multipleTestCases) {
ll t; cin >> t;
while (t--)
solve();
}
else {
solve();
}
return 0;
} | /*Hatsune Miku 4ever!*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define _for(i,a,b) for(int i = (a);i < b;i ++)
#define _rep(i,a,b) for(int i = (a);i > b;i --)
#define INF 0x3f3f3f3f
#define mod 1000000007
#define lowbit(x) ((x)&(-x))
#define pb push_back
#define MIKU 39
#define Design ios::sync_with_stdio(0),cin.tie(0),cout.tie(0)
#define debug() printf("Miku Check OK!\n")
#define maxn 200039
int n, m;
struct SegTree
{
struct SegNode
{
int l,r;
ll add;
ll ans;
#define l(x) tree[x].l
#define r(x) tree[x].r
#define add(x) tree[x].add
#define ANS(x) tree[x].ans
}tree[maxn<<2];
void build(int p,int l,int r)
{
add(p) = 0;
l(p) = l,r(p) = r;
if(l==r)
{
ANS(p) = 0;
return ;
}
int mid = (l+r)/2;
build(p*2, l, mid);
build(p*2+1, mid+1, r);
}
void spread(int p)
{
if(add(p))
{
ANS(p*2) = l(p) - add(p);
ANS(p*2+1) = (l(p)+r(p))/2+1-add(p);
add(p*2) = add(p);
add(p*2+1) = add(p);
add(p) = 0;
}
}
void change(int p,int l,int r,ll d)
{
if(l <= l(p) && r >= r(p))
{
ANS(p) = l(p) - d;
add(p) = d;
return ;
}
spread(p);
int mid = (l(p)+r(p))/2;
if(l <= mid)
change(p*2, l, r, d);
if(r > mid)
change(p*2+1, l, r, d);
ANS(p) = min(ANS(p*2),ANS(p*2+1));
}
ll ask(int p,int pos)
{
if(l(p)==r(p))
return pos - ANS(p);
spread(p);
int mid = (l(p)+r(p))/2;
if(pos <= mid)
return ask(p*2, pos);
else
return ask(p*2+1, pos);
}
}T;
int main()
{
int H, W;
scanf("%d%d",&H,&W);
T.build(1,1,W);
int now = 1;
_for(i,1,H+1)
{
int a, b;
scanf("%d%d",&a,&b);
if(now < a)
T.change(1,a,b,T.ask(1,a-1));
else if(now >= a && now <= b)
{
T.change(1,now,b,-1000000);
now = b+1;
}
if(now > W)
printf("-1\n");
else
printf("%lld\n",T.tree[1].ans+i);
}
return 0;
} | 1 |
#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <numeric>
#include <set>
using namespace std;
#define REP(i, n) for(int i = 0; i < n; i++)
#define FOR(i, m, n) for(int i = m; i < n; i++)
#define ALL(x) (x).begin(),(x).end() //sortなどの引数を省略したい
#define SIZE(x) ((ll)(x).size()) //sizeをsize_tからllに直しておく
#define MAX(x) *max_element(ALL(x)) //最大値を求める
#define MIN(x) *min_element(ALL(x)) //最小値を求める
typedef long long ll;
typedef long double ld;
int main(){
set<ll> v;
ll n;cin>>n;
REP(i,n){
ll a;cin>>a;
if(v.find(a)!=v.end()){
v.erase(a);
}else{
v.insert(a);
}
}
cout<<v.size()<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const long long INF = 1LL << 60;
int main() {
int N, count = 0;
cin >> N;
vector<int> v(N);
for(int i=0; i<N; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
for(int i=0; i<N; i++) {
if(v[i] == v[i+1] && i <= N-2) {
i++;
}
else {
count++;
}
}
cout << count << endl;
} | 1 |
#include <stdio.h>
#include <cstdio>
#include <iostream>
#include <iomanip>
#include <queue>
#include <set>
#include <vector>
#include <string>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <complex>
using ll = long long int;
using namespace std;
int main(){
ll N, tmp;
vector<ll> A;
cin >> N;
for(ll i = 0; i < N; i++){
cin >> tmp;
A.push_back(tmp);
}
// if N is even
if(N%2 == 0){
cerr << "N is even." << endl;
vector<ll> accum(N);
accum[0] = A[0];
for(ll i = 2; i < N; i+=2){
accum[i] = accum[i-2] + A[i];
}
accum[N-1] = A[N-1];
for(ll i = N-3; i >= 1; i-=2){
accum[i] = accum[i+2] + A[i];
}
ll ans = max(accum[N-2], accum[1]);
for(ll i = 0; i<=N-4; i+=2){
ans = max(ans, accum[i]+accum[i+3]);
}
cerr << "Answer:" << endl;
cout << ans << endl;
return 0;
}
// N is odd
else{
cerr << "N is odd." << endl;
vector<ll> accum(N);
accum[0] = A[0];
for(ll i = 2; i < N; i++){
accum[i] = accum[i-2] + A[i];
}
accum[N-2] = A[N-2];
for(ll i = N-4; i >= 1; i-=2){
accum[i] = accum[i+2] + A[i];
}
vector<ll> diff(N);
for(ll i = 1; i <= N-4; i+=2){
diff[i] = accum[i-1] + accum[i+2] - accum[1];
}
for(ll i = 2; i <= N-3; i+=2){
diff[i] = accum[N-1]-accum[i] + accum[1] - accum[i+1] - accum[1];
}
diff[N-2] = accum[N-3] - accum[1];
diff[0] = accum[2] - accum[1];
vector<ll> eomax(N);
eomax[N-3] = diff[N-3];
for(ll i = N-5; i >= 0; i-=2){
eomax[i] = max(eomax[i+2], diff[i]);
}
ll ans = max(max(accum[N-1]-accum[0], accum[N-3]), accum[1]);
for(ll oe = 1; oe < N-2; oe+=2){
ans = max(ans, accum[1]+diff[oe]+eomax[oe+1]);
}
cerr << "Answer:" << endl;
cout << ans << endl;
return 0;
}
}
| //ヘッダー
#include<bits/stdc++.h>
using namespace std;
//型定義
typedef long long ll;
//定数
const ll INF=1e+17;
const int MOD=1e+9+7;
//REPマクロ
#define REP(i,n) for(ll i=0;i<(ll)(n);i++)
#define REPD(i,n) for(ll i=n-1;i>=0;i--)
#define REP2(i,a,b) for(ll i=a;i<(ll)(b);i++)
#define REPD2(i,a,b) for(ll i=a;i>(ll)(b);i--)
//vectorの扱い
#define ALL(x) (x).begin(),(x).end() //sortなどの引数省略
#define SIZE(x) ((ll)(x).size()) //size
#define MAX(x) *max_element(ALL(x)) //最大値
#define MIN(x) *min_element(ALL(x)) //最小値
//グローバル変数
//ライブラリ挿入
int main(){
int N;
cin >> N;
vector<ll> A(N);
REP(i,N) cin >> A[i];
vector<vector<ll>> dp(N+1,vector<ll>(2,0));
dp[0][0]=0;
dp[0][1]=0;
dp[1][0]=0;
dp[1][1]=A[0];
REP2(i,1,N){
if(i%2==1){
dp[i+1][0]=max(dp[i][1],dp[i-1][0]+A[i]);
}else{
dp[i+1][0]=max(dp[i][0],dp[i-1][0]+A[i]);
dp[i+1][1]=dp[i-1][1]+A[i];
}
}
cout<<dp[N][0]<<endl;
} | 1 |
#include<stdio.h>
#include<string.h>
#define N 8
int mp[N][N],row[N],col[N],dneg[2*N-1],dops[2*N-1];
void init()
{
for(int i=0; i<N; i++)
row[i]=col[i]=0;
for(int i=0; i<2*N-1; i++)
dneg[i]=dops[i]=0;
for(int i=0; i<N; i++)
for(int j=0; j<N; j++)
mp[i][j]=0;
}
void check()
{
for(int i=0; i<N; i++)
for(int j=0; j<N; j++)
if(mp[i][j])
{
if(row[i]!=j)
return ;
}
for(int i=0; i<N; i++)
{
for(int j=0; j<N; j++)
{
printf("%c",(row[i]==j)?'Q':'.');
}
printf("\n");
}
return ;
}
void dfs(int i)
{
if(i==N)
{
check();
return ;
}
for(int j=0; j<N; j++)
{
if(col[j] || dops[i+j] || dneg[i-j+N-1]) continue;
row[i]=j;
col[j]=dops[i+j]=dneg[i-j+N-1]=1;
dfs(i+1);
row[i]=col[j]=dops[i+j]=dneg[i-j+N-1]=0;
}
}
int main()
{
int k,r,c;
while(~scanf("%d",&k))
{
init();
for(int i=0; i<k; i++)
{
scanf("%d%d",&r,&c);
mp[r][c]=1;
}
dfs(0);
}
return 0;
}
| // clang-format off
#include <bits/stdc++.h>
#define int long long
#define main signed main()
#define loop(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) loop(i, 0, n)
#define forever while (true)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define prec(n) fixed << setprecision(n)
template<typename A> using V = std::vector<A>;
template<typename A> using F = std::function<A>;
template<typename A, typename B> using P = std::pair<A, B>;
using pii = P<int, int>;
using vi = V<int>;
using vd = V<double>;
using vs = V<std::string>;
using vpii = V<pii>;
using vvi = V<vi>;
using vvpii = V<vpii>;
constexpr int INF = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
constexpr int MOD = 1000000007;
constexpr double PI = acos(-1);
template<typename A, typename B> bool cmin(A &a, const B &b) { return a > b ? (a = b, true) : false; }
template<typename A, typename B> bool cmax(A &a, const B &b) { return a < b ? (a = b, true) : false; }
template<typename T> std::istream &operator>>(std::istream &is, std::vector<T> &v) { for (T &x : v) is >> x; return is; }
using namespace std;
// clang-format on
using Weight = int;
struct Edge {
int src, dst;
Weight weight;
Edge(const int &s = 0, const int &d = 0, const Weight &w = 0) : src(s), dst(d), weight(w) {}
};
using Edges = std::vector<Edge>;
using Array = std::vector<Weight>;
using Matrix = std::vector<Array>;
class Graph {
std::vector<Edges> g;
public:
Graph(const int &size = 0) : g(size) {}
void addArc(const int &src, const int &dst, const Weight &w = 1) { g[src].emplace_back(src, dst, w); }
void addEdge(const int &node1, const int &node2, const Weight &w = 1) {
addArc(node1, node2, w);
addArc(node2, node1, w);
}
const Edges &operator[](const int &i) const { return g[i]; }
Graph toRootedTree(int r);
std::pair<std::vector<Weight>, std::vector<int>> dijkstra(const int &src, const int &inf);
Matrix warshallFloyd(const int &inf);
std::pair<Weight, Edges> prim(const int &r);
template<typename UnionFind> std::pair<Weight, Edges> kruskal();
Weight solveTSP(const int &inf);
};
Matrix Graph::warshallFloyd(const int &inf = std::numeric_limits<Weight>::max() / 8) {
int n = g.size();
Matrix d(n, Array(n, inf));
rep(i, n) d[i][i] = 0;
for (auto &adj : g) {
for (auto &e : adj) cmin(d[e.src][e.dst], e.weight);
}
rep(k, n) rep(i, n) rep(j, n) {
if (d[i][k] != inf && d[k][j] != inf) cmin(d[i][j], d[i][k] + d[k][j]);
}
return d;
}
main {
ios::sync_with_stdio(false);
int n, t;
cin >> n >> t;
Graph g(n);
while (t--) {
int s, t, d;
cin >> s >> t >> d;
g.addArc(s, t, d);
}
Matrix d = g.warshallFloyd(INF);
rep(i, n) if (d[i][i] < 0) {
cout << "NEGATIVE CYCLE" << endl;
return 0;
}
rep(i, n) {
rep(j, n) {
if (j) cout << ' ';
cout << (d[i][j] == INF ? "INF" : to_string(d[i][j]));
}
cout << endl;
}
} | 0 |
#include<algorithm>
using namespace std;
#define MAXN 100000
int AC[MAXN] = {};
int WA[MAXN] = {};
int main()
{
int ACCount = 0;
int WACount = 0;
int n,m;
scanf("%d %d",&n,&m);
for(int i = 0; i < m; i++)
{
int curNum;
char first, second;
scanf("%d %c%c", &curNum, &first, &second);
if(AC[curNum - 1] != 0)
{
continue;
}
if(first == 'A')
{
AC[curNum - 1] = 1;
WACount += WA[curNum - 1];
ACCount += 1;
}
else
{
WA[curNum - 1] += 1;
}
}
printf("%d %d",ACCount, WACount);
} | #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>;
vector<int> x(10), y(10);
double dist (int i, int j) {
double dx = x.at(i) - x.at(j);
double dy = y.at(i) - y.at(j);
return pow(dx*dx + dy*dy, 0.5);
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> x.at(i) >> y.at(i);
double sum = 0.0;
vector<int> v(n);
rep(i,n) v.at(i) = i + 1;
do {
for (int i = 0; i < n - 1; ++i) sum += dist(v.at(i), v.at(i+1));
} while (next_permutation(v.begin(), v.end()));
int factorial = 1;
for (int i = 1; i <= n; ++i) factorial *= i;
cout << std::fixed << std::setprecision(15);
cout << sum / factorial << endl;
return 0;
} | 0 |
#include<bits/stdc++.h>
typedef long long int ll;
#define pb push_back
#define pi 3.141592653589793238462643383279
#define int long long
#define ff first
#define ss second
#define endl '\n'
#define inf 21474836478965499999
#define all(x) (x).begin(), (x).end()
#define rep(i,x,y) for(int i=(int)x; i<y; i++)
#define high_functioning_sociopath ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
const unsigned int M = 1000000007;
/*------------------------------------- THE GAME IS ON ---------------------------------------------*/
void solve()
{
int n; cin>>n;
queue<int>q;
for(int i=0;i<n;i++)
{
int x;
cin>>x;
q.push(x);
}
int ht=0;
int prev=q.front();
q.pop();
while(q.size()>0)
{
int temp=q.front();
ht+=max(ll(0),prev-temp);
prev=max(temp,prev);
q.pop();
}
cout<<ht<<endl;
}
int32_t main()
{
high_functioning_sociopath
ll t=1;
//cin>>t;
while(t--)
{
solve();
}
} | #include<bits/stdc++.h>
using namespace std;
int main() {
int n;
cin>>n;
int t;
cin>>t;
long long int ans = 0, max = t;
for(int i = 1; i < n; i++) {
cin>>t;
if(t < max) {
ans += max-t;
}
else if(t > max) {
max = t;
}
}
cout<<ans<<endl;
return 0;
} | 1 |
#include <iostream>
using namespace std;
#include <stdio.h>
#include <algorithm>
#include <string>
/********
* ?????¢??¢?´¢ Linear Search
*********/
/*
int linearSearch(int strS int strT, int n )
{
int key;
for(int i =0 ; i < n; i++){
if(strS[i] == key){
return i;
}
}
return NOT_FOUND;
}
*/
int main(void)
{
int n , q;
int strS[10000]={0} ;
int strT[500]={0} ;
int count = 0 ;
cin >> n;
for(int i = 0; i<n; i++){
cin >> strS[i];
}
cin >> q;
for(int i = 0; i<n; i++){
cin >> strT[i];
}
for(int j = 0; j<q ; j++){
for(int i =0; i < n; i++){
if(strT[j] == strS[i]){
count++;
break;
}
}
}
cout << count << endl;
return 0;
} | #include <iostream>
#include <set>
#include <algorithm>
using namespace std;
#define V(a) a.begin(), a.end()
typedef set<int> s;
int main()
{
s a[2], C;
for (auto &i : a) {
int n, x;
cin >> n;
while (n--) {
cin >> x;
i.insert(x);
}
}
set_intersection(V(a[0]), V(a[1]), inserter(C, C.end()));
cout << C.size() << endl;
}
| 1 |
#include<bits/stdc++.h>
int main(){
int h, m, k;
scanf("%d %d", &h, &m);
int s = h*60 + m;
scanf("%d %d", &h, &m);
int g = h*60 + m;
scanf("%d", &k);
printf("%d\n", std::max(0, g-s-k));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
int h1, h2, m1, m2 , k; cin >> h1 >> m1 >> h2 >> m2 >> k;
m1 += 60 * h1; m2 += h2 * 60;
cout << m2 - m1 - k << '\n';
return 0;
} | 1 |
#include<stdio.h>
int main()
{
int N,R;
int Z;
scanf("%d %d",&N,&R);
Z=100*(10-N);
if(N>=10){
printf("%d",R);
}
else if(N<10){
printf("%d",R+Z);
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
const int maxn = 2e3 + 20;
const int maxm = maxn * maxn + 20;
const int mod = 1e9 + 7;
int dp[maxn][maxn] , fac[maxm] , caf[maxm];
inline void mkay(int &a)
{
if(a >= mod)
a -= mod;
else if(a < 0)
a += mod;
}
int bpw(int a , int b)
{
if(!b)
return 1;
int x = bpw(a , b / 2);
x = 1LL * x * x % mod;
if(b&1)
x = 1LL * x * a % mod;
return x;
}
int c(int s , int r)
{
if(r < 0 || r > s)
return 0;
return 1LL * fac[s] * caf[r] % mod * caf[s - r] % mod;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
fac[0] = 1;
for(int i = 1; i < maxm; i++)
fac[i] = 1LL * fac[i - 1] * i % mod;
caf[maxm - 1] = bpw(fac[maxm - 1] , mod - 2);
for(int i = maxm - 1; i > 0; i--)
caf[i - 1] = 1LL * caf[i] * i % mod;
int n , k;
cin >> n >> k;
if(k == 1)
return cout << 1 << endl , 0;
dp[0][0] = 1;
for(int j = 0; j <= n; j++)
for(int i = 0; i <= j; i++)
{
mkay(dp[i + 1][j] += 1LL * dp[i][j] * (n - i) % mod * c(n * k - (k - 1) * i - j - 1 , k - 2) % mod);
mkay(dp[i][j + 1] += dp[i][j]);
}
cout << dp[n][n] << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n; cin>>n;
for(int i=111; i<=999; i+=111) if(n<=i){cout<<i; break;}
} | #include<bits/stdc++.h>
#define all(v) v.begin(),v.end()
using namespace std;
using ll=long long;
#ifdef ONLINE_JUDGE
#define D(...)
#else
#define D(...)cerr<<__LINE__<<":"<<"["<<#__VA_ARGS__<<"]->",P(__VA_ARGS__)
#endif
void P(){cerr<<endl;}
template<typename H,typename...T>void P(H h,T...t){cerr<<h<<" ";P(t...);}
int main()
{
ios::sync_with_stdio(false);cin.tie(0);
int n;cin>>n;
while(1){
string s=to_string(n);
unordered_set<char>st(all(s));
if(int(st.size())==1){
return cout<<n,0;
}
++n;
}
} | 1 |
#include <iostream>
#include <vector>
#include <utility>
using namespace std;
vector<vector<int>> g(100010);
vector<int> check(100010, -1);
bool dfs(int key){
bool flag=false;
for(int i=0; i<g[key].size(); ++i){
if(check[g[key][i]]<0){
check[g[key][i]]=1-check[key];
flag |= dfs(g[key][i]);
}
else flag |= check[key]==check[g[key][i]];
}
return flag;
}
int main() {
int N, M; cin >> N >> M;
for(int i=0; i<M; ++i){
int u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
long solo=0, matsu=0, other=0;
for(int i=1; i<=N; ++i){
if(check[i]<0){
if(g[i].size()<1) ++solo;
else{
check[i]=0;
if(dfs(i)) ++other;
else ++matsu;
}
}
}
cout << solo*(2*N-solo)+matsu*matsu+(matsu+other)*(matsu+other) << endl;
return 0;
}
| #include<bits/stdc++.h>
#define MP make_pair
#define FR first
#define SE second
using namespace std;
const int S=(1<<20)+5;
char buf[S],*H,*T;
inline char Get()
{
if(H==T) T=(H=buf)+fread(buf,1,S,stdin);
if(H==T) return -1;return *H++;
}
inline int read()
{
int x=0;char c=Get();
while(!isdigit(c)) c=Get();
while(isdigit(c)) x=x*10+c-'0',c=Get();
return x;
}
const int N=200010;
struct Edge{int to,next;} e[N<<1];
int fa[N],sz[N],n,m,h[N],sum=0;
pair<int,int> circle[N];
bool parity[N],odd[N];
int cnt[2];
int find(int x){return fa[x]==x?x:fa[x]=find(fa[x]);}
void add_edge(int u,int v)
{
e[++sum].to=v;
e[sum].next=h[u];
h[u]=sum;
}
void dfs(int u,int fa)
{
parity[u]=parity[fa]^1;
for(int t=h[u];t;t=e[t].next)
if(e[t].to!=fa) dfs(e[t].to,u);
}
int main()
{
int u,v,tot=0;
n=read();m=read();
for(int i=1;i<=n;i++) fa[i]=i,sz[i]=1;
for(int i=1;i<=m;i++)
{
u=read();v=read();
if(find(u)!=find(v))
{
add_edge(u,v);
add_edge(v,u);
u=find(u);v=find(v);
fa[u]=v;sz[v]+=sz[u];
}
else circle[++tot]=MP(u,v);
}
for(int i=1;i<=n;i++)
if(fa[i]==i) dfs(i,0);
for(int i=1;i<=tot;i++)
if(parity[circle[i].FR]==parity[circle[i].SE])
odd[find(circle[i].FR)]=1;
int alone=0;
long long ans=0;
for(int i=1;i<=n;i++)
{
if(fa[i]!=i) continue;
if(sz[i]==1) alone++,ans+=n;
else cnt[odd[i]]++;
}
ans+=1ll*(n-alone)*alone;
ans+=2ll*cnt[0]*cnt[0];
ans+=1ll*cnt[1]*(cnt[1]+2*cnt[0]);
cout<<ans<<endl;
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
#include <utility>
#include <fstream>
#include <iomanip>
#include <complex>
#include <cmath>
#include <vector>
#include <cstring>
#include <string>
#include <sstream>
#include <map>
#include <set>
#include <queue>
#define IO ios::sync_with_stdio(0); cin.tie(NULL); cout.tie(NULL);
typedef long long ll;
typedef long double ld;
const ll INF = 1e18;
const int N = 3e2 + 5, inf = 1e9, mod = 998244353;
using namespace std;
int n, a, freq[4] = {};
ld dp[N][N][N] = {};
bool vis[N][N][N] = {};
ld solve ( int c1 , int c2 , int c3 )
{
if ( c1 + c2 + c3 == 0 )
return 0;
if ( vis[c1][c2][c3] )
return dp[c1][c2][c3];
vis[c1][c2][c3] = true;
ld ret = 1.0, c0 = n - ( c1 + c2 + c3 );
if ( c1 )
ret += solve ( c1 - 1 , c2 , c3 ) * ( 1.0 * c1 / n );
if ( c2 )
ret += solve ( c1 + 1 , c2 - 1 , c3 ) * ( 1.0 * c2 / n );
if ( c3 )
ret += solve ( c1 , c2 + 1 , c3 - 1 ) * ( 1.0 * c3 / n );
ret /= ( 1 - ( c0 / n ) );
return dp[c1][c2][c3] = ret;
}
int main()
{
IO
cin >> n;
for(int i = 0; i < n; i++)
{
cin >> a;
freq[a]++;
}
cout << fixed << setprecision(10) << solve( freq[1] , freq[2] , freq[3] ) << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define endl '\n'
//const int MOD = 1e9+7;
bool ok(int a, int b, int c, int d, vector<char> s){
int ans=0;
if(s[1]=='+')
ans = a+b;
else
ans = a-b;
if(s[3]=='+')
ans = ans + c;
else
ans = ans-c;
if(s[5]=='+')
ans += d;
else
ans -= d;
if(ans==7)
return true;
else
return false;
}
int main(){
string s;
cin >> s;
int a=s[0]-'0';
int b=s[1]-'0';
int c=s[2]-'0';
int d=s[3]-'0';
char sign[2] = {'+', '-'};
vector<char> ans(7);
ans[0]=s[0];
ans[2]=s[1];
ans[4]=s[2];
ans[6]=s[3];
for(int i=0; i<2; ++i){
for(int j=0; j<2; ++j){
for(int k=0; k<2; ++k){
ans[1]=char(sign[i]);
ans[3]=char(sign[j]);
ans[5]=char(sign[k]);
if(ok(a,b,c,d,ans)){
for(auto x:ans)
cout << x;
cout << "=7";
return 0;
}
}
}
}
}
| 0 |
//
// main.cpp
// testing
//
// Created by 伊藤大騎 on 2019/01/07.
// Copyright © 2019 HamamatsuJOHOKU. All rights reserved.
//
/*
科目選択 (Selecting Subjects)
JOI 君は物理，化学，生物，地学，歴史，地理の 6 科目のテストを受けた． それぞれのテストは 100 点満点で採点された．
JOI 君は物理，化学，生物，地学の 4 科目から 3 科目を選択し，歴史，地理の 2 科目から 1 科目を選択する．
テストの合計点が最も高くなるように科目を選ぶとき， JOI 君の選んだ科目のテストの合計点を求めよ．
入力は 6 行からなり，1 行に 1 つずつ整数が書かれている．
1 行目には JOI 君の物理のテストの点数 A が書かれている．
2 行目には JOI 君の化学のテストの点数 B が書かれている．
3 行目には JOI 君の生物のテストの点数 C が書かれている．
4 行目には JOI 君の地学のテストの点数 D が書かれている．
5 行目には JOI 君の歴史のテストの点数 E が書かれている．
6 行目には JOI 君の地理のテストの点数 F が書かれている．
書かれている整数 A, B, C, D, E, F はすべて 0 以上 100 以下である．
出力
JOI 君が選んだ科目のテストの合計点を 1 行で出力せよ．
入出力例
入力例 1 入力例 2
100 15
34 21
76 15
42 42
10 15
0 62
出力例 1 出力例 2
228 140
入出力例 1 では，JOI 君が物理，生物，地学，歴史の 4 科目を選ぶとき，テストの合計点が最高になる．
物理，生物，地学，歴史の点数はそれぞれ 100, 76, 42, 10 なので，選んだ科目のテストの合計点は 228 である．
入出力例 2 では，JOI 君が化学，生物，地学，地理の 4 科目を選ぶとき，テストの合計点が最高になる．
化学，生物，地学，地理の点数はそれぞれ 21, 15, 42, 62 なので，選んだ科目のテストの合計点は 140 である．
入出力例 2 では，JOI 君が物理，化学，地学，地理の 4 科目を選ぶ場合でも，選んだテストの合計点は 140 である．
*/
#include <iostream>
#include <algorithm>
using namespace std;
int main (){
int hairetsu[6]={0},ans=0,maxim=0;
for (int i=0;i<6;i++){
cin>>hairetsu[i];
}
for (int i=0;i<3;i++){
for (int j=0;j<4;j++){
if (maxim<hairetsu[j]){
maxim=hairetsu[j];
}
}
ans+=maxim;
for (int j=0;j<4;j++){
if (hairetsu[j]==maxim){
hairetsu[j]=0;
maxim=0;
}
}
}
ans+=max(hairetsu[4],hairetsu[5]);
cout<<ans<<endl;
return 0;
}
| #include <iostream>
using namespace std;
typedef struct {
int top;
int S;
int E;
int W;
int N;
int bottom;
} dice;
void swap4(int *a, int *b, int *c, int *d) {
int tmp = *a;
*a = *b;
*b = *c;
*c = *d;
*d = tmp;
}
void roll(dice *dp, char dir) {
if (dir == 'E') {
swap4(&(dp->top), &(dp->W), &(dp->bottom), &(dp->E));
} else if (dir == 'N') {
swap4(&(dp->top), &(dp->S), &(dp->bottom), &(dp->N));
} else if (dir == 'S') {
swap4(&(dp->top), &(dp->N), &(dp->bottom), &(dp->S));
} else {
swap4(&(dp->top), &(dp->E), &(dp->bottom), &(dp->W));
}
}
int main(void){
dice d;
dice *dp = &d;
cin >> dp->top >> dp->S >> dp->E >> dp->W >> dp->N >> dp->bottom;
string str;
cin >> str;
for (int i = 0; i < str.size(); i++) {
roll(dp, str[i]);
}
cout << dp->top << endl;
} | 0 |
#include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <algorithm>
#include <set>
#include <map>
#define vv(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))
typedef unsigned long long ull;
#define vvi std::vector<std::vector<int> >
#define vvs std::vector<std::vector<string> >
#define MODs 1000000007;
typedef long long int ll;
using namespace std;
int main(int argc, char const *argv[]) {
int N;
ll ans = 0;
string s, S, t, T="";
std::cin >> N;
std::cin >> s;
S = s.substr(0, N);
t = s.substr(N);
for(int i=0;i<N;i++) T+=t[N-1-i];
std::vector<int> num(26, 0);
for(int i=0;i<N;i++) num[S[i]-'a']++, num[T[i]-'a']--;
bool flag = true;
for(int i=0;i<26;i++) if(num[i]!=0) flag = false;
vvs str = vv(0, 2, "", string);
for(int i=0;i<(1<<N);i++){
int n = i+(1<<20), count=0;
string ah = "", bh = "";
while(count<N){
if(n%2==1) ah += T[count];
if(n%2==0) bh += T[count];
count++;
n/=2;
}
str.push_back(std::vector<string> {ah, bh});
}
sort(str.begin(), str.end());
for(int i=0;i<(1<<N);i++){
int n = i + (1<<20), count=0;
string ah="", bh="";
while(count<N){
if(n%2==1) ah += S[count];
if(n%2==0) bh += S[count];
count++;
n/=2;
}
int k = upper_bound(str.begin(), str.end(), std::vector<string> {ah,bh}) - lower_bound(str.begin(), str.end(), std::vector<string> {ah, bh});
ans += k;
}
std::cout << (!flag?0:ans) << '\n';
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
const ll INF = 1LL << 60;
const ll MOD = 1000000007;
template <class T>
bool chmax(T &a, const T &b) {
return (a < b) ? (a = b, 1) : 0;
}
template <class T>
bool chmin(T &a, const T &b) {
return (b < a) ? (a = b, 1) : 0;
}
template <class C>
void print(const C &c, std::ostream &os = std::cout) {
std::copy(std::begin(c), std::end(c), std::ostream_iterator<typename C::value_type>(os, " "));
os << std::endl;
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
map<pair<string, string>, int> cnt;
for (int i = 0; i < (1 << n); ++i) {
string red = "";
string blue = "";
for (int j = 0; j < n; ++j) {
if (1 << j & i) {
red += s[j];
} else {
blue = s[j] + blue;
}
}
cnt[make_pair(red, blue)]++;
}
ll ret = 0;
for (int i = 0; i < (1 << n); ++i) {
string red = "";
string blue = "";
for (int j = 0; j < n; ++j) {
if (1 << j & i) {
red = s[j + n] + red;
} else {
blue += s[j + n];
}
}
ret += cnt[make_pair(red, blue)];
}
cout << ret << "\n";
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(ll i = 0; i < n; i++)
#define rep2(i, x, n) for(int i = x; i <= n; i++)
#define rep3(i, x, n) for(int i = x; i >= n; i--)
#define elif else if
#define sp(x) fixed << setprecision(x)
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define sz(x) (int)x.size()
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const ll MOD = 1e9+7;
//const ll MOD = 998244353;
const int inf = (1<<30)-1;
const ll INF = (1LL<<60)-1;
const ld EPS = 1e-10;
template<typename T> bool chmax(T &x, const T &y) {return (x < y)? (x = y, true) : false;};
template<typename T> bool chmin(T &x, const T &y) {return (x > y)? (x = y, true) : false;};
int main(){
string A;
cin >> A;
int N = sz(A);
ll cnt[26];
fill(cnt, cnt+26, 0);
ll ans = 1;
rep(i, N){
int j = A[i]-'a';
ans += i-(cnt[j]++);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define debug(var) cerr << (#var) << " = " << (var) << endl;
#else
#define debug(var)
#endif
void init() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
int h[30];
void solve() {
string s; cin >> s;
for (int i = 0; i < (int)s.size(); ++i) {
++h[s[i]-'a'];
}
long long ans = 1LL*s.size()*(s.size()-1)/2;
for (int i = 0; i < 30; ++i) {
if (!h[i]) continue;
ans -= 1LL*h[i]*(h[i]-1)/2;
}
printf("%lld", ans+1);
}
int main() {
init();
int t = 1; //scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
int main()
{
int n = 0;
fscanf(stdin, "%d", &n);
vector<ll> rows(n + 5), cols(n + 5);
for (int i = 0; i < n; ++i) {
fscanf(stdin, "%lld %lld", &rows[i + 1], &cols[i + 1]);
}
vector<vector<ll> > dp(n + 5, vector<ll>(n + 5, 0));
for (int l = 2; l <= n; ++l) {
for (int i = 1; i <= n - l + 1; ++i) {
int j = l + i - 1;
dp[i][j] = std::numeric_limits<ll>::max();
for (int k = i; k <= j - 1; ++k) {
dp[i][j] = min(dp[i][j],
dp[i][k] + dp[k + 1][j] + rows[i] * cols[k] * cols[j]);
}
}
}
fprintf(stdout, "%lld\n", dp[1][n]);
return 0;
} | # include <bits/stdc++.h>
# define sz(x) (int)((x).size())
# define f first
# define s second
# define pb push_back
# define ub upper_bound
# define lb lower_bound
# define all(x) x.begin(), x.end()
# define pqueue priority_queue
# define Speed() ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
# define rep(i,n) for(int i=0;i<n;++i)
# define forn(i,n) for(int i=1;i<=n;++i)
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
# define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }
# define debug cerr<<"ERROR"<<endl
void err(istream_iterator<string> it) {}
template<typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
template<class T> void umin(T &a,T b){a=min(a,b);}
template<class T> void umax(T &a,T b){a=max(a,b);}
typedef long long ll;
typedef pair<int,int> pii;
const int dx[]={1,0,-1,0,-1,-1,1,1};
const int dy[]={0,1,0,-1,-1,1,-1,1};
const int inf=1e9,mod=1e9+7,N=2e5+5;
int f(int x){
return x*x;
}
void solve(){
int n;
cin>>n;
vector<int>x(n),y(n),v;
rep(i,n)cin>>x[i]>>y[i];
forn(i,n)v.pb(i);
int cnt=0;
double ans=0;
do{
cnt++;
rep(i,n-1){
ans+=sqrt(f(x[v[i]-1]-x[v[i+1]-1])+f(y[v[i]-1]-y[v[i+1]-1]));
}
}
while(next_permutation(all(v)));
double res=ans/cnt;
printf("%.12f",res);
}
int main(){
Speed();
int T=1;
//cin>>T;
while(T--)solve();
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double db;
typedef pair<ll,ll> P;
#define pb push_back
#define mp make_pair
#define fr(i,n) for(int i=0;i<n;i++)
#define Fr(i,n) for(int i=0;i++<n;)
#define ifr(i,n) for(int i=n-1;i>=0;i--)
#define iFr(i,n) for(int i=n;i>0;i--)
ll par[2][200010],size[2][200010];
void init(int num,int n){
fr(i,n){
par[num][i]=i;
size[num][i]=1;
}
}
int find(int num,int x){
if(par[num][x]==x) return x;
else return par[num][x]=find(num,par[num][x]);
}
void unit(int num,int x,int y){
x=find(num,x);
y=find(num,y);
if(x==y) return;
if(size[num][x]<size[num][y]){
par[num][x]=y;
size[num][y]+=size[num][x];
}
else{
par[num][y]=x;
size[num][x]+=size[num][y];
}
}
bool same(int num,int x,int y){
return find(num,x)==find(num,y);
}
void prt(vector<ll>& s){
for(auto it=s.begin();it!=s.end();it++) cout<<(*it)<<" ";
cout<<endl;
}
int main(){
ll n,k[2],p,q;
P pq[200010];
map<P,ll> tmp;
cin>>n>>k[0]>>k[1];
fr(i,2) init(i,n);
fr(j,2){fr(i,k[j]){cin>>p>>q;unit(j,--p,--q);}}
fr(i,n) tmp[mp(find(0,i),find(1,i))]++;
fr(i,n) cout<<tmp[mp(find(0,i),find(1,i))]<<" ";
cout<<endl;
} | //============================================================================
// Name : hoba.cpp :)
// Author : (O_O Diab) (Why_not) (el 3AQ)
// Version :
// Copyright : please, Don't touch me :(
// Description : problem (I) in C++
// MAIN IDEA : max sum of S(X) + S(S(X)) => 100 so brute force
//============================================================================
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define ll long long
#define rw freopen("input.txt","r",stdin),freopen("output.txt","w",stdout);
#define pb push_back
#define F first
#define S second
#define pf push_front
#define lp(i,a,b) for (int i=a;i<=(int)b;++i)
#define lp2(i,a,b) for (int i=a;i>=b;--i)
#define f(x) return cout<<x<<"\n",0
#define pii pair<int,int>
#define pll pair<ll,ll>
#define all(c) c.begin(),c.end()
#define allr(c) c.rbegin(),c.rend()
#define p(x) cout<<#x<<" = { "<<x<<" } \n"
#define vi vector<int>
#define vl vector<ll>
#define vii vector<pii>
#define vll vector<pll>
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define EPS 1e-6
// to convert string to number use int a = stoi(string);
// to convert number to string use string s = to_string(int);
#define FAST ios::sync_with_stdio(0),ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define clr(c,x) memset(c,x,sizeof(c));
using namespace __gnu_pbds;
using namespace std;
const ll INFL = 0x3f3f3f3f3f3f3f3fLL;
const int dx[] = { 0, 1, 0, -1, 1, -1, 1, -1 };
const int dy[] = { 1, 0, -1, 0, 1, -1, -1, 1 };
const int N = 2e5 + 5, mod = (int) 1e9 + 7, INF = 0x3f3f3f3f;
vi vv;
vector<vi> v, vec;
set<int> st;
int ans[N] = { }, comp[N] = { };
bool vis[N] = { };
void dfs(int node) {
vis[node] = true;
for (auto u : v[node])
if (!vis[u])
dfs(u);
vv.pb(node);
}
int main() {
#ifdef ONLINE_JUDGE
FAST
#endif
int n, k, l;
cin >> n >> k >> l;
v.resize(n + 1);
lp(i,1,k)
{
int x, y;
cin >> x >> y;
v[x].pb(y);
v[y].pb(x);
}
int cnt = 0;
lp(i,1,n)
{
if (vis[i])
continue;
vv.clear();
dfs(i);
cnt++;
for (auto u : vv)
comp[u] = cnt;
}
clr(vis, 0);
v.clear();
v.resize(n + 1);
vec.resize(n + 1);
lp(i,1,l)
{
int x, y;
cin >> x >> y;
v[x].pb(y);
v[y].pb(x);
}
lp(i,1,n)
{
if (vis[i])
continue;
vv.clear();
dfs(i);
st.clear();
for (auto u : vv) {
vec[comp[u]].pb(u);
st.insert(comp[u]);
}
for (auto u : st) {
for (auto k : vec[u])
ans[k] = vec[u].size();
vec[u].clear();
}
}
lp(i,1,n)
cout << ans[i] << " ";
return 0;
} | 1 |
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define rep(i, n) for(int i=0;i<n;++i)
#define rrep(i, n) for(int i=n;i>=0;--i)
const int inf=1e9+7;
const ll mod=1e9+7;
const ll big=1e18;
const double PI=2*asin(1);
int main() {
ll H, W, A, B;
cin>>H>>W>>A>>B;
H--;
W--;
ll ue[H+W+1];
ue[0] = 1;
for(ll i=1;i<=H+W;++i){
ue[i] = ue[i-1]*i%mod;
}
ll ans = ue[H+W];
ll h = mod - 2;
ll shita1=1, shita2=1, shita3=1, shita4=1;
ll tmpshita1, tmpshita2, tmpshita3, tmpshita4;
ll two;
while(h>0){
tmpshita1 = ue[H];
tmpshita2 = ue[W];
two = 1;
while(2*two<=h){
two *= 2;
tmpshita1 *= tmpshita1;
tmpshita1 %= mod;
tmpshita2 *= tmpshita2;
tmpshita2 %= mod;
}
h -= two;
shita1 *= tmpshita1;
shita1 %= mod;
shita2 *= tmpshita2;
shita2 %= mod;
}
ans = ans*shita1%mod*shita2%mod;
ll tmpans;
for(ll i=0;i<B;++i){
tmpans = ue[H-A+i]*ue[W+A-i-1]%mod;
shita1 = 1;
shita2 = 1;
shita3 = 1;
shita4 = 1;
h = mod - 2;
two = 1;
while(h>0){
two = 1;
tmpshita1 = ue[i];
tmpshita2 = ue[H-A];
tmpshita3 = ue[W-i];
tmpshita4 = ue[A-1];
while(2*two<=h){
two *= 2;
tmpshita1 *= tmpshita1;
tmpshita2 *= tmpshita2;
tmpshita3 *= tmpshita3;
tmpshita4 *= tmpshita4;
tmpshita1 %= mod;
tmpshita2 %= mod;
tmpshita3 %= mod;
tmpshita4 %= mod;
}
h -= two;
shita1 *= tmpshita1;
shita2 *= tmpshita2;
shita3 *= tmpshita3;
shita4 *= tmpshita4;
shita1 %= mod;
shita2 %= mod;
shita3 %= mod;
shita4 %= mod;
}
tmpans = tmpans*shita1%mod*shita2%mod*shita3%mod*shita4%mod;
ans = (ans-tmpans+mod)%mod;
}
cout<<ans<<endl;
}
| #include <bits/stdc++.h>
const char nl = '\n';
using namespace std;
using ll = long long;
using ld = long double;
const int MOD = 1e9+7;
const int N = 205, X = 1e5+10;
int n, x;
int s[N];
int dp[2][X]; // dp[i][j] = # of ways to end with j, last mod i
void add(int& a, int b) {
a += b;
if (a >= MOD) a -= MOD;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> x;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
sort(s, s + n, greater<int>());
dp[0][x] = 1;
for (int i = 0; i < n; i++) {
memset(dp[1], 0, sizeof dp[1]);
// take self
for (int j = 0; j <= x; j++) {
add(dp[1][j%s[i]], dp[0][j]);
}
// don't take self
for (int j = 0; j <= x; j++) {
add(dp[1][j], (ll) dp[0][j] * (n - i - 1) % MOD);
}
swap(dp[0], dp[1]);
}
int ans = 0;
for (int i = 0; i < s[n-1]; i++) {
add(ans, (ll) i * dp[0][i] % MOD);
}
cout << ans << nl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
bool feeld[25][25];
void solve() {
int x = 10, y = 10;
for (int i = 0; i < M; i++) {
char c;
int d;
cin >> c >> d;
if (c == 'N') {
for (int j = 0; j < d; j++) {
feeld[++y][x] = 0;
}
}
if (c == 'E') {
for (int j = 0; j < d; j++) {
feeld[y][++x] = 0;
}
}
if (c == 'S') {
for (int j = 0; j < d; j++) {
feeld[--y][x] = 0;
}
}
if (c == 'W') {
for (int j = 0; j < d; j++) {
feeld[y][--x] = 0;
}
}
}
bool isok = true;
for (int i = 0; i <= 20; i++) {
for (int j = 0; j <= 20; j++) {
isok *= !feeld[i][j];
}
}
if (isok) cout << "Yes" << endl;
else cout << "No" << endl;
}
int main() {
while (1) {
cin >> N; if (N == 0) break;
memset(feeld, 0, sizeof(feeld));
for (int i = 0; i < N; i++) {
int x, y; cin >> x >> y;
feeld[y][x] = 1;
}
cin >> M;
solve();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define TEMP_T template<typename T>
TEMP_T void sort(T& v){ sort(v.begin(), v.end()); }
TEMP_T void revs(T& v){ reverse(v.begin(), v.end()); }
TEMP_T void uniq(T& v){ sort(v); v.erase(unique(v.begin(), v.end()), v.end()); }
TEMP_T T cums(T& v){ T r(v.size()); partial_sum(v.begin(), v.end(), r); return r; }
TEMP_T void show(T& v, char delim=' ', char end='\n'){ for(int i=0; i<v.size()-1; i++) cout << v[i] << delim; cout << v[v.size()-1] << end; }
TEMP_T T acum(vector<T>& v, T b=0){ return accumulate(v.begin(), v.end(), b); }
TEMP_T vector<T> inpt(int n){ vector<T> v(n); for (int i=0; i<n; i++) cin >> v[i]; return v; }
static inline int in(){ int x; scanf("%d", &x); return x; }
static const int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
static const int dy[] = {1, -1, 0, 0, 1, -1, 1, -1};
struct Field {
Field(int w, int h) : w(w), h(h) {}
bool invalid(int x, int y){ return x < 0 || w <= x || y < 0 || h <= y; }
const int w, h;
};
struct Solver {
Solver(){}
int solve(){
}
};
int main()
{
int n;
while (n = in()){
int robo_x, robo_y;
robo_x = robo_y = 10;
set<pair<int, int> > gems;
for (int i = 0; i < n; i++){
int x, y;
x = in();
y = in();
gems.insert(make_pair(x, y));
}
set<pair<int, int> > robos;
int m = in();
for (int i = 0; i < m; i++){
string s;
int v;
int d;
cin >> s >> v;
if (s == "N") d = 0;
else if (s == "W") d = 3;
else if (s == "E") d = 2;
else d = 1;
for (int j = 0; j < v; j++){
robos.insert(make_pair(robo_x, robo_y));
robo_x += dx[d];
robo_y += dy[d];
robos.insert(make_pair(robo_x, robo_y));
}
}
vector<pair<int, int> > mult;
set_intersection(gems.begin(), gems.end(),
robos.begin(), robos.end(),
back_inserter(mult)
);
if (mult.size() == gems.size()){
puts("Yes");
}
else puts("No");
}
return (0);
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define LD long double
#define SC(t,x) static_cast<t>(x)
#define AR(t) vector < t >
#define PII pair < int, int >
#define PLL pair < LL, LL >
#define PIL pair < int, LL >
#define PLI pair < LL, int >
#define MP make_pair
#define PB push_back
#define PF push_front
#define POB pop_back
#define POF pop_front
#define PRF first
#define PRS second
#define INIT(ar,val) memset ( ar, val, sizeof ( ar ) )
#define lp(loop,start,end) for ( int loop = start; loop < end; ++loop )
#define lpd(loop,start,end) for ( int loop = start; loop > end; --loop )
#define lpi(loop,start,end) for ( int loop = start; loop <= end; ++loop )
#define lpdi(loop,start,end) for ( int loop = start; loop >= end; --loop )
#define qmax(a,b) (((a)>(b))?(a):(b))
#define qmin(a,b) (((a)<(b))?(a):(b))
#define qabs(a) (((a)>=0)?(a):(-(a)))
const int INF = 0x3fffffff;
const int SINF = 0x7fffffff;
const long long LINF = 0x3fffffffffffffff;
const long long SLINF = 0x7fffffffffffffff;
const int MAXN = 1000007;
const int MOD = 998244353;
int n, m;
LL frac[MAXN], rf[MAXN];
void init ();
void input ();
void work ();
void addv ( int &x, int y )
{
x += y;
if ( x >= MOD ) x -= MOD;
}
int qpow ( int a, int b )
{
LL base = a, ans = 1;
while ( b ){
if ( b & 1 ) ( ans *= base ) %= MOD;
( base *= base ) %= MOD;
b >>= 1;
}
return SC ( int, ans );
}
int C ( int n, int m )
{
return SC ( int, frac[n] * rf[m] % MOD * rf[n-m] % MOD );
}
int getmd ( int n, int m )
{
return C ( n + m, n );
}
int main()
{
init();
input();
work();
}
void init ()
{
// Init Everything Here
ios::sync_with_stdio ( false );
frac[0] = 1;
lp ( i, 1, MAXN ) frac[i] = frac[i-1] * i % MOD;
rf[MAXN-1] = qpow ( frac[MAXN-1], MOD-2 );
lpdi ( i, MAXN-2, 0 ) rf[i] = rf[i+1] * ( i + 1 ) % MOD;
}
void input ()
{
// input method
scanf ( "%d%d", &n, &m );
}
void work ()
{
// main work
int ans = 0;
lpi ( i, 1, qmin ( n, m ) ) addv ( ans, SC ( LL, getmd ( n-i, m-i ) ) * getmd ( i, i ) % MOD );
ans = SC ( LL, ans ) * qpow ( getmd ( n, m ) * 2 % MOD, MOD-2 ) % MOD;
addv ( ans, qmax ( n, m ) );
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace::std;
#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef array<int, 3> tri;
typedef long double ld;
template <class T> istream& operator>>(istream& I, vector<T>& v) {for (T &e: v) I >> e; return I;}
template <class T> ostream& operator<<(ostream &O, const vector<T>& v) {for (const T &e: v) O << e << ' '; return O;}
void _main() {
int n; cin >> n;
string s; cin >> s;
vector<int> w(n), e(n);
for (int i = 0; i < n; i++) {
if (i) w[i] = w[i - 1];
w[i] += s[i] == 'W';
}
for (int i = n - 1; i >= 0; i--) {
if (i + 1 < n) e[i] = e[i + 1];
e[i] += s[i] == 'E';
}
int ans = n;
for (int i = 0; i < n; i++) {
ans = min(ans, (i ? w[i - 1] : 0) + (i + 1 < n ? e[i + 1] : 0));
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
// freopen("input.txt", "r", stdin);
int _t = 1;
// cin >> _t;
while (_t--) _main();
return 0;
}
| 0 |
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <limits>
#include <queue>
#include <iomanip>
#include <set>
//#include <bits/stdc++.h>
template<typename T> bool chmax(T &a,T b){if(a<b){a=b;return true;}return false;}
template<typename T> bool chmin(T &a,T b){if(a>b){a=b;return true;}return false;}
using namespace std;
#define ALL(X) X.begin(),X.end()
using ll = long long int;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<vvll> vvvll;
const int MOD=1000000007;
//const int MOD=998244353;
const int INTMAX=2147483647;
const ll LLMAX=9223372036854775807;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
ll N;
cin>>N;
vll L(2*N);
for(ll i=0;i<2*N;i++)cin>>L[i];
sort(ALL(L));
ll ans=0;
for(ll i=0;i<2*N;i++){
ans+=L[i];
i++;
}
cout<<ans<<endl;
return 0;
}
| #include<stdio.h>
#include<algorithm>
#define reg register
#define ri reg int
#define rep(i, x, y) for(ri i = x; i <= y; ++i)
#define nrep(i, x, y) for(ri i = x; i >= y; --i)
#define DEBUG 1
#define ll long long
#define max(i, j) (i) > (j) ? (i) : (j)
#define min(i, j) (i) < (j) ? (i) : (j)
struct IO {
#define MAXSIZE (1 << 20)
#define isdigit(x) (x >= '0' && x <= '9')
char buf[MAXSIZE], *p1, *p2;
char pbuf[MAXSIZE], *pp;
#if DEBUG
#else
IO() : p1(buf), p2(buf), pp(pbuf) {}
~IO() {
fwrite(pbuf, 1, pp - pbuf, stdout);
}
#endif
inline char gc() {
#if DEBUG
return getchar();
#endif
if(p1 == p2)
p2 = (p1 = buf) + fread(buf, 1, MAXSIZE, stdin);
return p1 == p2 ? ' ' : *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
template <class T>
inline void read(T &x) {
register double tmp = 1;
register bool sign = 0;
x = 0;
register char ch = gc();
for(; !isdigit(ch); ch = gc())
if(ch == '-') sign = 1;
for(; isdigit(ch); ch = gc())
x = x * 10 + (ch - '0');
if(ch == '.')
for(ch = gc(); isdigit(ch); ch = gc())
tmp /= 10.0, x += tmp * (ch - '0');
if(sign) x = -x;
}
inline void read(char *s) {
register char ch = gc();
for(; blank(ch); ch = gc());
for(; !blank(ch); ch = gc())
*s++ = ch;
*s = 0;
}
inline void read(char &c) {
for(c = gc(); blank(c); c = gc());
}
inline void push(const char &c) {
#if DEBUG
putchar(c);
#else
if(pp - pbuf == MAXSIZE) {
fwrite(pbuf, 1, MAXSIZE, stdout);
pp = pbuf;
}
*pp++ = c;
#endif
}
template <class T>
inline void write(T x) {
if(x < 0) {
x = -x;
push('-');
}
static T sta[35];
T top = 0;
do{
sta[top++] = x % 10;
x /= 10;
}while(x);
while(top)
push(sta[--top] + '0');
}
template <class T>
inline void write(T x, char lastChar) {
write(x);
push(lastChar);
}
} io;
int a[110], n, ans;
int main() {
io.read(n);
rep(i, 1, n * 2) io.read(a[i]);
std::sort(a + 1, a + 2 * n + 1);
rep(i, 1, n) ans += a[2 * i - 1];
io.write(ans);
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i, n) for (ll i = 0; i < n; ++i)
#define P pair<ll, ll>
#define Graph vector<vector<ll>>
#define fi first
#define se second
constexpr ll mod = 1000000007;
constexpr ll INF = (1ll << 60);
constexpr double pi = 3.14159265358979323846;
template <typename T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
ll N, H, W;
cin >> N >> H >> W;
cout << (N - H + 1) * (N - W + 1) << "\n";
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin >> a >> b;
cout << max((2*max(a,b))-1, a+b) << endl;
return 0;
} | 0 |
#include<iostream>
#include<algorithm>
using namespace std;
static const int INFTY = (1 << 21);
int main(){
int t[105][105];int c[105][105];
int n,m,a,b,cost,time,kk,p,q,r;
while(cin >> n >> m,n,m){
for(int i=1;i<105;i++){
for(int j=1;j<105;j++){
t[i][j] = c[i][j] = INFTY;
}
}
for(int i = 0;i < n;i++){
cin >> a >> b >> cost >> time;
t[a][b] = time;
t[b][a] = time;
c[a][b] = cost;
c[b][a] = cost;
}
for(int k=1;k<=m;k++){
for(int i=1;i<=m;i++){
if(t[i][k] == INFTY) continue;
for(int j=1;j<=m;j++){
if(t[i][k] == INFTY) continue;
t[i][j] = min(t[i][j],t[i][k]+t[k][j]);
c[i][j] = min(c[i][j],c[i][k]+c[k][j]);
}
}
}
cin >> kk;
for(int i=0;i<kk;i++){
cin >> p >> q >> r;
if(r == 0) cout << c[p][q] << endl;
else cout << t[p][q] << endl;
}
}
return 0;
} | #include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main() {
string s, t, r;
int n, a, b;
cin >> s >> n;
while (n--) {
cin >> t >> a >> b;
if (t == "print")
cout << s.substr(a, b - a + 1) << endl;
else if (t == "reverse")
reverse(s.begin() + a, s.begin() + b + 1);
else {
cin >> r;
s.replace(a, b - a + 1, r);
}
}
} | 0 |
/// Bismillahir Rahmanir Rahim
//Author: Tanvir Hussain
//ICE,NSTU
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
const long long MOD = 1000000007;
#define SET(x) memset(x, 0, sizeof(x))
#define SET2d(x,m,n) memset(x, 0, sizeof(x[0][0]) * m * n)
#define SETBOOL(x) memset(x,false,sizeof(x))
#define CLR(x) memset(x, -1, sizeof(x))
#define CLR2d(x,m,n) memset(x, -1, sizeof(x[0][0]) * m * n)
#define mp make_pair
#define PII pair<int, int>
#define pf printf
#define sf scanf
#define ALL(x) x.begin(),x.end()
#define pb push_back
#define IOS ios::sync_with_stdio(false); cin.tie(0);
#define np std::string::npos
#define highest(x) numeric_limits<x>::max()
#define lowest(x) numeric_limits<x>::min()
#define Inf INFINITY
#define minv(v) *min_element(v.begin(),v.end())
#define maxv(v) *max_element(v.begin(),v.end())
#define cases(cs,t) for(int cs=1;cs<=t;cs++)
#define PI acos(-1)
#define no1 __builtin_popcount
#define BOUNDARY(i, j) ((i >= 0 && i < row) && (j >= 0 && j < column))
#define uniq(vec) vec.resize(distance(vec.begin(),unique(vec.begin(),vec.end())))
#define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
#define sz(a) int(a.size())
#define ff first
#define ss second
#define endl "\n"
#define forch(it,s) for(auto it:s)
#define each(it,s) for(auto it = s.begin(); it != s.end(); ++it)
#define rep(i,a) for(int i=0; i<a;i++)
#define rep1(i,a,b) for(int i=(a);i<=(b);++i)
#define irep(i,b,a) for(int i=(b);i>=(a);--i)
#define bits(n) __builtin_popcount(n)
#define maxpq priority_queue<int>
#define minpq priority_queue<int, vector<int>, greater<int> >
int gcd(int a, int b) { if (a == 0) return b; return gcd(b % a, a);}
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pair<int,int>> vpii;
typedef tree<pair<int, int>,null_type,less<pair<int, int>>,rb_tree_tag,tree_order_statistics_node_update> ordered_multiset;
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1,-1, 1, -1, 0, 0, -1, 1};
int dx4[] = {0, 0, 1, -1};
int dy4[] = {1, -1, 0, 0};
const int maxx=100005;
//this fuction sorts vector pair according to first element in descending order.
bool sortinrev(const pair<int,int> &a,const pair<int,int> &b)
{
return a.first>b.first;
}
template<typename T>inline T Bigmod(T base, T power, T MOD){
T ret=1;
while(power)
{
if(power & 1)ret=(ret*base)%MOD;
base=(base*base)%MOD;
power>>=1;
}
return ret;
}
double sq(double x) {return x*x;}
ll po(ll b,ll p){
ll res=1;
while(p){
res*=b;
p--;
}
return res;
}
ll lg2(ll x){
ll res=0;
while(x>1){
res++;
x/=2ll;
}
return res;
}
void solve(){
int n,u,v;
cin>>n>>u>>v;
u--,v--;
vi edg[n];
rep(i,n-1){
int u,v;
cin>>u>>v;
u--,v--;
edg[u].pb(v);
edg[v].pb(u);
}
vi taka(n,-1),akoi(n,-1);
queue<int>q;
taka[u]=0;
q.push(u);
while(!q.empty()){
int u=q.front();
q.pop();
forch(it,edg[u]){
if(taka[it]==-1){
taka[it]=taka[u]+1;
q.push(it);
}
}
}
akoi[v]=0;
q.push(v);
while(!q.empty()){
int u=q.front();
q.pop();
forch(it,edg[u]){
if(akoi[it]==-1){
akoi[it]=akoi[u]+1;
q.push(it);
}
}
}
int ans=0;
rep(i,n){
if(taka[i]<akoi[i]){
ans=max(ans,akoi[i]);
}
}
cout<<(ans-1)<<endl;
}
signed main()
{
IOS;
/*#ifndef ONLINE_JUDGE
freopen ("data.in","r",stdin);
freopen ("data.out","w",stdout);
#endif*/
int t;
t=1;
while(t--){
solve();
}
return 0;
}
///Alhamdulillah
| #include<bits/stdc++.h>
using namespace std;
vector<int>adj[100003],leaf;
int par[100003],depth[100005],sparse[100005][20],root=0,lz=0;
int lca(int p,int q)
{
int a,b,c,d,lp,i,j;
if(depth[p]<depth[q])
{
c=p; p=q; q=c;
}
for(j=19;j>=0;j--)
{
if((depth[p]-(1 << j))>=depth[q])
{
p=sparse[p][j]; if(depth[p]==depth[q])break;
}
}
if(p==q){ return p; }
else
{
for(j=19;j>=0;j--)
{
if(sparse[p][j]!=0 && sparse[p][j]!=sparse[q][j])
{
p=sparse[p][j]; q=sparse[q][j];
if(par[p]==par[q])break;
}
}
return par[p];
}
}
void dfs(int src)
{
int sz=adj[src].size();
if(sz==1 && src!=root){ leaf.push_back(src); lz++; }
for(int lp=0;lp<sz;lp++)
{
int u=adj[src][lp];
if(u!=root && par[u]==0)
{
par[u]=src; sparse[u][0]=src; depth[u]=depth[src]+1;
dfs(u);
}
}
}
int main()
{
int n,m,a,b,i,j,u,v,ans,z,x,y,fr,sc,tr,w;
scanf("%d %d %d",&n,&u,&v);
for(i=1;i<=n-1;i++)
{
scanf("%d %d",&a,&b);
adj[a].push_back(b); if(root==0){ if(adj[a].size()==2)root=a; }
adj[b].push_back(a); if(root==0){ if(adj[b].size()==2)root=b; }
}
if(n==2)printf("0\n");
else
{
dfs(root);
for(j=1;j<=19;j++)
{
for(i=1;i<=n;i++)
{
if(sparse[i][j-1]!=0)
{
sparse[i][j]=sparse[sparse[i][j-1]][j-1];
}
}
}
m=lca(u,v);
ans=(depth[v]-depth[m])+(depth[u]-depth[m]); ans=ans-1;
for(i=0;i<lz;i++)
{
y=leaf[i]; m=lca(u,y); w=lca(v,y);
fr=(depth[u]-depth[m])+(depth[y]-depth[m]);
sc=(depth[v]-depth[w])+(depth[y]-depth[w]);
if(fr<sc)
{
if(sc-1>ans)ans=sc-1;
}
}
printf("%d\n",ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
// 1個置くと3増えて全体でN*Q
// クオリティQは3の倍数になる必要がある(N != 0 mod 3)
using block = vector<string>;
// Quality 1
block b3 = {
"a..",
"a..",
".aa"
};
// Quality 3
block b4 = {
"aacd",
"bbcd",
"cdaa",
"cdbb"
};
// Quality 3
block b5 = {
"aabbc",
"bc..c",
"bc..d",
"c.ccd",
"cddee"
};
// Quality 3
block b7 = {
"ac..c..",
"ac..c..",
"b.cc.cc",
"bc..c..",
"ac..c..",
"a.cc.cc",
".aabbaa"
};
void horizontal_add(block &a, block b){
for (int i = 0; i < a.size(); ++i) a[i] += b[i];
}
void vertical_add(block &a, block b){
a.insert(a.end(), b.begin(), b.end());
}
block solve_k(int n, block b){
block res = b;
for (int i = 0; i < n - 1; ++i) {
horizontal_add(res, b);
}
block unit = res;
for (int i = 0; i < n - 1; ++i) {
vertical_add(res, unit);
}
return res;
}
block solve(int n){
block res;
if (n % 3 == 0) return solve_k(n/3, b3);
if (n % 4 == 0) return solve_k(n/4, b4);
int t = __builtin_ctz(n);
int m = n >> t; // m >= 5 が保証される
if ((m - 1) % 4) res = b7;
else res = b5;
for (int i = 0; i < (m - 5) / 4; ++i) {
horizontal_add(res, block(res.size(), "...."));
string s(res.size(), '.');
block below(4, s);
horizontal_add(below, b4);
vertical_add(res, below);
}
return solve_k(n/m, res);
}
int main() {
int N;
cin >> N;
if (N == 2) {
cout << -1 << "\n";
} else {
auto ans = solve(N);
for (int i = 0; i < N; ++i) {
cout << ans[i] << "\n";
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pli = pair<ll, int>;
using pil = pair<int, ll>;
using uint = unsigned int;
template <typename T>
using Graph = vector<vector<T>>;
const int MOD = 1e9 + 7;
const ld PI = acosl(-1);
int mdigit(ll val) {
int l = 0, r = 61;
while (r - l > 1) {
int mid = (l + r) / 2;
ll bit = (1LL << r) - (1LL << mid);
(val & bit ? l : r) = mid;
}
return l;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int T;
cin >> T;
for (int a = 0; a < T; ++a) {
int N;
cin >> N;
vector<ll> A(N);
for (int i = 0; i < N; ++i)
cin >> A[i];
string S;
cin >> S;
bool isok = true;
vector<ll> v(61);
for (int i = N - 1; i >= 0; --i) {
int tmp;
while (A[i] && v[tmp = mdigit(A[i])])
A[i] ^= v[tmp];
if (A[i]) {
if (S[i] == '0')
v[tmp] = A[i];
else {
isok = false;
break;
}
}
}
cout << !isok << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
string s;
int alp[27];
for (int i = 0; i < 26; i++) {
alp[i] = 0;
}
alp[26] = 1;
cin >> s;
if (s == "zyxwvutsrqponmlkjihgfedcba") {
puts("-1");
} else {
string ans = "";
for (int i = 0; i < (int)s.size(); i++) {
alp[s[i] - 'a']++;
}
if (s.size() < 26) {
for (int i = 0; i < 26; i++) {
if (alp[i] == 0) {
ans = s + (char)('a' + i);
break;
}
}
} else {
string s_next = s;
next_permutation(s_next.begin(), s_next.end());
for (int i = 0; i < (int)s.size(); i++) {
ans += s_next[i];
if (s[i] != s_next[i]) break;
}
}
cout << ans << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
string S, ans;
cin >> S;
if (S.size() == 26) {
ans = S;
if (!next_permutation(begin(ans), end(ans)))
ans = "-1";
else
for (int i = 0; i != 26; ++i) {
if (S[i] != ans[i]) {
ans.resize(i + 1);
break;
}
}
} else {
int d[26]{};
for (char c : S) ++d[c - 'a'];
ans = S + char('a' + find(d, d + 26, 0) - d);
}
cout << ans << endl;
}
| 1 |
#include <iostream>
#include <cmath>
#include <cstdio>
using namespace std;
int main()
{
int d;
double area;
int x;
//int y;
while(cin >> d)
{
x = 0;
//d = 0;
area = 0;
while(x <= 600 - d)
{
area += pow(x,2.0) * d;
x += d;
//cout << x << endl;
}
printf("%ld\n",(long int)area );
//cout << area << endl;
}
//cout << area << endl;
} | #include <iostream>
#include <cmath>
using namespace std;
int main(){
int d, ans, n;
while(cin >> d){
ans = pow(d, 3);
n = 600 / d - 1;
ans *= n*(n+1)*(2*n+1) / 6;
cout << ans << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#include <iomanip>
#include <math.h>
//#include <unistd.h>
//#include <stdio.h>
#define rep(i,x) for(ll i = 0;i<x;i++)
#define all(a) (a).begin(),(a).end()
using ll = long long;
using ld = long double;
using namespace std;
using dou = double;
const ll inf = 2147483647;
const ll INF = 1LL << 60;
const ld pi = 3.14159265358;
const ll mod = 1000000007;
typedef pair<ll,ll> P;
using graph = vector<vector<ll>>;
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;}
ll gcd(ll a,ll b){
if(a < b)swap(a,b);
if(a % b == 0)return b;
else return gcd(b,a%b);
}
//素数判定O(sqrt(N))
bool isp(ll n){
bool res = true;
if(n == 1)return false;
else{
for(ll i = 2;i * i <= n;i++){
if(n % i == 0){
res = false;
break;
}
}
return res;
}
}
ll fac[510000], finv[510000], inv[510000];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < 510000; 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 nCk(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;
}
//nのm乗をMODで割ったあまりO(logN)
ll modpow(ll n,ll m,ll MOD){
ll res = 1;
while(m){
if(m & 1)res = (res * n) % MOD;
m >>= 1;
n *= n;
n %= MOD;
}
return res;
}
//printf("%.10f\n", N);
/* vector<ll> vec = {1,2,5,6,8,9,10};
cout << binary_search(all(vec),5) << endl; -> true*/
/*
vector<ll> vec = {1,2,5,6,8,9,10};
auto n = upper_bound(all(vec),4);
cout << *n << endl; -> 5*/
// cout << fixed << setprecision(15);
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
ll S;
cin >> S;
if(S % 111 == 0)
cout << S / 111 * 111 << endl;
else cout << (S / 111 + 1) * 111 << endl;
} | // Created by conan1024hao in 2019.
// Copyright © 2019 conan1024hao. All rights reserved.
// 専用ライブラリです、自由にコピーして構いません。
// 感谢看我的代码！Wechat:conan1024hao Twitter/QQ:810396815
#pragma GCC optimize ("O3")
#include <iostream>
#include <iomanip>
#include <istream>
#include <ostream>
#include <sstream>
#include <iterator>
#include <vector>
#include <algorithm>
#include <queue>
#include <deque>
#include <list>
#include <stack>
#include <map>
#include <unordered_map>
#include <set>
#include <utility>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <string>
#include <ctime>
#include <cctype>
#include <cstdlib>
#define IINF 10e8
#define INF 10e16
#define MOD 1000000007
#define mod 1000000007
#define rep(i, a, n) for (ll i = a; i < (ll)(n); i++)
#define Endl endl
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define mmax(x,y)(x>y?x:y)
#define mmin(x,y)(x<y?x:y)
#define chmax(x,y) x=mmax(x,y)
#define chmin(x,y) x=mmin(x,y)
#define all(x) (x).begin(),(x).end()
#define siz(x) (ll)(x).size()
#define PI acos(-1.0)
using namespace std;
//using Int=int_fast64_t;
typedef long long int ll;
typedef pair<ll,ll>Pll;
typedef pair<int,int>Pin;
long long GCD(long long a, long long b) { return b ? GCD(b, a%b) : a; }
long long LCM(long long a, long long b) {return a/GCD(a,b)*b;}
int dx[8]={-1,0,1,0,1,1,-1,-1};
int dy[8]={0,-1,0,1,1,-1,1,-1};
char dir[4]={'u','l','d','r'};
ll cmp1(pair<ll,string>a,pair<ll,string> b){
if(a.fi!=b.fi)
return a.fi<b.fi;
else
return a.se<b.se;
}
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
int main(){//問題をちゃんと見ろ!!!!!!!!!!!!!!!!! llか?????????? memset()!!!!!!!!!!!! ペナを減らせ!!!!!!!!!!!!!
cin.tie(0);
ios::sync_with_stdio(false);
//-------------------------------
string s;cin>>s;
if(s.length()==2)
cout<<s<<Endl;
else{
reverse(all(s));
cout<<s<<Endl;
}
//-------------------------------
return 0;
}
//---------------------------------------------------------------------------
| 0 |
#include<bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/rope>
using namespace __gnu_pbds;
using namespace __gnu_cxx;
using namespace std;
typedef tree<int,null_type,less<int>,rb_tree_tag,
tree_order_statistics_node_update> indexed_set;
// order_of_key (val): returns the no. of values less than val
// find_by_order (k): returns the iterator to kth largest element.(0-based)
typedef long long int lli;
#define pb emplace_back
#define mp make_pair
#define ff first
#define ss second
#define pii pair<int,int>
#define vi vector<int>
#define vpii vector<pair<int,int>>
#define vc vector<char>
#define vs vector<string>
#define FOR(i,a,b) for (int i = a; i < b; i++)
#define FORD(i,a,b) for (int i = a; i >= b; i--)
#define fastio ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
/*-------CONSTANTS------- */
const int MAXN = 1000005;
const int SQRTN = 1003;
const int LOGN = 22;
const double PI=acos(-1);
const int INF = 1000000000;
const int MOD = 1000000007;
const int FMOD = 998244353;
const double eps = 1e-9;
/*-----------------------------MATH STUFF----------------------------- */
template<typename T> T gcd(T a, T b){return(b?__gcd(a,b):a);}
template<typename T> T lcm(T a, T b){return(a*(b/gcd(a,b)));}
int mod_neg(int a, int b, int c){int res;if(abs(a-b)<c)res=a-b;else res=(a-b)%c;return(res<0?res+c:res);}
int mulmod(int a, int b, int c){lli res=(lli)a*b;return(res>=c?res%c:res);}
template<typename T>T power_mod(T e, T n, T m){T x=1,p=e;while(n){if(n&1)x=mulmod(x,p,m);p=mulmod(p,p,m);n>>=1;}return x;}
template<typename T>T extended_euclid(T a, T b, T &x, T &y){T xx=0,yy=1;y=0;x=1;while(b){T q=a/b,t=b;b=a%b;a=t;\
t=xx;xx=x-q*xx;x=t;t=yy;yy=y-q*yy;y=t;}return a;}
template<typename T>T mod_inverse(T a, T n){T x,y,z=0;T d=extended_euclid(a,n,x,y);return(d>1?-1:mod_neg(x,z,n));}
//Factorials upto 1e5%MOD,nCr%MOD,nPr%MOD
lli fact[100000+5],fact_modinv[100000+5];
void fact_init(){
fact[0] = 1ll;
fact_modinv[0] = mod_inverse(fact[0],1ll*MOD);
for(int i = 1;i<=100000;i++){
fact[i] = mulmod(fact[i-1],i,1ll*MOD);
fact_modinv[i] = mod_inverse(fact[i],1ll*MOD);
}
}
lli choose(int n,int r){
return mulmod(fact_modinv[n-r],mulmod(fact[n],fact_modinv[r],MOD),MOD);
}
lli P(int n,int r){
return mulmod(fact[n],fact_modinv[n-r],1ll*MOD);
}
/*-----------------------------START----------------------------- */
int n,m;
vector<int> g[10000+5],gr[10000+5];
vector<int> topo;
bool visited1[10000+5],visited2[10000+5];
vector<int> scc[10000+5];
int par[10000+5];
void dfs(int u){
visited1[u] = true;
for(auto x : g[u])
if(!visited1[x])
dfs(x);
topo.push_back(u);
}
void dfs2(int u,int p){
visited2[u] = true;
par[u] = p;
for(auto x : gr[u])
if(!visited2[x])
dfs2(x,p);
}
int main(){
fastio;
cin>>n>>m;
for(int i = 0;i<m;i++){
int u,v;
cin>>u>>v;
g[u].pb(v);
gr[v].pb(u);
}
for(int i = 0;i<n;i++)
if(!visited1[i])
dfs(i);
reverse(topo.begin(),topo.end());
for(auto x : topo)
if(!visited2[x])
dfs2(x,x);
int q;cin>>q;
while(q--){
int u,v;
cin>>u>>v;
cout<<(par[u] == par[v])<<endl;
}
return 0;
}
| #include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
// 強連結成分分解
// 計算量: O(V + E)
// operator[]: 頂点kが属する強連結成分の番号を返す
class StronglyConnectedComponents {
int V;
vector<vector<int>> G, rG;
vector <int> comp; // 強連結成分の番号（トポロジカル順）
vector <int> order; // DFSで辿った順
vector <int> used;
void dfs(int cur) {
if (used[cur]) return;
used[cur] = true;
for (int to : G[cur]) dfs(to);
order.push_back(cur);
}
void rdfs(int cur, int cnt) {
if (comp[cur] != -1) return;
comp[cur] = cnt;
for (int to : rG[cur]) rdfs(to, cnt);
}
public:
StronglyConnectedComponents(vector<vector<int>> &edge) {
V = edge.size();
G.resize(V);
rG.resize(V);
comp.assign(V, -1);
used.assign(V, false);
for (int i = 0; i < V; i++) {
for (int e : edge[i]) {
G[i].push_back(e);
rG[e].push_back(i);
}
}
}
int operator[](int k) { return comp[k]; }
void build(vector<vector<int>> &buff) {
for (int i = 0; i < V; i++) dfs(i);
reverse(order.begin(), order.end());
int cnt = 0;
for (int i : order) if (comp[i] == -1) rdfs(i, cnt++);
buff.resize(cnt);
for (int i = 0; i < V; i++) {
for (int to : G[i]) {
int x = comp[i], y = comp[to];
if (x == y) continue;
buff[x].push_back(y);
}
}
}
};
// verified
// https://onlinejudge.u-aizu.ac.jp/courses/library/5/GRL/3/GRL_3_C
void AOJ_GRL_3_C() {
int V, E;
cin >> V >> E;
vector<vector<int>> edge(V), buff;
for (int i = 0; i < E; i++) {
int s, t;
cin >> s >> t;
edge[s].push_back(t);
}
StronglyConnectedComponents scc(edge);
scc.build(buff);
int Q;
cin >> Q;
while (Q--) {
int u, v;
cin >> u >> v;
cout << (scc[u] == scc[v] ? 1 : 0) << "\n";
}
}
int main() {
AOJ_GRL_3_C();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, s, n) for(int i = s; i < (int)n; i++)
#define per(i, n) for(int i = n; i >= 0; i--)
#define ROF(i, s, n) for(int i = s; i >= (int)n; i--)
#define FORIT(i, A) for (auto i : A)
#define PRINT(x) cout << (x) << "\n"
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define MP make_pair
#define EACH(i, n) for (__typeof((n).begin()) i = (n).begin(); i != (n).end(); ++i)
#define SZ(a) int((a).size())
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define CLR(a) memset((a), 0 ,sizeof(a))
#define dump(x) cout << #x << " = " << (x) << "\n";
#define debug(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << "\n";
#define sq(n) (n) * (n)
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef priority_queue<int> maxpq;
typedef priority_queue< int, vector<int>, greater<int> > minpq;
static const double EPS = 1e-10;
static const double PI = acos( -1.0 );
static const int mod = 1000000007;
static const int INF = 1 << 25;
static const LL LL_INF = 1152921504606846976;
int n, m, a, b, c;
LL d;
int main() {
while ( ~scanf( "%d %d", &n, &m ) && n && m ) {
LL mp[ 100 ][ 100 ];
for ( int i = 0; i < n; i++ ) {
for ( int j = 0; j < n; j++ ) {
mp[ i ][ j ] = LL_INF;
}
}
for ( int i = 0; i < n; i++ ) {
mp[ i ][ i ] = 0;
}
for ( int i = 0; i < m; i++ ) {
scanf( "%d", &a );
switch ( a ) {
case 0:
scanf( "%d %d", &b, &c );
if ( mp[ b - 1 ][ c - 1 ] == LL_INF ) {
printf( "-1\n" );
}
else {
printf( "%lld\n", mp[ b - 1 ][ c - 1 ] );
}
break;
case 1:
scanf( "%d %d %lld", &b, &c, &d );
if ( mp[ b - 1 ][ c - 1 ] > d ) {
mp[ b - 1 ][ c - 1 ] = mp[ c - 1 ][ b - 1 ] = min( d, mp[ b - 1 ][ c - 1 ] );
for ( int j = 0; j < n; j++ ) {
for ( int k = 0; k < n; k++ ) {
for ( int l = 0; l < n; l++ ) {
mp[ k ][ l ] = mp[ l ][ k ] = min( mp[ k ][ l ], mp[ k ][ j ] + mp[ j ][ l ] );
}
}
}
}
break;
}
}
}
return 0;
} | #include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <cmath>
#include <stdio.h>
#include <queue>
#include <deque>
#include <cstdio>
#include <set>
#include <map>
#include <bitset>
#include <stack>
#include <cctype>
using namespace std;
int h[10] = { 6,2,5,5,4,5,6,3,7,6 };
bool b[10] = { false };
int dp[10100][10];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a;
cin >> a;
b[a] = true;
}
for (int i = 0; i < n + 10; i++) {
for (int j = 0; j < 10; j++) {
dp[i][j] = -1;
}
}
for (int i = 0; i < 10; i++) {
dp[0][i] = 0;
}
for (int i = 0; i <= n; i++) {
if (dp[i][0] == -1) {
continue;
}
for (int j = 1; j < 10; j++) {
if (!b[j]) {
continue;
}
if (dp[i + h[j]][0] == -1) {
for (int k = 0; k < 10; k++) {
dp[i + h[j]][k] = dp[i][k];
if (j == k) {
dp[i + h[j]][k]++;
}
}
}
else {
int kari[10];
int sl = 0, sr = 0;
for (int k = 0; k < 10; k++) {
kari[k] = dp[i][k];
if (j == k) {
kari[k]++;
}
sl += dp[i + h[j]][k];
sr += kari[k];
}
bool bo = true;
if (sl != sr) {
if (sl > sr) {
bo = false;
}
}
else {
int l = 9, r = 9;
while (1) {
if (l == 0 && r == 0) {
bo = false;
break;
}
if (dp[i + h[j]][l] == 0) {
l--;
continue;
}
if (kari[r] == 0) {
r--;
continue;
}
if (l == r && dp[i + h[j]][l] == kari[r]) {
l--;
r--;
continue;
}
else if (l < r) {
break;
}
else if (l > r) {
bo = false;
break;
}
else if (dp[i + h[j]][l] < kari[r]) {
break;
}
else if (dp[i + h[j]][l] > kari[r]) {
bo = false;
break;
}
}
}
if (bo) {
for (int k = 0; k < 10; k++) {
dp[i + h[j]][k] = kari[k];
}
}
}
}
}
for (int i = 9; i > 0; i--) {
for (int j = 0; j < dp[n][i]; j++) {
cout << i;
}
}
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void input(int& rnTrgSu, int& rnTrgKin)
{
cin >> rnTrgSu >> rnTrgKin;
}
int dfs(int nPos, int nTrgSu, int nTrgKin, vector<int>& rvnMoneyCnt)
{
const vector<int> cnvnMoney{10000, 5000, 1000};
if (nTrgSu == 0 && nTrgKin == 0) return 1;
if (nTrgKin < 0) return -1;
if (nPos == rvnMoneyCnt.size()) return 0;
if (nPos == rvnMoneyCnt.size() - 1)
{
rvnMoneyCnt[nPos] = nTrgSu;
return dfs(nPos + 1, 0, nTrgKin - cnvnMoney[nPos] * nTrgSu, rvnMoneyCnt);
}
else
for (int i = 0; i <= nTrgSu; i++)
{
rvnMoneyCnt[nPos] = i;
for (int i = nPos + 1; i < rvnMoneyCnt.size(); i++)
rvnMoneyCnt[i] = 0;
int nReslt = dfs(nPos + 1, nTrgSu - i, nTrgKin - cnvnMoney[nPos] * i, rvnMoneyCnt);
if (nReslt == 1) return 1;
else if (nReslt == -1) break;
}
return 0;
}
void searchCntl(int nTrgSu, int nTrgKin)
{
vector<int> vnMoneyCnt(3);
if ( dfs(0, nTrgSu, nTrgKin, vnMoneyCnt) )
{
for (int i = 0; i < vnMoneyCnt.size(); i++)
{
if ( i ) cout << " ";
cout << vnMoneyCnt[i];
}
cout << endl;
}
else
cout << -1 << " " << -1 << " " << -1 << endl;
}
int main()
{
int nTrgSu, nTrgKin;
input(nTrgSu, nTrgKin);
searchCntl(nTrgSu, nTrgKin);
return 0;
} | #include <bits/stdc++.h>
#define rep(i,n) for (int i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int main(){
int k,x;
cin >> k >> x;
int mn = x - k + 1;
int mx = x + k - 1;
vector<int> ans;
for(int i = mn; i < mx; i++) cout << i << " ";
cout << mx << endl;
}
// cout << fixed << setprecision(15) << << endl; | 0 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define reps(i,n) for(int i=1;i<(int)(n);i++)
typedef long long ll;
using namespace std;
int gcd(int a, int b) { //最大公約数
if (b==0) return a;
else return gcd(b, a%b);
}
int lcm(int a, int b) { //最小公倍数
return a * b / gcd(a, b);
}
int main()
{
ll n,a[100010];
cin>>n;
rep(i,n)cin>>a[i];
sort(a,a+n,greater<ll>());
ll tate=0,yoko=0,cnt=0;
rep(i,n-1){
if(cnt==0&&a[i]==a[i+1]){
tate=a[i];
cnt=1;
i++;
}else if(cnt==1&&a[i]==a[i+1]){
yoko=a[i];
cnt=2;
}
}
if(tate==0||yoko==0){
cout<<0<<endl;
}else{
cout<<tate*yoko<<endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#ifdef LOCAL
#define debug(var) cerr << (#var) << " = " << (var) << endl;
#else
#define debug(var)
#endif
void init() {
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
}
const int N = 2e5+23;
int a[N];
map<int, int> m;
void solve() {
int n; scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", a+i);
++m[a[i]];
}
sort(a, a+n, greater<int>());
int ans = 0;
for (int i = 0; i < n; ++i) {
if (!m[a[i]]) continue;
for (int j = 1<<30; j >= a[i]; j >>= 1) {
int t = 1;
if (j-a[i] == a[i]) {
t = 2;
}
if (m.count(j-a[i]) && m[j-a[i]] >= t) {
++ans;
--m[a[i]];
--m[j-a[i]];
break;
}
}
}
printf("%d", ans);
}
int main() {
init();
int t = 1; //scanf("%d", &t);
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define ALL(a) a.begin(), a.end()
#define MOD 1000000007
using namespace std;
typedef long long ll;
int main() {
int N, M; cin >> N >> M;
vector<int> A(N), B(M); unordered_map<int, int> a, b; bool ok = true;
REP(i, 0, N) {
cin >> A[i];
if(a[A[i]]) ok = false;
a[A[i]] = i + 1;
}
REP(i, 0, M) {
cin >> B[i];
if(b[B[i]]) ok = false;
b[B[i]] = i + 1;
}
if (!ok) {
cout << 0 << endl;
return 0;
}
int count[N * M + 1] = {};
REP(i, 0, N) {
REP(j, 0, M) {
count[min(A[i], B[j])]++;
}
}
vector<int> acnt(N, 0), bcnt(M, 0);
REP(i, 0, N) {
REP(j, 0, M) {
if (A[i] <= B[j]) acnt[i]++;
}
}
REP(j, 0, M) {
REP(i, 0, N) {
if (A[i] >= B[j]) bcnt[j]++;
}
}
ll ans = 1; int cnt = 0;
for (int i = N * M; i > 0; i--) {
cnt += count[i];
if (a[i] && b[i]) {
continue;
} else if (a[i]) {
ans = (ans * acnt[a[i] - 1]) % MOD;
} else if (b[i]) {
ans = (ans * bcnt[b[i] - 1]) % MOD;
} else {
ans = (ans * (cnt - (N * M - i))) % MOD;
}
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
#define F first
#define S second
using namespace std;
using ll = long long;
typedef pair<int, int> P;
ll Mod = 1000000007;
int main() {
ll N,M;
cin >> N >> M;
int A[N],B[M];
int Acnt[1100000];
int Bcnt[1100000];
ll a = 0;
ll b = 0;
ll ans = 1;
for (int i = 0; i < 1100000; i++) {
Acnt[i] = 0; Bcnt[i] = 0;
}
for (int i = 0; i < N; i++) {
cin >> A[i];
Acnt[A[i]]++;
}
for (int i = 0; i < M; i++) {
cin >> B[i];
Bcnt[B[i]]++;
}
for (int i = N*M; i >= 1; i--) {
int s = Acnt[i] + Bcnt[i];
if (s > 2) {
ans = 0;
} else if (s == 2) {
ans *= 1;
a++; b++;
} else if (s == 1) {
if (Acnt[i] == 1) {
ans *= b;
a++;
} else {
ans *= a;
b++;
}
} else {
ll c = a*b;
c -= ((N*M) - i);
ans *= c;
}
ans %= Mod;
}
if (a == N && b == M) {
cout << ans << endl;
} else {
cout << 0 << endl;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#define loop(v, f, l) for(int v = (f), v##_ = (l); v < v##_; ++v)
using namespace std;
typedef long long int lint;
static inline int in(){ int x; scanf("%d", &x); return (x); }
static inline lint inl(){ lint x; scanf("%lld", &x); return (x); }
int main()
{
int n;
scanf("%d\n", &n);
loop(i, 0, n)
{
string line;
std::getline(cin, line);
int pos = 0;
while( (pos = line.find("Hoshino", pos)) != string::npos )
{
line.replace(pos, 7, "Hoshina");
}
cout << line << endl;
}
return (0);
} | #include <bits/stdc++.h>
using namespace std;
#define ld double
#define ll long long
#define pb emplace_back
#define mk make_pair
#define mod 1000000007
#define ff first
#define ss second
#define sz(x) (int)x.size()
#define FIO ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define all(x) x.begin(),x.end()
ll power(ll a, ll b) {ll res = 1; a = a % mod; while (b) {if (b & 1)res = (res * a) % mod; a = (a * a) % mod; b /= 2;} return res;}
ll invmod(ll a) {return power(a, mod - 2);}
int main(void)
{
FIO
int t = 1;
// cin >> t;
while (t--)
{
int a, b;
cin >> a >> b;
cout << a*b << '\n';
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template<class T> void ckmin(T &a, T b) { a = min(a, b); }
template<class T> void ckmax(T &a, T b) { a = max(a, b); }
#define pb push_back
#define mp make_pair
#define cotu cout
#define itn int
#define Red ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define F first
#define S second
#define sz(x) (int)x.size()
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for(int i = 0; i < n; ++i)
#define repr(i,n) for(int i = n - 1; i >= 0; --i)
#define Rep(i, a, n) for(int i = (a); i <=(n); ++i)
#define repst(i, n) for(auto it = n.begin(); it != n.end(); ++it)
#define Repr(i, a, n) for(int i = (n); i >= (a); --i)
#define sp(x) fixed << setprecision(x)
#define ordered_set tree<int , null_type,less<int >, rb_tree_tag,tree_order_statistics_node_update>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const int inf = int(1e9);
const int mod = inf + 7;
const int N = 1e6 + 555; // TL MB
const double PI = acos(-1.0);
void mul(ll &x, ll y){
x *= y;
if(x >= mod) x %= mod;
}
void add(ll &x, ll y){
x += y;
if(x >= mod) x -= mod;
if(x < 0) x += mod;
}
ll bp(ll a, ll n){
ll r = 1;
while(n){
if(n & 1) mul(r, a);
mul(a, a);
n >>= 1;
}
}
void solve()
{
int n;
cin >> n;
ll a[n];
vector<ll> p;
rep(i, n) cin >> a[i];
sort(a, a + n);
rep(i, n){
if(i && a[i] == a[i - 1]) p.pb(a[i++]);
}
sort(p.rbegin(), p.rend());
if(sz(p) <= 1) cout << 0;
else cout << p[0] * p[1];
}
int main()
{
// freopen("crosses.in", "r", stdin);
// freopen("crosses.out", "w", stdout);
Red;
int T = 1;
// cin >> T;
for(int i = 1; i <= T; ++i){
solve();
}
return 0;
} | #include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<set>
#include<bitset>
#include<map>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fd(i,a,b) for(int i=a;i>=b;i--)
using namespace std;
typedef long long LL;
typedef double db;
int get(){
char ch;
while(ch=getchar(),(ch<'0'||ch>'9')&&ch!='-');
if (ch=='-'){
int s=0;
while(ch=getchar(),ch>='0'&&ch<='9')s=s*10+ch-'0';
return -s;
}
int s=ch-'0';
while(ch=getchar(),ch>='0'&&ch<='9')s=s*10+ch-'0';
return s;
}
const int N = 1e+5+5;
int n;
int a[3][N];
int id[N],inv[N];
bool vis[N];
int main(){
n=get();
fo(i,0,2)fo(j,1,n)a[i][j]=get();
fo(i,1,n){
int x=(a[0][i]-1)/3+1;
if (a[0][i]==x*3-2&&a[1][i]==x*3-1&&a[2][i]==x*3)id[i]=x,inv[i]=0;
if (a[2][i]==x*3-2&&a[1][i]==x*3-1&&a[0][i]==x*3)id[i]=x,inv[i]=1;
if (!id[i])return printf("No\n"),0;
if (i%2!=id[i]%2)return printf("No\n"),0;
}
int inv0=0,inv1=0;
fo(i,1,n)
if (i&1)inv1^=inv[i];else inv0^=inv[i];
int flip0=(n/2)&1,flip1=(n&1)^((n/2)&1);
fo(i,1,n)
if (!vis[i]){
if (i&1)flip1^=1;else flip0^=1;
vis[i]=1;
for(int x=id[i];x!=i;x=id[x])vis[x]=1;
}
if (flip1!=inv0||inv1!=flip0)printf("No\n");
else printf("Yes\n");
return 0;
} | 0 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
#include <string>
using namespace std;
int main()
{
string s;
cin>>s;
int d=INT_MAX;
for(int i=0;i<=s.size()-3;i++)
{
int k=i+2;
int k1=0;
for(int j=i;j<=k;j++)
{
k1=k1*10+(s[j]-'0');
}
int c=k1>753?(k1-753):753-k1;
d=(c<d)?c:d;
}
cout<<d<<endl;
return 0;
}
| /*https://atcoder.jp/contests/abc114/tasks/abc114_b*/
#include<bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
#ifndef ONLINE_JUDGE
// for getting input from input.txt
freopen("input.txt", "r", stdin);
// for writing output to output.txt
freopen("output.txt", "w", stdout);
#endif
string s;
int min_dif = 1e5 + 1;
cin >> s;
for (int i = 0; i < s.length() - 2; i++)
{
char a, b, c;
a = s[i], b = s[i + 1], c = s[i + 2];
string n;
n += s[i];
n += s[i + 1];
n += s[i + 2];
// cout << a << " " << b << " " << c << endl;
// int x = stoi(n) + atoi(b) + atoi(c);
// cout << n << endl;
int x = stoi(n);
// cout << x <<< " ->" abs(x - 753)
min_dif = min(min_dif, abs(x - 753));
}
cout << min_dif;
} | 1 |
#include"bits/stdc++.h"
#define rep(i, N) for(int i = 0;i < N;i++)
typedef long long ll;
const int mod = 1e9 + 7;
using namespace std;
int main(void) {
int N, Q; cin >> N >> Q;
string S; cin >> S;
vector<int> l(Q), r(Q);
rep(i, Q) {
cin >> l[i] >> r[i];
l[i]--;
r[i]--;
}
rep(i, S.size()-1) {
if (S[i] == 'A' && S[i + 1] == 'C') {
S[i] = '@';
}
}
vector<int> sum(S.size(), 0);
sum[0] = (int)(S[0] == '@');
for(int i = 1;i < S.size();i++) {
sum[i] = sum[i - 1];
sum[i] += (int)(S[i] == '@');
}
rep(q, Q) {
int ans = sum[r[q]-1] - sum[l[q]];
ans += (int)(S[l[q]] == '@');
cout << ans << endl;
}
return 0;
} | #include<bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn = 1007, maxm = 2007;
const int inf = 1e9 + 7;
int cnt = 1;
int head[maxn], vis[maxn], dfn[maxn], vis2[maxn];
//head[x]:点x连接的最后一条边号
//vis[x]:标记每次dfs访问过的点，以免重复搜索耗时
//dfn[x]:x的时间戳
//vis[x]2:dfs中标记访问过的次数，找环
int b[maxn];
struct edge
{
int u, v, next;
}e[maxm];
void addedge(int u, int v)//前向星
{
e[cnt].u = u;
e[cnt].v = v;
e[cnt].next = head[u];
head[u] = cnt;
cnt++;
}
vector<int> v;
int ans = inf;
void dfs(int x, int num)
{
vis[x] = 1;//标记x访问过
dfn[x] = num;
for (int i = head[x]; i ; i = e[i].next)//遍历x点连接的所有边
{
int y = e[i].v;
if (vis2[y] == 1)//y第二次被访问，说明形成环
{
if (dfn[x] - dfn[y] + 1 < ans)//ans记录最小环的大小
{
ans = dfn[x] - dfn[y] + 1;
int sz = v.size();
for (int i = 1; i <= ans; i++)
b[i] = v[sz - i];//b[i]存最小环的点
}
}
if (vis[y] == 0)//y没有访问过
{
vis2[y] = 1;
v.push_back(y);
dfs(y, num + 1);
}
}
v.pop_back();
vis2[x] = 0;
}
int main()
{
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++)
{
int x, y;
scanf("%d%d", &x, &y);
addedge(x, y);
}
for (int i = 1; i <= n; i++)
{
if (vis[i] == 0)
{
v.clear();
v.push_back(i);
vis2[i] = 1;
dfs(i, 1);
}
}
if (ans == inf)
printf("-1\n");
else
{
printf("%d\n", ans);
for (int i = ans; i >= 1; i--)
printf("%d\n", b[i]);
}
return 0;
} | 0 |
#include <iostream>
#include <vector>
using namespace std;
#define REP(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)
typedef long long ll;
int main() {
int N;
while(cin >> N && N) {
vector<int> v(N);
rep(i, N) cin >> v[i];
ll mx = -1<<29;
rep(i, N) {
ll sum = 0;
REP(j, i, N) {
sum += v[j];
mx = max(mx, sum);
}
}
cout << mx << endl;
}
return 0;
} | #include <stdio.h>
int
main(void)
{
char line[80];
int a[5000];
int n;
while (fgets(line, sizeof line, stdin)) {
if (sscanf(line, "%d", &n) == 1) {
if (n == 0) {
break;
}
for (int i = 0; i < n; i++) {
if (fgets(line, sizeof line, stdin) == NULL) {
return 1;
}
if (sscanf(line, "%d", &(a[i])) != 1) {
return 1;
}
}
int m1 = -100001;
for (int i = 0; i < n; i++) {
int s = 0;
int m0 = -100001;
for (int j = i; j < n; j++) {
s += a[j];
if (m0 < s) {
m0 = s;
}
}
if (m1 < m0) {
m1 = m0;
}
}
printf("%d\n", m1);
}
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#define ll long long int
#define ull unsigned long long int
#define IO ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
using namespace std;
const int INF = 1e9 + 7;
const int N = 1e5+5;
int main() {
IO;
int sx, sy, tx, ty;
cin >> sx >> sy >> tx >> ty;
string ans, ur, ld, mdf="L", mof = "R";
while (ty > sy) {
ur += 'U';
ld += 'D';
sy++;
}
mdf += ur + 'U';
mof += ld + 'D';
while (tx > sx) {
ur += 'R';
ld += 'L';
mdf += 'R';
mof += 'L';
sx++;
}
mdf += "RD";
mof += "LU";
ans += ur + ld + mdf + mof;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
struct cww{cww(){ios::sync_with_stdio(false);cin.tie(0);}}star;
#define P(x) cout << (x) << endl
#define p(x) cout << (x)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define vv(type, c, m, n, i) vector<vector<type>> c(m, vector<type>(n, i));
#define rep(i,a,n) for(int i=(a), i##_len=(n); i<i##_len; ++i)
#define rrep(i,a,n) for(int i=(a), i##_len=(n); i>i##_len; --i)
#define len(x) ((int)(x).size())
#define mp make_pair
#define eb emplace_back
typedef long long ll;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<long long> vll;
typedef vector<string> vs;
typedef vector<bool> vb;
constexpr int MAX = 2e6;
vll L(MAX / 2 + 2), R(MAX / 2 + 2);
ll cnt = 0;
inline void merge(vll &a, ll left, ll mid, ll right) {
ll n1 = mid - left;
ll n2 = right - mid;
rep(i, 0, n1) L[i] = a[left + i];
rep(i, 0, n2) R[i] = a[mid + i];
L[n1] = R[n2] = 1e9;
ll i = 0, j = 0;
rep(k, left, right) {
if(L[i] <= R[j]) {
a[k] = L[i];
++i;
} else {
a[k] = R[j];
++j;
cnt = cnt + n1 - i;
}
}
}
inline void mergeSort(vll &a, ll left, ll right) {
if(left + 1 < right) {
ll mid = (left + right) / 2;
mergeSort(a, left, mid);
mergeSort(a, mid, right);
merge(a, left, mid, right);
}
}
int main() {
int n; cin >> n;
vll a(n); rep(i, 0, n) cin >> a[i];
mergeSort(a, 0, n);
P(cnt);
return 0;
} | 0 |
// J'aime
// Chemise Blanche
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define ii pair<int,int>
#define fi first
#define sc second
#define all(x) (x).begin(),(x).end()
#define dbg(x) cerr << __LINE__ << " > " << #x << " = " << (x) << endl
void MAIN() {
string s, t;
cin >> s >> t;
cout << t << s << '\n';
}
signed main() {
#ifdef _DEBUG
// freopen("in" , "r", stdin );
// freopen("out", "w", stdout);
#endif
ios::sync_with_stdio(0); cin.tie(0);
int T = 1;
// cin >> T;
while (T--) MAIN();
}
| // https://atcoder.jp/contests/abc149/tasks/abc149_a
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <string>
#include <algorithm>
#include <numeric>
#include <map>
#include <unordered_map>
#include <stack>
#include <queue>
#include <set>
#include <unordered_set>
#include <bitset>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
#define REP(i, n) for(size_t i = 0; i < (n); ++i)
int main()
{
string S, T;
cin >> S >> T;
T.insert(T.end(), S.begin(), S.end());
cout << T << endl;
return 0;
}
| 1 |
#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
int main(){
double x1,x2,y1,y2,d;
cin >> x1 >> y1 >> x2 >> y2;
d = sqrt(pow(x1-x2, 2) + pow(y1-y2, 2));
printf("%lf\n", d);
return 0;
} | #include <iostream>
using namespace std;
int main ()
{
int p, q, r;
cin >> p >> q >> r;
cout << min(min(p + q, p + r), q + r);
}
| 0 |
#include <iostream>
using namespace std;
const int DEPTH = 17;
const int INTMAX = (1LL << 31) - 1;
struct RUQ {
int d[1 << (DEPTH + 1)];
int t[1 << (DEPTH + 1)];
RUQ() {
int i;
for (i = 0; i < (1 << (DEPTH + 1)); i++) {
d[i] = INTMAX;
t[i] = -1;
}
}
//[l, r)
void update(int l, int r, int x, int Time, int a = 0, int b = (1 << DEPTH), int id = 0) {
if (a >= r || b <= l) return;
if (l <= a && b <= r) {
d[id] = x;
t[id] = Time;
return;
}
update(l, r, x, Time, a, (a + b) / 2, id * 2 + 1);
update(l, r, x, Time, (a + b) / 2, b, id * 2 + 2);
}
int getValue(int pos) {
pos += (1 << DEPTH) - 1;
int retD = d[pos];
int retT = t[pos];
while (pos > 0) {
pos = (pos - 1) / 2;
if (retT < t[pos]) {
retT = t[pos];
retD = d[pos];
}
}
return retD;
}
};
RUQ ruq;
int main() {
int n, q;
cin >> n >> q;
for (int i = 0; i < q; i++) {
int type;
cin >> type;
if (type == 0) {
int s, t, x;
cin >> s >> t >> x;
ruq.update(s, t + 1, x, i);
}
else {
int pos;
cin >> pos;
cout << ruq.getValue(pos) << endl;
}
}
return 0;
}
| #include <cmath>
#include <cstdio>
#include <vector>
#include <algorithm>
#pragma warning(disable : 4996)
using namespace std;
int N, Q;
int main() {
scanf("%d%d", &N, &Q);
vector<int> tp(Q), s(Q), t(Q), x(Q);
for (int i = 0; i < Q; i++) {
scanf("%d%d", &tp[i], &s[i]);
if (tp[i] == 0) scanf("%d%d", &t[i], &x[i]), t[i]++;
}
vector<int> d(N, 2147483647);
int B = sqrt(Q);
for (int i = 0; i < B; i++) {
int l = 1LL * i * Q / B, r = 1LL * (i + 1) * Q / B;
for (int j = l; j < r; j++) {
if (tp[j] == 1) {
bool flag = false;
for (int k = j - 1; k >= l; k--) {
if (tp[k] == 0 && s[k] <= s[j] && s[j] < t[k]) {
printf("%d\n", x[k]); flag = true;
break;
}
}
if (!flag) printf("%d\n", d[s[j]]);
}
}
vector<int> cp = { 0, N };
for (int j = l; j < r; j++) {
if (tp[j] == 0) {
cp.push_back(s[j]);
cp.push_back(t[j]);
}
}
sort(cp.begin(), cp.end());
cp.erase(unique(cp.begin(), cp.end()), cp.end());
vector<int> f(cp.size() - 1, -1);
for (int j = l; j < r; j++) {
if (tp[j] == 0) {
int pl = lower_bound(cp.begin(), cp.end(), s[j]) - cp.begin();
int pr = lower_bound(cp.begin(), cp.end(), t[j]) - cp.begin();
for (int k = pl; k < pr; k++) f[k] = x[j];
}
}
for (int j = 0; j < cp.size() - 1; j++) {
if (f[j] != -1) {
for (int k = cp[j]; k < cp[j + 1]; k++) d[k] = f[j];
}
}
}
return 0;
} | 1 |
//Badwaper gg
#include<bits/stdc++.h>
#define inf 1e9
#define eps 1e-6
#define mp make_pair
#define pb push_back
#define re register ll
#define fr first
#define sd second
#define FOR(i,a,b) for(re i=a;i<=b;i++)
#define REP(i,a,b) for(re i=a;i>=b;i--)
#define lowbit(x) (x&(-x))
#define Z(x) (x>=mod?x-mod:x)
#define N 41
#define M 200010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
inline ll read()
{
char ch=getchar();
ll s=0,w=1;
while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){s=s*10+ch-'0';ch=getchar();}
return s*w;
}
const int mod=1e9+7;
int f[N][M],to[M][N];
int n,x,y,z;
int main()
{
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
n=read(),x=read(),y=read(),z=read();y+=x;z+=y;
FOR(S,1,1<<z)FOR(i,1,10)
{
to[S][i]=1;
FOR(k,0,z-i)if((S>>k)&1)if(!(k<x&&k+i>x)&&!(k<y&&k+i>y))to[S][i]|=(1<<(i+k));
if((S==(1<<z))||(to[S][i]>=(1<<z)))to[S][i]=1<<z;
}
f[0][1]=1;
FOR(i,0,n-1)FOR(S,1,(1<<z))FOR(j,1,10)f[i+1][to[S][j]]=Z(f[i+1][to[S][j]]+f[i][S]);
printf("%d\n",f[n][1<<z]);
return 0;
}
| #include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
const int N = 45;
const int mod = 1e9 + 7;
using namespace std;
int n, x, y, z, now, lim, f[N][(1 << 17) + 5], ans;
template < typename T >
inline T read()
{
T x = 0, w = 1; char c = getchar();
while(c < '0' || c > '9') { if(c == '-') w = -1; c = getchar(); }
while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * w;
}
int fpow(int x, int y)
{
int res = 1;
for( ; y; y >>= 1, x = 1ll * x * x % mod)
if(y & 1) res = 1ll * res * x % mod;
return res;
}
void output(int x)
{
int a[100], cnt = 0;
while(x) a[cnt++] = x & 1, x >>= 1;
if(!cnt) return (void) (puts("0"));
for(int i = cnt - 1; i >= 0; i--) printf("%d", a[i]);
puts("");
}
int main()
{
n = read <int> (), x = read <int> (), y = read <int> (), z = read <int> ();
now = (1 << (x - 1 + y + z)) | (1 << (y - 1 + z)) | (1 << (z - 1)), lim = (1 << (x + y + z)) - 1;
f[0][0] = 1;
for(int tmp, i = 0; i < n; i++)
for(int j = 0; j <= lim; j++)
if(f[i][j])
{
for(int k = 1; k <= 10; k++)
{
tmp = ((j << k) | (1 << (k - 1))) & lim;
if((tmp & now) != now) f[i + 1][tmp] = (f[i + 1][tmp] + f[i][j]) % mod;
}
}
for(int j = 0; j <= lim; j++) if((j & now) != now) ans = (ans + f[n][j]) % mod;
printf("%d\n", (fpow(10, n) - ans + mod) % mod);
return 0;
}
| 1 |
///Bismillahir Rahmanir Rahim
#include<bits/stdc++.h>
#define ll long long
#define int ll
#define fi first
#define si second
#define mp make_pair
#define pb push_back
#define pi pair<ll,ll>
#define clr(x) memset(x,0,sizeof(x));
#define f(i,l,r) for(int i=l;i<=r;i++)
#define rf(i,r,l) for(int i=r;i>=l;i--)
#define done(i) cout<<"done = "<<i<<endl;
#define show(x,y) cout<<x<<" : ";for(auto z:y)cout<<z<<" ";cout<<endl;
#define fast ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
const ll inf=1e18;
const int mod=1e9+7;
const int M=100005;
int n;
string s;
char ses[M];
char fnd(int pos,char cur,char dan)
{
if(cur=='S')
{
if(s[pos]=='o')return dan;
else
{
if(dan=='S')return 'W';
else return 'S';
}
}
else if(cur=='W')
{
if(s[pos]=='x')return dan;
else
{
if(dan=='S')return 'W';
else return 'S';
}
}
}
void chk(char x,char y)
{
ses[0]=x;
ses[1]=y;
ses[n-1]=fnd(0,x,y);
for(int i=2;i<=n;i++)
{
char yo=fnd(i-1,ses[i-1],ses[i-2]);
if(i==n-1)
{
if(yo!=ses[n-1])
{
return ;
}
}
else if(i==n)
{
if(yo!=ses[0])return ;
continue;
}
ses[i]=yo;
}
ses[n]='\0';
cout<<ses<<endl;
exit(0);
}
main()
{
fast
cin>>n;
cin>>s;
chk('S','W');
chk('S','S');
chk('W','S');
chk('W','W');
cout<<"-1"<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int n;
string s;
cin >> n >> s;
vector<int> ans;
for(int i = 0; i < 4; i++){
ans.resize(n);
ans[0] = i%2;
ans[1] = i/2;
for(int j = 1; j < n-1; j++){
if(s[j] == 'o'){
if(ans[j] == 0) ans[j+1] = ans[j-1];
else ans[j+1] = !ans[j-1];
}
else{
if(ans[j] == 0) ans[j+1] = !ans[j-1];
else ans[j+1] = ans[j-1];
}
}
if(s[0] == 'o'){
if((ans[0] == 0) ^ (ans[1] == ans.back())) continue;
}
else{
if((ans[0] == 0) ^ (ans[1] != ans.back())) continue;
}
if(s.back() == 'o'){
if((ans.back() == 0) ^ (ans[0] == ans[n-2])) continue;
}
else{
if((ans.back() == 0) ^ (ans[0] != ans[n-2])) continue;
}
for(int j = 0; j < n; j++){
cout << "SW"[ans[j]];
}
cout << endl;
return 0;
}
cout << -1 << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod=1e9+7;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin>>n;
ll a[n+2];
for(int i=0;i<n;i++)cin>>a[i];
ll cnt[n+2]={0};
cnt[0]=a[0];
for(int i=1;i<n;i++)cnt[i]=cnt[i-1]+a[i];
ll sum=0;
ll res=cnt[n-1];
for(int i=0;i<n-1;i++){
if(i==0)sum+=(cnt[i]*((res-cnt[i])%mod))%mod;
else sum+=(((cnt[i]-cnt[i-1])%mod)*((res-cnt[i])%mod))%mod;
}
cout<<sum%mod<<endl;
}
| #include<bits/stdc++.h>
using namespace std;
#define int long long
#define vi vector<int>
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define pi 3.141592653589793238
#define eb emplace_back
#define rep(i,a,b) for (int i = a; i <= b; i++)
#define zip(i,a,b) for(int i=a;i<b;i++)
#define rzip(i,a,b) for(int i=a;i>=b;i--)
#define ll unsigned int
#define test int t;cin>>t; while(t--)
#define um unordered_map
#define en '\n'
#define us unordered_set
typedef pair<int, int> pii;
typedef pair<char, int> pci;
typedef pair<char, char> pcc;
typedef vector<pii> vii;
typedef long double ld;
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(),v.rend()
#define sz(x) (int)x.size()
#define INF (1e18+5)
#define inf (1e9+5)
#define mod 1000000007
void __print(int x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
// You should only debug a pair of simple data types. For example,
// the debug won't work if one of pair's elements is collection type
// (std::vector, std::map, std::set...).
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i : x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
// bool check_prime(int n) return whether a number is prime or not O(sqrt(N));
// int BE(int x,int n,int m) return x^n%m; O(logN);
// void sieve() from number 1-1000001 saare prime store kar lega in bool is_prime[1000001] array
// vector<int> z_array(string s) return vector which is Z-array of string s;
// vector<int> lps(string s) return vector which is lps array of string s;
// int power(int x,int n) return x^n; O(logN);
// using_ordered_set (template for using ordered set , replace first 2 lines of this page with this code..);
const int gf = 1e6 + 9;
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
#ifndef ONLINE_JUDGE
if (fopen("input.txt", "r"))
{
freopen ("input.txt" , "r" , stdin);
freopen ("output.txt" , "w" , stdout);
}
#endif
//_______________________________-code starts-_______________________________________________
int n;
cin >> n;
int a[n], b[n], c[n];
set<int>s;
zip(i, 0, n)cin >> a[i], s.insert(a[i]);
zip(i, 0, n)cin >> b[i];
zip(i, 0, n)cin >> c[i];
sort(a, a + n);
sort(b, b + n);
sort(c, c + n);
vi b1(n, 0);
zip(i, 0, n)
{
// first element-> b[i]
// c mai baaki saare elements bade hone chahiye..
int pos = upper_bound(c, c + n, b[i]) - c;
debug(pos);
b1[i] = n - pos;
}
rzip(i, n - 2, 0)
{
b1[i] += b1[i + 1];
}
debug(b1);
int ans = 0;
zip(i, 0, n)
{
int x = a[i];
// upper bound nikalna hoga array b mai.
int pos = upper_bound(b, b + n, x) - b;
if (pos < n)
{
ans += b1[pos];
}
}
cout << ans << en;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int MAXN = 1e5;
const int MAXM = 100;
int N, M;
vector<int> V1, V2, A, B;
int main()
{
int i, j;
scanf("%d%d", &N, &M);
int cnt=0;
for(i=1; i<=M; i++)
{
int X; scanf("%d", &X);
if(X%2) V2.push_back(X), cnt++;
else V1.push_back(X);
}
if(cnt>2) return !printf("Impossible");
if(cnt>0) A.push_back(V2[0]);
for(i=0; i<V1.size(); i++) A.push_back(V1[i]);
if(cnt>1) A.push_back(V2[1]);
if(A.size()==1)
{
if(A[0]>1) B.push_back(A[0]-1);
B.push_back(1);
}
else
{
B.push_back(A[0]+1);
for(i=1; i+1<A.size(); i++) B.push_back(A[i]);
if(A.back()>1) B.push_back(A.back()-1);
}
for(i=0; i<A.size(); i++) printf("%d ", A[i]);
printf("\n%d\n", B.size());
for(i=0; i<B.size(); i++) printf("%d ", B[i]);
}
| #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>
using namespace std;
template <typename T> inline void getint(T &num){
register int ch, neg = 0;
while(!isdigit(ch = getchar())) if(ch == '-') neg = 1;
num = ch & 15;
while(isdigit(ch = getchar())) num = num * 10 + (ch & 15);
if(neg) num = -num;
}
int N, M, A[100005], cnt = 0;
int main(){
getint(N), getint(M);
for(register int i = 1; i <= M; i++) getint(A[i]);
for(register int i = 1; i <= M; i++) if(A[i] & 1){
if(++cnt == 1) swap(A[i], A[1]);
else if(cnt == 2) swap(A[i], A[2]);
else return puts("Impossible"), 0;
}
if(cnt) swap(A[cnt], A[M]);
for(register int i = 1; i <= M; i++) printf("%d ", A[i]); puts("");
if(cnt <= 1){
printf("%d\n1 ", A[M] == 1 ? M : M + 1);
for(register int i = 1; i < M; i++) printf("%d ", A[i]);
if(A[M] > 1) printf("%d\n", A[M] - 1);
}
else{
printf("%d\n%d ", A[M] == 1 ? M - 1 : M, A[1] + 1);
for(register int i = 2; i < M; i++) printf("%d ", A[i]);
if(A[M] > 1) printf("%d\n", A[M] - 1);
}
return 0;
} | 1 |
#include <iostream>
#include <stdio.h>
#include <algorithm>
using namespace std;
int main() {
int c[6] = {0},same[5] = {0};
while(scanf("%d,%d,%d,%d,%d\n",&c[0],&c[1],&c[2],&c[3],&c[4]) == 5) {
int same[5] = {0};
int straight = 0;
for(int i=0;i<5;i++) {
for(int j=0;j<5;j++) {
if(c[i] == c[j]) {
same[i]++;
}
}
}
sort(c,c+5);
sort(same,same+5);
if(same[4] == 4) {
cout << "four card" << endl;
}
else if(same[4] == 3) {
if(same[1] == 2) {
cout << "full house" << endl;
}
else {
cout << "three card" << endl;
}
}
else if(same[4] == 2) {
if((same[3] == 2) &&(same[2] == 2)) {
cout << "two pair" << endl;
}
else {
cout << "one pair" << endl;
}
}
else if(same[4] == 1) {
for(int i=0;i<4;i++) {
if(c[i] == c[i+1]-1) {
straight = 1;
}
else {
straight = 0;
break;
}
}
if((c[0] == 1) && (c[1] == 10)) {
straight = 1;
}
if(straight) {
cout << "straight" << endl;
}
else {
cout << "null" << endl;
}
}
}
} | #include <iostream>
#include <string>
using namespace std;
int main()
{
int n; char c; string s;
while(cin >> n)
{
int cd[13]={0},pr[5]={0};
cd[n-1]++;
for(int i=0; i<4; i++)
{
cin >> c >> n;
cd[n-1]++;
}
for(int i=0; i<13; i++)
{
pr[cd[i]]++;
}
bool st=false;
for(int i=0; i<10; i++)
{
int sm=0;
for(int j=0; j<5; j++) sm+=(cd[(i+j)%13]?1:0);
if(sm==5) st=true;
}
s="null";
if(pr[4]) s="four card";
else if(pr[3]&&pr[2]) s="full house";
else if(st) s="straight";
else if(pr[3]) s="three card";
else if(pr[2]==2) s="two pair";
else if(pr[2]) s="one pair";
cout << s << endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
#define cans cout << ans << endl
#define cyes cout << "Yes" << endl
#define cno cout << "No" << endl
typedef long long ll;
int main(){
int n;
cin >> n;
string s;
cin >> s;
vector<int> l(n+1),r(n+1);
for(int i=1; i<=n-1; i++){
if(s[i-1]=='W') l[i] = l[i-1]+1;
else l[i] = l[i-1];
}
for(int i=n; i>=1; --i){
if(s[i-1]=='E') r[n-i+1] = r[n-i]+1;
else r[n-i+1] = r[n-i];
}
int ans = 1e9;
for(int i=0; i<=n-1; i++){
ans = min(ans,l[i]+r[n-i-1]);
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <iomanip>
#include <string>
#include <stack>
#include <vector>
#include <math.h>
#include <stdio.h>
#include <algorithm>
#include <utility>
#include <functional>
#include <iterator>
#include <map>
#include <set>
#include <queue>
#include <list>
#include <regex>
using namespace std;
using pii = pair<int,int>;
using ll=long long;
using ld=long double;
#define pb push_back
#define mp make_pair
#define sc second
#define fr first
#define stpr setprecision
#define cYES cout<<"YES"<<endl
#define cNO cout<<"NO"<<endl
#define cYes cout<<"Yes"<<endl
#define cNo cout<<"No"<<endl
#define rep(i,n) for(ll i=0;i<(n);++i)
#define Rep(i,a,b) for(ll i=(a);i<(b);++i)
#define rrep(i,n) for(int i=n-1;i>=0;i--)
#define rRep(i,a,b) for(int i=a;i>=b;i--)
#define crep(i) for(char i='a';i<='z';++i)
#define psortsecond(A,N) sort(A,A+N,[](const pii &a, const pii &b){return a.second<b.second;});
#define ALL(x) (x).begin(),(x).end()
#define debug(v) cout<<#v<<":";for(auto x:v){cout<<x<<' ';}cout<<endl;
#define endl '\n'
int ctoi(const char c){
if('0' <= c && c <= '9') return (c-'0');
return -1;
}
ll gcd(ll a,ll b){return (b == 0 ? a : gcd(b, a%b));}
ll lcm(ll a,ll b){return a*b/gcd(a,b);}
constexpr ll MOD=1000000007;
constexpr ll INF=1000000011;
constexpr ll MOD2=998244353;
constexpr ll LINF = 1001002003004005006ll;
constexpr ld EPS=10e-8;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
template<typename T> istream& operator>>(istream& is,vector<T>& v){for(auto&& x:v)is >> x;return is;}
template<typename T,typename U> istream& operator>>(istream& is, pair<T,U>& p){ is >> p.first; is >> p.second; return is;}
template<typename T,typename U> ostream& operator>>(ostream& os, const pair<T,U>& p){ os << p.first << ' ' << p.second; return os;}
template<class T> ostream& operator<<(ostream& os, vector<T>& v){
for(auto i=begin(v); i != end(v); ++i){
if(i !=begin(v)) os << ' ';
os << *i;
}
return os;
}
int main(){
string S;
cin >> S;
if(S.size()==3){
reverse(ALL(S));
}
cout << S << endl;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i,a,b) for(ll i=a;i<b;i++)
#define rrep(i,b,a) for(int i=b;i>=a;i--)
#define fori(a) for(auto i : a )
#define all(a) begin(a), end(a)
#define set(a,b) memset(a,b,sizeof(a))
#define sz(a) a.size()
#define pi 3.14159
#define ll long long
#define ull unsigned long long
#define pb push_back
#define PF push_front //deque
#define mp make_pair
#define pq priority_queue
#define mod 1000000007
#define f first
#define s second
#define pii pair< int, int >
#define vi vector<int>
#define vpii vector<pii>
#define debug(v) for(auto i:v) cout<<i<<" ";
#define tc int t; cin >> t; while(t--)
const ll INF=1e17;
using namespace std;
string repeat(string s, int n) {
string s1 = "";
for (int i=0; i<n;i++)
s1+=s;
return s1;
}
string getString(char x) {
string s(1, x);
return s;
}
void optimizeIO(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int gcd(int a, int b){
if (a == 0) return b;
return gcd(b % a, a);
}
ll ans1=0;
void recur(vector<pair<char,int>> str,int val,ll sum,int idx){
if(val<0) return;
else if(val==0){
ans1=max(ans1,sum);
return;
}
if(idx>=str.size()) return;
rep(j,idx,str.size()){
recur(str,val-str[j].s,sum*10+str[j].f-'0',idx+1);
recur(str,val-str[j].s,sum*10+str[j].f-'0',idx);
}
}
void solve(){
int n,m2;
cin>>n>>m2;
int a[m2];
rep(i,0,m2) cin>>a[i];
sort(a,a+m2);
map<int,int> m,m1;
m[1]=2;
m[2]=5;
m[3]=5;
m[4]=4;
m[5]=5;
m[6]=6;
m[7]=3;
m[8]=7;
m[9]=6;
rep(i,0,m2){
m1[m[a[i]]]=a[i];
}
int sma= (*m1.begin()).s;
int rep = max(n/m[sma]-7,0);
int rem=n%m[sma]+min(n/m[sma],7)*m[sma];
string ans="";
ans+=repeat(getString('0'+sma),rep);
vector<pair<char,int>> str;
for(auto i:m1){
str.pb({i.s+'0',i.f});
}
ans1=0;
recur(str,rem,0,0);
vector<char> res;
rep(i,0,ans.length()) res.pb(ans[i]);
// cout<<ans1<<endl;
while(ans1){
res.pb(ans1%10+'0');
ans1/=10;
}
sort(all(res),greater<char>());
rep(i,0,res.size()) cout<<res[i];
cout<<endl;
// if(rem==0) cout<<ans<<endl;
// else{
// int mx=-1;
// for(auto i:m1){
// if(i.f<=rem) mx=max(mx,i.s);
// }
// cout<<rem<<endl;
// if(mx!=-1 && sma>mx) ans+= getString(mx+'0');
// else if(mx!=-1 && sma<=mx) ans=getString(mx+'0')+ans;
// cout<<ans<<endl;
// }
}
int main(){
optimizeIO();
// tc
{ solve();
}
}
| #include "bits/stdc++.h"
using namespace std;
#define ASC(vec) vec.begin(), vec.end() // 昇順ソート 例：sort(ASC(vec));
#define DESC(vec) vec.rbegin(), vec.rend() // 降順ソート 例:sort(DESC(vec));
#define rep(i, n) for(int i = 0; i < (n); i++)
#define Rep(i, n) for(int i = 1; i < n; i++)
#define REP(i, vec) for(auto i = vec.begin(); i != vec.end(); ++i)
const int mod = 1000000007;
const int inf = (1 << 21);
const long long INF = 1LL << 60;
using ii = pair<int, int>;
using ll = long long;
using vi = vector<int>;
using vd = vector<double>;
using vb = vector<bool>;
using vl = vector<ll>;
using vs = vector<string>;
using vvi = vector<vector<int>>;
using vvl = vector<vector<ll>>;
using vvb = vector<vector<bool>>;
using vii = vector<pair<int, int>>;
using vll = vector<pair<ll, ll>>;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline T GCD(T a, T b) { return b ? GCD(b, a % b) : a; }
template<class T> inline T LCM(T a, T b) { return (a + (b - 1)) / b; }
int round_int(int a, int b) { return (a + (b - 1)) / b; }
constexpr array<int, 9> dx = { 0, 1, 0, -1, -1, 1, 1, -1, 0 };
constexpr array<int, 9> dy = { 1, 0, -1, 0, 1, 1, -1, -1, 0 };
// ──────────────────────────────────────────────────────────────────
constexpr array<int, 10> cost = { -1,2,5,5,4,5,6,3,7,6 };
int calc_cost(deque<int> d) {
int res = 0;
while (!d.empty()) {
int v = d.front(); d.pop_front();
res += cost[v];
}
return res;
}
int main() {
int n, m;
cin >> n >> m;
vi a(m);
rep(i, m) cin >> a[i];
vector<vector<deque<int>>> dp(n + 1, vector<deque<int>>(m));
for (int i = 0; i <= n; ++i) {
for (int j = 0; j < m; ++j) {
int c = cost[a[j]];
//cout << i << " " << j << endl;
if (i - c >= 0 && calc_cost(dp[i - c][j]) + c == i) {
deque<int> pre = dp[i - c][j];
if (pre.size() == 0) pre.push_back(a[j]);
else if (pre.front() > a[j]) pre.push_back(a[j]);
else pre.push_front(a[j]);
dp[i][j] = pre;
}
if (j != 0) {
deque<int> pre = dp[i][j - 1];
if (pre.size() < dp[i][j].size()) continue;
else if (pre.size() > dp[i][j].size()) dp[i][j] = pre;
else if (pre.size() == dp[i][j].size()) {
if (pre.size() == 0) continue;
deque<int> tmp1 = pre, tmp2 = dp[i][j];
for (int k = 0; k < pre.size(); ++k) {
int l = tmp1.front(), r = tmp2.front();
tmp1.pop_front(), tmp2.pop_front();
if (l > r) {
dp[i][j] = pre;
break;
}
else if (l < r) {
break;
}
}
}
}
}
}
int mx = dp[n][m - 1].size();
rep(i, mx) {
int v = dp[n][m - 1].front(); dp[n][m - 1].pop_front();
cout << v;
}
} | 1 |
#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;
} | #include "bits/stdc++.h"
#include "math.h"
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
typedef vector<vll> vvll;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<int> vin;
typedef pair<ll,ll> P;
typedef vector<P> vp;
#define rep(i,a,b) for(ll i=(a);i<(b);++i)
#define drep(i,a,b) for(ll i=(a);i>=(b);--i)
#define SIZE(a) int((a).size())
#define out(a) cout<<(a)<<endl;
const int INF=INT_MAX;
const int MAX = 510000;
const ll MOD = 10000;
ll fac[MAX], finv[MAX], inv[MAX];
int main (){
ll n,m,q;cin>>n>>m>>q;
vvll a(509,vll(509,0));
rep(i,0,m){
ll l,r;cin>>l>>r;
a[l][r]++;
}
rep(i,1,n+1){
rep(j,1,n+1){
a[i][j]+=a[i][j-1];
}
}
rep(i,1,n+1){
rep(j,1,n+1){
a[i][j]+=a[i-1][j];
}
}
rep(i,0,q){
ll p,q;cin>>p>>q;
cout<<a[q][q]+a[p-1][p-1]-a[p-1][q]-a[q][p-1]<<endl;
}
} | 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() { cout << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cout << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define dbg(...) cout << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define dbg(...) 42
#endif
const long long mod = 1e9+7; // CHECK
long long power(long long a, long long b, long long m = mod) {
if(b < 0) {
return power(power(a, -b), mod-2);
}
long long x = 1;
while(b) {
if(b & 1) {
x = 1ll * x * a % m;
}
a = 1ll * a * a % m;
b /= 2;
}
return x;
}
#define ll long long
const int INT_INF = 1e9+9;
const ll LL_INF = 2e18;
const int N = 3e5+9; // check N, mod
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0); cout.tie(0);
string s; cin >> s;
if (s == "zyxwvutsrqponmlkjihgfedcba") {
cout << "-1\n";
return 0;
}
int n = (int) s.size();
if (n == 26) {
int ind = -1;
for (int i = n-2; i >= 0; i--) {
if (s[i] < s[i+1]) {
ind = i;
break;
}
}
char now;
for (int i = n-1; i > ind; i--) {
if (s[i] > s[ind]) {
now = s[i];
break;
}
}
cout << s.substr(0, ind) << now << endl;
} else {
vector<int> oc(27);
for (int i = 0; i < n; i++) {
oc[s[i]-'a']=1;
}
int mex = 0;
while (oc[mex]) mex++;
cout << s << char('a' + mex) << endl;
}
return 0;
}
| #include <stdio.h>
#include <string>
#include <string.h>
#include <cstring>
#include <algorithm>
using namespace std;
int a;
char test[21];
char temp;
int main()
{
scanf("%s",test);
for(a=strlen(test)-1;a>=0;a--)
{
printf("%c",test[a]);
}
printf("\n");
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll,ll>;
using Map = map<char,ll>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
ll INF=1LL<<60;
ll MOD=1000000007;
int main(){
string N;
cin >> N;
ll n=N.size();
ll ans=0;
vector<ll> keta(n,0);
for(ll i=0;i<n;i++){
keta[i]=N[i]-'0'
;}
for(ll i=n-1;i>=0;i--){
if(keta[i]==10){
if(i>0){
keta[i-1]++;
keta[i]=0;
}
else ans+=1;
}
else if(keta[i]<=4){
ans+=keta[i];
}
else if(keta[i]>=6&&keta[i]<=9){
ans+=10-keta[i];
if(i>0){
keta[i-1]++;
}
else ans+=1;
}
else if(keta[i]=5){
if(i==0){
ans+=5;
}
else if(keta[i-1]<=4){
ans+=5;
}
else if(keta[i-1]>=5){
ans+=5;
keta[i-1]+=1;
}
}
;}
cout<<ans<<endl;
return 0;
}
| #include <limits.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
#define rep(i, n) for (ll i = 0; i < (n); ++i)
#define repLRE(i, l, r) for (ll i = (l); i <= (r); ++i)
#define rrepLRE(i, l, r) for (ll i = (l); i >= (r); --i)
#define Sort(v) sort(v.begin(), v.end())
#define Reverse(v) reverse(v.begin(), v.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))
using ll = long long;
using ull = unsigned long long;
using P = pair<ll, ll>;
using T = tuple<ll, ll, ll>;
using vll = vector<ll>;
using vP = vector<P>;
using vT = vector<T>;
using vvll = vector<vector<ll>>;
using vvP = vector<vector<P>>;
using dqll = deque<ll>;
ll dx[9] = {-1, 1, 0, 0, -1, -1, 1, 1, 0};
ll dy[9] = {0, 0, -1, 1, -1, 1, -1, 1, 0};
/* Macros reg. ends here */
const ll INF = 1LL << 50;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(15);
string s;
cin >> s;
set<ll> mi;
rep(i, 26) mi.insert(i);
ll n = s.size();
string ans = "";
rep(i, n) {
ll idx = s[i] - 'a';
if (mi.find(idx) != mi.end()) {
mi.erase(idx);
ans += s[i];
} else {
auto citr = mi.begin();
ans += *citr + 'a';
mi.erase(citr);
}
} // i
if (s == ans) {
if (!mi.empty()) {
rep(i, 26) {}
ans += *mi.begin() + 'a';
} else {
vector<char> tst;
rep(i, 26) tst.push_back(s[i]);
next_permutation(tst.begin(), tst.end());
string cmp = "";
for (char c : tst) cmp += c;
if (cmp < s) {
puts("-1");
return 0;
} else {
rep(i,26) if(ans[i] != cmp[i]){
ans = cmp.substr(0, i+1);
break;
}
}
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
using ll=long long;
const int MOD=(int)1e9+7;
const int INF=(int)1e9;
const ll LINF=(ll)1e18;
ll modpow(ll x,ll n){
ll res=1;
while(n>0){
if(n&1)res=res*x%MOD;
x=x*x%MOD;
n>>=1;
}
return res;
}
int main(){
int n,x;
cin>>n>>x;
int s[n+1];
for(int i=0;i<n;i++){
cin>>s[i];
}
s[n]=INF;
sort(s,s+n);
int crt=0;
ll dp[x+1]={};
for(int i=0;i<=x;i++){
while(s[crt]<=i)crt++;
if(crt==0){
dp[i]=i;
continue;
}
ll inv=modpow(crt,MOD-2);
for(int j=0;j<crt;j++){
dp[i]=(dp[i]+dp[i%s[j]])%MOD;
}
dp[i]=(dp[i]*inv)%MOD;
}
ll ans=dp[x];
for(int i=2;i<=n;i++){
ans=(ans*i)%MOD;
}
cout<<ans<<endl;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
long long modpow(long long a, long long n, long long mod) {
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main(){
const ll mod=998244353;
int n,d[100010];
cin >> n;
int i,ma=0;
for(i=0;i<n;i++){
cin >> d[i];
ma=max(ma,d[i]);
}
if(d[0]!=0){
cout << 0 << endl;
return 0;
}
vector<int> x(100010,0);
for(i=0;i<n;i++){
x[d[i]]++;
}
if(x[0]!=1){
cout << 0 << endl;
return 0;
}
for(i=0;i<=ma;i++){
if(x[i]==0){
cout << 0 << endl;
return 0;
}
}
ll ans=1;
for(i=1;i<=ma-1;i++){
ans*=modpow(x[i],x[i+1],998244353);
ans=ans%mod;
}
cout << ans << endl;
} | 0 |
/*
Contest 096
B - Maximum Sum
Rakesh Kumar --> 23/09/2020
*/
#include <bits/stdc++.h>
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0); std::cout.tie(0);
int a = 0, b = 0, c = 0;
std::cin >> a >> b >> c;
int k = 0;
std::cin >> k;
int v = std::max(std::max(a, b), c);
int total = a + b + c - v;
while (k--) {
v <<= 1;
}
total += v;
std::cout << total << std::endl;
return 0;
}
| /*Author- Soumak Poddar*/
#include<bits/stdc++.h>
using namespace std;
#define ll long long int
#define sll signed long long int
#define ull unsigned long long int
#define um unordered_map
#define us unordered_set
#define mm multimap
#define mp make_pair
#define pb push_back
#define M 1000000007
bool comp(pair<int,int> a,pair<int,int> b)
{
return a.second<b.second;
}
template<typename T>
T gcd(T a,T b)
{
if(a==0)
return b;
return gcd(b%a,a);
}
template<typename T>
T lcm(T a,T b)
{
T g=gcd<T>(a,b);
return (a*b)/g;
}
template<typename T>
bool isprime(T n)
{
if(n<=1)
return false;
for(int i=2;i<sqrt(n);i++)
if(n%i==0)
return false;
return true;
}
void solve();
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("error.txt", "w", stderr);
freopen("output.txt", "w", stdout);
#endif
int t=1;
// cin>>t;
while(t--)
{
solve();
cout<<"\n";
}
cerr<<"Time Taken : "<<(float)clock()/CLOCKS_PER_SEC<<" secs"<<endl;
return 0;
}
void solve()
{
int d,t,s;
cin>>d>>t>>s;
double at=(double)d/s;
if(at<=t)
cout<<"Yes";
else
cout<<"No";
} | 0 |
#include<iostream>
#include<vector>
using namespace std;
void show(int arr[], int N){
for(int i=0; i<N; i++)
if(i<N-1)
cout<<arr[i]<<' '<<flush;
else
cout<<arr[i]<<flush;
cout<<endl;
}
void swap(int& a, int& b){
int t=a;
a=b;
b=t;
}
int ShellSort(int* arr, int N);
int InsertionSort_r(int* arr, int N, int r);
int main()
{
int N;cin>>N;
int* arr= new int[N];
for(int i=0; i<N; i++)
cin>>arr[i];
int count=ShellSort(arr, N);
cout<<count<<endl;
for( int i=0; i<N; i++)
cout<<arr[i]<<endl;
delete[] arr;
}
int ShellSort(int* arr, int N)
{
int counter=0;
vector<int> range;
for( int i=1; i<=N; i= i*3 +1 )
range.push_back(i);
cout<<range.size()<<endl;
for( int i=range.size() -1; i >=0; i-- )
cout<<range[ i ]<<' '<<flush;
cout<<endl;
for( int i=range.size() -1; i>=0; i-- )
counter=InsertionSort_r(arr, N, range[ i ]);
return counter;
}
int InsertionSort_r(int arr[], int N, int r)
{
static int counter=0;
int compindex;
int comp;
int j;
for( int i=0; i<r; i++) {
for( int compindex=N- r -1 -i ; compindex> -1; compindex-=r ){
comp=arr[compindex];
j=r;
for( ; compindex+j<N; j+=r ){
if(comp > arr[compindex+j]){
arr[compindex + j -r] = arr[compindex + j];
counter++;
}
else
break;
}
arr[compindex + j - r] = comp;
}
}
return counter;
}
/* ?§£??????????????????????????????
o x x o x x x *
o x x o x x o *
x o x x o x x
x x o x x o x
??¨???????????????????????????????????????????????§???
o x x o x x x *
x o x x o x x
x x o x x o x
o x x o x x o *
?????¨?????????????§£?????????
????????????????????¨????????????????????????(0.2?§????????§£?????????????????????????)
int InsertionSort_r(int arr[], int N, int r)
{
static int cnt=0;
bool changed=false;
for( int compindex=r; compindex<N; compindex++) {
int comp= arr[compindex];
int j=compindex - r;
for( ; j>=0; j-=r ) {
if(arr[j] > comp){
arr[ j+r ]=arr[j];
cnt++;
changed=true;
}
else
break;
}
arr[ j+r ] =comp;
changed=false;
}
return cnt;
}
*/ | #include <iostream>
#include <algorithm>
#include <vector>
typedef int TInt;
typedef std::vector<TInt> TList;
TList Input()
{
int Count;
std::cin >> Count;
TList List(Count);
for(int i = 0; i < Count; ++i){
std::cin >> List[i];
}
return List;
}
int insertionSort(TList& A, int g)
{
int cnt = 0;
for(int i = g; i < A.size(); ++i){
TInt v = A[i];
int j = i - g;
while(j >= 0 && A[j] > v){
A[j+g] = A[j];
j = j - g;
cnt++;
}
A[j+g] = v;
}
return cnt;
}
void Reverse(TList& List)
{
TList R;
for(TList::reverse_iterator It = List.rbegin();
It != List.rend();
++It)
{
R.push_back(*It);
}
std::swap(R, List);
}
TList GetG(int Max)
{
TList G;
int h = 1;
while(h <= Max){
G.push_back(h);
h = 3 * h + 1;
}
// Reverse(G);
std::reverse(G.begin(), G.end());
return G;
}
int shellSort(TList& A, const TList& G)
{
int cnt = 0;
for(TList::const_iterator It = G.begin();
It != G.end();
++It){
cnt += insertionSort(A, *It);
}
return cnt;
}
void OutputLine(const TList& List)
{
TList::const_iterator It = List.begin();
std::cout << *(It++);
for(; It != List.end(); ++It){
std::cout << " " << *It;
}
std::cout << std::endl;
}
void Output(const TList& List)
{
TList::const_iterator It = List.begin();
// std::cout << *(It++);
for(; It != List.end(); ++It){
std::cout << *It << std::endl;
}
}
int main()
{
std::cin.tie(0);
std::ios::sync_with_stdio(false);
TList A = Input();
TList G = GetG(A.size());
int cnt = shellSort(A, G);
std::cout << G.size() << std::endl;
OutputLine(G);
std::cout << cnt << std::endl;
Output(A);
return 0;
} | 1 |
#include<iostream>
using namespace std;
int a;
int main() {
while (cin >> a) {
cout << (900 - a)*(900 - a) * 100 - 9000000 << endl;
}
} | #include <sstream>
#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <iostream>
#include <utility>
#include <set>
#include <cctype>
#include <queue>
#include <stack>
#include <cstdio>
#include <cstdlib>
#include <cmath>
using namespace std;
int f(int n) {
return n * n;
}
int main(void) {
int n;
while (cin >> n) {
int ans = 0;
for (int i = 0; i * n < 600; i++) {
ans += f(i*n) * n;
}
cout << ans << endl;
}
return 0;
} | 1 |
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
#include<string>
#include<vector>
#include<math.h>
#include<queue>
#include<algorithm>
#include<functional>
#include<cstdlib>
#include<cmath>
#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 CI cin >>
#define CO cout <<
#define E << endl;
using namespace std;
typedef pair<int, int> P;
typedef pair<long, long> LP;
typedef pair<int, P> PP;
typedef pair<long, LP> LPP;
int dy[] = { 0, 0, 1, -1, 0 };
int dx[] = { 1, -1, 0, 0, 0 };
string C;
void input(void) {
CI C;
return;
}
int main(void) {
input();
reverse(C.begin(), C.end());
CO C E
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int main(){
string str;
int i,j;
cin >> str;
string st="";
for( i=str.size()-1; i>=0 ; i-- )
st+=str[i] ;
cout << st << endl;
} | 1 |
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define rep(i,n) for(int i=0;i<(n);++i)
#define repi(i,a,b) for(int i=int(a);i<int(b);++i)
#define all(x) (x).begin(), (x).end()
#define PI 3.14159265358979323846264338327950L
using namespace std;
typedef long long ll;
typedef long double ld;
int main() {
ll n,y;
cin>>n>>y;
ll noguchi=0,higuchi=0;
rep(i,n+1){
rep(j,n+1-i){
if((y-(1000*i+5000*j))%10000==0&&(y-(1000*i+5000*j))/10000==n-i-j){
printf("%d %d %d",n-i-j,j,i);
return 0;
}
}
}
printf("-1 -1 -1");
} | #include <iostream>
#include <algorithm>
#include <iomanip>
#include <string>
#include <vector>
#include <math.h>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#define PI 3.14159265359
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pai;
typedef pair<ll, ll> pal;
const int MOD = 1e9+7;
const ll LLINF = 1e18;
int main(){
int n, y;
cin >> n >> y;
for (int i = 0; i <= 2000; i++){
for (int j = 0; i+j <= 2000; j++){
for (int k = 0; i+j+k <= 2000; k++){
if (i+j+k == n && i*1000 + j*5000 + k*10000 == y){
cout << k << " " << j << " " << i << endl;
return 0;
}
}
}
}
cout << -1 << " " << -1 << " " << -1 << endl;
return 0;
}
| 1 |
/// However long the night,
/// The dawn will break
/// ICPC next year
#include<bits/stdc++.h>
using namespace std ;
const int N = 1e6+5 ;
int n ,a[N] ,b[N] ;
vector<int> xorA ,xorB ;
int nn ,mm ,pat[N], str[N];
int F[N];
int getNextLen(int len, int c){
while(len && c != pat[len])
len = F[len-1];
if(c == pat[len]) ++len;
return len;
}
void computeF(){
for(int i = 1 ; i<nn ; ++i)
F[i] = getNextLen(F[i-1], pat[i]);
}
vector<int> search(){
int len = 0;
vector<int> res;
for(int i = 0 ; i<mm ; ++i){
len = getNextLen(len, str[i]);
if(len==nn){
res.push_back(i-len+1);
}
}
return res;
}
int main(){
memset(pat,-1,sizeof pat);
memset(str,-1,sizeof str);
scanf("%d",&n);
for(int i=0;i<n;++i) scanf("%d",a+i);
for(int i=0;i<n;++i) scanf("%d",b+i);
for(int i=0;i<n;++i){
xorA.push_back(a[i]^a[(i+1)%n]);
xorB.push_back(b[i]^b[(i+1)%n]);
}
for(int i=n;i<n+n+n;++i) xorA.push_back(xorA[i-n]);
for(int i=0;i<xorA.size();++i) str[i] = xorA[i] ;
for(int i=0;i<xorB.size();++i) pat[i] = xorB[i] ;
mm = xorA.size() ;
nn = xorB.size() ;
computeF() ;
auto v = search() ;
for(auto go:v){
if(go>=n) break ;
int x = a[go]^b[0] ;
printf("%d %d\n",go,x);
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
struct Compress {
vector<T> xs;
Compress(const vector<T>& vs) : xs(vs) {
sort(xs.begin(), xs.end());
xs.erase(unique(xs.begin(), xs.end()), xs.end());
}
int compress(const T& x) {
return lower_bound(xs.begin(), xs.end(), x) - xs.begin();
}
T decompress(int i) {
return xs[i];
}
};
vector<int> suffix_array(vector<int>& s) {
int n = s.size();
Compress<int> comp(s);
vector<int> t(n);
for (int i = 0; i < n; i++) t[i] = comp.compress(s[i]);
vector<int> p(n), c(n), cnt(n);
for (int i = 0; i < n; i++) cnt[t[i]]++;
for (int i = 1; i < n; i++) cnt[i] += cnt[i-1];
for (int i = 0; i < n; i++) p[--cnt[t[i]]] = i;
int cl = 0;
for (int i = 1; i < n; i++) {
if (s[p[i]] != s[p[i-1]]) cl++;
c[p[i]] = cl;
}
vector<int> pn(n), cn(n);
for (int h = 0; (1 << h) < n; h++) {
for (int i = 0; i < n; i++) {
pn[i] = p[i] - (1 << h);
if (pn[i] < 0) pn[i] += n;
}
fill(cnt.begin(), cnt.end(), 0);
for (int i = 0; i < n; i++) cnt[c[pn[i]]]++;
for (int i = 1; i < n; i++) cnt[i] += cnt[i-1];
for (int i = n - 1; i >= 0; i--) {
cnt[c[pn[i]]]--;
p[cnt[c[pn[i]]]] = pn[i];
}
cn[p[0]] = 0;
cl = 0;
for (int i = 1; i < n; i++) {
pair<int, int> cur(c[p[i]], c[(p[i] + (1 << h)) % n]);
pair<int, int> prev(c[p[i-1]], c[(p[i-1] + (1 << h)) % n]);
if (cur != prev) cl++;
cn[p[i]] = cl;
}
swap(c, cn);
}
return p;
}
int bin_search(vector<int>& a, vector<int>& b, vector<int>& sa, bool lower) {
int n = a.size();
int lb = -1, ub = n;
while (ub - lb > 1) {
int m = (lb + ub) / 2;
bool flag = false;
for (int i = 0; i < n; i++) {
int j = (sa[m] + i) % n;
if (a[i] < b[j]) {
ub = m;
flag = true;
break;
}
if (a[i] > b[j]) {
lb = m;
flag = true;
break;
}
}
if (!flag) {
if (lower) ub = m;
else lb = m;
}
}
return ub;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int N;
cin >> N;
vector<int> a(N), b(N);
for (int i = 0; i < N; i++) cin >> a[i];
for (int i = 0; i < N; i++) cin >> b[i];
vector<int> c(N), d(N);
for (int i = 0; i < N; i++) {
c[i] = a[i] ^ a[(i+1) % N];
d[i] = b[i] ^ b[(i+1) % N];
}
auto sa = suffix_array(d);
int lb = bin_search(c, d, sa, true);
int ub = bin_search(c, d, sa, false);
vector<pair<int, int>> ans;
for (int i = lb; i < ub; i++) {
int k = (N - sa[i]) % N;
int x = a[k] ^ b[0];
ans.push_back({k, x});
}
sort(ans.begin(), ans.end());
for (auto& p : ans) cout << p.first << " " << p.second << "\n";
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
//ライブラリ始まり
//定数
//円周率
const double PI = 3.1415926535897932384;
//天井
const int INF = 1000000000; // = 10^9
const ll LINF = 1000000000000000; // = 10^15
//ABC文字列
const string ABC = "ABCDEFGHIJKLMNOPQRSTUVWXYZABC";
const string abc = "abcdefghijklmnopqrstuvwxyzabc";
//よくあるmodくん
const ll MOD = 1000000007; // = 10^9 + 7
//データ構造
//Union_Find木
struct UnionFind {
vector<int> UF; // UF.at(i) : iの親の番号
vector<int> SIZE; // SIZE.at(root(i)) : iと連結されてる要素の数
UnionFind(int N) : UF(N), SIZE(N, 1) { // 最初は全てが根であるとして初期化
for(int i = 0; i < N; i++) {
UF.at(i) = i;
}
}
int root(int x) { // データxが属する木の根を再帰で得る：root(x) = {xの木の根}
if (UF.at(x) == x) {
return x;
}
return UF.at(x) = root(UF.at(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の根が同じ(=同じ木にある)時はそのまま
}
// xとyの根が同じでない(=同じ木にない)時：小さい方の根を大きい方の根につける
if (SIZE.at(rx) < SIZE.at(ry)) {
UF.at(rx) = ry;
SIZE.at(ry) += SIZE.at(rx);
SIZE.at(rx) = 0;
}
else {
UF.at(ry) = rx;
SIZE.at(rx) += SIZE.at(ry);
SIZE.at(ry) = 0;
}
}
bool same(int x, int y) { // 2つのデータx, yが属する木が同じならtrueを返す
int rx = root(x);
int ry = root(y);
return rx == ry;
}
int size(int x) { // xと連結されてる要素の数を返す
return SIZE.at(root(x));
}
};
//関数
//ctoi
int ctoi(char c){
if (c == '0') {
return 0;
}
if (c == '1') {
return 1;
}
if (c == '2') {
return 2;
}
if (c == '3') {
return 3;
}
if (c == '4') {
return 4;
}
if (c == '5') {
return 5;
}
if (c == '6') {
return 6;
}
if (c == '7') {
return 7;
}
if (c == '8') {
return 8;
}
if (c == '9') {
return 9;
}
return -1;
}
//素数判定
bool PN(int x) {
if (x <= 1) {
return false; // 1や0,-1は素数ではない
}
if (x == 2) {
return true; // √2 + 1 > 2 なので下でやると 2 ％ 2 = 0 となり判定できない
}
for (int i = 2; i < sqrt(x) + 1; i++) {
if (x % i == 0) {
return false; // 割れたら素数じゃない
}
}
return true;
}
//ライブラリ終わり
int main() {
ll N, A, B;
cin >> N >> A >> B;
vector<ll> M(N, 0);
vector<ll> X(N);
for (int i = 0; i < N; i++) {
cin >> X.at(i);
}
for (int i = 1; i < N; i++) {
M.at(i) = min(M.at(i - 1) + B,
M.at(i - 1) + A * (X.at(i) - X.at(i - 1)));
}
cout << M.at(N - 1) << endl;
} | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
const long MOD = 1000000007;
typedef pair<int, int> P;
typedef long long ll;
int main(){
int N, A, B;
cin >> N >> A >> B;
int X[N];
for(int i=0; i<N; i++) cin >> X[i];
sort(X, X+N);
int now = X[0];
ll ans = 0;
for(int i=0; i<N; i++){
ll w = (ll)A*(X[i] - now);
ll t = B;
ans = ans + min(w, t);
now = X[i];
}
cout << ans << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fo(a,b) for(int a=0;a<b;a++)
#define Sort(a) sort(a.begin(),a.end())
#define rev(a) reverse(a.begin(),a.end())
#define fi first
#define se second
#define co(a) cout<<a<<endl
#define sz size()
#define bgn begin()
#define en end()
#define pb(a) push_back(a)
#define pop pop_back
#define V vector
#define P pair
#define V2(a,b,c) V<V<int>> a(b,V<int>(c))
#define V2a(a,b,c,d) V<V<int>> a(b,V<int>(c,d))
#define incin(a) int a; cin>>a
#define yuko(a) setprecision(a)
//#define min min<int>
//#define max max<int>
template<class T>
void cou(vector<vector<T>> a){
int b=a.size();
int c=a[0].size();
fo(i,b){
fo(j,c){
cout<<a[i][j];
if(j==c-1)
cout<<endl;
else
cout<<' ';
}
}
}
/*template<>
void cou(vector<vector<char>> a){
int b=a.size();
int c=a[0].size();
fo(i,b){
fo(j,c){
cout<<a[i][j];
if(j==c-1)
cout<<endl;
else
cout<<' ';
}
}
}*/
int wari(int a,int b) {
if(a%b==0)
return a/b;
else
return a/b+1;
}
int keta(int a){
double b=a;
b=log10(b);
int c=b;
return c+1;
}
int souwa(int a){
return a*(a+1)/2;
}
int lcm(int a,int b){
int d=a,e=b,f;
if(a<b)
swap(a,b);
int c,m=1;
while(m){
c=a%b;
if(c==0){
f=b;
m--;
}
else{
a=b;
b=c;
}
}
return d*e/f;
}
int gcm(int a,int b){
int d=a,e=b,f;
if(a<b)
swap(a,b);
int c,m=1;
while(m){
c=a%b;
if(c==0){
f=b;
m--;
}
else{
a=b;
b=c;
}
}
return f;
}
bool prime(int a){
if(a<2)
return false;
else if(a==2)
return true;
else if(a%2==0)
return false;
double b=sqrt(a);
for(int i=3;i<=b;i+=2){
if(a%i==0){
return false;
}
}
return true;
}
struct Union{
vector<int> par;
Union(int n){
par= vector<int>(n, -1);
}
int find(int x){
if(par[x]<0)
return x;
else
return par[x]=find(par[x]);
}
bool same(int a,int b){
return find(a)==find(b);
}
int Size(int a){
return -par[find(a)];
}
void unite(int a,int b){
a=find(a);
b=find(b);
if(a==b)
return;
if(Size(b)>Size(a))
swap<int>(a,b);
par[a]+=par[b];
par[b]=a;
}
};
int ketas(int a){
string b=to_string(a);
int c=0;
fo(i,keta(a)){
c+=b[i]-'0';
}
return c;
}
/*struct aa{
vector<int> gt;
aa(int n){
gt= vector<int>(n, 1);
}
void c(V<int> d,int b){
if(d[b]==0){
gt[d[b]-1]++;
gt[gt.sz-1]++;
}
else{
gt[d[b]-1]++;
c(d,d[d[b]]-1);
}
}
void cok(int a){
cout<<gt[a-1]<<endl;
fo(i,a-1)
cout<<gt[i]<<endl;
}
};
*/
signed main(){
int a;
cin>>a;
cout<<180*(a-2)<<endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll inf = 1e9+7;
int main(){
ll a,b;
cin>>a>>b;
cout << a*b;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define inf INT_MAX
#define INF LLONG_MAX
#define ll long long
#define ull unsigned long long
#define M (int)(1e9+7)
#define P pair<int,int>
#define FOR(i,m,n) for(int i=(int)m;i<(int)n;i++)
#define RFOR(i,m,n) for(int i=(int)m;i>=(int)n;i--)
#define rep(i,n) FOR(i,0,n)
#define rrep(i,n) RFOR(i,n,0)
#define all(a) a.begin(),a.end()
const int vx[4] = {0,1,0,-1};
const int vy[4] = {1,0,-1,0};
#define F first
#define S second
#define PB push_back
#define EB emplace_back
#define int ll
#define vi vector<int>
#define IP pair<int,P>
#define PI pair<P,int>
#define PP pair<P,P>
#define Yes(f){cout<<(f?"Yes":"No")<<endl;}
#define YES(f){cout<<(f?"YES":"NO")<<endl;}
int Madd(int x,int y) {return (x+y)%M;}
int Msub(int x,int y) {return (x-y+M)%M;}
int Mmul(int x,int y) {return (x*y)%M;}
template< typename T >
struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template< typename T >
using Edges = vector< edge< T > >;
template< typename T >
using WG = vector< Edges< T > >;
using UG = vector< vector< int > >;
template< typename T >
using Matrix = vector< vector< T > >;
template< typename T >
struct LowLink {
const WG<T> &g;
vector< int > used, ord, low;
vector< int > articulation;
vector< pair< int, int > > bridge;
LowLink(const WG<T> &g) : g(g) {}
int dfs(int idx, int k, int par) {
used[idx] = true;
ord[idx] = k++;
low[idx] = ord[idx];
bool is_articulation = false;
int cnt = 0;
for(auto &e : g[idx]) {
if(!used[e.to]) {
++cnt;
k = dfs(e.to, k, idx);
low[idx] = min(low[idx], low[e.to]);
is_articulation |= ~par && low[e.to] >= ord[idx];
if(ord[idx] < low[e.to]) bridge.emplace_back(minmax(idx, (int) e.to));
} else if(e.to != par) {
low[idx] = min(low[idx], ord[e.to]);
}
}
is_articulation |= par == -1 && cnt > 1;
if(is_articulation) articulation.push_back(idx);
return k;
}
virtual void build() {
used.assign(g.size(), 0);
ord.assign(g.size(), 0);
low.assign(g.size(), 0);
int k = 0;
for(int i = 0; i < g.size(); i++) {
if(!used[i]) k = dfs(i, k, -1);
}
}
};
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(20);
int n,m;
cin>>n>>m;
WG<int> es(n);
rep(i,m){
int x,y;
cin>>x>>y;
es[x].PB(edge<int>(y,1));
es[y].PB(edge<int>(x,1));
}
LowLink<int> lowlink(es);
lowlink.build();
sort(all(lowlink.articulation));
for(int x:lowlink.articulation){
cout<<x<<endl;
}
}
| #include <iostream>
#include <vector>
#include <set>
#include <algorithm>
using namespace std;
int timer = 0;
struct needed {
needed(int verNum) {
for (int i = 0; i < verNum; i++) {
visited.push_back(false);
preNum.push_back(1 << 30);
lowest.push_back(1 << 30);
parent.push_back(-1);
}
}
vector<bool> visited;
vector<int> preNum; //?¨?????????????
vector<int> lowest;
vector<int> parent;
};
void DFS(int current, int previous, vector<int> verVal[], needed &need) {
need.preNum[current] = timer;
need.lowest[current] = timer;
timer++;
need.visited[current] = true;
for (int i = 0; i < verVal[current].size(); i++) {
int next = verVal[current][i];
if (!need.visited[next]) {
need.parent[next] = current;
DFS(next, current, verVal, need);
need.lowest[current] = min(need.lowest[current], need.lowest[next]);
}
else if (next != previous) {
need.lowest[current] = min(need.lowest[current], need.preNum[next]);
}
}
}
void ArticulationPoint(vector<int> verVal[], int verNum) {
needed need(verNum);
DFS(0, -1, verVal, need);
set<int> artPoints;
int childNumOfRoot = 0;
//root??????????????¨??¨
for (int i = 1; i < verNum; i++) {
int nowP = need.parent[i];
if (nowP == 0) childNumOfRoot++;
else if (need.preNum[nowP] <= need.lowest[i])
artPoints.insert(nowP);
}
//root?????¢?????????????????????????????????????????£??????????????§?????????
if (childNumOfRoot > 1) artPoints.insert(0);
for (set<int>::iterator it = artPoints.begin(); it != artPoints.end(); it++)
cout << *it << endl;
}
int main() {
int verNum, edgeNum;
cin >> verNum >> edgeNum;
vector<int> verVal[100000];
for (int i = 0; i < edgeNum; i++) {
int firVal, secVal;
cin >> firVal >> secVal;
verVal[firVal].push_back(secVal);
verVal[secVal].push_back(firVal);
}
ArticulationPoint(verVal, verNum);
return 0;
} | 1 |
/*
これを入れて実行
g++ code.cpp
./a.out
*/
#include <iostream>
#include <stdio.h>
#include <vector>
#include <string>
#include <queue>
#include <deque>
#include <algorithm>
#include <utility>
#include <set>
#include <map>
#include <unordered_map>
#include <cmath>
#include <math.h>
#include <tuple>
#include <iomanip>
#include <bitset>
#include <functional>
#define all(x) (x).begin(),(x).end()
using namespace std;
typedef long long ll;
typedef long double ld;
int dy4[4] = {-1, 0, +1, 0};
int dx4[4] = {0, +1, 0, -1};
int dy8[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
int dx8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const long long INF = 1LL << 60;
const ll MOD = 1e9 + 7;
bool greaterSecond(const pair<int, int>& f, const pair<int, int>& s){
return f.second > s.second;
}
ll gcd(ll a, ll b){
if (b == 0)return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b){
return a / gcd(a, b) * b;
}
ll nCr(ll n, ll r){
if(r == 0 || r == n){
return 1;
} else if(r == 1){
return n;
}
return (nCr(n - 1, r) + nCr(n - 1, r - 1));
}
ll nPr(ll n, ll r){
r = n - r;
ll ret = 1;
for (ll i = n; i >= r + 1; i--) ret *= i;
return ret;
}
//-----------------------ここから-----------
int main(void){
int n;
cin >> n;
string s;
cin >> s;
int q;
cin >> q;
vector<int> K(q);
for(int i = 0; i < q; i++) cin >> K[i];
for(int i = 0; i < q; i++){
int k = K[i];
int r = 0;
ll dcnt = 0;
ll dmcnt = 0;
ll dmccnt = 0;
ll mcnt = 0;
for(int l = 0; l < n; l++){
while(r < n && r - l < k){
if(s[r] == 'D'){
dcnt++;
} else if(s[r] == 'M'){
dmcnt += dcnt;
mcnt++;
} else if(s[r] == 'C') {
dmccnt += dmcnt;
}
r++;
}
//cout << l <<" " << r << " " << dcnt << " " << dmcnt << " " << dmccnt << endl;
//if(r == l) r++;
if(s[l] == 'D'){
dmcnt -= mcnt;
dcnt--;
}
if(s[l] == 'M') mcnt--;
}
cout << max(0LL,dmccnt) << endl;
}
} | #include<bits/stdc++.h>
using namespace std;
#define ll long long
int N;
string S;
int Q;
int k[100];
ll D[1000010];
ll M[1000010];
ll C[1000010];
ll sum[1000010];
ll ans[100];
void input(){
cin >> N >> S >> Q;
for(int i = 0; i < Q; i++){
cin >> k[i];
}
}
void solve(){
for(int i = 0; i < N; i++){
if(S[i] == 'M') M[i]++;
M[i + 1] = M[i];
if(S[i] == 'C') C[i]++;
C[i + 1] = C[i];
}
for(int i = 1; i < N; i++){
sum[i] = sum[i - 1];
if(S[i] == 'C') sum[i] += M[i];
}
for(int i = 0; i < Q; i++){
for(int j = 0; j < N; j++){
if(S[j] != 'D') continue;
int nd = min(j + k[i] - 1, N - 1);
ll res = sum[nd] - sum[j] - M[j] * (C[nd] - C[j]);
ans[i] += res;
}
}
}
void output(){
for(int i = 0; i < Q; i++){
cout << ans[i] << endl;
}
}
int main(){
input();
solve();
output();
return 0;
} | 1 |
#include <bits/stdc++.h>
#define dbug(x) cout<<#x<<"="<<x<<endl
using namespace std;
template <typename T> void read(T &t) {
t=0; char ch=getchar(); int f=1;
while ('0'>ch||ch>'9') { if (ch=='-') f=-1; ch=getchar(); }
do {(t*=10)+=ch-'0';ch=getchar();} while ('0'<=ch&&ch<='9'); t*=f;
}
typedef long long ll;
const int maxn=(1e5)+10;
int n,x; ll s[maxn],S;
struct node {
int l,r,a; ll t;
void init() {
read(a); read(l); read(r);
t=(ll)a*l+(ll)(x-a)*r;
S-=(ll)l*a;
}
} d[maxn];
bool cmp(node A,node B) {
return A.t>B.t;
}
bool solve(ll mid) {
ll q=mid/x,r=mid-q*x,tmp;
if (q==n) return 1;
for (int i=1;i<=n;i++) {
tmp=S;
if (i<=q) tmp+=s[q+1]-d[i].t;
else tmp+=s[q];
if (r>=d[i].a) tmp+=(ll)d[i].l*d[i].a+(r-d[i].a)*d[i].r;
else tmp+=r*d[i].l;
if (tmp>=0) return 1;
} return 0;
}
int main() {
//freopen("1.txt","r",stdin);
read(n); read(x);
for (int i=1;i<=n;i++) d[i].init();
sort(d+1,d+n+1,cmp);
for (int i=1;i<=n;i++) s[i]=s[i-1]+d[i].t;
ll l=0,r=(ll)x*n,mid,res;
while (l<=r) {
mid=(l+r)/2;
if (solve(mid)) r=mid-1,res=mid;
else l=mid+1;
}
printf("%lld\n",res);
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for(long long int i = 0; i < n; i++)
#define _rep(i, m, n) for(long long int i = m; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const ll mod = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll gcd(ll A, ll B){
if(B == 0)return A;
return gcd(B, A % B);
}
ll lcm(ll A, ll B){
return A * B / gcd(A, B);
}
using Graph = vector<vector<int>>;
Graph G;
int main(){
int d; cin >> d;
ll g; cin >> g;
vector<ll> p(d);
vector<ll> c(d);
rep(i, d) cin >> p[d - 1 - i] >> c[d - 1 - i];
int min_count = 100000000;
int count, sum;
bool flag;
for(int bit = 0; bit < (1 << d); bit++){
flag = false;
count = 0;
sum = 0;
for(int i = 0; i < d; i++){
if(bit & (1 << i)){
int num;
if((g - sum) > (d - i) * 100 * p[i] + c[i]){
sum += (d - i) * 100 * p[i] + c[i];
count += p[i];
}else{
num = min(((g - sum) + ((d - i) * 100) - 1) / ((d - i) * 100), p[i]);
count += num;
flag = true;
}
}
if(flag) break;
}
//cout << count << endl;
if(flag) min_count = min(count, min_count);
}
cout << min_count << endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);i++)
#define PI acos(-1)
typedef long long ll;
ll gcd(ll x,ll y){
if(y==0) return x;
else return gcd(y,x%y);
}
ll lcm(ll x,ll y){
return x/gcd(x,y)*y;
}
int main(){
int n;
cin>>n;
vector<int> a(n);
rep(i,n){
cin>>a[i];
}
sort(a.begin(),a.end());
vector<int> b;
b.push_back(0);
b.push_back(0);
rep(i,n-1){
if(a[i+1]==a[i]){
if(a[i+2]==a[i]){
if(a[i+3]==a[i]){
b.push_back(a[i]);
b.push_back(a[i]);
i+=3;
}
else{
b.push_back(a[i]);
i+=2;
}
}
else{
b.push_back(a[i]);
}
}
}
int p=0,q=0;
sort(b.begin(),b.end(),greater<int>());
cout<<(ll)b[0]*(ll)b[1];
return 0;
}
| // g++ A.cpp -Wall -Wextra -Woverflow -Wshadow -O2
#include <iostream>
#include <algorithm>
#include <utility>
#include <map>
#include <vector>
#include <cstring>
#include <climits>
#include <queue>
#include <cmath>
#include <iomanip>
#include <set>
#include <bitset>
using namespace std;
typedef long long LL;
typedef pair<int, int> pii;
typedef pair<int, pii> edge;
const int MAXN = 2 * 100005;
int n;
LL a[MAXN];
LL pref[MAXN];
LL get(int a, int b) {
return pref[b] - pref[a - 1];
}
int find(int L, int R) {
int b1 = L, b2 = R;
while (L + 1 < R) {
int mid = (L + R) / 2;
LL v1 = get(b1, mid);
LL v2 = get(mid + 1, b2);
if (v1 < v2) {
L = mid;
} else if (v1 > v2) {
R = mid;
} else {
L = mid;
R = mid;
break;
}
}
if (abs(get(b1, L) - get(L + 1, b2)) < abs(get(b1, R) - get(R + 1, b2))) {
return L;
}
return R;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
pref[i] = pref[i - 1] + a[i];
}
LL ans = LLONG_MAX;
for (int i = 2; i <= n - 2; i++) {
int L = find(1, i);
int R = find(i + 1, n);
LL B = get(1, L);
LL C = get(L + 1, i);
LL D = get(i + 1, R);
LL E = get(R + 1, n);
LL diff = max(B, max(C, max(D, E))) - min(B, min(C, min(D, E)));
ans = min(ans, diff);
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define maxn 1000010
#define ll long long
#define db double
#define vi vector<int>
#define pb push_back
#define mod 998244353
ll ksm(ll a, ll b) {
if (!b) return 1;
ll ns = ksm(a, b >> 1);
ns = ns * ns % mod;
if (b & 1) ns = ns * a % mod;
return ns;
}
// head
vi pl[26];
int ff[maxn];
int lb(int a) {
return a & -a;
}
int d[maxn];
int q(int pl) {
int ans = 0;
while (pl) {
ans = max(ans, d[pl]);
pl -= lb(pl);
}
return ans;
}
void upd(int pl, int num) {
while (pl < maxn) {
d[pl] = max(d[pl], num);
pl += lb(pl);
}
}
char s[maxn], t[maxn];
int main() {
int n;
cin >> n;
scanf("%s", s);
scanf("%s", t);
for (int i = 0; i < n; i++)
pl[s[i] - 'a'].pb(i);
int fl = 1;
for (int i = 0; i < n; i++)
if (s[i] != t[i]) fl = 0;
if (fl) {
cout << 0 << endl;
return 0;
}
int nx = maxn;
for (int i = n - 1; i >= 0; i--) {
if (i && t[i] == t[i - 1]) continue;
int ed = min(i + 1, nx); // <= i < nx
int x = lower_bound(pl[t[i] - 'a'].begin(), pl[t[i] - 'a'].end(), ed) - pl[t[i] - 'a'].begin();//lower_bound(p
if (!x) {
printf("-1\n");
return 0;
}
x--;
ff[i] = pl[t[i] - 'a'][x], nx = ff[i];
// cout << i << ' ' << x << ' ' << ff[i] << endl;
}
vi s;
int cnt = 0;
int ans = 0;
for (int i = 0; i < n; i++) {
if (i && t[i] == t[i - 1]) continue;
cnt++;
int bg = i - cnt;
s.pb(bg);
int uu = ff[i] - cnt;
int nans = upper_bound(s.begin(), s.end(), uu) - s.begin();
ans = max(ans, cnt - nans);
}
ans++;
cout << ans << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
int n,offset,j,pre,ans;
string s,t;
deque<int> q;
int main()
{
cin>>n>>s>>t;
q.push_back(n);j=n-1;
for (int i=n-1;i>=0;i--)
{
pre=j;
while(j>=0 && (j>i || s[j]!=t[i])) j--;
if (j<0)
{
printf("-1\n");
return 0;
}
if (pre==j)
{
while(!q.empty() && q.back()-offset>=i) q.pop_back();
q.push_back(i+offset);
}
else
{
offset++;
if (i!=j)
{
ans=max(ans,(int)q.size());
q.push_front(j+offset);
}
}
}
cout<<ans<<endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) {cerr << x;}
void __print(long x) {cerr << x;}
void __print(long long x) {cerr << x;}
void __print(unsigned x) {cerr << x;}
void __print(unsigned long x) {cerr << x;}
void __print(unsigned long long x) {cerr << x;}
void __print(float x) {cerr << x;}
void __print(double x) {cerr << x;}
void __print(long double x) {cerr << x;}
void __print(char x) {cerr << '\'' << x << '\'';}
void __print(const char *x) {cerr << '\"' << x << '\"';}
void __print(const string &x) {cerr << '\"' << x << '\"';}
void __print(bool x) {cerr << (x ? "true" : "false");}
template<typename T, typename V>
void __print(const pair<T, V> &x) {cerr << '{'; __print(x.first); cerr << ','; __print(x.second); cerr << '}';}
template<typename T>
void __print(const T &x) {int f = 0; cerr << '{'; for (auto &i : x) cerr << (f++ ? "," : ""), __print(i); cerr << "}";}
void _print() {cerr << "]\n";}
template <typename T, typename... V>
void _print(T t, V... v) {__print(t); if (sizeof...(v)) cerr << ", "; _print(v...);}
#ifndef ONLINE_JUDGE
#define debug(x...) cerr << "[" << #x << "] = ["; _print(x)
#else
#define debug(x...)
#endif
#define fast ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
#define ll long long
#define int long long
#define vll vector<long long>
#define pii pair<long long ,long long >
#define vvi vector< vector<long long > >
#define vpii vector<pair<int,int>>
#define pll pair<long long ,long long >
#define pb push_back
#define ff first
#define sec second
#define SORT(a) sort(a.begin(),a.end())
#define SORTR(a) sort(a.rbegin(),a.rend())
#define m_p make_pair
#define all(x) (x.begin(),x.end())
#define sz(v) ((int)(v.size()))
#define endl '\n'
typedef vector< long long > vi ;
const int MOD = 1e9 + 7 ;
int size = 10000000;
void solve() {
int a, b; cin >> a >> b;
cout << a*b << endl;
}
int32_t main() {
fast;
/*#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
*/
int T = 1; //cin>>T;
while (T--) {
solve();
}
return 0;
}
| #include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <algorithm>
#include <numeric>
#include <random>
#include <vector>
#include <array>
#include <bitset>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
int main() {
int a,b,c;
cin >> a >> b >> c;
swap(a, b);
swap(a, c);
cout << a << " " << b << " " << c;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,m,n) for(int i=(m); i<(int)(n); i++)
#define RREP(i,m,n) for(int i=(int)((n)-1); i>=m; i--)
#define rep(i,n) REP(i,0,n)
#define rrep(i,n) RREP(i,0,n)
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define fi first
#define se second
#define debug(...) {cerr<<"[L"<<__LINE__<<"] "; _debug(__VA_ARGS__);}
template<typename T>
string join(const vector<T>&v, string del=", "){ stringstream s;
for(auto x : v) s << del << x; return s.str().substr(del.size());
}
template<typename T>
ostream& operator<<(ostream& o, const vector<T>&v){
if(v.size()) o << "[" << join(v) << "]"; return o;
}
template<typename T>
ostream& operator<<(ostream& o, const vector<vector<T> >&vv){
int l = vv.size();
if(l){ o<<endl; rep(i,l) o << (i==0 ? "[ " : ",\n " ) << vv[i] << (i==l-1 ? " ]" : ""); }
return o;
}
template<typename T1, typename T2>
ostream& operator<<(ostream& o, const pair<T1, T2>& p){
return o << "(" << p.first << ", " << p.second << ")";
}
inline void _debug(){cerr<<endl;}
template<class First, class... Rest>
void _debug(const First& first, const Rest&... rest){cerr<<first<<" ";_debug(rest...);}
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
const double PI = (1*acos(0.0));
const double EPS = 1e-9;
const int INF = 0x3f3f3f3f;
const ll INFL = 0x3f3f3f3f3f3f3f3fLL;
const ll mod = 1e9 + 7;
inline void finput(string filename) {
freopen(filename.c_str(), "r", stdin);
}
int main(){
ios_base::sync_with_stdio(0);
// finput("./input");
int n; cin >> n;
vi a(n);
rep(i,n) cin >> a[i];
sort(all(a));
map<int,vi> mp;
rep(i,n) mp[a[i]].push_back(i);
vi used(n,0);
int ans = 0;
rrep(i,n){
if(used[i]) continue;
int lsb = __builtin_ffsll(a[i]) - 1;
int msb = (31 - __builtin_clz(a[i]));
int x = 1 << lsb;
REP(j,lsb,msb){
if((a[i]&(1<<j)) == 0) x |= 1<<j;
}
if(mp.count(x)){
if(mp[x].size() == 0) continue;
if(mp[x].back() == i){
mp[x].pop_back();
if(mp[x].size() == 0) continue;
}
int idx = mp[x].back();
used[idx] = 1;
mp[x].pop_back();
ans++;
}
}
cout << ans << endl;
return 0;
} | //q098.cpp
//Wed Sep 16 20:16:46 2020
#include <iostream>
#include <string>
#include <queue>
#include <map>
#include <unordered_map>
#include <vector>
#include <algorithm>
#include <math.h>
#include <set>
#define INTINF 2147483647
#define LLINF 9223372036854775807
#define MOD 1000000007
#define rep(i,n) for (int i=0;i<(n);++i)
using namespace std;
using ll=long long;
typedef pair<int,int> P;
int main(){
int n;
cin >> n;
ll ans = 1;
vector<int> count(3,0);
rep(i,n){
ll a;
cin >> a;
ll tmp = 0;
ll flag = 1;
rep(j,3){
if(count[j]==a){
tmp++;
if(flag){
count[j]++;
flag = 0;
}
}
}
ans = ans*tmp%MOD;
}
cout << ans << endl;
// printf("%.4f\n",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
//#include <atcoder/all>
//using namespace atcoder;
template <typename T> bool chmax(T &u, const T z) { if (u < z) {u = z; return true;} else return false; }
template <typename T> bool chmin(T &u, const T z) { if (u > z) {u = z; return true;} else return false; }
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define ll long long
typedef pair<ll, ll> P;
const ll INF = 1LL << 60;
//const int MOD = 1000000007;
const ll MOD=998244353;
ll gcd(ll x, ll y) { return y ? gcd(y, x % y) : x; }
int main(){
string s;
cin>>s;
int n=s.size();
rep(i,n-1){
string t=s.substr(i,2);
if(t=="AC"){
cout<<"Yes"<<endl;
return 0;
}
}
cout<<"No"<<endl;
return 0;
}
| #include <iostream>
using namespace std;
int main()
{
string test;
getline(cin,test);
if (test[0] == 'A' && test[1] == 'C')
{
cout << "Yes" << endl;
}
else if(test[1] == 'A' && test[2] == 'C')
{
cout << "Yes" << endl;
}
else if(test[2] == 'A' && test[3] == 'C')
{
cout << "Yes" << endl;
}
else if(test[3] == 'A' && test[4] == 'C')
{
cout << "Yes" << endl;
}
else
cout << "No" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
typedef long long ll;
typedef long double ld;
const int inf=1e9+7;
const ll longinf=1LL<<60;
#define REP(i,m,n) for(int i=(int)(m) ; i < (int) (n) ; ++i )
#define rep(i,n) REP(i,0,n)
#define F first
#define S second
const int mx=200010;
const ll mod=1e9+7;
int main(){
int a,b;
cin >> a >> b;
vector<vector<char>> data(100, vector<char>(100,'.'));
rep(i,50)rep(j,100){ data[i][j]='#'; }
int cnt=a-1;
rep(i,25)rep(j,50)if(cnt){ data[i*2][j*2]='.'; cnt--;}
cnt=b-1;
rep(i,25)rep(j,50)if(cnt){ data[51+i*2][j*2]='#'; cnt--;}
cout << 100 << " " << 100 << endl;
rep(i,100){ rep(j,100){ cout << data[i][j]; } cout<<endl; }
return 0;
} | #include<iostream>
using namespace std;
int main() {
int a, b; cin >> a >> b; a--; b--;
cout << "100 100" << endl;
for (int i = 0; i < 50; i++) {
for (int j = 0; j < 100; j++) {
if (a > 0 && i % 2 == 0 && j % 2 == 1) { cout << '.'; a--; }
else cout << '#';
}
cout << endl;
}
for (int i = 0; i < 50; i++) {
for (int j = 0; j < 100; j++) {
if (b > 0 && i % 2 == 1 && j % 2 == 1) { cout << '#'; b--; }
else cout << '.';
}
cout << endl;
}
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
typedef pair<ll,ll> P;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; } template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
#define M 1000000007
#define all(a) (a).begin(),(a).end()
#define rep(i,n) reps(i,0,n)
#define reps(i,m,n) for(int i=(m);i<(n);i++)
int main(){
ll n,k;cin>>n>>k;
vector<ll> a(n),b(k);
rep(i,n)cin>>a[i];
rep(i,k)cin>>b[i];
ll c=0LL,d=0LL;
ll j=-n+1;
rep(i,n){
c+=a[i]*j;
j+=2;
}
j=-k+1;
rep(i,k){
d+=b[i]*j;
j+=2;
}
cout<<(c%M)*(d%M)%M;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef unsigned ui;
typedef unsigned long long ul;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ld, ld> pdd;
typedef pair<bool, bool> pbb;
typedef vector<int> vi;
#define pb push_back
#define fi first
#define se second
#define mid ((l + r) >> 1)
#define ls (i << 1)
#define rs (i << 1 | 1)
#define enum(i, j, k) for(int i = j; i <= (k); i ++)
#define open(i, j, k) for(int i = j; i < (k); i ++)
#define dec(i, j, k) for(int i = j; i >= (k); i --)
#define fill(x, k) memset(x, k, sizeof x)
#define copy(x, y) memcpy(x, y, sizeof x)
#define fio(x) freopen(x".in", "r", stdin); freopen(x".out", "w", stdout);
template <class T> bool chkmin(T &x, T y)
{ return y < x ? (x = y , true) : false; }
template <class T> bool chkmax(T &x, T y)
{ return y > x ? (x = y , true) : false; }
struct __init { __init()
{
ios::sync_with_stdio(false); cin.tie(0);
cout.precision(16); cout << fixed;
srand(time(0) ^ ui(ul(new char)));
}};
static __init __init__;
/* default code ends here */
const ll mod = 1e9 + 7;
const int maxn = 1e5 + 10;
int n, m;
ll a[maxn], b[maxn];
int main()
{
cin >> n >> m;
enum(i, 1, n)
cin >> a[i];
enum(i, 1, m)
cin >> b[i];
ll s1 = 0, s2 = 0;
enum(i, 1, n - 1)
s1 = (s1 + (a[i + 1] - a[i]) * i % mod * (n - i)) % mod;
enum(i, 1, m - 1)
s2 = (s2 + (b[i + 1] - b[i]) * i % mod * (m - i)) % mod;
cout << s1 * s2 % mod << '\n';
return 0;
}
| 1 |
#include <iostream>
#include <math.h>
using namespace std;
class point{
public:
double x, y;
int set();
};
int point::set()
{
cin >> x >> y;
return 0;
}
int main()
{
point P1, P2;
P1.set();
P2.set();
cout << fixed << sqrt((P1.x - P2.x)*(P1.x - P2.x) + (P1.y - P2.y)*(P1.y - P2.y)) << endl;
return 0;
} | #include <iostream>
#include <cmath>
#include <cstdio>
int main()
{
using namespace std;
double x1, x2, y1, y2;
double dis;
cin >> x1 >> y1 >> x2 >> y2;
dis = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
printf("%.8lf\n", dis);
return 0;
} | 1 |
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cmath>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <queue>
#include <ctime>
#include <cassert>
#include <complex>
#include <string>
#include <cstring>
#include <chrono>
#include <random>
#include <queue>
#include <bitset>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define pb push_back
#define mp make_pair
#define all(a) begin(a),end(a)
#define FOR(x,val,to) for(int x=(val);x<int((to));++x)
#define FORE(x,val,to) for(auto x=(val);x<=(to);++x)
#define FORR(x,arr) for(auto &x: arr)
#define FORS(x,plus,arr) for(auto x = begin(arr)+(plus); x != end(arr); ++x)
#define FORREV(x,plus,arr) for(auto x = (arr).rbegin()+(plus); x !=(arr).rend(); ++x)
#define REE(s_) {cout<<s_<<'\n';exit(0);}
#define GET(arr) for(auto &i: (arr)) sc(i)
#define whatis(x) cerr << #x << " is " << x << endl;
#define e1 first
#define e2 second
#define INF 0x7f7f7f7f
typedef std::pair<int,int> pi;
typedef std::vector<int> vi;
typedef std::vector<std::string> vs;
typedef int64_t ll;
typedef uint64_t ull;
#define umap unordered_map
#define uset unordered_set
using namespace std;
using namespace __gnu_pbds;
#ifdef _WIN32
#define getchar_unlocked() _getchar_nolock()
#define _CRT_DISABLE_PERFCRIT_LOCKS
#endif
template<class T> ostream& operator<<(ostream &os, set<T> V) { os<<"[";for(auto const &vv:V)os<<vv<<","; os<<"]"; return os; }
template<class T> ostream& operator<<(ostream &os, vector<T> V) { os<<"[";for(auto const &vv:V)os<<vv<<","; os<<"]"; return os; }
template<class L, class R> ostream& operator<<(ostream &os, pair<L, R> P) { os<<"("<<P.first<<","<<P.second<<")"; return os; }
inline int fstoi(const string &str){auto it=str.begin();bool neg=0;int num=0;if(*it=='-')neg=1;else num=*it-'0';++it;while(it<str.end()) num=num*10+(*it++-'0');if(neg)num*=-1;return num;}
inline void getch(char &x){while(x = getchar_unlocked(), x < 33){;}}
inline void getstr(string &str){str.clear(); char cur;while(cur=getchar_unlocked(),cur<33){;}while(cur>32){str+=cur;cur=getchar_unlocked();}}
template<typename T> inline bool sc(T &num){ bool neg=0; int c; num=0; while(c=getchar_unlocked(),c<33){if(c == EOF) return false;} if(c=='-'){ neg=1; c=getchar_unlocked(); } for(;c>47;c=getchar_unlocked()) num=num*10+c-48; if(neg) num*=-1; return true;}template<typename T, typename ...Args> inline void sc(T &num, Args &...args){ bool neg=0; int c; num=0; while(c=getchar_unlocked(),c<33){;} if(c=='-'){ neg=1; c=getchar_unlocked(); } for(;c>47;c=getchar_unlocked()) num=num*10+c-48; if(neg) num*=-1; sc(args...); }
template<typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>; //s.find_by_order(), s.order_of_key() <- works like lower_bound
template<typename T> using ordered_map = tree<T, int, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
bool srt(pi a, pi b){
return a.e1+a.e2 < b.e1+b.e2;
}
int main(){
ios_base::sync_with_stdio(0);cin.tie(0);
int n;
sc(n);
pi a[n];
FORR(i,a)
sc(i.e1,i.e2);
sort(a,a+n,srt);
ll dp[n+1];
ll LINF = 1e18;
FORR(i,dp)
i = LINF;
dp[0] = 0;
FORR(i,a){
/* whatis(i) */
for(int x = n-1; x >= 0; --x){
/* whatis(x) */
/* whatis(dp[x]) */
if(dp[x] == LINF) continue;
if(dp[x] > i.e1) continue;
/* if(dp[ */
dp[x+1] = min(dp[x+1],dp[x]+i.e2);
}
}
for(int i = n+1; --i;)
if(dp[i] != LINF) REE(i)
}
| #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define REP(i,s,n) for(int i=(int)(s);i<(int)(n);i++)
using namespace std;
typedef long long int ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef pair<int, int> PI;
typedef pair<ll, ll> PL;
struct cmp {
bool operator()(PL x, PL y) const {
if (x.first <= y.first && x.second <= y.second) {
return x != y;
}
if (x.first >= y.first && x.second >= y.second) {
return false;
}
bool flip = false;
if (x > y) {
swap(x, y);
flip = true;
}
bool ans = false;
// x.0 <= y.0, x.1 >= y.1
if (x.first >= y.second) {
ans = false;
} else {
ans = true;
}
if (flip) ans = !ans;
return ans;
}
};
const ll inf = 1e16;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
VL h(n), p(n);
vector<PL> pool;
vector<VL> dp(n + 1, VL(n + 1, inf));
REP(i, 0, n) {
cin >> h[i] >> p[i];
pool.push_back(PL(h[i]+p[i], p[i]));
}
sort(pool.begin(), pool.end());
dp[0][0] = 0;
REP(i, 0, n) {
ll y = pool[i].second;
ll x = pool[i].first - y;
REP(j, 0, i + 2) {
dp[i + 1][j] = dp[i][j];
if (j >= 1 && dp[i][j - 1] <= x) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - 1] + y);
}
}
}
int ma = 0;
REP(i, 0, n + 1) {
if (dp[n][i] < inf) {
ma = max(ma, i);
}
}
cout << ma << "\n";
}
| 1 |
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
using namespace std;
int main(){
long long N;
long long travel[5];
cin >> N;
for (int i = 0; i < 5; i++){
cin >> travel[i];
}
sort(travel, travel + 5);
cout << 4 + (N + travel[0] - 1)/ travel[0] << endl;
return 0;
}
| #include<stdio.h>
#define INFTY 2000000000
long long count = 0;
void merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int L[n1+1], R[n2+1];
for (int i = 0; i < n1; i++) L[i] = A[left + i];
for (int i = 0; i < n2; i++) R[i] = A[mid + i];
L[n1] = INFTY;
R[n2] = INFTY;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
count += n1 - i;
j++;
}
}
}
void mergeSort(int A[], int left, int right) {
if (left+1 < right) {
int mid = (left + right)/2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int main() {
int n;
scanf("%d", &n);
int S[n];
for ( int i = 0; i < n; i++ ) scanf("%d", &S[i]);
mergeSort(S, 0, n);
printf("%llu\n", count);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define MOD 1000000007LL
#define rep(i, n) for(ll (i) = 0LL;(i) < (ll)(n);(i)++)
#define rep2(i, s, e) for(ll (i) = (ll)(s);(i) < (ll)(e);(i)++)
#define repi(i, n) for(ll (i) = 0LL;(i) <= (ll)(n);(i)++)
#define repi2(i, s, e) for(ll (i) = (ll)(s);(i) <= (ll)(e);(i)++)
#define per(i, n) for(ll (i) = (ll)(n) - 1LL;(i) >= 0LL;(i)--)
#define per2(i, s, e) for(ll (i) = (ll)(s) - 1LL;(i) >= (ll)(e);(i)--)
#define peri(i, n) for(ll (i) = (ll)(n);(i) >= 0LL;(i)--)
#define peri2(i, s, e) for(ll (i) = (ll)(s);(i) >= (ll)(e);(i)--)
#define iter(i, it) for(auto &(i): (it))
template<typename T, typename U> ostream& operator<<(ostream &s, const pair<T, U> m) {
cout << "(" << m.first << ", " << m.second << ")";
return s;
}
template<typename T, typename U> ostream& operator<<(ostream &s, const map<T, U> m) {
ll c = 0;
cout << "{ ";
iter(i, m) cout << i << (c++ == m.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const vector<T> &v) {
cout << "{ ";
rep(i, v.size()) cout << v[i] << (i == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
template<typename T> ostream& operator<<(ostream &s, const list<T> &v) {
ll c = 0;
cout << "{ ";
iter(i, v) cout << i << (c++ == v.size() - 1 ? " " : ", ");
cout << "}";
return s;
}
int main(void) {
ll N;
cin >> N;
vector<pair<ll, pair<ll, ll>>> A;
rep(i, N) {
ll a, b;
cin >> a >> b;
A.emplace_back(a + b, pair<ll, ll>{a, b});
}
sort(A.rbegin(), A.rend());
ll a = 0, b = 0;
rep(i, A.size()) {
if(i % 2) b += A[i].second.second;
else a += A[i].second.first;
}
cout << a - b << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
#define int ll
#define REP(i,n) for (int i = 0; i < (n); ++i)
#define FORE(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define ALL(vec) (vec).begin(), (vec).end()
#define REVALL(vec) (vec).rbegin(), (vec).rend()
#define debug(x) cerr << #x << ": " << x << '\n'
#define hyphen() cerr << "--\n"
#define fst first
#define pb push_back
const int MOD = (int)1e9 + 7;
int bigger(int a, int b) {
return a >= b ? a : b;
}
int smaller(int a, int b) {
return a >= b ? b : a;
}
signed main() {
int N;
cin >> N;
vector<int> As(N);
vector<int> Bs(N);
REP(i, N) {
cin >> As.at(i) >> Bs.at(i);
}
// (priority, score, ind)
vector<tuple<int, int, int>> sorted_for_a(N);
vector<tuple<int, int, int>> sorted_for_b(N);
REP(i, N) {
int a = As.at(i);
int b = Bs.at(i);
int priority = a + b;
tuple<int, int, int> ta = make_tuple(priority, a, i);
tuple<int, int, int> tb = make_tuple(priority, b, i);
sorted_for_a.pb(ta);
sorted_for_b.pb(tb);
}
sort(REVALL(sorted_for_a));
sort(REVALL(sorted_for_b));
queue<tuple<int, int, int>> a_queue;
for (auto a : sorted_for_a) {
a_queue.push(a);
}
queue<tuple<int, int, int>> b_queue;
for (auto b : sorted_for_b) {
b_queue.push(b);
}
// それが食べられたことを表す配列
vector<bool> eaten(N, false);
// ここから作業開始
int score_a = 0;
int score_b = 0;
tuple<int,int,int> ta;
tuple<int,int,int> tb;
while(!a_queue.empty() || !b_queue.empty()) {
// Aのターン
// 食べられていない料理が見つかるまで捨てる
while(true) {
if (a_queue.empty()) {
break;
}
ta = a_queue.front();
a_queue.pop();
int& ind = get<2>(ta);
if (!eaten.at(ind)) {
break;
}
}
if (a_queue.empty()) {
break;
}
// Aが食べる処理
int& a = get<1>(ta);
int& ind_a = get<2>(ta);
debug(a);
debug(ind_a);
score_a += a;
debug(ind_a);
eaten.at(ind_a) = true;
// 食べられていない料理が見つかるまで捨てる
while(true) {
if (b_queue.empty()) {
break;
}
tb = b_queue.front();
b_queue.pop();
int& ind = get<2>(tb);
if (!eaten.at(ind)) {
break;
}
}
// Bが食べる処理
// 後攻はもう食べるものが無い可能性がある
if (b_queue.empty()) {
break;
}
int& b = get<1>(tb);
int& ind_b = get<2>(tb);
debug(b);
debug(ind_b);
score_b += b;
debug(ind_b);
eaten.at(ind_b) = true;
}
cout << score_a - score_b << endl;
}
| 1 |
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <iostream>
#include <sstream>
#include <vector>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <utility>
#include <algorithm>
#include <functional>
using namespace std;
#define rep(i,n) for((i)=0;(i)<(int)(n);(i)++)
#define foreach(itr,c) for(__typeof((c).begin()) itr=(c).begin();itr!=(c).end();itr++)
/*
vector<string> split(string& s, char x){ // O(s.length())
int i;
vector<string> res(1);
int word = 0;
rep(i,s.size()){
if(s[i] != x) res[word].push_back(s[i]);
else if(i != 0 && i != s.size()-1){
word++;
res.push_back("");
}
}
return res;
}
*/
int main(){
int i,j,N;
scanf("%d\n",&N);
rep(i,N){
string in;
getline(cin,in);
/*
vector<string> sp = split(in,' ');
rep(j,sp.size()){
if(sp[j] == "Hoshino") sp[j] = "Hoshina";
if(sp[j] == "Hoshino.") sp[j] = "Hoshina.";
cout << sp[j];
if(j != sp.size()-1) cout << ' '; else cout << endl;
}
*/
int found = -1;
while((found = in.find("Hoshino")) != -1) in[found + 6] = 'a';
cout << in << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i=0; i<(n); ++i)
int main(void){
int n;
string h = "Hoshino";
string s;
cin >> n;
getline(cin, s);
stringstream ss(s);
ss >> n;
rep(loop, n) {
getline(cin, s);
rep(i, s.size()){
if(i+h.size()-1 >= s.size()) break;
bool same = true;
rep(j, h.size()) {
if(s[i+j]!=h[j]) {
same = false;
break;
}
}
if(same) s[i+h.size()-1] = 'a';
}
cout << s << endl;
}
} | 1 |
#include<iostream>
#include<cstring>
using namespace std;
int main()
{
int n,m;
for(;cin>>n>>m;)
{
int a[n];
for(int i=0;i<n;i++)
cin>>a[i];
int cnt[n];
int ans=0;
int anscnt=0;
memset(cnt,0,sizeof(cnt));
for(int i=0;i<m;i++)
{
int b;
cin>>b;
for(int j=0;j<n;j++)
{
if(a[j]<=b)
{
cnt[j]++;
if(cnt[j]>anscnt)
{
anscnt=cnt[j];
ans=j+1;
}
break;
}
}
}
cout<<ans<<endl;
}
} | //
// main.cpp
#include <iostream>
#include <vector>
using namespace std;
int main(){
int n,m;
int A[1001]={},B[1001]={};
vector<pair<int,int> > vec;
cin >> n >> m;
for(int i=0;i<n;i++){
cin >> A[i];
// vec.push_back(make_pair(A[i],i));
}
for(int i=0;i<m;i++){
cin >> B[i];
}
// sort(vec.begin(),vec.end(),greater<pair<int,int> >());
int answer[1001]={};
for(int j=0;j<m;j++){
for(int i=0;i<n;i++){
if(A[i] <= B[j]){
answer[i] ++;
break;
}
}
}
int Max = -1;
for(int i=0;i<n;i++){
Max = max(Max,answer[i]);
}
for(int i=0;i<n;i++){
if(Max == answer[i]){
cout << i+1 << endl;
break;
}
}
return 0;
} | 1 |
#include <bits/stdc++.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
typedef pair<ll,ll> P;
typedef priority_queue<P,vector<P>,greater<P>> P_queue;
#define REP(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)
#define pb push_back
#define mp make_pair
#define ALL(a) a.begin(),a.end()
#define SORT(a) sort(ALL(a))
#define U_ERASE(V) V.erase(unique(ALL(V)), V.end());
const ll MOD=998244353;
const ll mod=1000000007;
const ll INF=1e15;
vec dx={1,0,-1,0};
vec dy={0,1,0,-1};
ll d[401][401];
const ll MAXN=200001;
ll par[MAXN];
ll rnk[MAXN];
ll Size[MAXN];
vec D(MAXN,-1);
ll Co[MAXN][2];
void shoki(){
for(ll i=0;i<MAXN;i++) {par[i]=i; rnk[i]=0; Size[i]=1;}
}
ll sch(ll x){
if(par[x]==x) return x;
else return par[x]=sch(par[x]);
}
void con(ll A,ll B){
A=sch(A);
B=sch(B);
if(A==B) return;
if(rnk[A]>rnk[B]) swap(A,B);
par[A]=B;
Size[B]+=Size[A];
Size[A]=Size[B];
if(rnk[A]==rnk[B]) rnk[B]++;
return;
}
ll is_size(ll k){
return Size[sch(k)];
}
bool same(ll A,ll B){
return sch(A)==sch(B);
}
int main(){
shoki();
rep(i,401) rep(j,401) d[i][j]=INF;
ll H,W; cin>>H>>W;
rep(i,H){
string S; cin>>S;
rep(j,W){
if(S.at(j)=='#') d[i][j]=1;
else d[i][j]=0;
D.at(i*450+j)=d[i][j];
}
}
rep(i,H) rep(j,W){
if(i!=H-1){
if(d[i][j]!=d[i+1][j]) con(i*450+j,(i+1)*450+j);
}
if(j!=W-1){
if(d[i][j]!=d[i][j+1]) con(i*450+j,i*450+j+1);
}
}
rep(i,H) rep(j,W){
ll x=i*450+j;
//cout<<sch(x)<<endl;
Co[sch(x)][D.at(x)]++;
}
ll ans=0;
rep(i,H) rep(j,W){
ll x=i*450+j;
// cout<<Co[x][0]<<' '<<Co[x][1]<<endl;
ans+=Co[x][0]*Co[x][1];
}
cout<<ans<<endl;
} | #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 h, w;
vector<string> s;
vector<int> G[160160];
bool visited[160160];
vector<ll> cnt;
void dfs(int v) {
if (visited[v]) return;
visited[v] = true;
if (s[v / w][v % w] == '#') cnt[0]++;
else cnt[1]++;
for (int u: G[v]) {
dfs(u);
}
}
int main() {
cin >> h >> w;
s.resize(h);
rep(i, h) cin >> s[i];
rep(i, h) {
rep(j, w) {
rep(k, 4) {
int ry = i + dy[k], rx = j + dx[k];
if (ry < 0 || ry >= h || rx < 0 || rx >= w) continue;
if (s[i][j] != s[ry][rx]) {
G[i * w + j].push_back(ry * w + rx);
}
}
}
}
ll ans = 0;
rep(i, h) {
rep(j, w) {
if (visited[i * w + j]) continue;
cnt = vector<ll>(2, 0);
dfs(i * w + j);
ans += cnt[0] * cnt[1];
}
}
cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
typedef pair<ll, ll> PLL;
#define chmax(x, y) do { x = max(x, y); } while(0)
#define chmin(x, y) do { x = min(x, y); } while(0)
#define _overload3(_1, _2, _3, name, ...) name
#define _rep(i, n) repi(i, 0, n)
#define repi(i, a, b) \
for (ll i = static_cast<ll>(a); i < static_cast<ll>(b); ++i)
#define rep(...) _overload3(__VA_ARGS__, repi, _rep, ) (__VA_ARGS__) // NOLINT
template<typename T>
using reversed_priority_queue = std::priority_queue<T, std::vector<T>, std::greater<T> >;
ll N, Q;
string s;
signed main() {
cin >> N >> s >> Q;
while (Q--) {
ll k;
cin >> k;
vector<ll> d(N, 0), m(N, 0), dm(N, 0);
// d, m, dm の構築
if (s[0] == 'D') d[0] = 1;
if (s[0] == 'M') m[0] = 1;
for (int i = 1; i < N; i++) {
d[i] = d[i-1];
m[i] = m[i-1];
dm[i] = dm[i-1];
if (s[i] == 'D') {
d[i] += 1;
}
if (s[i] == 'M') {
m[i] += 1;
dm[i] += d[i-1];
}
}
ll ans = 0;
// 集計
for (int i = 2; i < N; i++) {
if (s[i] != 'C') continue;
ans += dm[i-1];
if (i - k >= 0) {
ans -= dm[i-k];
ans -= d[i-k] * (m[i-1] - m[i-k]);
}
}
cout << ans << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
#define ll long long
#define ALL(v) (v).begin(),(v).end()
#define REP(i,p,n) for(int i=p;i<(int)(n);++i)
#define rep(i,n) REP(i,0,n)
#define dump(a) (cerr << #a << "=" << (a) << endl)
#define DUMP(list) cout << "{ "; for(auto nth : list){ cout << nth << " "; } cout << "}" << endl;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
using namespace std;
int N;
string S;
long long m, c, t;
void add(int i) {
if (S[i] == 'M') ++m;
else if (S[i] == 'C') ++c, t += m;
}
void erase(int i) {
if (S[i] == 'M') --m, t -= c;
else if (S[i] == 'C') --c;
}
long long solve(int K) {
long long res = 0;
m = 0; t = 0;
int r = 0;
for (int l = 0; l < N;) {
while(r < N && r - l <K) add(r++);
if (S[l] == 'D') res += t;
erase(l++);
}
return res;
}
int main(){
while (cin >> N >> S) {
int Q; cin >> Q;
for (int i = 0; i < Q; ++i) {
int k; cin >> k;
cout << solve(k) << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
#include <iostream>
#include <algorithm>
#include <ctype.h>
#include <math.h>
#include <stack>
#include <string>
#include <string.h>
using namespace std;
double PI = 3.1415926535897932;
long mod = 1000000007;
const long INF = 1e9 + 1;
int main() {
string n;
cin >> n;
while(1) {
if(n[0] == n[1] & n[1] == n[2]){
cout << n << endl;
return 0;
}
else {
int t = stoi(n);
t++;
n = to_string(t);
}
}
} | #include <string>
#include <iostream>
using namespace std;
string reverse_seq(string str)
{
string str_ = "";
for(string::size_type i = 0; i < str.size(); i++)
{
str_ = str[i] + str_;
}
return str_;
}
int main()
{
string str;
cin>>str;
cout << reverse_seq(str) << endl;
} | 0 |
#include <iostream>
#include <vector>
#include <set>
using namespace std;
#define rep(i,n) for(i = 0;i < n;++i)
template <typename T>
struct RUQ //calculateはminimum
{
int n;
const T ex = 1 << 30; //dat 初期値(minなので)
const T em = 1 << 30; //lazy 初期値(minなので)
vector<T> dat, lazy; //tree本体
RUQ(vector<T> v){
int x = 1;
int i;
n = v.size();
while(x < n) x <<= 1;
n = x;
dat.resize(2*n-1, ex);
lazy.resize(2*n-1, em);
for(i = 0;i < v.size();++i){
dat[i + n - 1] = v[i];
}
for(i = n-2;i >= 0;--i){
dat[i] = calculate(dat[2*i+1], dat[2*i+2]);
}
}
T calculate(T a, T b){
return min(a, b); //minで使う
}
void eval(int now){
if(lazy[now] == em) return;
if(now < n - 1){ //最小値なのでそのまま代入
lazy[2*now + 1] = lazy[now];
lazy[2*now + 2] = lazy[now];
}
dat[now] = lazy[now];
lazy[now] = em;
}
void update(int a, int b, T x, int now, int l, int r){
eval(now);
if(a <= l && r<= b){
lazy[now] = x; //上から書き換える。最小値なので代入する
eval(now);
}else if(a < r && l < b){
update(a, b, x, 2*now + 1, l, (l + r)/2);
update(a, b, x, 2*now + 2, (l + r)/2, r);
dat[now] = calculate(dat[2*now + 1], dat[2*now + 2]);
}
}
void update(int a, int b, T x){update(a, b, x, 0, 0, n);}
T query(int a, int b){return query_sub(a, b, 0, 0, n);}
T query_sub(int a, int b, int now, int l, int r){
eval(now);
if(r <= a || b <= l) return ex;
else if(a <= l && r <= b) return dat[now];
else{
T vl = query_sub(a, b, 2*now + 1, l, (l + r)/2);
T vr = query_sub(a, b, 2*now + 2, (l + r)/2, r);
return calculate(vl, vr);
}
}
inline T operator[](int a) { return query(a, a + 1); }
void print() {
for (int i = 0; i < 2 * n - 1; ++i) {
cout << (*this)[i];
if (i != n) cout << ",";
}
cout << endl;
}
};
int main()
{
cin.tie(0); ios::sync_with_stdio(false);
int i;
int h,w;
cin >> h >> w;
vector<int> v(w, 0);
const int INF = 1e9;
set<int> st;
rep(i,w) st.insert(i);
RUQ<int> ruq(v);
rep(i,h){
int a,b;
cin >> a >> b;
--a; --b;
auto x = st.lower_bound(a);
auto y = st.upper_bound(b);
if(x == y){
ruq.update(a, b+1, INF);
int ans = ruq.query(0, w);
if(ans == INF) cout << -1 << endl;
else cout << ans + i + 1 << endl;
}else if(b+1 == w){
st.erase(x, y);
ruq.update(a, b+1, INF);
int ans = ruq.query(0, w);
if(ans == INF) cout << -1 << endl;
else cout << ans + i + 1 << endl;
}else{
auto it = prev(y);
int ind = *it;
st.erase(x, y);
st.insert(b+1);
int tmp = ruq.query(ind, ind+1) + (b + 1 - ind);
ruq.update(b+1, b+2, min(tmp, ruq.query(b+1, b+2)));
ruq.update(a, b+1, INF);
int ans = ruq.query(0, w);
if(ans == INF) cout << -1 << endl;
else cout << ans + i + 1 << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
#include <string>
#include <vector>
#include <algorithm>
#define rep(i,n) for (int i = 0;i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int,int>;
int INF = 1e9;
void chmax(int& a, int b) { a = max(a, b);}
void chmin(int& a,int b) {a = min(a,b);}
int main(){
int h,w;cin >> h >> w;
map<int,int> mp;
multiset<int> m;
rep(i,w) mp[i] = i;
rep(i,w) m.insert(0);
rep(i,h){
int l,r;cin >> l >> r;
--l;
map<int,int>::iterator it = mp.lower_bound(l);
int mr = -1;
while(it != mp.end() && it->first <= r){
mr = it->second;
m.erase(m.find(it->first - it->second));
mp.erase(it++);
}
if(mr != -1 && r < w) {
mp[r] = mr;
m.insert(r-mr);
}
int ans = -1;
if(m.size()>0) {
ans = *m.begin() + (i+1);
}
cout << ans << endl;
}
} | 1 |
//#pragma GCC target("avx2")
#pragma GCC optimize("O3")
//#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
#include <atcoder/all>
using namespace atcoder;
#ifdef LOCAL
#include <prettyprint.hpp>
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]: ", d_err(__VA_ARGS__);
#else
#define debug(...) 83;
#endif
void d_err() {
cerr << endl;
}
template <typename H, typename... T>
void d_err(H h, T... t) {
cerr << h << " ";
d_err(t...);
}
template <typename T>
void print(T x) {
cout << x << "\n";
}
#define ALL(x) (x).begin(), (x).end()
#define FOR(i, m, n) for (ll i = (m); i < (n); ++i)
#define REVFOR(i, m, n) for (ll i = (n - 1); i >= (m); --i)
#define REP(i, n) FOR(i, 0, n)
#define REVREP(i, n) REVFOR(i, 0, n)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define eb emplace_back
#define bcnt __builtin_popcountll
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<ll,ll> Pll;
typedef pair<int,int> Pin;
ll INF = 1e16;
int inf = 1e9;
ll MOD = 1e9+7;
int main(){
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(20);
int n, q;
cin >> n >> q;
fenwick_tree<ll> ft(n);
REP(i, n) {
ll a; cin >> a;
ft.add(i, a);
}
REP(i, q) {
int t, a, b;
cin >> t >> a >> b;
if (t == 0) {
ft.add(a, b);
} else {
print(ft.sum(a, b));
}
}
}
| #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct Union{
vector<int> par;
vector<int> size;
Union(int n) : par(n), size(n,1){
for(int i=0; i < n; i++){
size[i] = 1;
par[i] = i;
}
}
int find(int x){
if (x == par[x]) return x;
return par[x] = find(par[x]);
}
void unite(int x, int y){
x = find(x);
y = find(y);
if(x == y) return;
if(size[x] < size[y]) swap(x, y);
par[y] = x;
size[x] += size[y];
}
bool same(int x, int y){
return find(x) == find(y);
}
int getSize(int x){
return size[find(x)];
}
};
struct Edge{
int a, b, cost;
bool operator<(const Edge& o) const{
return cost < o.cost;
}
};
struct Graph{
int n;
vector<Edge> e;
int kruskal(){
sort(e.begin(), e.end());
Union u(n);
int min_cost = 0;
for(int i=0; i<e.size(); i++){
Edge& x = e[i];
if (u.same(x.a, x.b) == false){
min_cost += x.cost;
u.unite(x.a, x.b);
}
}
return min_cost;
}
};
int main(){
Graph g;
Edge e;
int m;
cin >> g.n >> m;
for(int i=0; i<m; i++){
cin >> e.a >> e.b >> e.cost;
g.e.push_back(e);
}
cout << g.kruskal() << endl;
return 0;
}
| 0 |
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
template <typename TYPE>
void print_vec(const vector<TYPE>& v){
for(int i=0; i<v.size(); i++){
cout << v[i] << " ";
}
cout << endl;
}
template <typename TYPE>
void print_vec2(const vector<vector<TYPE>>& v){
cout << endl; cout << " ";
for(int i=0; i<v[0].size(); i++) cout << i << " ";
cout << endl;
for(int i=0; i<v.size(); i++){
cout << "i=" << i << ": ";
for(int j=0; j<v[i].size(); j++){
if(v[i][j] == 0) cout << "\x1B[0m" << v[i][j] << " ";
else cout << "\x1B[31m" << v[i][j] << " ";//https://stackoverrun.com/ja/q/12618775
}
cout << "\x1B[0m" << endl;
}
}
int main(){
int N;
cin >> N;
vector<ll> A(N);
int num_minus = 0;
for(int i=0; i<N; i++){
ll a;
cin >> a;
if(a<0){
num_minus++;
a *= -1;
}
A[i] = a;
}
sort(A.rbegin(), A.rend());
ll ans = 0;
for(int i=0; i<N; i++) ans += A[i];
if(num_minus % 2 ==1) ans -= 2*A.back();
cout << ans << endl;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
#define ll long long
#define mtv(kit) cout<<#kit<<" - "<<kit<<"\n";
#define ff first
#define ss second
#define pb push_back
#define rep(i,a,b) for(i=a;i<b;i++)
#define pii pair<ll , ll>
#define all(x) x.begin(),x.end()
#define nl "\n"
#define ump unordered_map
void doit(){
ll n,i,k,j;
cin >> n;
vector< ll >v(n);
for(i = 0; i < n; i++)cin>>v[i];
vector<pii>answer(61,{0,0});
rep(i,0,n){
rep(j,0,61){
if(v[i] & (1LL << j) )answer[j].ff++;
else answer[j].ss++;
}
}
ll ans = 0,mod = 1e9+7;
rep(i,0,61){
ll k1 = (answer[i].ff * answer[i].ss)%mod ;
ll k2 = (1LL << i)%mod;
k1 = (k1*k2)%mod;
ans = ((ans % mod) + (k1 % mod)) % mod;
}
cout << ans;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input1.txt","r",stdin);
freopen("output1.txt","w",stdout);
#endif
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t = 1;
// cin >> t;
for(ll i = 1; i <= t; i++){
doit();
}
}
| 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
int INF = 1000000009;
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
string s;
cout << 0 << endl;
cin >> s;
if(s == "Vacant"){
return 0;
}
int ok = n;
int ng = 0;
string tmp;
while(tmp!="Vacant")
{
int mid = (ok + ng) / 2;
cout << mid << endl;
cin >> tmp;
if(mid%2^tmp==s){
ng = mid;
}
else
{
ok = mid;
}
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
int N;
const double EPS = 1e-10;
struct state{
string name;
double k;
state(){}
state(int P,int A,int B,int C,int D, int E,int F,int S,int M){
int time = A + B + C + (D + E)*M;
int num = M * F;
int mon = num * S;
int s = mon - P;
k = (double)s/(double)time;
}
bool operator<(const state& st) const {
return abs(k-st.k) < EPS ? name < st.name : k > st.k;
}
};
state st[111];
int main(){
while( cin >> N && N ){
for(int i=0;i<N;i++){
string L;int P,A,B,C,D,E,F,S,M;
cin >> L >> P >> A >> B >> C >> D >> E >> F >> S >> M;
st[i] = state(P,A,B,C,D,E,F,S,M);
st[i].name = L;
}
sort(st,st+N);
for(int i=0;i<N;i++)
cout << st[i].name << endl;
cout << "#" << endl;
}
} | 0 |
#include<iostream>
#include<map>
#include<vector>
#include<algorithm>
#include<cmath>
#include<climits>
#include<ctime>
#include<cstring>
#include<iomanip>
#define ALL(v) (v).begin(),(v).end()
#define REP(i,p,n) for(int i=p;i<(int)(n);++i)
#define rep(i,n) REP(i,0,n)
#define dump(a) (cerr << #a << "=" << (a) << endl)
#define DUMP(list) cout << "{"; for(auto nth : list){ cout << nth << " ";}cout << "}" << endl;
using namespace std;
string table[]={"qwertasdfgzxcvb","yuiophjklnm"};
int main(){
while(true){
int n,q;
vector<int> date;
cin >> n >> q;
if(n==0&&q==0) break;
for(int i=0;i<=100;i++){
date.push_back(0);
}
for(int i=0;i<n;i++){
int m,d;
cin >> m;
for(int k=0;k<m;k++){
cin >> d;
date[d]++;
}
}
int decide=0,day=0;
for(int i=0;i<100;i++){
if(date[i]>decide && date[i] >= q){
decide=date[i];
day=i;
}
}
cout << day << endl;
}
} | #include <iostream>
#include <map>
using namespace std;
#define MN 101
int n;
int ks[MN];
string raw;
map<char, int> kmap;
map<int, char> rkmap;
void init_() {
for (char i = 'a'; i <= 'z'; i++) {
kmap[i] = i - 'a';
rkmap[i - 'a'] = i;
}
for (char i = 'A'; i <= 'Z'; i++) {
kmap[i] = i - 'A' + 26;
rkmap[i - 'A' + 26] = i;
}
}
bool init() {
cin >> n;
if (n == 0) return false;
for (int i = 0; i < n; i++) {
cin >> ks[i];
}
cin >> raw;
return true;
}
char before(char r, int b) {
int i = kmap[r];
return rkmap[(i + 52 - b) % 52];
}
void solve() {
string ans = raw;
int kindex = 0;
for (int i = 0; i < raw.size(); i++) {
ans[i] = before(raw[i], ks[kindex]);
kindex = (kindex + 1 + n) % n;
}
cout << ans << endl;
}
int main() {
init_();
while (init()) {
solve();
}
return 0;
} | 0 |
#include "bits/stdc++.h"
#define REP(i,num) for(int i=0;i<(num);++i)
#define LOOP(i) while(i--)
#define ALL(c) c.begin(),c.end()
#define PRINTALL(c) for(auto& x:c){cout<<x<<' ';}cout<<endl;
#define PAIRCOMP(c,comp) [](const pair<ll,ll>& lhs,const pair<ll,ll>& rhs){return lhs.c comp rhs.c;}
using namespace std;
using ll = long long;
constexpr ll atcoder_mod = 1e9+7;
template<typename T=int>
T in(){T x; cin >> x; return (x);}
template<typename T=int,typename C=vector<T>>
C vecin(int N){C x(N);REP(i,N){x[i]=in<T>();}return move(x);}
void vout(){cout << endl;}
template<typename Head,typename... Tail>
void vout(Head&& h,Tail&&... t){cout << ' ' << h;vout(forward<Tail>(t)...);}
void out(){cout << endl;}
template<typename Head,typename... Tail>
void out(Head&& h,Tail&&... t){cout << h;vout(forward<Tail>(t)...);}
class Data{
public:
ll first,second,third;
Data()=default;
Data(ll f,ll s,ll t):first(f),second(s),third(t){}
};
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout<<fixed<<setprecision(10);
ll N=in(),K=in();
out(N-K+1);
return 0;
}
| #include<iostream>
#include<iomanip>
#include<string>
#include<algorithm>
#include<vector>
#include<utility>
#include<tuple>
#include<map>
#include<queue>
#include<stack>
#include<deque>
#include<bitset>
#include<math.h>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
vector<int> num(n,0);
for(int i=0;i<m;i++){
int s,c;
cin >> s >> c;
if(num.size()>=2 && s==1 && c==0){
cout << -1 << endl;
return 0;
}
if(num.at(s-1)==0 || num.at(s-1)==c){
num.at(s-1)=c;
}else{
cout << -1 << endl;
return 0;
}
}
if(num.at(0)==0 && num.size()>=2) num.at(0)=1;
for(int i=0;i<n;i++) cout << num.at(i);
cout << endl;
} | 0 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <utility>
#include <tuple>
#include <cstdint>
#include <cstdio>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <deque>
#include <unordered_map>
#include <unordered_set>
#include <bitset>
#include <cctype>
#include <functional>
#include <ctime>
#include <fstream>
#include <cmath>
#include <limits>
#include <chrono>
#include <numeric>
#include <type_traits>
#include <iomanip>
#include <float.h>
#include <math.h>
#include <cassert>
#pragma warning (disable: 4996)
using namespace std;
using ll = long long;
unsigned euclidean_gcd(unsigned a, unsigned b) {
if (a < b) return euclidean_gcd(b, a);
unsigned r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
ll ll_gcd(ll a, ll b) {
if (a < b) return ll_gcd(b, a);
ll r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
struct UnionFind {
vector <ll> par;
vector <ll> siz;
UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL);
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
ll root(ll x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) {
return root(x) == root(y);
}
ll size(ll x) {
return siz[root(x)];
}
};
long long modpow(long long a, long long n, long long mod) {
if (n < 0)return 0;
long long res = 1;
while (n > 0) {
if (n & 1) res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
long long modinv(long long a, long long mod) {
return modpow(a, mod - 2, mod);
}
ll merge_cnt(vector<ll>& a) {
int n = a.size();
if (n <= 1) { return 0; }
ll cnt = 0;
vector<ll> b(a.begin(), a.begin() + n / 2);
vector<ll> c(a.begin() + n / 2, a.end());
cnt += merge_cnt(b);
cnt += merge_cnt(c);
int ai = 0, bi = 0, ci = 0;
while (ai < n) {
if (bi < b.size() && (ci == c.size() || b[bi] <= c[ci])) {
a[ai++] = b[bi++];
}
else {
cnt += n / 2 - bi;
a[ai++] = c[ci++];
}
}
return cnt;
}
int main() {
ll n;
cin >> n;
cout << 0 << endl;
string s;
cin >> s;
if (s == "Vacant")return 0;
else {
ll ok = 0;
ll ng = n;
while (true) {
ll mid = (ok + ng) / 2;
cout << mid << endl;
string t;
cin >> t;
if (t == "Vacant")return 0;
if (!((t == s) ^ (ok % 2 == mid % 2))) {
ok = mid;
s = t;
}
else ng = mid;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define d(x) cerr << #x ":" << x << endl;
#define dd(x, y) cerr << "(" #x "," #y "):(" << x << "," << y << ")" << endl
#define rep(i, n) for (int i = (int)(0); i < (int)(n); i++)
#define repp(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define all(v) v.begin(), v.end()
#define dump(v) \
cerr << #v ":[ "; \
for (auto macro_vi : v) { \
cerr << macro_vi << " "; \
} \
cerr << "]" << endl;
#define ddump(v) \
cerr << #v ":" << endl; \
for (auto macro_row : v) { \
cerr << "["; \
for (auto macro__vi : macro_row) { \
cerr << macro__vi << " "; \
} \
cerr << "]" << endl; \
}
using lint = long long;
const int INF = 1e9;
const lint LINF = 1e18;
const lint MOD = 1e9 + 7;
const double EPS = 1e-10;
int query(int u) {
cout << u << endl;
fflush(stdout);
string x;
cin >> x;
if (x == "Vacant") {
return 0;
} else if (x == "Male") {
return 1;
} else
return -1;
}
int main() {
int N;
cin >> N;
int basic = query(0);
if (basic == 0) return 0;
int low = 0, high = N;
while (true) {
int mid = (low + high) >> 1;
int col = query(mid);
if (col == 0) return 0;
int exp = (mid % 2 == 1 ? -basic : basic);
if (exp == col) {
low = mid + 1;
} else {
high = mid - 1;
}
}
} | 1 |
#include <bits/stdc++.h>
#define ll long long
#define rep(i,n) for(int i=0;i<n;i++)
#define rrep(i,n) for(int i=1;i<=n;i++)
#define drep(i,n) for(int i=n;i>=0;i--)
#define INF 100000005
#define MAX 100000001
#define dmp make_pair
#define dpb push_back
#define fi first
#define se second
using namespace std;
//__gcd(a,b), __builtin_popcount(a);
int n, m, a[10], ans;
map<int,int> mp;
int solve(int tmp[4], int k, int sum, int p){
int t, u[4];
rep(i,4)u[i] = tmp[i];
u[k++] = p;
if(a[p] >= 10)sum = sum*100+a[p];
else sum = sum*10+a[p];
if(m == k){
if(mp[sum]==0)ans++;
mp[sum] = 1;
return 0;
}
for(int i = 0;i < n;i++){
t = 1;
rep(j,k)if(u[j] == i)t = 0;
if(t)solve(u, k, sum, i);
}
return 0;
}
int main(){
int u[4] = {0,0,0,0};
while(1){
ans = 0;
mp.clear();
scanf("%d%d", &n, &m);
if(!n)break;
rep(i,n)scanf("%d", &a[i]);
for(int i = 0;i < n;i++){
solve(u, 0, 0, i);
}
printf("%d\n", ans);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n,k;
int ans;
vector<int>v;
vector<int>pos;
int sol(int i,int j){
int smsm=0;
int tmp=k;
priority_queue<int>pq;
for(int s=0;s<=i&&tmp;s++){
smsm+=v[s];
pq.push(-v[s]);
tmp--;if(tmp==0)break;
}
if(j<=i){
int ssss=smsm;
int ttmp=tmp;
priority_queue<int>ppq=pq;
while(ppq.size()&&ttmp){
if(ppq.top()<=0)break;
ssss+=ppq.top();ppq.pop();
ttmp--;if(ttmp==0)break;
}
ans=max(ans,ssss);
}else{
priority_queue<int>ppq=pq;
int ttmp=tmp;
int ssss=smsm;
for(int z=i+1;z<=j&&ttmp;z++){
ppq.push(-v[z]);
ssss+=v[z];
ttmp--;
if(ttmp==0)break;
}
while(ppq.size()&&ttmp){
if(ppq.top()<=0)break;
ssss+=ppq.top();ppq.pop();
ttmp--;
if(ttmp==0)break;
}
ans=max(ans,ssss);
ppq=pq;ttmp=tmp;ssss=smsm;
for(int z=n-1;z>=j&&ttmp;z--){
ppq.push(-v[z]);
ssss+=v[z];
ttmp--;if(ttmp==0)break;
}
while(ppq.size()&&ttmp){
if(ppq.top()<=0)break;
ssss+=ppq.top();ppq.pop();
ttmp--;if(ttmp==0)break;
}
ans=max(ans,ssss);
}
priority_queue<int>cls;
smsm=0;tmp=k;pq=cls;
for(int z=n-1;z>=i&&tmp;z--){
smsm+=v[z];
pq.push(-v[z]);
tmp--;if(tmp==0)break;
}
if(j>=i){
int ssss=smsm;
int ttmp=tmp;
priority_queue<int>ppq=pq;
while(ppq.size()&&ttmp){
if(ppq.top()<=0)break;
ssss+=ppq.top();ppq.pop();
ttmp--;if(ttmp==0)break;
}
ans=max(ans,ssss);
}else{
priority_queue<int>ppq=pq;
int ttmp=tmp;
int ssss=smsm;
for(int z=i-1;z>=j&&ttmp;z--){
ppq.push(-v[z]);
ssss+=v[z];
ttmp--;if(ttmp==0)break;
}
while(ppq.size()&&ttmp){
if(ppq.top()<=0)break;
ssss+=ppq.top();ppq.pop();
ttmp--;if(ttmp==0)break;
}
ans=max(ans,ssss);
ppq=pq;ttmp=tmp;ssss=smsm;
for(int z=0;z<=j&&ttmp;z++){
ppq.push(-v[z]);
ssss+=v[z];
ttmp--;if(ttmp==0)break;
}
while(ppq.size()&&ttmp){
if(ppq.top()<=0)break;
ssss+=ppq.top();ppq.pop();
ttmp--;if(ttmp==0)break;
}
ans=max(ans,ssss);
}
}
int main(){
ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
cin>>n>>k;
for(int i=0;i<n;i++){
int a;cin>>a;
v.push_back(a);
if(a>0)pos.push_back(i);
}
for(int i=0;i<pos.size();i++){
for(int j=0;j<pos.size();j++){
sol(pos[i],pos[j]);
// cout<<"---------------"<<endl;
// cout<<pos[i]<<' '<<pos[j]<<endl;
// cout<<ans<<endl;
}
}
cout<<ans;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N=1e5+10;
int n,m,a[N],ans,v,p;
LL sum[N];
bool ck(int x){
if(n-x+1<=p)return true;
if(x+p-1>=v){
int pos=a[n-p+1];
return (a[x]+m>=pos);
}
int lft=v-(x+p-1);
LL mid=0,num=0;
for(int i=x+1;i<=n-p+1;i++){
if(a[i]>a[x]+m)return false;
mid+=a[i];num++;
}
mid+=1ll*m*lft;
LL tmp=(mid+num-1)/num;
//cout<<x<<" "<<lft<<" "<<a[x]+m<<" "<<tmp<<endl;
return a[x]+m>=tmp;
}
int main(){
scanf("%d%d%d%d",&n,&m,&v,&p);
for(int i=1;i<=n;i++)scanf("%d",&a[i]);
sort(a+1,a+n+1);
for(int i=1;i<=n;i++)sum[i]=sum[i-1]+a[i];
int L=1,R=n;
while(L<=R){
int mid=(L+R)>>1;
if(ck(mid))ans=mid,R=mid-1;
else L=mid+1;
}
printf("%d\n",(n-ans+1));
}
| #include <bits/stdc++.h>
typedef long long int LL;
typedef unsigned long long int ULL;
using namespace std;
// 插入此處
LL a[100005];
int main() {
LL n, m, v, p;
cin >> n >> m >> v >> p;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n, [](LL x, LL y) { return x > y; });
// for (int i = 0; i < n; i++) {
// printf("%lld ", a[i]);
// }
// puts("");
LL ans;
LL agg = 0;
for (ans = p; ans < n; ans++) {
// 前後都還夠塞
LL les = n - ans;
LL re = v - (p - 1) - les;
agg += a[ans - 1];
if (re <= 0) {
if (a[p - 1] <= a[ans] + m) {
continue;
} else {
break;
}
} else {
// 要開始塞中間了
LL space = (ans - p + 1) * (a[ans] + m) - agg;
LL vote = re * m;
// printf("ans = %lld, re = %lld, space = %lld, vote = %lld\n", ans, re, space, vote);
if (a[p - 1] <= a[ans] + m && space >= vote) {
continue;
} else {
break;
}
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i,l,n) for(int i=l;i<n;i++)
#define all(a) a.begin(),a.end()
#define o(a) cout<<a<<endl
using namespace std;
int main(){
int n,q;
while(1){
pair<int,int> data[101]={};
rep(i,0,101){
data[i].second=-i;
}
cin>>n>>q;
if(n==0 && q==0) break;
rep(i,0,n){
int m,d;
cin>>m;
rep(j,0,m){
cin>>d;
data[d].first++;
}
}
sort(data,data+101);
reverse(data,data+101);
if(data[0].first<q) cout<<0<<endl;
else cout<<-data[0].second<<endl;
}
}
/*for(map<int,int>::iterator it=dat.begin();it!=dat.end();it++)
if(it->second>Max){
max=it->second;
ans=it->first;
}*/ | #include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if(a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if(a > b) {
a = b;
return 1;
}
return 0;
}
#ifdef DEBUG
void debug() { cerr << "\n"; }
template <class T> void debug(const T &x) { cerr << x << "\n"; }
template <class T, class... Args> void debug(const T &x, const Args &... args) {
cerr << x << " ";
debug(args...);
}
template <class T> void debugVector(const vector<T> &v) {
for(const T &x : v) {
cerr << x << " ";
}
cerr << "\n";
}
#else
template <class T, class... Args>
void debug(const T &x, const Args &... args) {}
template <class T> void debugVector(const vector<T> &v) {}
#endif
using ll = long long;
#define ALL(v) (v).begin(), (v).end()
#define RALL(v) (v).rbegin(), (v).rend()
const double EPS = 1e-7;
const int INF = 1 << 30;
const ll LLINF = 1LL << 60;
constexpr int MOD = 1000000007;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
//-------------------------------------
void solve() {
int N;
cin >> N;
vector<ll> a(N);
for(int i = 0; i < N; i++) {
cin >> a[i];
}
string s;
cin >> s;
reverse(ALL(a));
reverse(ALL(s));
vector<ll> base;
for(int i = 0; i < N; i++) {
ll v = a[i];
sort(RALL(base));
for(ll e : base) {
chmin(v, v ^ e);
}
if(v) {
if(s[i] == '0') {
base.emplace_back(v);
} else {
cout << 1 << "\n";
return;
}
}
}
cout << 0 << "\n";
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int t;
cin >> t;
for(int i = 0; i < t; i++) {
solve();
}
} | 0 |
#include <bits/stdc++.h>
#define ll long long
using namespace std;
#define pb push_back
void solve(){
ll sx,sy,tx,ty;
cin>>sx>>sy>>tx>>ty;
ll dx=tx-sx;
ll dy=ty-sy;
string s1,s2;
for(int i=0;i<dy;i++){
s1+='U';
s2+='D';
}
for(int i=0;i<dx;i++)
{
s1+='R';
s2+='L';
}
string f1= "LU"+s1+"RD";
string f2="RD"+s2+"LU";
cout<<s1+s2+f1+f2<<endl;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
int t=1 ; while(t--)
solve();
return 0;
}
| #include <iostream>
#include <bits/stdc++.h>
#include <string>
#include <ctype.h>
#include <algorithm>
#include <cmath>
#define REP(i, n) for(int i=0;i<(int)(n);i++)
#define ALL(x) (x).begin(),(x).end()
#define square(x) (x) * (x)
#define cube(x) (x) * (x) * (x)
const int INF = 1e9;
using namespace std;
class dice{
private:
int s[6];
int top;
int bottom;
int r_side;
int l_side;
int face;
int rev;
public:
dice(){
top = 0;
bottom = 5;
r_side = 2;
l_side = 3;
face = 1;
rev = 4;
s[0] = 1;
s[1] = 2;
s[2] = 3;
s[3] = 4;
s[4] = 5;
s[5] = 6;
}
dice(int a[5]){
top = 0;
bottom = 5;
r_side = 2;
l_side = 3;
face = 1;
rev = 4;
REP(i, 6) s[i] = a[i];
}
dice(int x, int y, int z, int u, int v, int w){
top = 0;
bottom = 5;
r_side = 2;
l_side = 3;
face = 1;
rev = 4;
s[0] = x;
s[1] = y;
s[2] = z;
s[3] = u;
s[4] = v;
s[5] = w;
}
int get_top() {
return s[top];
}
int get_bottom(){
return s[bottom];
}
int get_r_side(){
return s[r_side];
}
int get_l_side(){
return s[l_side];
}
int get_face(){
return s[face];
}
int get_rev(){
return s[rev];
}
int set_top(int i) {
top = i;
bottom = 5 - top;
r_side = (i+1)%5;
l_side = 5 - r_side;
face = (i+2)%5;
rev = 5 - face;
return s[top];
}
int rotate_r(int i) {
while(i<0)
i+=4;
i %= 4;
REP(j, i){
int temp = face;
face = r_side;
r_side = rev;
rev = l_side;
l_side = temp;
}
return s[top];
}
int roll_r(int i) {
while(i<0)
i+=4;
i %= 4;
REP(j, i){
int temp = top;
top = l_side;
l_side = bottom;
bottom = r_side;
r_side = temp;
}
return s[top];
}
int roll_f(int i){
while(i<0)
i+=4;
i %= 4;
REP(j, i){
int temp = top;
top = face;
face = bottom;
bottom = rev;
rev = temp;
}
return s[top];
}
};
int main() {
int in[6];
REP(i, 6) cin >> in[i];
dice d = dice(in);
string roll;
cin >> roll;
while(roll.size() != 0){
string order = roll.substr(0, 1);
if(order == "E")
d.roll_r(1);
else if(order == "S")
d.roll_f(-1);
else if(order == "N")
d.roll_f(1);
else if(order == "W")
d.roll_r(-1);
roll = roll.substr(1);
}
cout << d.get_top() << endl;
return 0;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.