code_file1
stringlengths 80
4k
| code_file2
stringlengths 91
4k
| similar_or_different
int64 0
1
|
|---|---|---|
#include <iostream>
#include <string>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <unordered_map>
#include <map>
#include <set>
#include <algorithm>
#include <queue>
#include <stack>
#include <functional>
#include <bitset>
#include <assert.h>
#include <unordered_map>
#include <fstream>
#include <ctime>
#include <complex>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef pair<ll,ll> P;
typedef pair<int,int> pii;
typedef vector<P> vpl;
typedef tuple<ll,ll,ll> tapu;
#define rep(i,n) for(int i=0; i<(n); i++)
#define REP(i,a,b) for(int i=(a); i<(b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1<<30;
const ll linf = 1LL<<62;
const int MAX = 510000;
ll dy[8] = {1,-1,0,0,1,-1,1,-1};
ll dx[8] = {0,0,1,-1,1,-1,-1,1};
const double pi = acos(-1);
const double eps = 1e-7;
template<typename T1,typename T2> inline bool chmin(T1 &a,T2 b){
if(a>b){
a = b; return true;
}
else return false;
}
template<typename T1,typename T2> inline bool chmax(T1 &a,T2 b){
if(a<b){
a = b; return true;
}
else return false;
}
template<typename T> inline void print(T &a){
rep(i,a.size()) cout << a[i] << " ";
cout << "\n";
}
template<typename T1,typename T2> inline void print2(T1 a, T2 b){cout << a << " " << b << "\n";}
template<typename T1,typename T2,typename T3> inline void print3(T1 a, T2 b, T3 c){
cout << a << " " << b << " " << c << "\n";
}
ll pcount(ll x) {return __builtin_popcountll(x);}
//const int mod = 1e9 + 7;
const int mod = 998244353;
int main(){
int h,w; cin >> h >> w;
vs s(h); rep(i,h) cin >> s[i];
vvl dist(h+1,vl(w,0));
rep(j,w) rep(k,2) dist[0][j] = w-j;
int ans = w;
rep(j,w){
vector<pii> st;
st.emplace_back(0,0);
REP(i,1,h+1){
if(i < h){
if(j==0 || dist[i][j-1] == 1){
int d = 0;
bool rev = s[i][j] != s[i-1][j];
REP(k,j,w){
if(rev == (s[i][k] != s[i-1][k])) d++;
else break;
}
dist[i][j] = d;
}else{
dist[i][j] = dist[i][j-1] - 1;
}
}
if(st.empty() || st.back().first < dist[i][j]){
st.emplace_back(dist[i][j],i);
}else{
int pos = i;
while(!st.empty()){
if(st.back().first >= dist[i][j]){
pii p = st.back();
chmax(ans, p.first*(i-p.second)+p.first);
pos = p.second;
st.pop_back();
}else{
st.emplace_back(dist[i][j], pos);
break;
}
}
}
}
}
cout << ans << "\n";
} | // Have a nice day
// ∠( ᐛ 」∠)
#include<bits/stdc++.h>
#define mp make_pair
#define pb push_back
#define x first
#define y second
using namespace std;
typedef long long LL;
typedef pair<int,int> pii;
template <typename T> inline T read()
{
T sum=0, fl=1; char ch=getchar();
for(; !isdigit(ch); ch=getchar()) if(ch=='-') fl=-1;
for(; isdigit(ch); ch=getchar()) sum=(sum<<3)+(sum<<1)+ch-'0';
return sum*fl;
}
const int maxn=2000+5;
int n, m, ans;
char s[maxn][maxn];
int l[maxn], r[maxn], h[maxn], c[maxn][maxn];
void Solve()
{
n=read<int>(), m=read<int>(); ans=max(n, m);
for(int i=1; i<=n; ++i) scanf("%s", s[i]+1);
--n, --m;
for(int i=1; i<=n; ++i)
for(int j=1; j<=m; ++j)
if(((s[i][j]=='#')+(s[i+1][j]=='#')+(s[i][j+1]=='#')+(s[i+1][j+1]=='#'))&1);
else c[i][j]=1;
for(int i=1; i<=m; ++i) l[i]=r[i]=maxn;
for(int i=1; i<=n; ++i)
{
for(int j=1, p=0; j<=m; ++j)
{
if(c[i][j]) ++p; else p=0;
l[j]=min(l[j], p);
}
for(int j=m, p=0; j>=1; --j)
{
if(c[i][j]) ++p; else p=0;
r[j]=min(r[j], p);
}
for(int j=1; j<=m; ++j)
{
if(c[i][j]) ++h[j], ans=max(ans, (l[j]+r[j])*(h[j]+1));
else l[j]=r[j]=maxn, h[j]=0;
}
}
printf("%d\n", ans);
}
int main()
{
// freopen("081d.in","r",stdin);
//freopen("081d.out","w",stdout);
Solve();
return 0;
}
| 1 |
#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 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 double EPS = 1e-10;
int main() {
int H, W;
cin >> H >> W;
vector<string> G(H);
rep(i, H) cin >> G[i];
int cnt = 0;
rep(i, H) rep(j, W) {
if (G[i][j] == '#') { cnt++; }
}
vector<vector<lint>> dist(H, vector<lint>(W, LINF));
dist[0][0] = 0;
queue<pair<int, int>> q({{0, 0}});
while (!q.empty()) {
int cx, cy;
tie(cx, cy) = q.front();
q.pop();
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
for (int i = 0; i < 4; i++) {
int nx = cx + dx[i], ny = cy + dy[i];
if (0 <= nx && nx < H && 0 <= ny && ny < W && G[nx][ny] == '.' &&
dist[nx][ny] == LINF) {
dist[nx][ny] = dist[cx][cy] + 1;
q.push({nx, ny});
}
}
}
// ddump(G);
// ddump(dist);
if (dist[H - 1][W - 1] == LINF) {
cout << -1 << endl;
} else {
cout << (H * W - cnt) - (dist[H - 1][W - 1] + 1) << endl;
}
return 0;
} | #include <vector>
#include <queue>
#include <iostream>
#include <set>
#include <algorithm>
#define ii pair<int, int>
#define iii pair<ii, int>
#define pq priority_queue
using namespace std;
int bfs(vector<vector<char>> graph, ii start, ii goal, int h, int w) {
queue<iii> possible;
set<ii> visited;
possible.push(make_pair(start, 0));
while (!possible.empty()) {
ii xy = possible.front().first;
int dist_from_start = possible.front().second;
possible.pop();
if (visited.find(xy) == visited.end()) {
if (xy == goal) {
return dist_from_start;
}
if (xy.first + 1 < h && graph[xy.first + 1][xy.second] == '.') {
possible.push(make_pair(make_pair(xy.first + 1, xy.second), dist_from_start + 1));
}
if (xy.first - 1 >= 0 && graph[xy.first - 1][xy.second] == '.') {
possible.push(make_pair(make_pair(xy.first - 1, xy.second), dist_from_start + 1));
}
if (xy.second - 1 >= 0 && graph[xy.first][xy.second - 1] == '.') {
possible.push(make_pair(make_pair(xy.first, xy.second - 1), dist_from_start + 1));
}
if (xy.second + 1 < w && graph[xy.first][xy.second + 1] == '.') {
possible.push(make_pair(make_pair(xy.first, xy.second + 1), dist_from_start + 1));
}
visited.insert(xy);
}
}
return -1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int h, w;
cin >> h >> w;
vector<vector<char>> graph(h, vector<char>(w));
cin.get();
int no_black = 0;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
cin.get(graph[i][j]);
if (graph[i][j] == '#') {
no_black++;
}
}
cin.get(); //get \n character
}
int answer = bfs(graph, make_pair(0, 0), make_pair(h - 1, w - 1), h, w);
if (answer >= 0) {
answer = h * w - answer - no_black - 1;
}
cout << answer;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define mod 1000000007
#define INF 1LL<<60
#define pi 3.14159265358979323846
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;}
int main(){
ll x,y;cin>>x>>y;
ll ans=0;
if(x==y){cout<<0<<endl;return 0;}//ｘ yが一致する場合
if(x==0){//x==0の場合
if(y>0){
cout<<y<<endl;
return 0;
}else{
cout<<abs(y)+1<<endl;
return 0;
}
}
if(y==0){//y==0の場合
if(x>0){
cout<<x+1<<endl;
return 0;
}else{
cout<<abs(x)<<endl;
return 0;
}
}
if(x>=0 && y>=0){//x yの正負で場合わけ
if(abs(y)>=abs(x)){
ans=abs(y)-abs(x);
}else{
ans=abs(x)-abs(y)+2;
}
}else if(x>=0 && y<0){
if(abs(y)>=abs(x)){
ans=abs(y)-abs(x)+1;
}else{
ans=abs(x)-abs(y)+1;
}
}else if(x<0 && y>=0){
if(abs(y)>=abs(x)){
ans=abs(y)-abs(x)+1;
}else{
ans=abs(x)-abs(y)+1;
}
}else if(x<0 && y<0){
if(abs(y)>=abs(x)){
ans=abs(y)-abs(x)+2;
}else{
ans=abs(x)-abs(y);
}
}
cout<<ans<<endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for(int i = 0; i < n; i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int k, x;
cin >> k >> x;
int left = x - k + 1, right = x + k - 1;
for(int i = left; i < right; i++)
cout << i << " ";
cout << right << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int n, k;
cin >> n >> k;
vector<int> a(n);
rep(i, n) cin >> a[i];
rep(ki, k) {
vector<int> b(n + 1);
rep(i, n) {
int l = max(0, i - a[i]);
int r = min(i + a[i] + 1, n);
b[l]++;
b[r]--;
}
rep(i, n) b[i + 1] += b[i];
b.pop_back();
if (a == b) break;
a = b;
}
rep (i, n) {
cout << a[i] << endl;
}
} | #include <bits/stdc++.h>
#define sz(arr) (int)(arr).size()
#define rng(arr) arr.begin(), arr.end()
#define show(x) cout << #x << " = " << x << endl;
using namespace std;
typedef long long int ll;
void _cin() {}
template <class Head, class... Tail>
void _cin(Head&& head, Tail&&... tail) {
cin >> head;
_cin(forward<Tail>(tail)...);
}
#define Cin(T, ...) \
T __VA_ARGS__; \
_cin(__VA_ARGS__)
#define Cins(T, n, xs) \
vector<T> xs(n); \
for (int i = 0; i < n; ++i) cin >> xs[i]
void Main();
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(15);
Main();
return 0;
}
void Main() {
Cin(int, n);
Cin(string, a, b, c);
int ans = 0;
for (int i = 0; i < n; ++i) {
map<char, int> mp;
mp[a[i]]++;
mp[b[i]]++;
mp[c[i]]++;
int ma = 0;
for (auto e : mp) ma = max(ma, e.second);
ans += 3 - ma;
}
cout << ans << endl;
} | 0 |
/*
{
AuThOr Gwj
*/
#pragma GCC optimize(2)
#include<bits/stdc++.h>
#define rb(a,b,c) for(int a=b;a<=c;++a)
#define rl(a,b,c) for(int a=b;a>=c;--a)
#define LL long long
#define IT iterator
#define PB push_back
#define II(a,b) make_pair(a,b)
#define FIR first
#define SEC second
#define FREO freopen("check.out","w",stdout)
#define rep(a,b) for(int a=0;a<b;++a)
#define SRAND mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())
#define random(a) rng()%a
#define ALL(a) a.begin(),a.end()
#define POB pop_back
#define ff fflush(stdout)
#define fastio ios::sync_with_stdio(false)
#define R(a) cin>>a
#define R2(a,b) cin>>a>>b
#define int LL
using namespace std;
const int INF=0x3f3f3f3f;
typedef pair<int,int> mp;
/*}
*/
int n,a[200000+20];
double a_[200000+20];
int all[65][65];
signed main(){
fastio;
R(n);
LL res=0;
rb(i,1,n){
R(a_[i]);
;
a[i]=llround(a_[i]*=1000000000.0);
int A,B;
A=B=0;
while(a[i]%5==0){
a[i]/=5;
A++;
}
while(a[i]%2==0){
a[i]/=2;
B++;
}
// cout<<A<<" "<<B<<endl;
rb(k,0,64)
rb(j,0,64){
if(k+A>=18&&j+B>=18){
res+=all[k][j];
}
}
all[A][B]++;
}
cout<<res<<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MOD (long long)(1e9+7)
#define INF (1LL<<60)
#define rep(i,n) for(ll i = 0; i < (n); i++)
#define rep1(i,n) for(ll i = 1; i <= (n); i++)
template<class T> inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template<class T> inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
// 最大公約数
ll gcd(ll a, ll b)
{
if(b == 0) return a;
return gcd(b, a % b);
}
// mod m におけるa の逆元
ll modinv(ll a, ll m) {
ll b = m, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
// 素因数分解
vector<pair<ll, ll>> prim;
void pf(ll n)
{
ll s = sqrt(n);
ll r = 0;
for(ll i = 2; i <= s; i++) {
if((n % i) == 0) {
r = 0;
do {
r++;
n = n / i;
} while((n % i) == 0);
prim.push_back({i, r});
}
}
if(n > s) {
prim.push_back({n, 1});
}
}
void solve()
{
ll X; cin >> X;
ll a = X / 500;
X %= 500;
ll b = X / 5;
ll ans = a* 1000 + b * 5;
cout << ans << endl;
}
int main(void)
{
// ll t; cin >> t; rep(i, t)
solve();
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
//#define int long long
//signed main(){
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int h,w;
cin >> h >> w;
vector<bool> a(h*w,false);
queue<int> que;
for(int i = 0; i < h; i++) {
string tmp;
cin >> tmp;
for(int j = 0; j < w; j++) {
int idx=i*w+j;
if(tmp[j]=='#'){
a[idx]=true;
que.push(idx);
}
}
}
int cnt=0;
int ans=0;
while(cnt<h*w) {
int n=que.size();
cnt+=n;
for(int i = 0; i < n; i++) {
int idx=que.front();
int add[4]={1,-1,w,-w};
for(int j = 0; j < 4; j++) {
int t=idx+add[j];
int r=idx/w+add[j]/w;
int c=idx%w+add[j]%w;
if(r<0||r>=h||c<0||c>=w||a[t]==true) continue;
a[t]=true;
que.push(t);
}
que.pop();
}
ans++;
}
cout << ans-1 << "\n";
return 0;
} | //高知能系Vtuberの高井茅乃です。
//Twitter: https://twitter.com/takaichino
//YouTube: https://www.youtube.com/channel/UCTOxnI3eOI_o1HRgzq-LEZw
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INTINF 1999999999
#define REP(i,n) for(int i=0;i<n;i++)
#define REP1(i,n) for(int i=1;i<=n;i++)
#define MODA 1000000007
//二次元平面を探索しよう
template <typename T,typename U>
std::pair<T,U> operator+(const std::pair<T,U> & l,const std::pair<T,U> & r) {
return {l.first+r.first,l.second+r.second};
}
vector<pair<int, int>> nei;
void nei_init(){
nei.push_back(make_pair(-1,0));nei.push_back(make_pair(1,0));nei.push_back(make_pair(0,-1));nei.push_back(make_pair(0,1));
//4近傍ならコメントアウト
//nei.push_back(make_pair(-1,-1));nei.push_back(make_pair(1,-1));nei.push_back(make_pair(1,1));nei.push_back(make_pair(-1,1));
}
bool is_safe(pair<int, int> p, int h, int w){
if(p.first < 0 || p.second < 0) return false;
else if(p.first >=h || p.second >=w) return false;
else return true;
}
//
int main() {
int ans = 0;
int tmp;
nei_init();
int h, w;
cin >> h >> w;
vector<string> mp(h);
REP(i, h) cin >> mp[i];
queue<pair<pair<int, int>,int> > q;
bool ch[h][w] ={};
int count = h*w;
REP(i, h) REP(j, w) if(mp[i][j] == '#'){
q.push(make_pair(make_pair(i, j),1));
ch[i][j] = true;
count--;
}
pair<int, int> now;
int ope;
while(!q.empty() && count > 0){
now = q.front().first;
ope = q.front().second;
q.pop();
ans = max(ans, ope);
REP(i, nei.size()){
pair<int, int> see = make_pair(now.first+nei[i].first, now.second+nei[i].second);
if(is_safe(see, h, w) && !ch[see.first][see.second]){
q.push(make_pair(see, ope+1));
ch[see.first][see.second] = true;
count--;
}
}
}
cout << ans << endl;
} | 1 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
using namespace std;
#define rep(i,n) for(int i = 0; i < (int)(n); i++)
#define invrep(i,n) for(int i = (int)(n); i > 0; i++)
using ll = long long;
int main() {
int k;
cin >> k;
string n;
cin >> n;
if (n.size() > k) {
string ans = "";
rep (i, n.size()) {
if (i < k) ans += n[i];
else {
ans += "...";
break;
}
}
cout << ans << endl;
return 0;
}
cout << n << endl;
return 0;
} | #include <iostream>
#include <string>
int main(){
std::string s;
int n;
std::cin>>n,std::cin.get();
for(;n;n--){
getline(std::cin,s);
int pos=0;
while(pos=s.find("Hoshino",pos),pos!=std::string::npos){
s.replace(pos,7,"Hoshina");
pos+=7;
}
std::cout<<s<<std::endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using ll = long long;
using namespace std;
const int INFint = 2e9+1;
const ll INFll = 2e18+1;
ll MOD=1e9+7;
int H,W,T;
string s[10];
int main(){
int N,M;
cin>>N>>M;
vector<int> A(M);
for(int i(0);i<M;i++){
cin>>A[i];
}
sort(A.rbegin(),A.rend());
int num[10] = {0,2,5,5,4,5,6,3,7,6};
map<int,int> ma;
set<int> honsuu;
for(int i(0);i<M;i++){
ma[num[A[i]]] = max(ma[num[A[i]]],A[i]);
honsuu.insert(num[A[i]]);
}
int dp[10001] = {0}; //iを作るのに必要な最大個数
for(auto m:honsuu){
dp[m] = 1;
}
for(int i(0);i<=N;i++){
for(auto m:honsuu){
if(i-m >= 0 && dp[i-m] != 0){
if(dp[i-m] + 1 >= dp[i]){
dp[i] = dp[i-m] + 1;
}
}
}
}
vector<int> ans;
int now = N;
while(dp[now] != 1){
for(int i(0);i<M;i++){
if(dp[now] - dp[now-num[A[i]]] == 1){
ans.push_back(A[i]);
now = now - num[A[i]];
break;
}
}
}
ans.push_back(ma[now]);
sort(ans.rbegin(),ans.rend());
for(int i(0);i<int(ans.size());i++){
cout << ans[i];
}
cout << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> iint;
typedef pair<ll,ll> llll;
#define ALL(x) (x).begin(),(x).end()
const ll zero = 0;
const ll INF = 3000000000000000000; //10^18
const int inINF = 1000000000; //10^9
const ll MOD = 1000000007; //10^9+7
const ll MOD2 = 998244353;
int main(){
int N, T;
cin >> N >> T;
vector<iint> A(N);
for (int i = 0; i < N; i++) {
cin >> A[i].first >> A[i].second;
}
sort(ALL(A));
vector<vector<int>> dp(N+1, vector<int>(T));
int ans = 0;
for (int i = 0; i < N+1; i++) {
dp[i][0] = 0;
}
for (int i = 0; i < T; i++) {
dp[0][i] = 0;
}
for (int n = 1; n < N+1; n++) {
for (int t = 1; t < T; t++) {
if(t - A[n-1].first >= 0){
dp[n][t] = max(dp[n-1][t], dp[n-1][t-A[n-1].first] + A[n-1].second);
}
else{
dp[n][t] = dp[n-1][t];
}
}
for (int t = T; t < T+A[n-1].first; t++) {
if(t - A[n-1].first >= 0){
ans = max(ans, dp[n-1][t-A[n-1].first] + A[n-1].second);
}
}
}
printf("%d\n", ans);
} | 0 |
#include<bits/stdc++.h>
using namespace std ;
int main() {
int N , M ;
cin >> N >> M ;
int max_L = 0 ;
int min_R = 5+ 10e5 ;
for(int i = 0 ; i < M ; i++ ){
int L , R ;
cin >> L >> R ;
max_L = max(max_L , L);
min_R = min(min_R , R);
}
min_R++ ;
if(min_R > max_L){
cout << min_R - max_L << endl ;
}
else{
cout << 0 << endl ;
}
} | #include <vector>
#include <iostream>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for(int i = 0; i < M; ++i) {
cin >> L[i] >> R[i];
}
vector<int> p(N + 1);
for(int i = 0; i < M; ++i) {
++p[L[i] - 1];
--p[R[i]];
}
int sum = 0, ans = 0;
for(int i = 0; i < N; ++i) {
sum += p[i];
if(sum == M) ++ans;
}
cout << ans << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
main()
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long i,j,k,l,m,n,o,p,q;
while(cin>>m>>n>>o>>p)
{
if(m+n>o+p)
cout<<"Left"<<endl;
else if(m+n<o+p)
cout<<"Right"<<endl;
else
cout<<"Balanced"<<endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a,b,c,d;
cin >> a >> b >> c >> d;
int L=a+b;
int R=c+d;
if(L>R){
cout << "Left" << endl;
}
if(L<R){
cout << "Right" << endl;
}
if(L==R){
cout << "Balanced" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n, y;
cin >> n >> y;
int ans10 = -1, ans5 = -1, ans1 = -1;
for(int i=0; i<=n; i++){
for(int j=0; j<=n-i; j++){
int total = 10000*i + 5000*j + 1000*(n-i-j);
if(total == y){
ans10 = i;
ans5 = j;
ans1 = n-i-j;
}
}
}
cout << ans10 << " " << ans5 << " " << ans1 << endl;
} | #include<iostream>
using namespace std;
int main() {
int n, Y, x = 0, y, z;
cin >> n >> Y;
bool can = false;
int t = Y / 1000 - n;
while (t >= 0) {
y = t / 4; // >= 0
z = n - x - y;
if (t % 4 == 0 && z >= 0) {
can = true;
break;
}
t -= 9;
x++;
}
if (can) cout << x << ' ' << y << ' ' << z << endl;
else cout << "-1 -1 -1" << endl;
} | 1 |
//This Code was made by Chinese_zjc_.
#include <iostream>
#include <fstream>
#include <iomanip>
#include <algorithm>
#include <vector>
#include <bitset>
#include <cmath>
#include <queue>
#include <stack>
#include <string>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <map>
#include <set>
#include <ctime>
// #include<windows.h>
#define int long long
#define double long double
using namespace std;
const double PI = acos(-1);
const double eps = 0.0000000001;
const int INF = 0x3fffffffffffffff;
int n, k, dp[55][55];
signed main()
{
ios::sync_with_stdio(false);
cin >> n >> k;
cout << n - k + 1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string a,b;
cin>>a>>b;
cout<<b<<a;
} | 0 |
#include<cstdio>
#include<algorithm>
#define int long long
using namespace std;
int n,a[1100][1100];
int tot,p[110000]; bool vis[110000];
void init(){
vis[1]=true;
for (int i=2;i<=10000;i++){
if (!vis[i]) p[++tot]=i;
if (tot==1000) break;
for (int j=1;j<=tot&&(i*p[j]<=10000);j++){
vis[i*p[j]]=true;
if (i%p[j]==0) break;
}
}
}
inline int lcm(int x,int y){
if (!x||!y) return x|y;
return x/__gcd(x, y)*y;
}
signed main(){
init();
scanf("%lld",&n);
if (n==2){
puts("4 7\n23 10");
return 0;
}
for (int i=1;i<=n;i++)
for (int j=1;j<=n;j++)
if (((i+j)&1)==0)
a[i][j]=p[(i+j)/2]*p[(i-j+n+1)/2+n];
for (int i=1;i<=n;i++)
for (int j=1;j<=n;j++)
if (!a[i][j])
a[i][j]=lcm(lcm(a[i-1][j],a[i][j-1]),lcm(a[i][j+1],a[i+1][j]))+1;
for (int i=1;i<=n;i++){
for (int j=1;j<n;j++) printf("%lld ",a[i][j]);
printf("%lld\n",a[i][n]);
}
return 0;
}
| #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <math.h>
using namespace std;
const int MAXN = 1e5 + 10;
int N;
int p[MAXN], pn;
bool np[MAXN];
inline void init(int n) {
register int i, j;
np[1] = 1; p[0] = p[n] = 1;
for(i = 2; i <= n; ++i) {
if(!np[i])
p[++pn] = i;
for(j = 1; j <= pn && i * p[j] <= n; ++j) {
np[i * p[j]] = 1;
if(i % p[j] == 0)
break;
}
}
}
int main() {
register int i, j; init(1e4);
scanf("%d", &N);
for(i = 0; i < N; ++i) {
for(j = 0; j < N; ++j) {
int s = (i + j) >> 1, d = (i - j) >> 1;
if((i ^ j) & 1) printf("%lld ", 1ll * p[s + 1] * p[d + N + (N >> 1) + 1]);
else printf("%lld ", 1ll * p[s + 1] * p[s] * p[d + N + (N >> 1) + 1] * p[d + N + (N >> 1)] + 1);
}
puts("");
}
return 0;
} | 1 |
/*
Contest 104
B - AcCepted
Rakesh Kumar --> 27/09/2020
*/
#include <bits/stdc++.h>
bool check_lower(const std::string& s, std::size_t pos) {
for (std::size_t i = 1; i < s.size(); ++i) {
if (i != pos && !(s[i] >= 'a' && s[i] <= 'z'))
return false;
}
return true;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0); std::cout.tie(0);
std::string s;
std::getline(std::cin, s);
std::string r = "WA";
if (s[0] == 'A') {
const std::size_t pos = s.find('C');
if (pos != std::string::npos) {
if (pos >= 2 && pos <= s.size() - 2) {
if (check_lower(s, pos)) {
r = "AC";
}
}
}
}
std::cout << r << std::endl;
return 0;
}
| //include
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <cmath>
#include <iomanip>
#include <math.h>
#include <utility>
#include <functional>
#include <cstdlib>
//using
using namespace std;
using vl = vector <long long>;
using vs = vector <string>;
using vc = vector <char>;
using ll= long long;
using vvl = vector<vector<ll> >;
using vvc = vector<vector<char> >;
//vector<vector<char> > hyou(N, vector<char>(N));
using vd = vector <double>;
//define
//#define int long long
#define rep(i,n) for(int i=0; i<n; i++)
#define print(n) cout<<n<<endl;
#define sortp(d) sort(d.begin(),d.end()) //1234
#define sortm(d) sort(d.rbegin(),d.rend()) //4321
//素数判定 O(√A)
bool is_prime(int x){
if(x<=1) return false;
for(int i=2;i*i<=x;i++)
if(x%i==0) return false;
return true;
}
/*順列生成
do {
// 順列に対する処理
} while (next_permutation(配列変数.begin(), 配列変数.end()));*/
//絶対値 abs()
//文字→数字 '0' アルファベット→数字 'a' 'A'が65番,'a'が97番だわ
//型キャスト char('a'+1)
//reverse 回文
//if(isupper('A'))->大なら真
//各位の和
int wa(ll x)
{
ll sum = 0;
while(x!=0){
sum += x% 10;
x /= 10;
}
return sum;
}
//グローバル変数宣言
ll p=0,q=0,r=0;
int main()
{
string s;
cin>>s;
p=s.size();
rep(i,p)
{
if(i==0){
if (s[0]!='A')
{
print("WA")return 0;
}}
else if (i==1||i==p-1)
{
if(isupper(s[i]))
{
print("WA")return 0;
}
}
else
{
if(s[i]=='C')q++;
else if(isupper(s[i]))
{
print("WA")return 0;
}
}
}
if(q!=1){print("WA")return 0;} else print("AC")
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<ll> vll;
#define all(x) (x).begin(), (x).end()
#define endl '\n'
#define fsp(x) cout << fixed << setprecision(x)
const ll inf = LLONG_MAX;
const long double pi = M_PI;
void Yes() {cout << "Yes" << endl;}
void No() {cout << "No" << endl;}
void YES() {cout << "YES" << endl;}
void NO() {cout << "NO" << endl;}
int main() {
ll n, h, w;
cin >> n >> h >> w;
ll ans = (n - h + 1) * (n - w + 1);
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N, H, W;
cin >> N >> H >> W;
int cnt = 0;
for (int i = H; i <= N; i++) {
for (int j = W; j <= N; j++) {
if (N >= i && N >= j) cnt++;
}
}
cout << cnt << endl;
} | 1 |
#include<bits/stdc++.h>
#define ll long long
#define rep(i, n) for(int i=0;i<(n);++i)
#define per(i, n) for(int i=(n)-1;i>=0;--i)
#define repa(i, n) for(int i=1;i<(n);++i)
#define foreach(i, n) for(auto &i:(n))
#define pii pair<int, int>
#define pll pair<long long, long long>
#define all(x) (x).begin(), (x).end()
#define bit(x) (1ll << (x))
const ll MOD = (ll)1e9+7;
const ll INF = (ll)1e9+7;
const ll INFLL = (ll)1e18;
using namespace std;
template<class t, class u> bool chmax(t &a, u b){if(a<b){a=b;return true;}return false;}
template<class t, class u> bool chmin(t &a, u b){if(a>b){a=b;return true;}return false;}
ll modpow(ll x, ll b){
ll res = 1;
while(b){
if(b&1)res = res * x % MOD;
x = x * x % MOD;
b>>=1;
}
return res;
}
ll modinv(ll x){
return modpow(x, MOD-2);
}
int main(){
int n;
cin >> n;
vector<vector<ll>> citys(n, vector<ll>(2));
foreach(i, citys){
foreach(j, i)cin>>j;
}
vector<vector<pll>> roads(n);
rep(i, 2){
vector<pll> line;
rep(j, n){
line.emplace_back(citys[j][i], j);
}
sort(all(line));
rep(j, n-1){
pll a = line[j];
pll b = line[j+1];
roads[a.second].emplace_back(abs(a.first-b.first), b.second);
roads[b.second].emplace_back(abs(a.first-b.first), a.second);
}
}
vector<bool> used(n, false);
priority_queue<pll, vector<pll>, greater<pll>> pq;
ll ans = 0;
pq.emplace(0, 0);
while(pq.size()){
pll d = pq.top();
pq.pop();
if(used[d.second])continue;
used[d.second] = true;
ans += d.first;
foreach(i, roads[d.second]){
if(used[i.second])continue;
pq.push(i);
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define All(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
ll prim(int n, vector<vector<pll>> &edge)
{
priority_queue<pll, vector<pll>, greater<pll>> pq;
vector<bool> used(n, false);
// 点0からスタート
pq.push(pll(0, 0));
ll all_len = 0;
while (!pq.empty())
{
ll now = pq.top().second, len = pq.top().first;
pq.pop();
if (used[now])
continue;
used[now] = true;
all_len += len;
for (int i = 0; i < edge[now].size(); i++)
{
ll next_len = edge[now][i].first;
ll next = edge[now][i].second;
pq.push(pll(next_len, next));
}
}
return all_len;
}
int main()
{
int N;
cin >> N;
vector<pll> xy, yx;
map<pll, ll> mp;
int cnt = 0;
for (int i = 0; i < N; i++)
{
ll x, y;
cin >> x >> y;
if(!mp.count(pll(x, y))) {
mp[pll(x, y)] = cnt;
xy.push_back(pll(x, y));
yx.push_back(pll(y, x));
cnt++;
}
}
sort(All(xy));
sort(All(yx));
vector<vector<pll>> edge(cnt);
for (int i = 0; i < cnt - 1; i++)
{
auto now = xy[i];
int nowp = mp[now];
auto next = xy[i + 1];
int nexp = mp[next];
edge[nowp].push_back(pll(min(llabs(now.first - next.first), llabs(now.second - next.second)), nexp));
edge[nexp].push_back(pll(min(llabs(now.first - next.first), llabs(now.second - next.second)), nowp));
}
for (int i = 0; i < cnt - 1; i++)
{
auto now = yx[i];
int nowp = mp[pll(now.second, now.first)];
auto next = yx[i + 1];
int nexp = mp[pll(next.second, next.first)];
edge[nowp].push_back(pll(min(llabs(now.first - next.first), llabs(now.second - next.second)), nexp));
edge[nexp].push_back(pll(min(llabs(now.first - next.first), llabs(now.second - next.second)), nowp));
}
cout << prim(cnt, edge) << endl;
} | 1 |
#include<bits/stdc++.h>
#define pb push_back
#define fi first
#define se second
#define io std::ios::sync_with_stdio(false)
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pii;
const double pi=acos(-1);
const ll P = 998244353, INF = 0x3f3f3f3f;
ll gcd(ll a,ll b){return b?gcd(b,a%b):a;}
ll qpow(ll a,ll n){ll r=1%P;for (a%=P; n; a=a*a%P,n>>=1)if(n&1)r=r*a%P;return r;}
const double eps=1e-5;
ll lcm(ll a,ll b){return a*b/gcd(a,b);};
const int maxn = 200 + 10;
ll a[maxn];
const int L = 63;
ll d[L];
bool add(ll x){
for(int i = L - 1; i >= 0; i--) if(x & 1ll << i){
if(d[i] == -1){d[i] = x; return true;}
x ^= d[i];
}
return false;
}
int main(){
// Fast;
int t; scanf("%d", &t); while(t--){
memset(d, -1, sizeof d);
int n; scanf("%d", &n);
for(int i = 0; i < n; i++) scanf("%lld", a + i);
char s[maxn]; scanf("%s", s);
int flag = 0;
for(int i = n - 1; i >= 0; i--){
if(add(a[i]) && s[i] == '1'){
flag = 1;
break;
}
}
printf("%d\n", flag);
}
return 0;
} | #include<iostream>
#include<algorithm>
using namespace std;
const int N = 100000;
int partition(int l, int r, int A[]) {
int i, j, x;
x = A[r];
i = l - 1;
for (j = l; j < r; j++) {
if (A[j] <= x) {
i++;
swap(A[i], A[j]);
}
}
swap(A[i+1], A[r]);
return i + 1;
}
int main() {
int i, n;
int A[N];
cin >> n;
for (i = 0; i < n; i++) cin >> A[i];
int q = partition(0, n-1, A);
for (i = 0; i < n; i++) {
if (i > 0) cout << " ";
if (i == q) cout << "[" << A[i] << "]";
else cout << A[i];
}
cout << endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
signed main(){
int a,b,c,d;
cin>>a>>b>>c>>d;
int x=c-a,y=d-b;
for(int i=0;i<x;i++)cout<<'R';
for(int i=0;i<y;i++)cout<<'U';
for(int i=0;i<x;i++)cout<<'L';
for(int i=0;i<y;i++)cout<<'D';
cout<<'D';
for(int i=0;i<x+1;i++)cout<<'R';
for(int i=0;i<y+1;i++)cout<<'U';
cout<<"LU";
for(int i=0;i<x+1;i++)cout<<'L';
for(int i=0;i<y+1;i++)cout<<'D';
cout<<"R\n";
} | #include <bits/stdc++.h>
#define CHOOSE(a) CHOOSE2 a
#define CHOOSE2(a0, a1, a2, a3, a4, x, ...) x
#define dump_1(x1) cerr << #x1 << ": " << x1 << endl
#define dump_2(x1, x2) \
cerr << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << endl
#define dump_3(x1, x2, x3) \
cerr << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << ", " #x3 << ": " \
<< x3 << endl
#define dump_4(x1, x2, x3, x4) \
cerr << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << ", " #x3 << ": " \
<< x3 << ", " #x4 << ": " << x4 << endl
#define dump_5(x1, x2, x3, x4, x5) \
cerr << #x1 << ": " << x1 << ", " #x2 << ": " << x2 << ", " #x3 << ": " \
<< x3 << ", " #x4 << ": " << x4 << ", " #x5 << ": " << x5 << endl
#define dump(...) \
CHOOSE((__VA_ARGS__, dump_5, dump_4, dump_3, dump_2, dump_1, ~))(__VA_ARGS__)
#define check(s) cerr << s << endl
#define rep(i, n) for (int i = 0; i < n; i++)
#define repr(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define sz(x) ((int)(x).size())
#define unique(v) v.erase(unique(v.begin(), v.end()), v.end());
#define chmax(x, y) x = max(x, y)
#define chmin(x, y) x = min(x, y)
using namespace std;
using ll = long long;
vector<int> dx = {0, 1, 0, -1};
vector<int> dy = {1, 0, -1, 0};
const ll LINF = 2e18;
const int INF = 1e9;
void solve(ll sx, ll sy, ll tx, ll ty) {
ll dx = tx - sx;
ll dy = ty - sy;
cout << string(dy, 'U') << string(dx, 'R');
cout << string(dy, 'D') << string(dx, 'L');
cout << 'L' << string(dy + 1, 'U') << string(dx + 1, 'R') << 'D';
cout << 'R' << string(dy + 1, 'D') << string(dx + 1, 'L') << 'U';
cout << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
ll sx;
scanf("%lld", &sx);
ll sy;
scanf("%lld", &sy);
ll tx;
scanf("%lld", &tx);
ll ty;
scanf("%lld", &ty);
solve(sx, sy, tx, ty);
return 0;
}
| 1 |
#include <iostream>
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
bool isprime(ll x){
for(int i=2;i*i<=x;i++){
if(x%i==0)return false;
}
return true;
}
int main()
{
vector<ll>common;
ll a,b;
cin>>a>>b;
set<ll>f,g;
bool ok=false;
while (a % 2 == 0)
{
f.insert(2);
a = a/2;
}
// n must be odd at this point. So we can skip
// one element (Note i = i +2)
for (int i = 3; i <= sqrt(a); i = i + 2)
{
// While i divides n, print i and divide n
while (a % i == 0)
{
f.insert(i);
a = a/i;
}
}
// This condition is to handle the case when n
// is a prime number greater than 2
if (a > 2)
f.insert(a);
while (b % 2 == 0)
{
g.insert(2);
b = b/2;
}
// n must be odd at this point. So we can skip
// one element (Note i = i +2)
for (int i = 3; i <= sqrt(b); i = i + 2)
{
// While i divides n, print i and divide n
while (b % i == 0)
{
g.insert(i);
b = b/i;
}
}
// This condition is to handle the case when n
// is a prime number greater than 2
if (b > 2)
g.insert(b);
ll ans=0;
for(auto x:g){
if(f.count(x))ans++;
}
ans++;
cout<<ans;
return 0;
}
| #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD=1000000007;
#define INF 1LL<<30
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define all(x) (x).begin(),(x).end()
ll gcd(ll x,ll y) {return y ? gcd(y,x%y) : x;}
ll lcm(ll x, ll y) {return x/gcd(x,y)*y;}
// 素因数分解 O(√n)
// たとえば 60 = 2^2 x 3 x 5 だったら {(2, 2), (3, 1), (5, 1)} を返す
// 素因数の個数はlogn
vector<pair<ll,ll>> prime_factorize(ll n){
vector<pair<ll,ll>> res;
for(ll p=2;p*p<=n;p++){
if(n%p!=0) continue;
int num=0; // 指数
while(n%p==0){
num++;
n/=p;
}
res.push_back({p,num});
}
if(n!=1) res.push_back({n,1});
return res;
}
int main(){
ll a,b;
cin>>a>>b;
ll g=gcd(a,b);
if(g==1){
cout<<1<<endl;
return 0;
}
auto pf=prime_factorize(g);
cout<<pf.size()+1<<endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main () {
int K, T;
cin >> K >> T;
int ma = 0;
for (int i = 0; i < T; i ++) {
int a;
cin >> a;
ma = max(ma, a);
}
int kj = K - ma;
cout << max(ma - kj - 1, 0) << endl;
} | #include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <algorithm>
#include <utility>
#include <cmath>
#include <stack>
#include <queue>
#include <functional>
#include <limits.h>
#include <set>
#include <map>
#include <tuple>
using namespace std;
#define ll long long
#define ull unsigned long long
#define rep(i,N) for (ll i=0;i<N;i++)
#define loop(i,N,M) for(ll i=N;i<M;i++)
#define MAX(v) *max_element(v.begin(),v.end())
#define MIN(v) *min_element(v.begin(),v.end())
#define SORTL2S(type,v) sort(v.begin(),v.end(),greater<type>())
#define SORTS2L(type,v) sort(v.begin(),v.end())
#define SORTMF(v,func) sort(v.begin(),v.end(),func)
#define MP(a,b) make_pair(a,b)
#if __has_include("debug.hpp")
#include "debug.hpp"
#else
template<typename T>
void debug(T& obj) {}
#endif
template<typename T>
T in(){
T val;
cin >> val;
return val;
}
template<typename T>
vector<T> inv(ll num) {
vector<T> val(num);
rep(i,num) cin >> val[i];
return val;
}
//----------------------------------------------------------------------
void solve() {
ll n,m;
cin >> n >> m;
vector<ll> wa(n,0);
vector<bool> ac(n,false);
rep(i,m) {
ll p;
string s;
cin >> p >> s;
p--;
if (s=="AC") ac[p]=true;
else if (ac[p]==false) wa[p]++;
}
ll sum=0;
ll pena=0;
rep(i,n) {
if (ac[i]) {sum++;pena += wa[i];}
}
cout << sum << " " << pena;
}
//----------------------------------------------------------------------
int main(int argc, char* argv[]) {
solve();
return 0;
}
| 0 |
#include <cstdio>
#include <algorithm>
int N, M, g[15][15], f[32768][15];
int main()
{
scanf("%d%d", &N, &M);
for (int i = 0, u, v, w; i < M; i++)
{
scanf("%d%d%d", &u, &v, &w);
u--, v--;
g[u][v] = g[v][u] = w;
}
for (int i = 0; i < 1 << N; i++)
for (int j = 0; j < N; j++)
f[i][j] = 2000000000;
for (int i = 1; i < 1 << N; i += 2)
f[i][0] = 0;
for (int i = 1; i < 1 << N; i++)
for (int j = 0; j < N; j++)
if (f[i][j] < 2000000000)
{
static int s[15];
for (int k = 0; k < N; k++)
{
s[k] = 0;
for (int l = 0; l < N; l++)
if (i >> l & 1)
s[k] += g[k][l];
}
for (int k = i; k < 1 << N; k = k + 1 | i)
{
int S = 0;
for (int l = 0; l < N; l++)
if (k - i >> l & 1)
S += s[l];
for (int l = 0; l < N; l++)
if (k - i >> l & 1 && g[j][l])
f[k][l] = std::min(f[k][l], f[i][j] + S - g[j][l]);
}
}
printf("%d\n", f[(1 << N) - 1][N - 1]);
return 0;
}
| #include<bits/stdc++.h>
#define int long long
using namespace std;
int n, q, a, b, l, val[800007][3], tag[800007];
int read()
{
int num = 0;
char c = getchar();
while (c<'0' || c>'9')c = getchar();
while (c >= '0' && c <= '9')num = num * 10 + c - '0', c = getchar();
return num;
}
int add(int w, int v)
{
for (int j = 0; j <= 2; j++)
val[w][j] += v;
tag[w] += v;
return 0;
}
int down(int w)
{
if (!tag[w])return 0;
add(2 * w, tag[w]);
add(2 * w + 1, tag[w]);
tag[w] = 0;
return 0;
}
int up(int w)
{
for (int i = 0; i <= 2; i++)
val[w][i] = min(val[2 * w][i], val[2 * w + 1][i]);
return 0;
}
int change(int w, int l, int r, int x, int v)
{
if (l == r)
{
val[w][0] = v;
val[w][1] = v - x;
val[w][2] = v + x;
return 0;
}
down(w);
int mid = (l + r) / 2;
if (x <= mid)change(2 * w, l, mid, x, v);
else change(2 * w + 1, mid + 1, r, x, v);
up(w);
return 0;
}
int ask(int p, int w, int l, int r, int x, int y)
{
if (x <= l && r <= y)
return val[w][p];
down(w);
int mid = (l + r) / 2, res = 1e18;
if (x <= mid)res = min(res, ask(p, 2 * w, l, mid, x, y));
if (y > mid)res = min(res, ask(p, 2 * w + 1, mid + 1, r, x, y));
return res;
}
signed main()
{
n = read();
q = read();
a = read();
b = read();
l = read();
memset(val, 0x3f, sizeof val);
change(1, 1, n, b, abs(l - a));
change(1, 1, n, a, abs(l - b));
for (int i = 2; i <= q; i++)
{
int num = read(), len = abs(num - l);
int res1 = ask(0, 1, 1, n, num, num) + len;
int res2 = ask(1, 1, 1, n, 1, num) + num;
int res3 = ask(2, 1, 1, n, num + 1, n) - num;
add(1, len);
change(1, 1, n, l, min(res1, min(res2, res3)));
l = num;
}
printf("%lld\n", val[1][0]);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
const ll mod=1e9+7,INF=mod*mod*3;//M_PI
#define rep(i,N) for(ll i=0; i<(N); i++)
#define rep1(i,N) for(ll i=1; i<(N); i++)
#define f first
#define s second
#define pb push_back
#define mp make_pair
ll N;
ll p[200005];
ll ans;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cin>>N;
rep(i,N) cin>>p[i];
ll pm=INF;
rep(i,N){
if(pm>=p[i]) pm=p[i];
if(pm>=p[i]) ans++;
}
cout<<ans<<endl;
}
| #include<cstdio>
#include<iostream>
#include<map>
#include<set>
#include<vector>
#include<cstring>
#include<cassert>
#include<sstream>
#include<cmath>
#include<algorithm>
#include<queue>
#include<limits>
#include<ctime>
#include<stack>
#include<bits/stdc++.h>
#include<string>
#include<stdlib.h>
#include<stdio.h>
typedef long long ll;
using namespace std;
const ll x=1000000007;
int mod(ll a){
return a%x;
}
int main(){
ll n;
cin>>n;
ll a[n],ans=0,mins=n+1;
for(int i=0;i<n;i++){
cin>>a[i];
if(a[i]<mins){
ans+=mins-a[i]-1;
mins=a[i];
}
}
cout<<n-ans;
} | 1 |
#include <iostream>
#include <stdio.h>
char judge(int, int, int);
int main()
{
int pm, pe, pj;
int number;
while (true) {
std::cin >> number;
if (number == 0) {
break;
}
for (int i = 0; i < number; i++) {
std::cin >> pm >> pe >> pj;
std::cout << judge(pm, pe, pj) <<std::endl;
}
}
return 0;
}
char judge(int pm, int pe, int pj) {
int avarage = (pm + pe + pj) /3;
if (pm == 100 || pe == 100 || pj == 100) {
return 'A';
} else if ((pm + pe) / 2 >= 90 || avarage >= 80) {
return 'A' ;
} else if (avarage >= 70) {
return 'B';
} else if (avarage >= 50 && (pm >= 80 || pe >= 80)) {
return 'B';
} else {
return 'C';
}
} | #include <iostream>
#include <vector>
//#include <fstream>
using namespace std;
int main()
{
// cut here before submit
// freopen ("testcase.divstudent", "r", stdin );
const char rank[] = { 'A', 'B', 'C' };
int n;
while (cin >> n && n ){
vector <vector <int> > s(n, vector <int> (3, 0 ) );
for (int i = 0; i < n; ++i){
for (int j = 0; j < 3; ++j){
cin >> s[i][j]; // pm, pe, pj order
} // end for
} // end for
/*
100 _ÌÈÚª é A
wÆpê̽Ï_ª 90 _Èã A
3 ÈÚ̽Ï_ª 80 _Èã A
3 ÈÚ̽Ï_ª 70 _Èã B
3 ÈÚ̽Ï_ª 50 _ÈãÅw©pêª 80 _Èã B
ãÌðð½³È¢ C
¡Ìðð½·êÍAæèxÌ¢NXɪ¯çêÜ·B
*/
for (int i = 0; i < n; ++i){
double me = (s[i][0] + s[i][1])/2.;
double avg = (s[i][0] + s[i][1] + s[i][2])/3.;
if ( s[i][0] == 100 || s[i][1] == 100 || s[i][2] == 100
|| me >= 90.0 || avg >= 80. ) {
cout << rank[0] << endl;
continue;
} // end if
if ( avg >= 70. || (avg >= 50. && (s[i][0] >= 80 || s[i][1] >= 80 ) ) ) {
cout << rank[1] << endl;
continue;
} // end if
cout << rank[2] << endl;
} // end for
} // end loop
return 0;
} | 1 |
#include <bits/stdc++.h>
#define INF 1000000000
#define LINF 1000000000000000000
#define MOD 1000000007
#define mod 1000007
#define INF63 1061109567
#define INF127 9187201950435737471
#define UINF 18446744073709551615
#define F first
#define S second
#define ll long long
#define N 200010
using namespace std;
int n,a[N],b[N],dxa[N],dxb[N],enr[4*N],ext[4*N];
int main(){
int i,j,cnt=0;
cin>>n;
for(i=0;i<n;i++)
{
cin>>a[i];
}
for(i=0;i<n;i++)
{
cin>>b[i];
}
for(i=0;i<n;i++)
{
dxa[i]=a[i]^a[(i+1)%n];
}
for(i=0;i<n;i++)
{
dxb[i]=b[i]^b[(i+1)%n];
}
for(i=0;i<n;i++)
{
enr[cnt++]=dxb[i];
}
enr[cnt++]=-INF;
for(i=0;i<n;i++)
{
enr[cnt++]=dxa[i];
}
for(i=0;i<n;i++)
{
enr[cnt++]=dxa[i];
}
memset(ext,0,sizeof(ext));
ext[0]=3*n+1;
cnt=0;
for(i=1;i<=3*n;)
{
while(i+cnt<=3*n)
{
if(enr[cnt]!=enr[i+cnt])
{
break;
}
cnt++;
}
ext[i]=cnt;
j=1;
if(cnt<=0)
{
i++;
continue;
}
else
{
while(i+j<=3*n)
{
if(j+ext[j]>=cnt)
{
break;
}
ext[i+j]=ext[j];
j++;
}
}
i+=j;
cnt-=j;
}
for(i=n+1;i<2*n+1;i++)
{
if(ext[i]==n)
{
cout<<i-n-1<<" "<<(a[i-n-1]^b[0])<<endl;
}
}
return 0;
} | #include<bits/stdc++.h>
#define N 105
using namespace std;
typedef pair<int,int> P;
int n,a,b,c,d,ans[N],cnt,prevx;
P x[N];
int main(){
cin>>n;
for(int i=0;i<n;i++)x[i].second=i+1;
for(int i=0;i<n*(n-1)/2;i++){
cin>>a>>b>>c>>d;
if(c==d)x[a-1].first++,x[b-1].first++;
else if(c<d)x[b-1].first+=3;
else x[a-1].first+=3;
}
sort(x,x+N,greater<P>());
cnt=1;
prevx=x[0].first;
for(int i=0;i<n;i++){
if(prevx>x[i].first){
cnt=i+1;
prevx=x[i].first;
}
ans[x[i].second-1]=cnt;
}
for(int i=0;i<n;i++)
cout<<ans[i]<<endl;
return 0;
} | 0 |
#include<stdio.h>
int main(){
char input1[102];
char input2[102];
scanf("%s %s", input1, input2);
printf("%s%s\n", input2, input1);
return 0;
} | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = a; i < (b); i++)
#define rrep(i, a, b) for (int i = a; i >= (b); i--)
#define all(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
using P = pair<int, int>;
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
void hr() {
cerr << "--------------" << endl;
}
const int INF = 1001001001;
const int MOD = 1000000007;
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
string s, t;
cin >> s >> t;
cout << t + s << endl;
return 0;
} | 1 |
#include<bits/stdc++.h>
#define _ ios_base::sync_with_stdio(0);cin.tie(0);
#define REP(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;
const int MAX_V=102;
int vote[MAX_V];
int main(){ _;
int n,q,m,tmp,result,resultCount;
while(cin>>n>>q,(n|q)!=0){
REP(i,MAX_V) vote[i]=0;
REP(i,n){
cin>>m;
REP(j,m){
cin>>tmp;
vote[tmp]++;
}
}
result=0;
resultCount=q-1;
REP(i,MAX_V){
if(vote[i]>resultCount){
result=i;
resultCount=vote[i];
}
}
cout<<result<<endl;
}
} | #include "bits/stdc++.h"
using namespace std;
typedef vector<int> vi;
typedef pair<int,int> pii;
typedef long long ll;
#define dump(x) cerr << #x << " = " << (x) << endl
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(a) (a).begin(),(a).end()
#define pb push_back
int main(){
int n,m;
int cost[600][600];
while(cin>>n>>m){
if(n==0&&m==0)break;
rep(i,600)rep(j,600)cost[i][j]=999999999;
rep(i,m){
int a,b;
cin>>a>>b;
a--,b--;
cost[a][b] = cost[b][a] = 1;
}
rep(k,n){
rep(i,n){
rep(j,n){
cost[i][j] = min(cost[i][j],cost[i][k]+cost[k][j]);
}
}
}
int sum=0;
rep(i,600){
if(cost[0][i]<=2&&i!=0)sum++;
}
cout<<sum<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string S;cin>>S;int i;
for(i=1;i<S.size();i++)if(S.at(i-1)=='A'&&S.at(i)=='C')break;
if(i==S.size())cout<<"No"<<endl;
else cout<<"Yes"<<endl;
} | #include <bits/stdc++.h>
#include <boost/range/adaptors.hpp>
#include <boost/range/irange.hpp>
using namespace std;
using namespace boost;
using namespace boost::adaptors;
int main() {
int64_t n;
cin >> n;
vector<int64_t> ans;
for (auto i : irange(2L, 55556L)) {
if (i % 5 != 1) {
continue;
}
bool ok = true;
for (auto j = 2L; j * j <= i; ++j) {
if (i % j == 0) {
ok = false;
break;
}
}
if (ok) {
ans.push_back(i);
}
if (ans.size() == n) {
break;
}
}
const auto* delim = "";
for (auto a : ans) {
cout << delim << a;
delim = " ";
}
cout << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
int N;
cin >> N;
vector<int> A(N);
for (int i = 0; i < N; i++) scanf("%d", &A[i]);
vector<vector<int>> accum(1<<20);
int now = 0;
vector<ll> zero(N+1, 0);
for (int i = 0; i < N; i++) {
now ^= A[i];
accum[now].push_back(i+1);
if (now == 0) zero[i+1]++;
}
for (int i = 0; i < N; i++) {
zero[i+1] += zero[i];
}
ll mod = 1e9+7;
if (now > 0) {
int K = accum[now].size();
vector<ll> dp0(K+1, 0), dp1(K+1, 0);
dp0[0] = 1;
for (int i = 1; i <= K; i++) {
if (i == 1) {
dp0[i] = 1;
dp1[i] = 1;
}
else {
ll n = zero[accum[now][i-1]] - zero[accum[now][i-2]];
dp0[i] = (dp0[i-1] + n * dp1[i-1]) % mod;
dp1[i] = (dp0[i-1] + (n+1) * dp1[i-1]) % mod;
}
}
cout << dp0[K]%mod << endl;
}
else {
ll ans = 1;
for (int i = 0; i < (int)accum[0].size()-1; i++) {
ans = ans * 2 % mod;
}
for (int i = 1; i < (1<<20); i++) {
if (accum[i].empty()) continue;
int K = accum[i].size();
vector<ll> dp0(K+1, 0), dp1(K+1, 0);
dp0[0] = 1;
for (int j = 1; j <= K; j++) {
if (j == 1) {
dp0[j] = 1;
dp1[j] = 1;
}
else {
ll n = zero[accum[i][j-1]] - zero[accum[i][j-2]];
dp0[j] = (dp0[j-1] + n * dp1[j-1]) % mod;
dp1[j] = (dp0[j-1] + (n+1) * dp1[j-1]) % mod;
}
}
ans += dp1[K];
}
cout << ans%mod << endl;
}
return 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;
} | 1 |
#include<bits/stdc++.h>
#define ll long long
using namespace std;
int main()
{
ll n,i,j,sum=0,x,mn=INT_MAX;
cin>>n;
ll ar[n+1],cnt=0;
for(i=0;i<n;i++)
{
cin>>ar[i];
sum=sum+abs(ar[i]);
if(ar[i]<0)
{
cnt++;
x=abs(ar[i]);
if(x<mn)
mn=x;
}
else
{
if(ar[i]<mn)
mn=ar[i];
}
}
if(cnt%2==0)
{
cout<<sum<<endl;
}
else
{
sum=sum-(2*mn);
cout<<sum<<endl;
}
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define irep(i, n) for (int i = (n); i >= 0; i--)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1 << 25;
const int MOD = 1e9+7;
int a[int(1e5+10)];
ll dp[100010][2];
int main() {
int n;
cin >> n;
rep(i,n) cin >> a[i];
dp[0][0] = 0;
dp[0][1] = -(1LL<<60);
rep(i,n) {
dp[i+1][0]=max(dp[i][0]+a[i],dp[i][1]-a[i]);
dp[i+1][1]=max(dp[i][0]-a[i],dp[i][1]+a[i]);
}
cout << dp[n][0] << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define _for(i,j,N) for(int i = (j);i < (N);i++)
#define _rep(i,j,N) for(int i = (j);i <= (N);i++)
#define ALL(x) x.begin(),x.end()
int get_int(){int x;scanf("%d",&x);return x;}
typedef long long ll;
const int mod = 998244353;
inline int mul(int x,int y){return 1ll*x*y%mod;}
int add(int x,int y) {return x+y>=mod?x+y-mod:x+y;}
int sub(int x,int y) {return x-y>=0?x-y:x-y+mod;}
int sq(int x){return 1ll*x*x%mod;}
int pows(int a,int b){return b == 0?1:(b&1?mul(a,sq(pows(a,b/2))):sq(pows(a,b/2)));}
const int maxn = 305;
int cnt[maxn*maxn];
int cnt2[maxn*maxn];
int sum;
int N;
void cal(int n,vector<int> &vi){
cnt[0] = 1;
cnt2[0] = 1;
_for(i,0,N){
int l = vi[i];
for(int j = sum;j>=0;j--){
cnt2[j] = add(cnt2[j],cnt2[j]);
if(j-l >= 0) {
cnt[j] = add(cnt[j],cnt[j-l]);
cnt2[j] = add(cnt2[j],cnt2[j-l]);
}
}
}
}
int main()
{
vector<int> vi;
N = get_int();
_for(i,0,N){
int num = get_int();
sum += num;
vi.push_back(num);
}
sort(ALL(vi));
int ans = pows(3,N);
//printf("all:%d\n",ans);
cal(N,vi);
//_rep(i,0,sum) printf("%d\n",cnt2[i]);
_rep(i,(sum+1)/2,sum){
ans = sub(ans,mul(3,cnt2[i]));
//printf("%d\n",cnt2[i]);
}
if(!(sum&1)){
ans = add(ans,mul(cnt[sum/2],3));
}
printf("%d\n",ans);
return 0;
}
| #include <iostream>
#include<vector>
#include<algorithm>
#include<string>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<math.h>
using namespace std;
typedef long long ll;
#define int long long
typedef vector<int> VI;
typedef pair<int, int> pii;
typedef priority_queue<int> PQ;
#define fore(i,a) for(auto &i:a)
#define REP(i,n) for(int i=0;i<n;i++)
#define eREP(i,n) for(int i=0;i<=n;i++)
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define eFOR(i,a,b) for(int i=(a);i<=(b);++i)
#define SORT(c) sort((c).begin(),(c).end())
#define rSORT(c) sort((c).rbegin(),(c).rend())
#define LB(x,a) lower_bound((x).begin(),(x).end(),(a))
#define UB(x,a) upper_bound((x).begin(),(x).end(),(a))
#define INF 1000000000
#define LLINF 9223372036854775807
//#define mod 998244353
//vector<vector<int> > dp;
//vector<vector<vector<int> > > vvvi;
//dp=vector<vector<int> >(N, vector<int>(M,0));
//vector<pair<int,int> > v;
//v.push_back(make_pair(x,y));
//priority_queue<int,vector<int>, greater<int> > q2;
int dp1[310][90909] = { 0 };
int dp2[310][90909] = { 0 };
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
int N, sum = 0;
int mod = 998244353;
cin >> N;
VI A(N);
REP(i, N) {
cin >> A[i];
sum += A[i];
}
dp1[0][0] = 1;
REP(i, N) {
REP(j, 90909) {
if (j + A[i] < 90909) {
dp1[i + 1][j + A[i]] += dp1[i][j];
dp1[i + 1][j + A[i]] %= mod;
}
dp1[i + 1][j] += 2 * dp1[i][j];
dp1[i + 1][j] %= mod;
}
}
int x = 0;
REP(j, 90909) {
if (j * 2 >= sum) {
x += dp1[N][j];
x %= mod;
}
}
dp2[0][0] = 1;
REP(i, N) {
REP(j, 90909) {
if (j + A[i] < 90909) {
dp2[i + 1][j + A[i]] += dp2[i][j];
dp2[i + 1][j + A[i]] %= mod;
}
dp2[i + 1][j] += dp2[i][j];
dp2[i + 1][j] %=mod;
}
}
int y = (sum % 2 == 0) ? dp2[N][sum / 2] : 0;
int ans = 1;
REP(i, N) {
ans *= 3;
ans %= mod;
}
//cout << x << endl;
//cout << y << endl;
//cout << ans << endl;
//cout << (ans-3*x+3*y)%mod << endl;
ans = (ans - 3 * x + 8 * mod) % mod;
ans += 3 * y;
cout << ans % mod << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double r, a;
cin >> r;
a = 2 * r * 3.1415;
cout << a << endl;
} | #include<bits/stdc++.h>
#include<vector>
#include<list>
#include<stack>
#include<queue>
#include<algorithm>
using namespace std;
int main(){
int n;
while(scanf("%d",&n)!=EOF){
long ans=0;
//printf("%d\n",n);
for(int i=0;i<600;i+=n){
ans+=i*i*n;
}
printf("%ld\n",ans);
}
return 0;
} | 0 |
#include <iostream>
#include <string>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string a, b, c;
cin >> a >> b >> c;
if (a[a.length() - 1] == b[0] && b[b.length() - 1] == c[0])
cout << "YES";
else
cout << "NO";
} | #include<bits/stdc++.h>
using namespace std;
int main() {
bool A=0;
char ch,ch_;
cin>>ch;
ch_=ch;
while((cin>>ch)!=0) {
if(ch_=='A'&&ch=='C') {
cout<<"Yes";
return 0;
}
ch_=ch;
}
cout<<"No";
return 0;
} | 0 |
#include <bits/stdc++.h>
#define repr(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) for(int i=0;i<n;i++)
#define reprrev(i,a,b) for(int i=b-1;i>=a;i--) // [a, b)
#define reprev(i,n) reprrev(i,0,n)
#define _GLIBCXX_DEBUG
using ll = long long;
using ull = unsigned long long;
template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return true; } return false; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return true; } return false; }
const ll mod = 1e9+7;
void chmod(ll &M){
if(M >= mod) M %= mod;
else if(M < 0){
M += (abs(M)/mod + 1)*mod;
M %= mod;
}
}
ll modpow(ll x, ll n){
if(n==0) return 1;
ll res=modpow(x, n/2);
if(n%2==0) return res*res%mod;
else return res*res%mod*x%mod;
}
int getl(int i, int N) { return i==0? N-1:i-1; };
int getr(int i, int N) { return i==N-1? 0:i+1; };
long long GCD(long long a, long long b) {
if (b == 0) return a;
else return GCD(b, a % b);
}
using namespace std;
/* <-----------------------------------------------------------------------------------> */
/* <-----------------------------------------------------------------------------------> */
/* <-----------------------------------------------------------------------------------> */
/* <-----------------------------------------------------------------------------------> */
int main()
{
int K, X;
cin >> K >> X;
cerr << K << " " << X << " " << X - K + 1 << X + K << "\n";
for (int i = X - K + 1; i < X + K; i++) {
if(i == X + K - 1) cout << i << "\n";
else cout << i << " ";
}
} | #include <bits/stdc++.h>
using namespace std;
#define all(a) a.begin(), a.end()
#define rep(i, n) for(int i = 0; i < n; i++)
typedef long long ll;
int main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
int k, x;
cin >> k >> x;
for(int i = x - k + 1; i < x + k; i++) {
cout << i << " ";
}
return 0;
}
| 1 |
#include<iostream>
#include<algorithm>
using namespace std;
int main()
{
int N, x;
cin >> N >> x;
int a[N];
for(int i = 0; i < N; i++)
cin >> a[i];
sort(a, a + N);
int cnt = 0, i = 0;
while(x >= a[i] && i < N){
cnt++;
x -= a[i++];
}
if(i == N && x > 0)
cnt--;
cout << cnt << endl;
return 0;
} | #include <bits/stdc++.h>
#define ios ios_base::sync_with_stdio(0),cin.tie(0),cout.tie(0);
#define pb push_back
#define all(v) v.begin(), v.end()
#define rip return;
#define fo(i,a,b) for(int i = a ; a < b ? i <= b : i >= b ; i += (a < b ? 1 : -1))
#define F first
#define S second
#define sz(x) int(x.size())
using namespace std;
using ll = long long;
using pii = pair <int, int>;
using pll = pair <ll, ll>;
using ld = long double;
const int mod = 1e9 + 7;
// const int mod = 998244353;
const ll inf = 2e9;
const ll INF = 1e18;
const ld EPS = 1e-7;
const int N = 1e6 + 55;
int dp[N], dp2[N];
int solve (string s) {
s = "0" + s;
int n = s.size();
fo (i, 0, n + 1) {
dp[i] = 0, dp2[i] = 0;
}
dp2[0] = 1;
fo (i, 1, n) {
int u = s[i - 1] - '0';
dp[i] = min (dp[i - 1] + u, dp2[i - 1] + 10 - u);
dp2[i] = min (dp2[i - 1] + 9 - u, dp[i - 1] + 1 + u);
}
return dp[n];
}
int to_int (string s) {
int res = 0;
for (char c : s) {
res = res * 10 + c - '0';
}
return res;
}
int dig (int x) {
int res = 0;
while (x) res += x % 10, x /= 10;
return res;
}
pair <int, int> brute (string s) {
int u = to_int (s);
int best = dig (u), sec = u;
for (int v = u ; v <= 1e7 ; ++ v) {
int cur = dig (v) + dig (v - u);
if (cur < best) {
sec = v;
best = cur;
}
// best = min (best, dig (v) + dig (v - u));
}
return {best, sec};
}
int main () {
// ios;
// cout << fixed << setprecision (10);
int tt = 1;
// cin >> tt;
while (tt-- || 0) {
string s;
cin >> s;
// cout << brute (s).F << " " << brute (s).S << "\n";
// if (solve (s) != brute (s).F) {
// cout << "ERROR " << solve (s) << " " << brute (s).F << "\n\t" << brute (s).S << "\nERROR " << s << "\n";
// return 0;
// }
cout <<
solve(s);
// cout << "\n";
}
}
| 0 |
#include <iostream>
#include <string>
#include <math.h>
#include <bits/stdc++.h>
#define ll long long int
using namespace std;
int main()
{
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
int N,M;
cin>>N>>M;
int freq[N+1];
memset(freq,0,sizeof(freq));
int i,j,k;
bool check[N+1];
memset(check,false,sizeof(check));
string s;
for(i=1;i<=M;i++)
{
cin>>j>>s;
if(s.compare("AC")==0)
{
check[j]=true;
}
else
{
if(check[j]==false)
freq[j]++;
}
}
j=0;
k=0;
for(i=1;i<=N;i++)
{
if(check[i])
{
j++;
k=k+freq[i];
}
}
cout<<j<<" "<<k;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
#define INF 1000000007
#define LINF (1LL << 62)
#define PI 3.14159265358979
typedef long long i64;
typedef pair<i64,i64> P;
inline i64 mod(i64 a, i64 m) { return (a % m + m) % m; }
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int n, a[111],b[111],c[111],d[111];
P p[111], pp[111];
bool used[111];
void solve(){
cin >> n;
for(int i = 0; i < n; i++){
cin >> a[i] >> b[i];
p[i] = {b[i],a[i]};
}
for(int i = 0; i < n; i++){
cin >> c[i] >> d[i];
pp[i] = {c[i],d[i]};
}
sort(p,p+n,greater<P>());
sort(pp,pp+n);
int cnt = 0;
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
if(pp[i].second < p[j].first) continue;
if(pp[i].first < p[j].second) continue;
if(used[j]) continue;
used[j] = 1;
cnt++;
break;
}
}
cout << cnt << endl;
}
int main(){
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int t = 1;
//cin >> t;
while(t--){
solve();
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
bool nul[200];
bool nul1[200];
int main() {
ios_base::sync_with_stdio(false);
cout.precision(15);
double pog =1/10e10;
int n;
cin>>n;
double x[200], y[200];
for(int i=0;i<n;i++){
cin>>x[i]>>y[i];
}
if(n==2){
cout<<"0.5"<<endl<<"0.5";
return 0;
}
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
int r=0;
bool h=1;
for(int k=0;k<n;k++){
if(k!=i&&k!=j){
double s=(x[i]-x[k])*(y[i]-y[j])-(y[i]-y[k])*(x[i]-x[j]);
if(s>pog){
if(r==-1){
h=0;
}
r=1;
}
if(s+pog<0){
if(r==1){
h=0;
}
r=-1;
}
}
}
if(h==1){
nul[i]=1;
nul[j]=1;
// cout<<i<<" "<<j<<endl;
}
}
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
for(int k=0;k<n;k++){
if(k!=i&&j!=i&&j!=k){
double s=(x[i]-x[k])*(y[i]-y[j])-(y[i]-y[k])*(x[i]-x[j]);
if(s<pog&&s+pog>0){
double f=abs(x[i]-x[k])+abs(y[i]-y[k]);
double g=abs(x[i]-x[j])+abs(y[i]-y[j]);
double s=abs(x[j]-x[k])+abs(y[j]-y[k]);
// cout<<i<<" "<<j<<endl;
if(g+f+pog>s&&g+f-pog<s){
nul1[i]=1;
// cout<<"eys"<<endl;
}
}
}
}
}
}
double ans[200];
for(int i=0;i<n;i++){
if(nul[i]==0||nul1[i]==1){
ans[i]=0;
}
else{
int j1;
int j2;
int j3;
int sled=0;
for(int j=0;j<n;j++){
int r=0;
bool h=1;
bool p=1;
for(int k=0;k<n;k++){
if(k!=i&&k!=j){
double s=(x[i]-x[k])*(y[i]-y[j])-(y[i]-y[k])*(x[i]-x[j]);
if(s>0){
if(r==-1){
h=0;
}
r=1;
}
if(s<0){
if(r==1){
h=0;
}
r=-1;
}
if(s==0&&sled>0){
double f=abs(x[i]-x[j1])+abs(y[i]-y[j1]);
double g=abs(x[i]-x[j])+abs(y[i]-y[j]);
double s=abs(x[j]-x[j1])+abs(y[j]-y[j1]);
if(s+f==g||s+g==f){
p=0;
}
}
}
}
if(h==1&&j!=i&&p==0){
j3=j;
}
if(h==1&&sled==1&&j!=i&&p==1){
j2=j;
sled++;
}
if(h==1&&sled==0&&j!=i&&p==1){
j1=j;
sled++;
}
}
if(sled<2){
ans[i]=0.5;
}
else{
double a=sqrt((x[j1]-x[j2])*(x[j1]-x[j2])+(y[j1]-y[j2])*(y[j1]-y[j2]));
double b=sqrt((x[j1]-x[i])*(x[j1]-x[i])+(y[j1]-y[i])*(y[j1]-y[i]));
double c=sqrt((x[j2]-x[i])*(x[j2]-x[i])+(y[j2]-y[i])*(y[j2]-y[i]));
double angle=acos((c*c+b*b-a*a)/(2*b*c));
double pi= acos(-1);
ans[i] = (pi-angle)/(2*pi);
}
}
}
for(int i=0;i<n;i++){
cout<<ans[i]<<endl;
}
return 0;
} | #include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<algorithm>
#include<complex>
#define rep(i, a, n) for(int i=a;i<n;i++)
#define REP(i, n) rep(i, 0, n)
#define repb(i, a, b) for(int i = a; i >= b; i--)
#define all(a) a.begin(), a.end()
#define int long long
#define R long double
#define P complex<R>
using namespace std;
const int mod = 1000000007;
const int INF = 1e12;
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;}
const R PI = acos(-1.0L);
const R inf = 1e13;
int x[110], y[110];
R ans[110];
inline R dist(int i, P q) {
P p = P(x[i], y[i]);
return norm(p - q);
}
signed main(){
int n;
cin>>n;
for (int i=0;i<n;i++)
{
cin>>x[i]>>y[i];
}
int limit = 200000;
rep(i, 0, limit){
R cur = 2.0 * PI / limit * i;
P point = polar(inf, cur);
R d = 1e130;
int idx = -1;
rep(j, 0, n) if(chmin(d, dist(j, point))) idx = j;
ans[idx] += 1.0;
}
cout.precision(20);
rep(i, 0, n) cout << fixed << 1.0 * ans[i] / limit << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string s; cin >> s;
int ans = 2147483647;
for (int i = 0; i < s.size()-2; i++) {
string tmp = s.substr(i, 3);
ans = min(ans, abs(stoi(tmp) - 753));
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <stdio.h>
#include <string>
#include <algorithm>
#include <vector>
#include <math.h>
#include <numeric>
#include <queue>
#include <numeric>
#include <iomanip>
#include <sstream>
#include <cmath>
#include <map>
#include <functional>
#include <limits>
#include <set>
#include <stack>
#include <cctype>
#define rep(i,a,b) for((i)=a;i<(int)(b);i++)
#define AAA (1000000007)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pairII;
typedef vector<int> vecI;
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 powD(ll a, ll b) {
ll ans = 1;
a %= AAA;
for (int i = 0; i < b; i++)
{
ans *= a;
ans %= AAA;
}
return ans;
}
int main() {
int i, j, k;
int N, M, K;
string S;
cin >> S;
const int na = 753;
j = S[0] - '0';
j *= 10;
j += S[1] - '0';
j *= 10;
j += S[2] - '0';
int ans = abs(j - na);
rep(i, 3, S.size()) {
j %= 100;
j *= 10;
j += S[i] - '0';
ans = min(ans, abs(j - na));
}
cout << ans << endl;
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int main(){
int n,p;
while(cin>>n>>p){
bool f=true;
int d[55]={};
int cn=p;
if(n==0)break;
while(f){
for(int i=0;i<n;i++){
if(cn>0){
d[i]++;
cn--;
}
else if(cn==0){
cn=d[i];
d[i]=0;
}
if(d[i]==p){
cout<<i<<endl;
f=false;
break;
}
}
}
}
return 0;
} | #include <iostream>
using namespace std;
int main(){
int a,b;
cin >> a >> b;
cout << a*b;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
//#define int long long
//signed main(){
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
double r;
cin >> r;
cout << fixed << setprecision(10) << 2*M_PI*r << "\n";
return 0;
} | #include <iostream>
#include <math.h>
using namespace std;
void Solve(int a)
{
const double pi = 3.14;
float ans;
ans = 2 * pi * a;
cout << ans;
}
int main()
{
int x;
cin >> x;
Solve(x);
return 0;
} | 1 |
#include <stdio.h>
#include <string.h>
int main(){
char A[11], B[11], C[11];
scanf("%s %s %s", A, B, C);
int lenA=0, lenB=0, lenC=0;
lenA = strlen(A);
lenB = strlen(B);
lenC = strlen(C);
if(A[lenA-1] == B[0] && B[lenB-1] == C[0] ){
printf("YES");
} else {
printf("NO");
}
return 0;
} | #include <bits/stdc++.h>
#include <fstream>
using namespace std;
int n;
bool bad = false;
int check(vector<pair<int, int>> p){
sort(p.begin(), p.end());
int sum = 0;
for (int i = 0; i < n; i++) {
auto x = p[i];
int hituyo = x.first;
int yojo = x.second;
if (yojo >= 0) {
if (hituyo <= sum) {
sum += yojo;
} else {
bad = true;
break;
}
}
}
return sum;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout << setprecision(20) << fixed;
/*
ifstream in("input.txt");
cin.rdbuf(in.rdbuf());
//*/
cin >> n;
vector<pair<int, int>> p1, p2;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
int tmp = 0;
int hituyo = 0;
for (int j = 0; j < s.size(); j++) {
if (s[j] == '(') {
tmp++;
} else {
tmp--;
}
if ((-1) * tmp > hituyo) {
hituyo = tmp * (-1);
}
}
p1.emplace_back(hituyo, tmp);
tmp = 0;
hituyo = 0;
for (int j = s.size() - 1; j >= 0; j--) {
if (s[j] == ')') {
tmp++;
} else {
tmp--;
}
if ((-1) * tmp > hituyo) {
hituyo = tmp * (-1);
}
}
p2.emplace_back(hituyo, tmp);
}
int sum1 = check(p1);
int sum2 = check(p2);
/*
for (auto x : p) {
cout << x.first << " " << x.second << endl;
}
//*/
if (bad || sum1 != sum2) {
cout << "No" << endl;
} else {
cout << "Yes" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct base{
#define type long long
#define log 60
type d[log+1] = {};
bool insert(type x){
for(int i=log; ~i; i--) if((x>>i)&1){
if(!d[i]){
d[i] = x;
break;
}
x ^= d[i];
}
return x;
}
type max(){
type ret = 0;
for(int i=log; ~i; i--)
if((ret^d[i]) > ret)
ret ^= d[i];
return ret;
}
};
int main()
{
int n;
scanf("%d",&n);
long long xo = 0;
vector <long long> v(n) ,prt(60 ,0);
for(auto&a : v){
scanf("%lld",&a) ,xo ^= a;
for(int b=0; b<60; b++)
prt[b] ^= (a>>b)&1;
}
base h;
for(auto&a : v){
for(int b=0; b<60; b++)
a &= ~(prt[b]<<b);
h.insert(a);
}
long long mx = h.max();
printf("%lld\n",(xo^mx)+mx);
}
| #include <bits/stdc++.h>
#define MIN_INT -2147483648
#define MAX_INT 2147483647
#define MIN_LONG -9223372036854775808L
#define MAX_LONG 9223372036854775807L
#define long long long int
using namespace std;
// @author: pashka
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
vector<long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
long s = 0;
for (long x : a) s ^= x;
vector<long> b(n - 1);
for (int i = 0; i < n - 1; i++) {
b[i] = a[i] & (~s);
}
sort(b.begin(), b.end());
reverse(b.begin(), b.end());
vector<long> q;
long c = 0;
for (long x : b) {
for (long y : q) {
x = min(x, x ^ y);
}
if (x > 0) {
q.push_back(x);
c = max(c, c ^ x);
}
}
s += c * 2;
cout << s;
return 0;
} | 1 |
#include<iostream>
#include<string>
#include<cstdio>
#include<algorithm>
#include<stack>
#include<queue>
#include<vector>
#include<cmath>
#include<utility>
#include<set>
#include<complex>
#define vi vector<int>
#define vvi vector<vector<int> >
#define ll long long int
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vb vector<bool>
#define vc vector<char>
#define vs vector<string>
#define ld long double
#define INF 1e9
#define EPS 0.0000000001
#define rep(i,n) for(int i=0;i<n;i++)
#define CC puts("-------ok--------");
#define all(in) in.begin(), in.end()
#define bv vector<bool>
using namespace std;
typedef pair<int, int> PI;
#define MAX 1000009
int main(){
int e;
while(cin>>e,e){
vector<PI> v3;
for(int i =0;i<=100;i++){
PI temp;
temp.first=pow(i,3);temp.second=i;
v3.push_back(temp);
}
vector<PI> v2;
for(int i=0; i<=10000;i++){
PI temp;
temp.first=pow(i,2); temp.second=i;
v2.push_back(temp);
}
PI min; min.first=INF; min.second=INF;
for(int i=(int)v3.size()-1; i>=0;i--){
for(int j=(int)v2.size()-1; j>=0;j--){
if(v3[i].first+v2[j].first<=e){
if(min.second+min.first>e-(v3[i].first+v2[j].first)+v3[i].second+v2[j].second){
min.second=v3[i].second+v2[j].second;
min.first=e-(v3[i].first+v2[j].first);
}
}
}
}
cout<<min.second+min.first<<endl;
}
return 0;
} | #include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<algorithm>
#define ll long long
#define maxn 200010
inline ll read()
{
ll x=0; char c=getchar(),f=1;
for(;c<'0'||'9'<c;c=getchar())if(c=='-')f=-1;
for(;'0'<=c&&c<='9';c=getchar())x=x*10+c-'0';
return x*f;
}
inline void write(ll x)
{
static int buf[20],len; len=0;
if(x<0)x=-x,putchar('-');
for(;x;x/=10)buf[len++]=x%10;
if(!len)putchar('0');
else while(len)putchar(buf[--len]+'0');
}
inline void writeln(ll x){write(x); putchar('\n');}
inline void writesp(ll x){write(x); putchar(' ');}
int a[maxn],d[maxn];
int cur[maxn],ans[maxn];
int n,m;
ll k;
int mul(int* a,int* b,int n)
{
static int t[maxn];
for(int i=1;i<=n;i++)
t[i]=a[b[i]];
for(int i=1;i<=n;i++)
a[i]=t[i];
}
int main()
{
n=read();
for(int i=1;i<=n;i++)
a[i]=read();
int S=a[1];
for(int i=1;i<n;i++)
d[i]=a[i+1]-a[i];
m=read(); k=read();
for(int i=1;i<n;i++)
cur[i]=ans[i]=i;
for(int i=1;i<=m;i++){
int x=read();
std::swap(cur[x-1],cur[x]);
}
for(;k;k>>=1,mul(cur,cur,n-1))
if(k&1)mul(ans,cur,n-1);
ll X=a[1];
for(int i=1;i<=n;i++){
writeln(X);
X+=d[ans[i]];
}
return 0;
} | 0 |
#include <iostream>
using namespace std;
int main(void){
int one;
int two;
int three;
cin>>one>>two>>three;
if(one==two){
if(one!=three||two!=three){
cout<<"Yes";
}
else{
cout<<"No";
}
}
else if(one ==three){
if(one!=two||three!=two){
cout<<"Yes";
}
else{
cout<<"No";
}
}
else if(two==three){
if(two!=one||three!=one){
cout<<"Yes";
}
else{
cout<<"No";
}
}
else{
cout<<"No";
}
return 0;
} | #include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#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(v) v.begin(), v.end()
using ll = long long;
using ull = unsigned long long;
using namespace std;
int main() {
string S;
cin >> S;
REP(i, S.size()-1) {
if (S[i] == 'A' && S[i+1] == 'C') {
cout << "Yes" << endl;
return 0;
}
}
cout << "No" << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, x, y;
cin >> n >> m >> x >> y;
int xmax = x;
int ymin = y;
int a, b;
for (int i = 0; i < n; i++) {
cin >> a;
xmax = max(a, xmax);
}
for (int i = 0; i < m; i++) {
cin >> b;
ymin = min(b, ymin);
}
if (xmax < ymin) {
cout << "No War" << endl;
}
else {
cout << "War" << endl;
}
}
| #include <bits/stdc++.h>
#define rep(i, f, n) for (ll i = (f); i < (ll)(n); i++)
#define repe(i, f, n) for (ll i = (f); i <= (ll)(n); i++)
using namespace std;
using ll = long long;
using pint = pair<int, int>;
bool is_war(const vector<int>& x, const vector<int>& y) {
return *max_element(x.begin(), x.end()) >= *min_element(y.begin(), y.end());
}
int main() {
int N, M;
cin >> N >> M;
vector<int> x(N + 1), y(M + 1);
cin >> x[0] >> y[0];
rep(i, 0, N) cin >> x[i + 1];
rep(i, 0, M) cin >> y[i + 1];
if (is_war(x, y))
cout << "War" << endl;
else
cout << "No War" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int x, y;
cin >> x >> y;
int add = x + y;
int sub = x - y;
int into = x * y;
if (add >= sub && add >= into) {
cout << add << "\n";
} else if (sub >= add && sub >= into) {
cout << sub << "\n";
} else {
cout << into << "\n";
}
}
| #include <bits/stdc++.h>
#include <set>
#include <numeric>
#define rep(i,n) for (int i=0; i < (n); ++i)
#define all(a) a.begin(), a.end()
using ll = long long;
using namespace std;
// ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
// const double PI = acos(-1);
// int gcd(int x, int y) { return (x % y)? gcd(y, x % y): y; }
// int a[12][12];
void solve() {
int x,y;
cin >> x >> y;
cout << max({x+y, x-y, x*y})<< endl;
}
int main() {
solve();
return 0;
} | 1 |
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
using namespace std;
#define MAX_V 100000
int V, E;
vector<int> G[MAX_V];
bool visited[MAX_V];
int prenum[MAX_V];
int parent[MAX_V];
int lowest[MAX_V];
int timer, root;
void add_edge(int from, int to) {
G[from].push_back(to);
G[to].push_back(from);
}
void dfs(int u, int prev) {
prenum[u] = timer;
lowest[u] = timer;
timer++;
visited[u] = true;
for(int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if(!visited[v]) {
parent[v] = u;
dfs(v, u);
lowest[u] = min(lowest[u], lowest[v]);
} else if(v != prev) {
lowest[u] = min(lowest[u], prenum[v]);
}
}
}
int main () {
cin >> V >> E;
for(int i = 0; i < E; i++) {
int v1, v2;
cin >> v1 >> v2;
add_edge(v1, v2);
}
for(int i = 0; i < V; i++) {
visited[i] = false;
}
root = 0;
timer = 1;
dfs(root, -1);
set<int> ans;
// (1)
int num = 0;
for(int i = 0; i < V; i++) {
if(i == root) continue;
if(parent[i] == root) num++;
}
if(num >= 2) ans.insert(root);
// (2)
for(int i = 0; i < V; i++) {
if(i == root || parent[i] == root) continue;
else if(prenum[parent[i]] <= lowest[i])
ans.insert(parent[i]);
// cout << i << endl;
}
set<int>::iterator it = ans.begin();
while(it != ans.end()) {
cout << *it << endl;
it++;
}
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
typedef unsigned long long int ulli;
#define vec(s) vector<s>
#define vvec(s) vector<vector<s>>
typedef vector<lli> vi;
typedef vector<vi> vvi;
typedef pair<lli, lli> pii;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define YN(x) cout << (x ? "Yes" : "No") << endl;
#define out(s) cout << s << endl;
#define pb(s) push_back(s);
#define sp " "
#define INF 10000000000
#define LINF 9000000000000000000
#define all(s) s.begin(), s.end()
void vout(vi v)
{
for (int i = 0; i < v.size(); i++)
cout << v.at(i) << endl;
}
int main()
{
lli n, m;
cin >> n >> m;
vi rec(n, 0);
lli ans = 0, ans2 = 0;
vec(bool) c(n, false);
rep(i, m)
{
lli p;
string s;
cin >> p >> s;
p--;
if (s == "WA")
{
rec[p]++;
}
else
{
if (!c[p])
{
ans += rec[p];
ans2++;
c[p] = true;
}
}
}
out(ans2 << sp << ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N; cin >> N;
string S; cin >> S;
int sumE = 0, sumW = 0, ans = N, leftE = 0, leftW = 0;
for (int i = 0; i < N; i++) {
if (S.at(i) == 'E') sumE++;
if (S.at(i) == 'W') sumW++;
}
for (int i = 0; i < N; i++) {
int tmp = 0;
if (S.at(i) == 'E') tmp = 1;
if (S.at(i) == 'W') tmp = 0;
int cost = leftW + sumE - leftE - tmp;
ans = min(ans, cost);
if (S.at(i) == 'E') leftE++;
if (S.at(i) == 'W') leftW++;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main()
{
int n, k;
cin >> n >> k;
vector<int> l(n);
for (int i = 0; i < n; i++)
{
cin >> l[i];
}
sort(l.begin(), l.end());
reverse(l.begin(), l.end());
int total = 0;
for (int i = 0; i < k; i++)
{
total += l[i];
}
cout << total << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
// iostream is too mainstream
#include <cstdio>
// bitch please
#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <list>
#include <cmath>
#include <iomanip>
#include <time.h>
#define dibs reserve
#define OVER9000 1234567890
#define ALL_THE(CAKE,LIE) for(auto LIE =CAKE.begin(); LIE != CAKE.end(); LIE++)
#define tisic 47
#define soclose 1e-8
#define chocolate win
// so much chocolate
#define patkan 9
#define ff first
#define ss second
#define abs(x) (((x) < 0)?-(x):(x))
#define uint unsigned int
#define dbl long double
#define pi 3.14159265358979323846
using namespace std;
// mylittledoge
using cat = long long;
#ifdef DONLINE_JUDGE
// palindromic tree is better than splay tree!
#define lld I64d
#endif
void strcpy(auto & S, string * p, int sz, int offset_r, int offset_c, int offset_val) {
for(int k = 0; k < sz; k++) for(int l = 0; l < sz; l++) if(p[k][l] != '.')
S[offset_r+k][offset_c+l] = p[k][l] + offset_val * 4;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(10);
int N;
cin >> N;
if(N == 2) {
cout << "-1\n";
return 0;
}
string p3[] = {
"aab",
"d.b",
"dcc"
};
string p4[] = {
"aacd",
"bbcd",
"cdaa",
"cdbb"
};
string p5[] = {
"aabba",
"b.cca",
"bd..b",
"ad..b",
"abbaa",
};
string p7[] = {
"....aba",
"....aba",
"....bab",
"....bab",
"aabb.cc",
"bbaad..",
"aabbd..",
};
vector<string> S(N);
for(int i = 0; i < N; i++) for(int j = 0; j < N; j++) S[i] += '.';
int r = 1;
while(N%2 == 0 && N >= 6) N /= 2, r *= 2;
for(int rr = 0; rr < r; rr++) for(int rc = 0; rc < r; rc++) {
int n = N;
while(n >= 8 || n == 4) {
n -= 4;
strcpy(S, p4, 4, rr*N+n, rc*N+n, (rr+rc)%2);
}
if(n == 3) strcpy(S, p3, 3, rr*N, rc*N, (rr+rc)%2);
if(n == 5) strcpy(S, p5, 5, rr*N, rc*N, (rr+rc)%2);
if(n == 7) strcpy(S, p7, 7, rr*N, rc*N, (rr+rc)%2);
}
for(int i = 0; i < r*N; i++) cout << S[i] << "\n";
return 0;
}
// look at my code
// my code is amazing
| #pragma region
#include "bits/stdc++.h"
using namespace std;
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define _rep3(i, begin, end) for (register int i = (begin); i < (end); i++)
#define _irep3(i, begin, end) for (register int i = (end)-1; i >= (begin); i--)
#define _rep2(i, n) _rep3(i, 0, n)
#define _irep2(i, n) _irep3(i, 0, n)
#define _overload3(_1, _2, _3, name, ...) name
#define rep(...) _overload3(__VA_ARGS__, _rep3, _rep2, )(__VA_ARGS__)
#define irep(...) _overload3(__VA_ARGS__, _irep3, _irep2, )(__VA_ARGS__)
#define out(x) cout << (x) << '\n';
#define debug(x) cerr << #x << " = " << (x) << " (line: " << __LINE__ << ") " << endl;
typedef long long ll;
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "vec[ ";
rep(i, vec.size()) i == 0 ? os << vec[i] : os << ", " << vec[i];
os << " ]";
return os;
}
#pragma endregion
#define MOD 1000000007
#define INF 2147483647
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(16);
ll N;
cin >> N;
if (N == 2) {
out(-1);
return 0;
}
if (N == 3) {
out("abb");
out("a.a");
out("bba");
return 0;
}
if (N == 4) {
out("abaa");
out("abcc");
out("ccba");
out("aaba");
return 0;
}
vector<string> ans(N, string(N, '.'));
ans[0][0] = 'c';
ans[0][1] = 'c';
ans[1][0] = 'd';
ans[2][0] = 'd';
ans[0][N - 1] = 'c';
ans[1][N - 1] = 'c';
ans[0][N - 2] = 'd';
ans[0][N - 3] = 'd';
ans[N - 1][N - 1] = 'c';
ans[N - 1][N - 2] = 'c';
ans[N - 2][N - 1] = 'd';
ans[N - 3][N - 1] = 'd';
ans[N - 1][0] = 'c';
ans[N - 2][0] = 'c';
ans[N - 1][1] = 'd';
ans[N - 1][2] = 'd';
rep(i, N - 4) {
char c = i % 2 == 0 ? 'a' : 'b';
ans[i + 1][i + 2] = c;
ans[i + 1][i + 3] = c;
ans[i + 2][i + 1] = c;
ans[i + 3][i + 1] = c;
}
rep(i, N) out(ans[i]);
}
| 1 |
#include <iostream>
#include <map>
#include <vector>
typedef long long ll;
using namespace std;
int main (int argc, char const* argv[]) {
int N, id, price, num;
const ll LIMIT = 1000000LL;
while (true) {
cin >> N;
if (N == 0) break;
map<int,pair<bool,ll> > dict;
vector<int> id_list;
for (int i = 0; i < N; i += 1) {
cin >> id >> price >> num;
ll tmp = (ll)price * (ll)num;
// New
if (dict.count(id) == 0) {
if (LIMIT <= tmp) {
dict.insert(make_pair(id,make_pair(true,0)));
} else {
dict.insert(make_pair(id,make_pair(false,tmp)));
}
id_list.push_back(id);
// Add
} else {
if (dict[id].first) continue;
if (LIMIT <= tmp + dict[id].second) {
dict[id].first = true;
} else {
dict[id].second += tmp;
}
}
}
// Print
bool printed = false;
for (int i = 0; i < id_list.size(); i += 1) {
if (dict[id_list[i]].first) {
cout << id_list[i] << endl;
printed = true;
}
}
if (!printed) cout << "NA" << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int order[4000];
bool search(int);
class Member {
public:
Member() {sum = 0;}
void add(long price, long num) {
sum += (long long int)price*num;
}
bool milion()
{
if (sum >= 1000000) return true;
else return false;
}
private:
long long int sum;
int id;
};
bool search(int num)
{
for (int i=0; i<4000; i++)
if (order[i] == num ) return true;
return false;
}
int main()
{
int n, idx, memNum;
long price, num;
bool nothing;
ios::sync_with_stdio();
while (1) {
Member *member = new Member[4000];
memNum=0;
nothing =true;
for (int i=0; i<4000; i++) order[i] = -1;
if (cin >> n, !n) break;
for (int i=0; i<n; i++) {
scanf("%d %ld %ld", &idx, &price, &num);
member[idx].add(price, num);
if (!search(idx)) order[memNum++] = idx;
}
for (int i=0; i<4000 && order[i] > 0; i++)
if (member[order[i]].milion()) { cout << order[i] << endl; nothing = false; }
if (nothing) cout << "NA" << endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define fcout(d) cout << fixed << setprecision(d)
#define rep(i,n) for(int (i) = 0; (i) < (n); ++(i))
#define rep1(i,n) for(int (i) = 1; (i) <= (n); ++(i))
#define repU(i,bottom,ceiling) for(auto (i) = (bottom); (i) <= (ceiling); ++(i))
#define repD(i,ceiling,bottom) for(auto (i) = (ceiling); (i) >= (bottom); --(i))
#define l_bnd lower_bound
#define u_bnd upper_bound
#define puf push_front
#define pub push_back
#define pof pop_front
#define pob pop_back
#define mkp make_pair
#define mkt make_tuple
#define fir first
#define sec second
#define divceil(n,d) ((n)/(d) + ((n)%(d) > 0))
#define parity(a,b) (((a) & 1LL)^((b) & 1LL)^1LL)
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
const pair<int,int> DIR[] = { {1,0},{0,1},{-1,0},{0,-1},{1,1},{-1,1},{-1,-1},{1,-1} };
const int INF_32 = -1 + (1 << 30);
const ll INF_64 = -1 + (1LL << 62);
const int MOD = (int)1e9 + 7;
ull next_subset(ull subset){
ull tem = subset + (subset & -subset);
ull btm = (~tem & subset) / (subset & -subset) >> 1;
return btm | tem;
}
int V,E,r;
vector<pair<int,int> > adj[100000];
ll dist[100000];
void solve(){
fill(dist,dist + V,INF_64);
dist[r] = 0;
queue<int> que;
que.push(r);
while(!que.empty()){
int v = que.front();
que.pop();
rep(i,adj[v].size()){
pair<int,int> p = adj[v][i];
if(dist[p.fir] < dist[v] + p.sec) continue;
que.push(p.fir);
dist[p.fir] = dist[v] + p.sec;
}
}
rep(i,V){
if(dist[i] == INF_64) cout<<"INF\n";
else cout<<dist[i]<<endl;
}
return;
}
void input(){
cin>>V>>E>>r;
rep(i,E){
int s,t,d;
cin>>s>>t>>d;
adj[s].pub({t,d});
}
return;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
input();
solve();
return 0;
}
| #include <cstdio>
#include <algorithm>
using namespace std;
typedef long long ll;
#define chmin(a,b) a=min(a,b)
#define rep(i,x) for(ll i=0;i<(x);++i)
const ll linf = 3e18;
ll cost[100][100];
ll d[100];
bool used[100];
ll N, K;
void dijkstra(ll s)
{
fill_n(d, N, linf);
fill_n(used, N, false);
d[s] = 0;
while (true) {
ll v = -1;
rep(u, N) {
if (!used[u] && (v == -1 || d[v] > d[u])) v = u;
}
if (v == -1) break;
used[v] = true;
rep(u, N) {
chmin(d[u], d[v] + cost[v][u]);
}
}
}
signed main()
{
while (scanf("%lld %lld", &N, &K), N || K) {
fill(cost[0], cost[N], linf);
rep(i, K) {
ll t; scanf("%lld", &t);
if (t == 1) {
ll a, b, c; scanf("%lld %lld %lld", &a, &b, &c); a--; b--;
chmin(cost[a][b], c);
chmin(cost[b][a], c);
} else {
ll a, b; scanf("%lld %lld", &a, &b); a--; b--;
dijkstra(a);
printf("%lld\n", d[b] == linf ? -1 : d[b]);
}
}
}
} | 0 |
#include <iostream>
#include <algorithm>
using namespace std;
int main() {
int scores[2] = {0, 0};
int points[2][10];
for (int i = 0; i < 2; ++i) {
for (int j = 0; j < 10; ++j) {
cin >> points[i][j];
}
sort(points[i], points[i]+10);
for (int j = 0; j < 3; ++j) {
scores[i] += points[i][9 - j];
}
}
cout << scores[0] << ' ' << scores[1] << endl;
return 0;
} | #include <iostream>
int main()
{
int a, b, c;
std::cin >> a >> b >> c;
if (a==b) {
if (a!=c) std::cout << "Yes" << std::endl;
else std::cout << "No" << std::endl;
}
else {
if (a==c || b==c) std::cout << "Yes" << std::endl;
else std::cout << "No" << std::endl;
}
return 0;
} | 0 |
#include <iostream>
using namespace std;
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
int d;
while(cin >> d){
int sum = 0;
for(int i = d; i < 600; i += d){
sum += d * i * i;
}
cout << sum << endl;
}
return 0;
} | #include<stdio.h>
main(){
int n;
int i,j;
scanf("%d",&n);
for(i=1;i<=n;i++){
if(i%3==0){
printf(" %d",i);
}else{
j = i;
while(j>0){
if(j%10==3){
printf(" %d",i);
break;
}
j /= 10;
}
}
}
printf("\n");
} | 0 |
#include<iostream>
#include<stdio.h>
using namespace std;
int main()
{
int n,sum=0,sumy=0;
while (1){
sum = 0;
sumy = 0;
cin >> n;
if (n == 0)break;
int ma[101][101] = { 0 };
for (int i = 0; i < n; i++){
sum = 0;
for (int i2 = 0; i2 < n; i2++){
cin >> ma[i][i2];
sum += ma[i][i2];
}
sumy += sum;
ma[i][n] += sum;
}
ma[n][n] += sumy;
for (int i = 0; i < n; i++){
sum = 0;
for (int i2 = 0; i2 < n; i2++){
sum += ma[i2][i];
sumy += sum;
}
ma[n][i] += sum;
}
n++;
for (int i = 0; i < n; i++){
for (int i2 = 0; i2 < n; i2++){
printf("%5d", ma[i][i2]);
}
cout << endl;
}
}
} | #include <iostream>
using namespace std;
int main() {
int a,b,c;
while(1) {
cin >> a >> b >> c;
if(a == 0 && b == 0 && c == 0) break;
int n;
cin >> n;
int flg[301];
for(int i=0;i<301;i++) flg[i] = 2;
int d[1001],m[1001],k[1001],r;
for(int i=0;i<n;i++) {
cin >> d[i]>> m[i] >> k[i] >> r;
if(r == 1) {
flg[d[i]] = flg[m[i]] = flg[k[i]] = 1;
i--;
n--;
}
}
int sum;
for(int i=0;i<n;i++){
sum = 0;
if(flg[d[i]] == 1 ) sum++;
if(flg[m[i]] == 1) sum++;
if(sum == 2) {
flg[k[i]] = 0;
continue;
}
if(flg[k[i]] == 1) sum++;
if(sum == 2) {
if(flg[d[i]] == 2) flg[d[i]] = 0;
else flg[m[i]] = 0;
}
}
for(int i=1;i<=a+b+c;i++) {
cout << flg[i] << endl;
}
}
return 0;
} | 0 |
#include<iostream>
#include<string>
using namespace std;
int main(){
string S;
cin>>S;
char check='a';
bool flag=0;
for(check='a';check<='z';check++){
flag=1;
for(size_t i=0;i<=S.length()-1;i++){
if(S[i]==check){
flag=0;
break;
}
}
if(flag==1){
cout<<check;
return 0;
}
}
cout<<"None";
return 0;
} | /*
ID: anonymo14
TASK: wormhole
LANG: C++
*/
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pair<int,int>> vpii;
#define F first
#define S second
#define PU push
#define PUF push_front
#define PUB push_back
#define PO pop
#define POF pop_front
#define POB pop_back
#define REP(i,a,b) for(int i=a; i<=b; i++)
#define MOD 1000000007
void solve(int test_case) {
string s;
cin>>s;
bitset<26> b;
for(char c:s)b[(int)(c-'a')]=1;
int i = 0;
for(;i<26;i++) {
if(!b[i]){break;}
}
if(i<26)cout<<(char)(i+'a'); else cout<<"None";
}
int main() {
////// FILE BASED IO////
//freopen("wormhole.in", "r", stdin);
//freopen("wormhole.out", "w", stdout);
///////////////
ios::sync_with_stdio(0);
cin.tie(0);
int t=1;
//cin>>t;
REP(i,1,t) {
solve(i);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const long long INF = 1LL << 60;
int main(){
int N, K;
cin >> N >> K;
vector<int> D(10, 0);
for(int i=0; i<K; i++) {
int a;
cin >> a;
D[a] = 1;
}
for(int i=N; i<=100000; i++) {
int num = i;
bool flg = true;
while(num) {
int x = num % 10;
if (D[x] == 1) {
flg = false;
break;
}
num /= 10;
}
if(flg && i>= N) {
cout << i << endl;
return 0;
}
}
} | #include<iostream>
#include<unordered_map>
#include<bitset>
#include<math.h>
#include<vector>
#include<set>
#include<algorithm>
#include<ctype.h>
#include<unordered_set>
#include<string>
#include<iomanip>
#include<queue>
#include<limits>
#include<map>
#include<stack>
#include<iterator>
#include<cstring>
#include<deque>
#include<chrono>
using namespace std;
#define pi 3.141592653589793238
#define MOD 1000000007
#define INF 999999999999999999
#define pb push_back
#define ff first
#define ss second
#define mt make_tuple
#define ll long long
#define fast ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define f0 get<0>
#define f1 get<1>
#define f2 get<2>
typedef vector<ll> vi;
typedef vector<vi> vvi;
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main() {
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
fast;
ll T = 1, i, j;
//cin >> T;
while (T--) {
ll n, k;
cin >> n >> k;
vector<ll> v(n);
for(i =0 ; i <n ;i++){
cin >> v[i];
}
while(k--){
vector<ll> v2(n + 1);
for(i =0 ; i <n ;i++){
ll lo, hi;
lo = max(0LL, i - v[i]);
hi = min(i + v[i], n - 1);
v2[lo]++;
v2[hi + 1]--;
}
for(i = 1 ;i < n; i++){
v2[i] += v2[i - 1] ;
}
for(i =0 ;i < n; i++){
v[i] = v2[i];
}
bool flag = true;
for(i =0 ;i < n; i++){
if(v[i] != n){
flag = false;
break;
}
}
if(flag){
break;
}
}
for(i =0 ;i < n; i++){
cout << v[i] <<" ";
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int H, W;
cin >> H >> W;
vector<vector<char>> s(H, vector<char>(W));
int memo = 0;
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
cin >> s.at(i).at(j);
if (s.at(i).at(j) == '.') {
memo++;
}
}
}
vector<vector<int>> M(H, vector<int>(W, 0));
queue<int> X;
queue<int> Y;
X.push(0);
Y.push(0);
vector<int> vx = {1, -1, 0, 0}, vy = {0, 0, 1, -1};
s.at(0).at(0) = '#';
while (X.size() > 0) {
for (int i = 0; i < 4; i++) {
if ((X.front() + vx.at(i)) >= 0 && (Y.front() + vy.at(i)) >= 0
&& (X.front() + vx.at(i)) < H && (Y.front() + vy.at(i)) < W
&& s.at(X.front() + vx.at(i)).at(Y.front() + vy.at(i)) == '.'
&& M.at(X.front() + vx.at(i)).at(Y.front() + vy.at(i)) == 0) {
X.push(X.front() + vx.at(i));
Y.push(Y.front() + vy.at(i));
M.at(X.front() + vx.at(i)).at(Y.front() + vy.at(i)) = M.at(X.front()).at(Y.front()) + 1;
}
}
X.pop();
Y.pop();
}
if (M.at(H - 1).at(W - 1) != 0) {
cout << memo - (M.at(H - 1).at(W - 1) + 1) << endl;
}
else {
cout << -1 << endl;
}
} | #include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
using namespace std;
// info
int board[8][8];
int res[8];
void fillBoard(int row, int col, int cnt);
void printBoard();
void recur(int row);
int main()
{
fill(res, res+8, -1);
// rep(i, 8){
// fill(board[i], board[i]+8, 0);
// }
int n; cin >> n;
rep(i, n){
int row, col;
cin >> row >> col;
fillBoard(row, col, 1);
res[row] = col;
}
// printBoard();
// rep(i, 8)
// {
// rep(j, 8)
// {
// cout << board[i][j]
// << (j < 7 ? " " : "\n");
// }
// }
recur(0);
return 0;
}
void fillBoard(int row, int col, int cnt)
{
board[row][col] += cnt;
rep(i, 8)
{
if (i != col)
{
board[row][i] += cnt;
int j1 = row - col + i;
if (j1 >= 0 && j1 < 8)
board[j1][i] += cnt;
int j2 = col + row - i;
if (j2 >= 0 && j2 < 8) // here!!
board[j2][i] += cnt;
}
if (i != row)
board[i][col] += cnt;
}
}
void printBoard()
{
rep(i, 8)
{
rep(j, 8)
{
cout << (res[i] == j?"Q":".")
<< (j < 7 ? "" : "\n");
}
}
}
void recur(int row)
{
if (row == 8)
{
printBoard();
return;
}
if (res[row] < 0)
{
// int flag = -1;
rep(col, 8)
{
if (board[row][col] == 0)
{
// flag++;
fillBoard(row, col, 1);
res[row] = col;
recur(row + 1);
res[row] = -1;
fillBoard(row, col, -1);
}
}
// if(flag < 0) return;
}
else
recur(row + 1);
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
struct Graph{
Graph(int n):E(n),d(n){}
vector<vector<tuple<int,int,int>>>E;
vector<int>d;
void add_edge(int a,int b,int c,int d){
E[a].push_back(make_tuple(b,c,d));
}
void dijkstra(int s,int f){
priority_queue<P,vector<P>,greater<P>>q;
fill(d.begin(),d.end(),1e9);
q.push({d[s]=0,s});
while(q.size()){
auto p=q.top();q.pop();
if(p.first>d[p.second])continue;
for(auto& a:E[p.second]){
int x=get<0>(a),y=get<1>(a)+p.first;
if(f)y=get<2>(a)+p.first;
if(y<d[x])d[x]=y,q.push({y,x});
}
}
}
};
main(){
int n,m,a,b,c,d,k;
while(cin>>n>>m,n){
Graph E(m);
for(int i=0;i++<n;E.add_edge(--a,--b,c,d),E.add_edge(b,a,c,d))cin>>a>>b>>c>>d;
cin>>k;
for(int i=0;i++<k;cout<<E.d[--b]<<endl){
cin>>a>>b>>c;
E.dijkstra(--a,c);
}
}
} | #include<iostream>
#include<queue>
#include<vector>
#include<limits>
using namespace std;
struct RequestObj {
int begin, end, type;
};
int n, m;//???,???????????°
int k;//????????¨????????°
int time_table[100][100];
int cheap_table[100][100];
RequestObj request[200];
const int INF = 10000000;
int main() {
while (cin >> n >> m, n * m) {
for (int i = 0; i < m; i++)for (int j = 0; j < m; j++)time_table[i][j] = INF, cheap_table[i][j] = INF;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
cin >> cheap_table[a - 1][b - 1] >> time_table[a - 1][b - 1];
cheap_table[b - 1][a - 1] = cheap_table[a - 1][b - 1];
time_table[b - 1][a - 1] = time_table[a - 1][b - 1];
}
cin >> k;
for (int i = 0; i < k; i++) {
cin >> request[i].begin >> request[i].end >> request[i].type;
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < m; k++) {
if (cheap_table[j][i] + cheap_table[i][k] < cheap_table[j][k]) {
cheap_table[j][k] = cheap_table[j][i] + cheap_table[i][k];
}
}
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < m; k++) {
if (time_table[j][i] + time_table[i][k] < time_table[j][k]) {
time_table[j][k] = time_table[j][i] + time_table[i][k];
}
}
}
}
for (int i = 0; i < k; i++) {
if (request[i].type == 0) {
cout << cheap_table[request[i].begin - 1][request[i].end - 1] << endl;
}
else {
cout << time_table[request[i].begin - 1][request[i].end - 1] << endl;
}
}
for (int i = 0; i < m; i++)for (int j = 0; j < m; j++)time_table[i][j] = INF, cheap_table[i][j] = INF;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i,a,b) for(ll i=(ll)(a);i<(ll)(b);i++)
#define rep(i,n) repl(i,0,n)
#define each(itr,v) for(auto itr:v)
#define pb push_back
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define mmax(x,y) (x>y?x:y)
#define mmin(x,y) (x<y?x:y)
#define maxch(x,y) x=mmax(x,y)
#define minch(x,y) x=mmin(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt __builtin_popcount
#define INF INT_MAX/3
#define MAX_LEN 1010
template<size_t N>
const bitset<N> operator+(const bitset<N>& lhs, const bitset<N>& rhs)
{
bitset<N> a(lhs), b(rhs), ret(lhs ^ rhs);
for (b = (a & b) << 1, a = ret; b.any(); b = (a & b) << 1, a = ret) ret ^= b;
return ret;
}
template<size_t N>
int edit_distance_bitset(const string& s1, const string& s2)
{
int m = s1.size();
int n = s2.size();
const bitset<N> ONE(1);
bitset<N> Peq[0x100];
bitset<N> Pv, Mv, Eq, Xv, Xh, Ph, Mh;
int Score = m;
for (int i = 0; i < m; i++) {
Peq[s1[i]] |= ONE << i;
Pv |= (ONE << i);
}
for (int j = 0; j < n; j++) {
Eq = Peq[s2[j]];
Xv = Eq | Mv;
Xh = (((Eq & Pv) + Pv) ^ Pv) | Eq;
Ph = Mv | ~(Xh | Pv);
Mh = Pv & Xh;
if ((Ph & (ONE << (m - 1))).any()) Score++;
else if ((Mh & (ONE << (m - 1))).any()) Score--;
Ph = Ph << 1 | ONE;
Pv = (Mh << 1) | ~(Xv | Ph);
Mv = Ph & Xv;
}
return Score;
}
int main(){
string a,b;
cin>>a>>b;
cout<<edit_distance_bitset<MAX_LEN>(a,b)<<endl;
return 0;
} | #include <iostream>
#include <string>
#include <algorithm>
#include <cstring>
using namespace std;
void solve(string, string);
int main(){
string s, t;
cin >> s >> t;
solve(s, t);
return 0;
}
void solve(string s, string t){
int m=s.length(), n=t.length();
s = " "+s; t = " "+t;
int dp[m+1][n+1];
for(int i=0; i<=m; i++) dp[i][0] = i;
for(int i=0; i<=n; i++) dp[0][i] = i;
for(int i=1; i<=m; i++){
for(int j=1; j<=n; j++){
int ins=dp[i-1][j]+1;
int del=dp[i][j-1]+1;
int rep;
if(s[i]==t[j]){
rep = dp[i-1][j-1];
dp[i][j] = min(ins, min(del, rep));
}
else{
rep = dp[i-1][j-1]+1;
dp[i][j] = min(ins, min(del, rep));
}
}
}
cout << dp[m][n] << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n,ans;
cin >> n;
ans=n/11*2;
n=n%11;
if(n>0) ans++;
if(n>6) ans++;
cout << ans << endl;
} | #include <iostream>
int main()
{
std::string s; std::cin >> s;
for (size_t i = 0; i < s.size() - 8; i++) {
std::cout << s[i];
}
std::cout << std::endl;
return 0;
}
| 0 |
#include <iostream>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
vector<long long> divisor(long long n) {
vector<long long> ret;
for (long long i = 1; i * i <= n; i++) {
if (n % i == 0) {
ret.push_back(i);
if (i * i != n) ret.push_back(n / i);
}
}
sort(ret.begin(), ret.end(), greater<long long>());
return ret;
}
int main(){
long long n, m;
cin >> n >> m;
vector<long long> ret;
ret = divisor(m);
long long ans = 1;
for(long long i = 0; i < ret.size(); i++){
if(m/ret[i] >= n){
ans = ret[i];
break;
}
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <algorithm>
#include <vector>
#include <array>
#include <iomanip>
#include <set>
using namespace std;
typedef long long ll;
#define FOR(i,a,b) for(ll i=a;i<=(ll)(b);i++)
#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 SORT(s) sort((s).begin(),(s).end())
int main(){
ll N,K; cin >> N >> K;
if(N%K==0) cout << "0" << endl;
else cout << "1" << endl;
}
| 0 |
// -*- mode:c++; coding:utf-8; c-basic-offset:2; -*-
// ALDS1_10_B: Matrix Chain Multiplication
#include <algorithm>
#include <climits>
#include <cstdio>
using uint = unsigned int;
static uint matrix_chain_multiplication(const uint p[], const uint n)
{
uint m[n][n];
for (auto i = 0u; i < n; ++i) m[i][i] = 0u;
for (auto d = 1u; d < n; ++d) {
for (auto i = 0u, j = i+d; j < n; ++i, ++j) {
auto min = UINT_MAX;
for (auto k = i; k < j; ++k) {
// min(Mi..j = (Mi..k) * (Mk+1..j)
// = (Mi..k) + (Mk+1..j) + p[i]*p[k+1]*p[j+1])
auto cost = m[i][k] + m[k+1][j] + p[i]*p[k+1]*p[j+1];
min = std::min(min, cost);
}
m[i][j] = min;
}
}
return m[0][n-1];
}
int main()
{
uint n;
std::scanf("%u", &n);
uint p[n+1];
for (auto i = 0u; i < n; ++i) {
std::scanf("%u %u", &p[i], &p[i+1]);
}
auto c = matrix_chain_multiplication(p, n);
std::printf("%u\n", c);
}
// eof | #include <stdio.h>
int main() {
int n, i, j, k, l, p[101], m[101][101];
scanf("%d", &n);
for ( i = 1; i <= n; i++) {
scanf("%d", &p[i - 1]);
scanf("%d", &p[i]);
}
for ( i = 1; i <= n; i++) {
m[i][i] = 0;
}
for ( l = 2; l <= n; l++) {
for ( i = 1; i <= n - l + 1; i++) {
int j = i + l - 1;
m[i][j] = ( 1 << 21);
for ( k = i; k <= j - 1; k++) {
if ( m[i][j] < m[i][k] + m[k + 1][j] + p[i - 1]*p[k]*p[j]) {
m[i][j] = m[i][j];
} else {
m[i][j] = m[i][k] + m[k + 1][j] + p[i - 1]*p[k]*p[j];
}
}
}
}
printf("%d\n", m[1][n]);
return 0;
} | 1 |
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int N,X,a=0;
cin>>N>>X;
int l[N];
for(int i=0;i<N;++i)cin>>l[i];
sort(l,l+N);
for(int i=0;i<N;++i){
X-=l[i];
if(X>=0)a++;
else break;
}
if(X>0)cout<<a-1;
else cout<<a;
}
| #include <bits/stdc++.h>
#define rep(i,n) for(ll i=0;i<n;++i)
#define all_map(itr,mp) for(auto itr=mp.begin();itr!=mp.end();itr++)
#define ALL(a) (a).begin(),(a).end()
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
const ll MOD = 1e9 + 7;
const ll LINF = 1LL << 62;
const int INF = 1e9 + 7;
int main(){
ll n, m;
cin >> n >> m;
map<ll, ll> mp;
ll ans = 0;
ll sum = 0;
rep(i, n){
ll a;
cin >> a;
sum += a;
if(sum % m == 0)ans++;
if(mp.count(sum % m) > 0){
ans += mp[sum % m];
mp[sum % m]++;
}
else {
mp[sum % m] = 1;
}
}
cout << ans << endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
void solveA()
{
long long a,b,tem;
cin>>a>>b;
tem=(a+b);
if(tem%2==0)
{
cout<<tem/2<<endl;
}
else
{
cout<<"IMPOSSIBLE"<<endl;
}
}
void solveB()
{
int n,i,j,count;
cin>>n;
int ar[n];
for(i=0;i<n;i++)
{
cin>>ar[i];
}
j=1;
count=0;
for(i=0;i<n;i++)
{
if(ar[i]!=j)
{
count++;
}
if(count>2)
{
cout<<"NO"<<endl;
return;
}
j++;
}
cout<<"YES"<<endl;
}
void solveC()
{
int a,b,x,y;
cin>>a>>b;
x=max(a,b);
y=min(a,b);
if((x-y)>=2)
{
cout<<2*x-1<<endl;
}
else
{
cout<<x+y<<endl;
}
}
void solveD()
{
int n,i,j;
cin>>n;
int ar[n];
for(i=0;i<n;i++)
{
cin>>ar[i];
}
int count=n;
for(i=n-1;i>=0;i--)
{
for(j=i-1;j>=0;j--)
{
if(ar[i]<ar[j])
{
count--;
break;
}
}
}
cout<<count<<endl;
}
void solveE()
{
int h,w,x,y,H,W;
cin>>H>>W;
cin>>h>>w;
x=h*W;
y=(H-h)*w;
cout<<(H*W)-(x+y)<<endl;
}
void solveF()
{
int n,m,c,i,j;
cin>>n>>m>>c;
int b[m];
int ar[n][m];
for(i=0;i<m;i++)
{
cin>>b[i];
}
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
cin>>ar[i][j];
}
}
int count=0;
int sum;
for(i=0;i<n;i++)
{
sum=0;
for(j=0;j<m;j++)
{
sum=sum+ar[i][j]*b[j];
}
if((sum+c)>0)
{
count++;
}
}
cout<<count<<endl;
}
void solveG()
{
}
int main()
{
// solveA();
//solveB();
solveC();
//solveD();
//solveE();
// solveF();
return 0;
} | #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()
{
int n;
cin >> n;
cin.ignore();
while(--n >= 0){
string s;
getline(cin, s);
int i = 0;
for(;;){
i = s.find("Hoshino", i);
if(i == string::npos)
break;
s.replace(i, 7, "Hoshina");
}
cout << s << endl;
}
} | 0 |
#include <iostream>
#include <stdio.h>
#include <fstream>
#include <algorithm>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <vector>
#include <limits.h>
#include <math.h>
#include <functional>
#include <bitset>
#define repeat(i,n) for (long long i = 0; (i) < (n); ++ (i))
#define debug(x) cerr << #x << ": " << x << '\n'
#define debugArray(x,n) for(long long i = 0; (i) < (n); ++ (i)) cerr << #x << "[" << i << "]: " << x[i] << '\n'
#define debugArrayP(x,n) for(long long i = 0; (i) < (n); ++ (i)) cerr << #x << "[" << i << "]: " << x[i].first<< " " << x[i].second << '\n'
using namespace std;
typedef long long ll;
typedef pair<int,int> Pii;
typedef vector<int> vint;
typedef vector<ll> vll;
const ll INF = LLONG_MAX/10;
const ll MOD = 1e9+7;
ll rev(ll x,int n){
ll ret=0;
repeat(i,n){
ret *= 10;
ret += x%10;
x /= 10;
}
return ret;
}
ll dfs(ll D,int n,int cnt,int dig,ll N){
if(cnt>=n/2){
return rev(N,n)==N+D? N:-1;
}
if(cnt>=0){
if(dig>=0){
ll d=dig;
repeat(c,n-1-cnt) d*=10;
N += d;
}else{
ll d=-dig;
repeat(c,cnt) d*=10;
N += d;
}
}
ll ret = -1;
for(int i=-9;i<=(cnt<0? 0:9);i++){
ret = max(ret,dfs(D,n,cnt+1,i,N));
}
return ret;
}
int main(){
ll D;cin >> D;
if(D%9!=0){
cout << 0 << endl;
return 0;
}
int num10=0;
while(D%10==0){
D/=10;
num10++;
}
string Dstr=to_string(D);
int n = Dstr.length();
//debug(n);
ll ans = 0;
repeat(d,7){
int m = n+d;
ll N=0;
if(d>0){
if(D%10!=9)break;
if(d>1 && D%100!=89)break;
repeat(c,d-1){
N*=10;
N+=9;
}
repeat(c,n){
N*=10;
}
N+=1;
}
//debug(N);
N = dfs(D,m,d-1,0,N);
debug(N);
if(N>0){
string Nstr = to_string(N);
while(Nstr.length()<m) Nstr = "0"+Nstr;
ll a=1;
repeat(j,(m+1)/2){
int mi=Nstr[j]-'0',ma=Nstr[m-1-j]-'0';
if(mi>ma)swap(mi,ma);
a *= j==0? 9-ma+ (num10>0):10-(ma-mi);
}
debug(a);
ans += a;
}
}
if(ans>0&&num10>0){
repeat(c,num10-1)ans *= 10;
ans *= 9;
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using Int = long long;
array<Int, 18> POW10;
int main()
{
POW10[0] = 1;
for (int i = 1; i < POW10.size(); i++) POW10[i] = POW10[i-1] * 10;
int D; cin >> D;
int digits = 0;
for (int val = 1; val <= D; val *= 10, digits++) {}
Int ans = 0;
for (int d = digits; d <= digits*2; d++) {
vector<Int> A, S = {0};
for (int k = d/2; k < d; k++) {
A.push_back(POW10[k] - POW10[d-1-k]);
S.push_back(S.back() + A.back());
}
function<void(int, Int, Int)> recur = [&](int idx, Int rest, Int acc) {
int ten = (idx == A.size()-1 ? 9 : 10);
if (idx == 0) {
if (A[0] == 0) { if (rest == 0) ans += acc * ten; }
else if (rest % A[0] == 0 && abs(rest / A[0]) <= 9) ans += acc * (ten - abs(rest / A[0]));
} else {
for (int i = -9; i <= 9; i++) {
Int r = rest - i * A[idx];
if (abs(r) <= abs(S[idx]*9)) recur(idx-1, r, acc * (ten - abs(i)));
}
}
};
recur(A.size()-1, D, 1);
}
cout << ans << '\n';
return 0;
} | 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,t;
cin>>n>>t;
vector<int>vec(n);
for(int i=0;i<n;i++)
cin>>vec[i];
int sum=0;
for(int i=0;i<n-1;i++)
sum+=min(t,vec[i+1]-vec[i]);
sum+=t;
cout<<sum<<endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define zero_pad(num) setfill('0') << std::right << setw(num)
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<int, int>;
int main() {
ll x, y;
cin >> x >> y;
if(x == y)cout << 0 << endl;
else if(x == -y)cout << 1 << endl;
else if(abs(x) < abs(y)){
ll ans = abs(y) - abs(x);
if(x < 0 && y < 0)ans += 2;
else if(x < 0 || y < 0)ans++;
cout << ans << endl;
}else{
ll ans = abs(x) - abs(y);
if(x > 0 && y > 0)ans += 2;
else if(x > 0 || y > 0)ans++;
cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;
using vc = vector<char>;
using vvc = vector<vc>;
using pll = pair<ll, ll>;
using stkll = vector<pll>;
const ll INF = 1LL << 60;
const ll MOD = 1e9 + 7;
#define rep(i, n) for (ll i = 0; i < (n); i++)
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
#ifndef ONLINE_JUDGE
#define debug(x) cerr << #x << ": " << x << endl;
#else
#define debug(x)
#endif
vvll g;
vll color(110000, 0);
bool dfs(ll x, ll p = -1, ll c = 0) {
color[x] = c;
for(auto nx : g[x]) {
if(color[nx] == c) return false;
if(color[nx] ==0 && !dfs(nx, x, -c)) return false;
}
return true;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
ll n, m;
cin >> n >> m;
g = vvll(n);
rep(i,m) {
ll a, b;
cin >> a >> b;
a--, b--;
g[a].push_back(b);
g[b].push_back(a);
}
bool is_bipartite = dfs(0, -1, 1);
if(is_bipartite) {
ll cw = 0, cb = 0;
rep(i, n) {
if(color[i] == 1) cw++;
else cb++;
}
cout << cw * cb - m << endl;
}
else cout << n * (n-1) / 2 - m << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define inf 10e17
#define rep(i,n) for(long long i=0; i<n; i++)
#define repr(i,n,m) for(long long i=m; i<n; i++)
#define mod 1000000007
#define sorti(x) sort(x.begin(), x.end())
#define sortd(x) sort(x.begin(), x.end(), std::greater<long long>())
#define debug(x) std::cerr << (x) << std::endl;
#define roll(x) for (auto&& itr : x) { cerr << (itr) << " "; }
template <class T> inline void chmax(T &ans, T t) { if (t > ans) ans = t;}
template <class T> inline void chmin(T &ans, T t) { if (t < ans) ans = t;}
int main() {
int n, m;
cin >> n >> m;
vector<int> a(n-1+m), b(n-1+m), in(n);
vector<vector<int>> G(n);
for (int i = 0; i < n+m-1; ++i) {
cin >> a[i] >> b[i];
a[i] --, b[i] --;
G[a[i]].push_back(b[i]);
in[b[i]] ++;
}
int root = -1;
int edge = n+m-1;
for (int i = 0; i < n; ++i) {
if (in[i] == 0) {
root = i;
break;
}
}
queue<int> que;
que.push(root);
vector<int> dist(n);
while (!que.empty()) {
auto now = que.front();
que.pop();
for (auto to : G[now]) {
chmax(dist[to], dist[now] + 1);
in[to] --;
if (in[to] == 0) {
// 根の子の入次数は1だから必ずここには入る
// 親に対しても有向辺を貼る可能性はないので途中で探索が終わることもない
que.push(to);
}
}
}
vector<int> ans(n, 0);
for (int i = 0; i < n; ++i) {
for (auto&& to : G[i]) {
if (dist[to] - dist[i] == 1) {
ans[to] = i+1;
}
}
}
for (auto it : ans) {
cout << it << endl;
}
} | 0 |
#include<bits/stdc++.h>
#define rep(i, n) for(int i=0; i<int(n); i++)
using namespace std;
typedef long long ll;
const int mod = 1e9 + 7;
vector<int> G[1048576];
int main(){
int N; cin >> N;
int A[N];
rep(i, N) cin >> A[i];
int rui[N];
rui[0] = A[0];
rep(i, N-1){
rui[i+1] = rui[i] ^ A[i+1];
}
int sum[N];
rep(i, N){
G[rui[i]].push_back(i);
if(i == 0){
if(rui[i] == 0) sum[i] = 1;
else sum[i] = 0;
}else{
if(rui[i] == 0) sum[i] = sum[i-1] + 1;
else sum[i] = sum[i-1];
}
}
ll ans = 0, s = 1;
if(rui[N-1] == 0){
rep(i, sum[N-1] - 1) s = (s * 2) % mod;
ans = s;
for(int i=1; i<1048576; i++){
if(!G[i].size()) continue;
int p = G[i].size();
ll dp[p], su = 0;
dp[p-1] = 1, su = dp[p-1];
for(int j=p-2; j>=0; j--){
int nn = sum[G[i][j+1]] - sum[G[i][j]];
dp[j] = (su * nn % mod + dp[j+1]) % mod;
su = (su + dp[j]) % mod;
}
ans = (ans + su) % mod;
}
}else{
int x = rui[N-1];
ll dp[G[x].size()], su = 0;
dp[G[x].size() - 1] = 1, su = 1;
for(int i=G[x].size() - 2; i>=0; i--){
if(i == G[x].size() - 2){
int nn = sum[G[x][i+1]] - sum[G[x][i]];
dp[i] = nn;
su = (su + nn) % mod;
continue;
}
int nn = sum[G[x][i+1]] - sum[G[x][i]];
dp[i] = (su * nn % mod + dp[i+1]) % mod;
su = (su + dp[i]) % mod;
}
ans = (ans + su) % mod;
}
cout << ans << endl;
return 0;
}
| //高知能系Vtuberの高井茅乃です。
//Twitter: https://twitter.com/takaichino
//YouTube: https://www.youtube.com/channel/UCTOxnI3eOI_o1HRgzq-LEZw
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INTINF 1999999999
#define REP(i,n) for(int i=0;i<n;i++)
#define REP1(i,n) for(int i=1;i<=n;i++)
#define MODA 1000000007
int main() {
ll ans = 0;
int tmp;
int n;
cin >> n;
map<int, int> o, e;
REP(i, n){
cin >> tmp;
if(i %2 == 0) e[tmp] ++;
else o[tmp]++;
}
vector< pair <int, int >> od , ev;
for(auto it = e.begin(); it != e.end(); it++){
ev.push_back(make_pair(it->second, it->first));
}
for(auto it = o.begin(); it != o.end(); it++){
od.push_back(make_pair(it->second, it->first));
}
ev.push_back(make_pair(0, -1));
od.push_back(make_pair(0, -1));
sort(ev.begin(), ev.end(), greater<pair<int, int>>());
sort(od.begin(), od.end(), greater<pair<int, int>>());
if(ev[0].second != od[0].second){
cout << n - ev[0].first - od[0].first;
}
else{
cout << min(n - ev[1].first - od[0].first, n - ev[0].first - od[1].first);
}
//cout << ans << endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
cout<<n+(n*n)+(n*n*n)<<endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair <int, int>;
#define rep(i, n) for (int i = 0; i < (int) (n); i++)
#define repr(i, a, b) for (int i = a; i < b; i++)
#define each(i, mp) for (auto &i : mp)
const int INF = 1001001001;
int main()
{
int a;
cin >> a;
ll ans = 0;
rep(i, 3) ans += pow(a, i + 1);
cout << ans << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N;
cin >> N;
vector<int> A(N);
for(int i = 0; i < N; i++){
cin >> A.at(i);
}
sort(A.begin(), A.end());
long long temp = 0, ans = 0;;
long long i = 0, num;
while(i < N){
temp = 0;
num = A.at(i);
while(i < N && A.at(i) == num){
temp++;
i++;
}
if(temp % 2 == 1){
ans++;
}
}
cout << ans << endl;
return 0;
} | #include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>
using namespace std;
#define MAX_N 100
#define MAX_EDGE_COST 20000
int Graph[MAX_N+1][MAX_N+1];
int n;
int prim(int initial_vertex) {
bool visited[n+1];
for(int i=1;i<=n;i++) visited[i] = false;
vector<int> vertexes;
vertexes.push_back(initial_vertex);
visited[initial_vertex] = true;
int total_edge_cost = 0;
while(vertexes.size() < n) {
// find minimum edge cost in vertexes
int minimum_edge_cost = MAX_EDGE_COST;
int next_v;
for(int i=0;i<vertexes.size();i++) {
int v = vertexes[i];
for(int j=1;j<=n;j++) {
if(!visited[j]) {
if(Graph[v][j] != -1) {
if(Graph[v][j] < minimum_edge_cost) {
minimum_edge_cost = Graph[v][j];
next_v = j;
}
}
}
}
}
visited[next_v] = true;
vertexes.push_back(next_v);
total_edge_cost += minimum_edge_cost;
}
return total_edge_cost;
}
int main() {
scanf("%d",&n);
for(int i=1;i<=n;i++) {
for(int j=1;j<=n;j++) {
scanf("%d ",&Graph[i][j]);
}
}
printf("%d\n",prim(1));
} | 0 |
#include<bits/stdc++.h>
#define tmp(x) std::cout<<"& "<<(x)<<" &\n"
#define rep(i,a,b) for(int i=(a);i<=(b);++i)
#define per(i,a,b) for(int i=(a);i>=(b);--i)
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define sz(x) ((int)x.size())
#define all(x) x.begin(),x.end()
typedef long long ll;
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vi vector<int>
using namespace std;
const int maxn=3e5+100;
const int inf=(int)1e9+7;
int n;
vector<pair<int,char> > x[maxn],y[maxn],le[2*maxn],ri[2*maxn];
int ans=inf;
void work(vi v1,vi v2,int aa){
if(!v2.empty()&&!v1.empty()){
vector<int>::iterator it1,it2;
sort(v2.begin(),v2.end());
sort(v1.begin(),v1.end());
it2=v2.begin(),it1=v1.begin();
for(auto p1:v1){
for(auto p2:v2){
if(p2<p1)continue;
else {
ans=min(ans,abs(p1-p2)*10/aa);
break;
}
}
}
/*while(*it1!=*v1.end()&&*it2!=*v2.end()){
while(*it2!=*v2.end()&&*it2<*it1)++it2;
if(*it2==*v2.end())break;
ans=min(ans,abs(*it1-*it2)*10/aa);
++it1;
}*/
}
}
int main(){
// freopen("in.txt","r",stdin);
scanf("%d",&n);
int xx,yy;char c;
rep(i,1,n){
scanf("%d%d %c",&xx,&yy,&c);
x[xx].push_back(make_pair(yy,c));
y[yy].push_back(make_pair(xx,c));
le[xx-yy+200000].push_back(make_pair(xx,c));
ri[xx+yy].push_back(make_pair(xx,c));
}
rep(i,0,200000){
if(!x[i].empty()){
vector<int>up,down;
for(auto p:x[i]){
if(p.second=='U')up.push_back(p.first);
if(p.second=='D')down.push_back(p.first);
}
work(up,down,2);
}
if(!y[i].empty()){
vector<int>right,left;
for(auto p:y[i]){
if(p.second=='R')right.push_back(p.first);
if(p.second=='L')left.push_back(p.first);
}
work(right,left,2);
}
}
rep(i,0,400000){
if(!le[i].empty()){
vector<int> right,down,left,up;
for(auto p:le[i]){
if(p.second=='D')down.push_back(p.first);
else if(p.second=='R')right.push_back(p.first);
else if(p.second=='U')up.push_back(p.first);
else if(p.second=='L')left.push_back(p.first);
}
work(right,down,1);
work(up,left,1);
}
if(!ri[i].empty()) {
vector<int> right, up,left, down;
for (auto p:ri[i]) {
if (p.second == 'U')up.push_back(p.first);
else if (p.second == 'R')right.push_back(p.first);
else if (p.second == 'D')down.push_back(p.first);
else if (p.second == 'L')left.push_back(p.first);
}
work(right, up,1);
work(down, left,1);
}
}
if(ans==inf)printf("SAFE");
else printf("%d",ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> P;
typedef pair<P,char> Q;
ll N;
vector<Q> v;
vector<vector<P>> V,H;
set<P> S;
vector<vector<ll>> LU,LD,RU,RD;
int main(){
cin >> N;
V.resize(200010);
H.resize(200010);
LU.resize(400010);
LD.resize(400010);
RU.resize(400010);
RD.resize(400010);
ll offset = 200000;
for(int i=0;i<N;i++){
ll x,y;
char u;
cin >> x >> y >> u;
v.push_back({{x,y},u});
}
for(auto &e : v){
ll x = e.first.first;
ll y = e.first.second;
if(S.find({x,y}) != S.end()){
cout << 0 << endl;
return 0;
}
S.insert({x,y});
}
for(auto &e : v){
ll x = e.first.first;
ll y = e.first.second;
if(e.second == 'U'){
V[x].push_back({y,0});
RU[x+y].push_back(x);
LU[x-y+offset].push_back(x);
}
if(e.second == 'D'){
V[x].push_back({y,1});
LD[x+y].push_back(x);
RD[x-y+offset].push_back(x);
}
if(e.second == 'R'){
H[y].push_back({x,0});
}
if(e.second == 'L'){
H[y].push_back({x,1});
}
}
ll ans = 1e18;
for(int i=0;i<=200000;i++) sort(V[i].begin(),V[i].end());
for(int i=0;i<=200000;i++) sort(H[i].begin(),H[i].end());
for(int i=0;i<=200000;i++){
ll tmp = -1;
for(auto &e : V[i]){
ll x = e.first;
ll d = e.second;
if(d == 0) tmp = x;
else{
if(tmp == -1) continue;
ans = min(ans, (x-tmp) * 5);
}
}
}
for(int i=0;i<=200000;i++){
ll tmp = -1;
for(auto &e : H[i]){
ll y = e.first;
ll d = e.second;
if(d == 0) tmp = y;
else{
if(tmp == -1) continue;
ans = min(ans, (y-tmp) * 5);
}
}
}
for(int i=0;i<=400000;i++) sort(LU[i].begin(),LU[i].end());
for(int i=0;i<=400000;i++) sort(LD[i].begin(),LD[i].end());
for(int i=0;i<=400000;i++) sort(RU[i].begin(),RU[i].end());
for(int i=0;i<=400000;i++) sort(RD[i].begin(),RD[i].end());
for(auto &e : v){
ll x = e.first.first;
ll y = e.first.second;
if(e.second == 'U'){
continue;
}
if(e.second == 'D'){
continue;
}
if(e.second == 'R'){
auto itr_d = upper_bound(RD[x-y+offset].begin(),RD[x-y+offset].end(),x);
if(itr_d != RD[x-y+offset].end()) ans = min(ans,((*itr_d) - x)*10);
auto itr_u = upper_bound(RU[x+y].begin(),RU[x+y].end(),x);
if(itr_u != RU[x+y].end()) ans = min(ans,((*itr_u) - x)*10);
}
if(e.second == 'L'){
auto itr_d = upper_bound(LD[x+y].begin(),LD[x+y].end(),x);
if(itr_d != LD[x+y].begin() && LD[x+y].size() != 0) ans = min(ans,(x - *(itr_d-1))*10);
auto itr_u = upper_bound(LU[x-y+offset].begin(),LU[x-y+offset].end(),x);
if(itr_u != LU[x-y+offset].begin() && LU[x-y+offset].size() != 0) ans = min(ans,(x - *(itr_u-1))*10);
}
}
if(ans == 1e18) cout << "SAFE" << endl;
else cout << ans << endl;
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, e) for (int i = (int)(s); i <= (int)(e); i++)
#define printYesNo(is_ok) puts(is_ok ? "Yes" : "No");
#define SORT(v) sort(v.begin(), v.end());
#define RSORT(v) sort(v.rbegin(), v.rend());
#define REVERSE(v) reverse(v.begin(), v.end());
template <typename T>
void printlnVector(T v)
{
rep(i, v.size())
{
cout << v[i] << endl;
}
}
template <typename T>
void printVector(T v)
{
rep(i, v.size())
{
cout << v[i] << " ";
}
cout << endl;
}
int main()
{
int N, H, W;
cin >> N >> H >> W;
H = max(0, N - H + 1);
W = max(0, N - W + 1);
int ans = H * W;
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = int64_t;
constexpr ll mod = ll(1e9 + 7);
int main () {
ios::sync_with_stdio(0); cin.tie(0);
int TT = 1;
// cin >> TT;
while (TT--) {
ll n,h,w;
cin >> n >> h >> w;
--h;
--w;
cout << max(ll(0), ((n-h)*(n-w))) << endl;
}
}
| 1 |
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#include <unordered_set>
#include <queue>
#include <set>
#include <iomanip>
#include <stack>
#define int long long
#define ld long double
#define dbg(x) cout <<#x<<":"<<x<<'\n';
#define dbg2(x,y) cout<<#x<<":"<<x<<' '<<#y<<":"<<y<<'\n';
#define endl '\n'
#define inf 1000000010
#define eps 1e-8l
using namespace std;
const int N=2e5+5;
std::vector<int> g[N],c(N),gd(N),p(N),r(N);
vector<bool> vis(N);
int power(int x,int y){int res = 1;while(y>0){if(y&1)res = (res*x);x = (x*x);y = y>>1;}return res;}
//int n,m;
int n,a,b,da,db,md,nd,m;
int const dpn=2e5+5;
int dp[dpn];
bool comp(pair<int,int> l,pair<int,int> r){
if(l.first!=r.first)
return (l.first<r.first);
return l.second>r.second;
}
int find(int i){
if(p[i]!=i)
return p[i]=find(p[i]);
return i;
}
void join(int x,int y){
int px=find(x);
int py=find(y);
if(r[px]>r[py])
p[py]=px;
else if(r[px]<r[py])
p[px]=py;
else
p[py]=px,r[px]++;
}
int32_t main(){
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
int t=1;
//cin>>t;
while(t--){
//int n;
//int n;
int d,t,s;
cin>>d>>t>>s;
if((double)d/(double)s<=(double)t)
cout<<"Yes\n";
else
cout<<"No\n";
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main () {
ios_base::sync_with_stdio(false);
cin.tie(0);
int d, t, s; cin >> d >> t >> s;
cout << (t * s >= d ? "Yes" : "No") << endl;
return 0;
}
| 1 |
// clang-format off
#include <bits/stdc++.h>
#define int long long
#define main signed main()
// #define main int main()
#define loop(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) loop(i, 0, n)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define prec(n) fixed << setprecision(n)
#define stlice(from, to) substr(from, (to) - (from) + 1)
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
using namespace std;
using pii = pair<int, int>;
using vi = vector<int>;
using vd = vector<double>;
using vc = vector<char>;
using vb = vector<bool>;
using vs = vector<string>;
using vpii = vector<pii>;
using vvi = vector<vi>;
using vvb = vector<vb>;
using vvpii = vector<vpii>;
template<typename A> using fn = function<A>;
constexpr int INF = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
constexpr int MOD = 1000000007;
constexpr double PI = acos(-1);
template<typename A, typename B> bool cmin(A &a, const B &b) { return a > b ? (a = b, true) : false; }
template<typename A, typename B> bool cmax(A &a, const B &b) { return a < b ? (a = b, true) : false; }
constexpr bool odd(const int &n) { return n & 1; }
constexpr bool even(const int &n) { return !odd(n); }
void solve();
main { solve(); return 0; }
// clang-format on
template<typename A>
using vpix = vector<pair<int, A>>;
vpix<char> u;
vpix<string> m;
int f(string s) {
int c = 0, l = 0;
for (int i = s.size() - 1; i >= 0; i--) {
for (auto p : u) {
if (s[i] == p.second) {
c += p.first * (l <= p.first ? 1 : -1);
l = p.first;
}
}
}
return c;
}
void solve() {
u.pb(mp(1000, 'M'));
u.pb(mp(500, 'D'));
u.pb(mp(100, 'C'));
u.pb(mp(50, 'L'));
u.pb(mp(10, 'X'));
u.pb(mp(5, 'V'));
u.pb(mp(1, 'I'));
string s;
while (cin >> s) cout << f(s) << endl;
} | #include "bits/stdc++.h"
#include <unordered_set>
#define REP(i, n) for(decltype(n) i = 0; i < (n); i++)
#define REP2(i, x, n) for(decltype(x) i = (x); i < (n); i++)
#define REP3(i, x, n) for(decltype(x) i = (x); i <= (n); i++)
#define RREP(i, n) for (decltype(n) i = (n) - 1; i >= 0; i--)
#define ALL(a) (a).begin(),(a).end()
#define SORT(c) sort((c).begin(),(c).end())
#define DESCSORT(c) sort(c.begin(), c.end(), greater<int>())
#define LL long long int
#define LD long double
#define INF 1000000000
#define PI 3.14159265358979323846
#define _CRT_SECURE_NO_WARNINGS
using namespace std;
// N, E, S, W
const int dx[4] = { -1, 0, 1, 0 };
const int dy[4] = { 0, 1, 0, -1 };
typedef pair<int, int> pii;
typedef pair<LL, LL> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<LL> vll;
//==============================================
vi A, G;
int cnt = 0;
int gSize;
void insertionSort(int n,int g) {
REP2(i, g, n) {
int v = A[i];
int j = i - g;
while (j >= 0 && A[j] > v) {
A[j + g] = A[j];
j -= g;
cnt++;
}
A[j + g] = v;
}
}
void shellSort(int n) {
int h = 1;
while (h <= n) {
G.push_back(h);
h = 3 * h + 1;
}
gSize = G.size();
RREP(i, gSize) {
insertionSort(n, G[i]);
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int tmp;
REP(i, n) cin >> tmp, A.push_back(tmp);
shellSort(n);
cout << gSize << "\n";
RREP(i, gSize) {
cout << G[i];
if (i)cout << " ";
}
cout << "\n";
cout << cnt << "\n";
REP(i, n) {
cout << A[i] << "\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
char s[100];
int main(){
scanf("%s", s+1);
if(strlen(s+1) == 3) reverse(s+1, s+1+strlen(s+1));
printf("%s", s+1);
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rrep(i, n) for (int i = 1; i < (int)(n+1); i++)
const long long INF = 1LL << 60;
int main(){
string S;
cin>>S;
int a=S.size();
if(a==2){
cout<<S<<endl;
}
else{
cout<<S[2]<<S[1]<<S[0]<<endl;
}
}
| 1 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int N, M;
cin >> N >> M;
vector<int> L(M), R(M);
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i];
}
int lmax = *max_element(L.begin(), L.end());
int rmin = *min_element(R.begin(), R.end());
int d = rmin - lmax + 1;
if (d < 0)
d = 0;
cout << d << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int,int> pii;
typedef int _loop_int;
#define REP(i,n) for(_loop_int i=0;i<(_loop_int)(n);++i)
#define FOR(i,a,b) for(_loop_int i=(_loop_int)(a);i<(_loop_int)(b);++i)
#define FORR(i,a,b) for(_loop_int i=(_loop_int)(b)-1;i>=(_loop_int)(a);--i)
#define DEBUG(x) cout<<#x<<": "<<x<<endl
#define DEBUG2(x,y) cout<<#x<<": "<<x<<" "<<#y<<": "<<y<<endl
#define DEBUG_VEC(v) cout<<#v<<":";REP(i,v.size())cout<<" "<<v[i];cout<<endl
#define DEBUG_ARR(v,n) cout<<#v<<":";REP(i,n)cout<<" "<<v[i];cout<<endl
#define ALL(a) (a).begin(),(a).end()
const ll MOD = 1000000007ll;
#define FIX(a) ((a)%MOD+MOD)%MOD
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>
void DEBUG_DP(T* viewdp, int ilen, int jlen){
REP(i,ilen){
REP(j,jlen){
if(viewdp[i][j] != -1)
printf("[% 4d]", viewdp[i][j]);
else
printf("[ ]");
}
puts("");
}
}
const int N=81;
const int C=6400;
const int K=C*2+1;
int h,w;
int a[N][N], b[N][N];
bitset<K> dp[N][N];
int ans = INT_MAX;
int main() {
ios::sync_with_stdio(false); cin.tie(0);
REP(i,N){
fill(a[i], a[i]+N, -1);
fill(b[i], b[i]+N, -1);
}
cin>>h>>w;
REP(i,h) REP(j,w) cin>>a[i][j];
REP(i,h) REP(j,w) cin>>b[i][j];
//int sx=0,sy=0, gx=w-1, gy=h-1;
dp[0][0][abs(a[0][0]-b[0][0]) + 6400]=true;
REP(i,h) REP(j,w){
int ab =abs(a[i+1][j]-b[i+1][j]);
dp[i+1][j] |= dp[i][j] << ab;
dp[i+1][j] |= dp[i][j] >> ab;
ab =abs(a[i][j+1]-b[i][j+1]);
dp[i][j+1] |= dp[i][j] << ab;
dp[i][j+1] |= dp[i][j] >> ab;
}
REP(i,K){
if(dp[h-1][w-1][i]) chmin(ans, abs(6400-i));
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long lli;
lli rec(int l, int r, vector<int> &A) {
if(r-l <= 1) return 0;
int m = (l+r)/2;
lli res = rec(l, m, A) + rec(m, r, A);
queue<int> a, b;
for(int i = l; i < m; ++i) a.push(A[i]);
for(int i = m; i < r; ++i) b.push(A[i]);
int k = l;
while(a.size() && b.size()) {
if(a.front() <= b.front()) {
A[k++] = a.front();
a.pop();
} else {
A[k++] = b.front();
b.pop();
res += a.size();
}
}
while(a.size()) {
A[k++] = a.front();
a.pop();
}
while(b.size()) {
A[k++] = b.front();
b.pop();
}
return res;
}
int main() {
int n;
vector<int> A;
cin >> n;
A.resize(n);
for(int i = 0; i < n; ++i) cin >> A[i];
cout << rec(0, n, A) << endl;
return 0;
} | #include <stdio.h>
void merge(int *,int,int,int);
void mergesort(int*,int,int);
long long cnt=0;
int L[100002],R[100002];
int main(){
int A[200000],i,n;
scanf("%d",&n);
for(i=0;i<n;i++)scanf("%d",&A[i]);
mergesort(A,0,n);
printf("%ld\n",cnt);
return 0;
}
void merge(int *a,int left,int mid,int right){
int i,k,j,n1=mid-left,n2=right-mid;
for(i=0;i<n1;i++){
L[i]=a[left+i];
}
for(i=0;i<n2;i++){
R[i]=a[mid+i];
}
L[n1]=2147483647;
R[n2]=2147483647;
i=0;
j=0;
for(k=left;k<right;k++){
if(L[i]<=R[j])a[k]=L[i++];
else{
a[k]=R[j++];
cnt+=n1-i;
}
}
return;
}
void mergesort(int *a,int left,int right){
int mid;
if(left+1<right){
mid=(left+right)/2;
mergesort(a,left,mid);
mergesort(a,mid,right);
merge(a,left,mid,right);
}
else return;
}
| 1 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <cstdio>
#include <string>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <cmath>
#include <functional>
#include <numeric>
#include <iomanip>
#define fi first
#define se second
#define fcout(n) cout<<fixed<<setprecision((n))
#define cinl(str) getline(cin,(str))
using namespace std;
bool value(int y,int x,int R,int C){return 0<=y&&y<R&&0<=x&&x<C;}
typedef pair<int,int> pii;
typedef long long ll;
typedef vector<int> vi;
typedef vector<long long > vll;
typedef vector< vi > vvi;
double pie=acos(-1);
int INF=10000009;
int dx[4] = { 0,-1,0,1 };
int dy[4] = { -1,0,1,0 };
int main() {
int day=0;
int x,y;
int md[12]={31,29,31,30,31,30,31,31,30,31,30,31};
string s[7]={"Wednesday","Thursday","Friday","Saturday","Sunday","Monday","Tuesday"};
while(true){
cin>>x>>y;
if(x==0) break;
for(int i=0;i<x-1;i++){
day+=md[i];
}
day+=y;
day%=7;
cout<<s[day]<<endl;
day=0;
}
} | #include <bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<(b);++i)
#define erep(i,a,b) for(int i=a;i<=(int)(b);++i)
#define per(i,a,b) for(int i=(b);i>(a);--i)
#define eper(i,a,b) for(int i=((int)(a));i>=b;--i)
#define pb push_back
#define mp make_pair
#define INF (1<<28)-1
#define MOD 1000000007
#define all(x) (x).begin(),(x).end()
using namespace std;
typedef long long ll;
typedef pair<int,int> Pii;
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a = b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a = b; return 1; } return 0; }
int dy[]={0, 0, 1, -1};
int dx[]={1, -1, 0, 0};
int gcd(int a,int b){return b?gcd(b,a%b):a;}
int lcm(int a,int b){return a/gcd(a, b)*b;}
int n, k;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while (true) {
cin >> n >> k;
if (n == 0 && k == 0) break;
vector<string> a(n);
map<string, bool> mm;
rep(i, 0, n) cin >> a[i];
sort(all(a));
do {
string sub = "";
rep(i, 0, k) sub += a[i];
mm[sub] = true;
} while (next_permutation(all(a)));
cout << mm.size() << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define precise(n,k) fixed << setprecision(k) << n
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define ld long double
const int MOD = int(1e9+7);
const int oo = int(1e9 + 20);
const ll lloo = (ll)(1e18 + 10);
template <typename T, class F = function<T(const T&, const T&)>>
class SegmentTree {
int NEUTRAL;
int n;
vector<int> tree;
F func;
public:
SegmentTree(vector<int> values, int neutral, const F& f) : func(f) {
NEUTRAL = neutral;
n = values.size();
tree.resize(n*2);
// Build
for (int i=0; i < n; i++){
tree[n+i] = values[i];
}
for (int i = n - 1; i > 0; --i) {
tree[i] = func(tree[i*2], tree[i*2+1]);
}
}
void update(int index, int value) {
tree[index+n] = value;
index = index + n;
for (int i = index; i > 1; i >>= 1){
tree[i/2] = func(tree[i], tree[i^1]);
}
}
int query(int l, int r) {
int ans = NEUTRAL;
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l&1) {
ans = func(ans, tree[l++]);
}
if (r&1) {
ans = func(ans, tree[--r]);
}
}
return ans;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
n++;
vector<int> val(n);
for(int i = 1; i < n; ++i) {
cin >> val[i];
}
SegmentTree<int> st(val, -oo, [&](int x, int y) -> int {return max(x, y);});
vector<bool> visited(n, false);
int colors = 0;
int last;
for(int i = 1; i < n; ++i) {
if(!visited[i]) {
colors++;
last = val[i];
visited[i] = true;
st.update(i, -oo);
if(st.query(i+1, n) <= last) continue;
for(int j = i + 1; j < n; ++j) {
if(!visited[j] && last < val[j]) {
last = val[j];
visited[j] = true;
st.update(j, -oo);
if(st.query(j+1, n) <= last) break;
}
}
}
}
cout << colors << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
ll dp[5009];
ll a[5000];
int main()
{
ll n;ll ans=0;
multiset<ll>s;cin>>n;
for(int i=0;i<n;i++){
ll x;cin>>x;
if(s.size()==0){
s.insert(x);
ans++;
}
else
{
auto z=s.begin();
if(*z>=x){
s.insert(x);ans++
; }else{
auto it=s.lower_bound(x);it--;
s.erase(s.find(*it));
s.insert(x);
}
}
}cout<<ans;
} | 1 |
#include <iostream>
#include <string>
using namespace std;
int next_turn(char c) {
return int(c) - int('a');
}
int main()
{
string S[3];
cin >> S[0] >> S[1] >> S[2];
int pos[3] = {0};
int turn = 0;
for (;;) {
if (pos[turn] >= S[turn].length()) {
cout << char(int('A')+turn) << endl;
break;
}
int next = next_turn(S[turn][pos[turn]]);
pos[turn]++;
turn = next;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main(){
vector<queue<char>> s(3);
for(int ix=0;ix<3;ix++){
string tmp;
cin >> tmp;
for(int ixx=0;ixx<tmp.size();ixx++) s.at(ix).push(tmp.at(ixx));
}
char card;
int turnplayer = 0;
while(!s.at(turnplayer).empty()){
card = s.at(turnplayer).front();
s.at(turnplayer).pop();
turnplayer = card - 'a';
}
if(turnplayer == 0) cout << "A" << endl;
if(turnplayer == 1) cout << "B" << endl;
if(turnplayer == 2) cout << "C" << endl;
} | 1 |
#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
#define MP make_pair
#define PII pair<int, int>
#define PLL pair<ll, ll>
#define PLI pair<ll, int>
#define PIL pair<int, ll>
#define STR string
#define Fst first
#define Snd second
#define SHN 1e9
#define LSHN 1e18
using namespace std;
ll md=2038077799,mul=1400312813;
int n;
ll ai[200010],bi[200010],a[200010],b[200010];
vector<int> v;
ll hasha,hashb,etc;
ll ksm(int x)
{
if (!x) return 1ll;
return (((ksm(x/2)*ksm(x/2))%md)*(x%2 ? mul : 1))%md;
}
int main()
{
cin >>n;
for (int i=0;i<n;i++) cin >>ai[i];
for (int i=0;i<n;i++) cin >>bi[i];
for (int i=0;i<n;i++) a[i]=ai[i]^ai[(i+1)%n],b[i]=bi[i]^bi[(i+1)%n];
etc=ksm(n-1);
for (int i=0;i<n;i++)
{
hasha=(((hasha*mul)%md)+a[i])%md;
hashb=(((hashb*mul)%md)+b[i])%md;
}
for (int i=0;i<n;i++)
{
if (hasha==hashb) v.push_back(i);
hasha=(hasha+md-((a[i]*etc)%md))%md;
hasha=(((hasha*mul)%md)+a[i])%md;
}
for (int i=0;i<v.size();i++) cout <<v[i]<<" "<<(ai[v[i]]^bi[0])<<"\n";
return 0;
} | #include <bits/stdc++.h>
#define ll long long int
#define ld long double
const ll MOD = 998244353;
const ll INF = 1e18;
using namespace std;
ll dp[1 << 20], pre[1 << 20];
main(){
#ifdef XOX
freopen("D:\\V S Code\\cpp\\competitiveProgramming\\Input.txt", "r", stdin);
freopen("D:\\V S Code\\cpp\\competitiveProgramming\\OPT.txt", "w", stdout);
#endif
ios::sync_with_stdio(!cin.tie(NULL));
int n;
cin >> n;
memset(dp, 0, sizeof(dp));
memset(pre, 0, sizeof(pre));
ll tmp, mask;
for(int i = 0; i < n; i++){
for(int j = 0; j < n; j++){
cin >> tmp;
mask = (1 << i)|(1 << j);
dp[mask] += tmp;
}
}
for(int i = 0; i < n; i++){
for(int mask = 0; mask < (1 << n); mask++){
if(mask&(1 << i)) dp[mask] += dp[mask^(1 << i)];
}
}
for(int mask = 0; mask < (1 << n); mask++){
pre[mask] = dp[mask];
for(int sub = mask; sub; sub = (sub - 1)&mask){
pre[mask] = max(pre[mask], pre[sub] + dp[mask^sub]);
}
}
cout << pre[(1 << n) - 1] / 2;
} | 0 |
#include <bits/stdc++.h>
#include<unordered_map>
using namespace std;
using VS = vector<string>; using LL = long long;
using VI = vector<int>; using VVI = vector<VI>;
using PII = pair<int, int>; using PLL = pair<LL, LL>;
using VL = vector<LL>; using VVL = vector<VL>;
#define ALL(a) begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i, s, e) for (int(i) = (s); (i) < (e); (i)++)
#define FORR(i, s, e) for (int(i) = (s); (i) > (e); (i)--)
//#pragma GCC optimize ("-O3")
#ifdef YANG33
#include "mydebug.hpp"
#else
#define DD(x)
#endif
const int INF = 1e9; const LL LINF = 1e16;
const LL MOD = 1000000007; const double PI = acos(-1.0);
int DX[8] = { 0, 0, 1, -1, 1, 1, -1, -1 }; int DY[8] = { 1, -1, 0, 0, 1, -1, 1, -1 };
/* ----- __MAKE_TIME__ Problem: __PROBLEM__ / Link: __CONTEST_URL__ ----- */
/* ------問題------
-----問題ここまで----- */
/* -----解説等-----
----解説ここまで---- */
struct UnionFind {
vector<int> data;
UnionFind() {}
UnionFind(int n) { data.assign(n, -1); }
bool unionSet(int x, int y) {
x = root(x); y = root(y);
if (x != y) {
if (data[y] < data[x]) swap(x, y);
data[x] += data[y]; data[y] = x;
}
return x != y;
}
bool same(int x, int y) { return root(x) == root(y); }
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
int size(int x) { return -data[root(x)]; }
void initV(int x) { data[x] = -1; }
};
UnionFind uf(1e5);
vector<vector<PII>> f(const vector<PII>&edge) {
for (const auto& it : edge) {
uf.initV(it.first);
uf.initV(it.second);
}
for (const auto& it : edge) {
uf.unionSet(it.first, it.second);
}
int rootid = 0;
unordered_map<int, int>roots; // mapでもたいしてかわらない
for (const auto& it : edge) {
if (roots.find(uf.root(it.first)) == roots.end()) {
roots[uf.root(it.first)] = rootid++;
}
}
vector<vector<PII>>res(rootid);
for (const auto& it : edge) {
res[roots[uf.root(it.first)]].push_back(it);
}
return res;
}
VI Dijkstra(vector<vector<PII>>& G, int s) {// BFS
VI dist(SZ(G), INF);
dist[s] = 0;
queue<PII> que;
que.push(PII(0, s));
while (!que.empty()) {
PII p = que.front(); que.pop();
int v; /* 頂点*/ int d; /* 頂点vまでの距離 */
tie(d, v) = p;
FOR(i, 0, (int)G[v].size()) {
int nv = G[v][i].first;
if (dist[nv] > dist[v] + G[v][i].second) {
dist[nv] = dist[v] + G[v][i].second;
que.push(PII(dist[nv], nv));
}
}
}
return dist;
}
int read() { int in; scanf("%d", &in); return in; }
const int Max = 1e6;
vector<PII>Cedge[Max];
int main() {
LL N = read(), M = read();
FOR(i, 0, M) {
int p = read() - 1, q = read() - 1, c = read() - 1;
Cedge[c].push_back(PII(p, q));
}
vector<vector<PII>>G(N + M);
int cid = N;
FOR(c, 0, 1e6) {
auto res = f(Cedge[c]);
for (auto subedges : res) {
for (auto e : subedges) {
G[cid].push_back(PII(e.first, 1));
G[e.first].push_back(PII(cid, 1));
G[cid].push_back(PII(e.second, 1));
G[e.second].push_back(PII(cid, 1));
}
cid++;
}
}
auto res = Dijkstra(G, 0);
LL ans = res[N - 1] / 2;
if (ans == INF / 2)ans = -1;
cout << ans << "\n";
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
#include <math.h>
#include <set>
#include <map>
#include <string>
#include <stack>
#include <queue>
#include <iomanip>
#include <numeric>
#include <tuple>
#include <bitset>
#include <complex>
#include <unistd.h>
#include <cassert>
#include <cctype>
#include <random>
#include <time.h>
#define _USE_MATH_DEFINES
#define _GLIBCXX_DEBUG
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> plglg;
typedef pair<double, ll> pdlg;
typedef tuple<int, int, int> tiii;
typedef tuple<ll, ll, ll> tlglglg;
typedef tuple<double, double, double> tddd;
typedef complex<double> xy_t;
typedef vector<ll> vll;
typedef vector< vector<ll> > matrix;
#define REP(i, x, y) for(ll i = (ll)x; i < (ll)y; i++)
#define DREP(i, x, y, d) for(ll i = (ll)x; i < (ll)y; i += (ll)d)
#define PER(i, x, y) for(ll i = (ll)x; i > (ll)y; i--)
#define DPER(i, x, y, d) for(ll i = (ll)x; i > (ll)y; i -= (ll)d)
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
double pi = 3.141592653589793;
ll mod = 1000000007;
int intmax = 2147483647;
int intmin = -2147483648;
ll llmax = 9223372036854775807;
ll llmin = -9223372036854775807;
int iinf = intmax / 8;
ll inf = llmax / 8;
double eps = 1e-12;
struct edge {
ll to, cost;
};
int V;
vector<edge> G[1000000];
vector<edge> G2[1000000];
ll d[1000000];
void addedge(int st, int ed, ll co) {
edge e;
e.to = ed;
e.cost = co;
G[st].push_back(e);
}
void addedge2(int st, int ed, ll co) {
edge e;
e.to = ed;
e.cost = co;
G2[st].push_back(e);
}
ll ptlab[3000000];
map<plglg, ll> mp;
void BFS01(int n) {
fill(d, d + V, llmax);
deque<int> que;
d[n] = 0;
que.push_front(n);
while (que.size() > 0) {
int base = que.front();
que.pop_front();
int s = G[base].size();
for (int i = 0; i < s; i++) {
edge e = G[base][i];
if (e.cost == 1 && d[e.to] > d[base] + 1) {
d[e.to] = d[base] + 1;
que.push_back(e.to);
} else if (e.cost == 0 && d[e.to] > d[base]) {
d[e.to] = d[base];
que.push_front(e.to);
}
}
}
}
int main() {
ll N, M;
cin >> N >> M;
ll p[M], q[M], c[M];
REP(i, 0, M) {
cin >> p[i] >> q[i] >> c[i];
addedge2(p[i] - 1, q[i] - 1, c[i]);
addedge2(q[i] - 1, p[i] - 1, c[i]);
}
REP(i, 0, N) {
mp[plglg(i, -1)] = i;
ptlab[i] = i;
}
ll pt = N;
REP(i, 0, N) {
REP(j, 0, G2[i].size()) {
edge e = G2[i][j];
if (mp.count(plglg(e.to, e.cost)) == 0) {
mp[plglg(e.to, e.cost)] = pt;
ptlab[pt] = e.to;
pt++;
}
}
}
V = pt;
REP(i, N, pt) {
ll label = ptlab[i];
addedge(label, i, 1);
}
REP(i, 0, N) {
REP(j, 0, G2[i].size()) {
edge e = G2[i][j];
if (mp.count(plglg(i, e.cost)) == 1) {
addedge(mp[plglg(i, e.cost)], mp[plglg(e.to, e.cost)], 0);
}
addedge(mp[plglg(e.to, e.cost)], ptlab[e.to], 0);
}
}
BFS01(0);
ll ans = d[N - 1];
if (ans != llmax) {
cout << ans << endl;
} else {
cout << -1 << endl;
}
}
| 1 |
#include<iostream>
#include<string>
using namespace std;
int main(){
int n, k[100], x, i, j;
string sta="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", s;
while(cin>>n, n){
for(i=0;i<n;i++) cin>>k[i];
cin>>s;
for(i=0;i<s.size();i++){
for(j=0;j<56;j++){
if(s[i]==sta[j]){
x=j-k[i%n];
if(x<0){
x+=52;
break;
}else break;
}
}
cout<<sta[x];
}
cout<<endl;
}
return 0;
} | // King's Inspection
#include <iostream>
#include <cstring>
#include <vector>
#include <cstdio>
using namespace std;
int main() {
int n;
int now=0;
int k[102];
string station;
string ans;
string alpha = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
while(1) {
// Input
cin>>n;
if(n == 0) {
break;
}
for(int i=0; i<n; i++) {
cin>>k[i];
}
cin.ignore();
// Output
now = 0;
getline(cin, station);
for(int i=0; i<station.length(); i++) {
int tmp;
tmp = alpha.find(station[i]);
ans[i] = alpha[(tmp-k[now]+52)%52];
now++;
if(now == n) {
now = 0;
}
}
for(int i=0; i<station.length(); i++) {
cout<<ans[i];
}
cout<<endl;
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, q, a, b;
scanf("%d%d%d%d", &n, &q, &a, &b);
a--, b--;
vector<int> x(q);
for (int i = 0; i < q; ++i) {
scanf("%d", &x[i]);
x[i]--;
}
constexpr int64_t kInf = 1'000'000'000'000'000'000;
vector<int64_t> dp(n, kInf);
vector<int64_t> pref(n + 1, kInf), suff(n + 1, kInf);
auto Modify = [&](int p, int64_t v, vector<int64_t> &fw) {
for (int i = p + 1; i <= n; i += i & -i) fw[i] = min(fw[i], v);
};
auto Query = [&](int p, const vector<int64_t> &fw) {
int64_t res = kInf;
for (int i = p + 1; i > 0; i -= i & -i) res = min(res, fw[i]);
return res;
};
int64_t sum = 0;
dp[a] = 0;
Modify(a, -a, pref);
Modify(n - 1 - a, a, suff);
for (int i = 0, v = b; i < q; ++i) {
int64_t res = min(Query(x[i], pref) + x[i], Query(n - 1 - x[i], suff) - x[i]) + sum;
sum += abs(x[i] - v);
dp[v] = min(dp[v], res - sum);
Modify(v, dp[v] - v, pref);
Modify(n - 1 - v, dp[v] + v, suff);
v = x[i];
}
int64_t ans = *min_element(dp.begin(), dp.end()) + sum;
cout << ans << "\n";
return 0;
}
| #include<iostream>
#include<vector>
using namespace std;
using ll = long long;
int main(){
int n,k;
cin>>n>>k;
vector<int> x(n);
for(int i=0;i<n;i++) cin>>x[i];
ll ans=1e10;
for(int i=0;i+k<=n;i++){
ll l=abs(x[i])+abs(x[i+k-1]-x[i]);
ll r=abs(x[i+k-1])+abs(x[i+k-1]-x[i]);
ans=min(ans,min(l,r));
}
cout<<ans<<endl;
} | 0 |
#include<stdio.h>
int main(){
int N;
long long int result = 0;
scanf("%d", &N);
for(int i = 1 ; i <= N ; i++){
if(i % 3!=0 && i % 5 !=0){
result += i;
}
}
if(result > 266666333332){
printf("266666333332");
}else{
printf("%lld", result);
}
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll n;
cin >> n;
vector<ll> a(n);
ll minus=0;
bool allplus=false;
ll abs_tot=0;
ll abs_min = pow(10,9);
for(int i=0; i<n; i++){
cin >> a.at(i);
if(a.at(i)==0)allplus=true;
if(a.at(i)<0)minus++;
abs_tot += abs(a.at(i));
abs_min=min(abs_min, abs(a.at(i)));
}
if(minus%2==0) allplus=true;
if(allplus) cout << abs_tot << endl;
else cout << abs_tot - 2*abs_min << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int p, q, r; cin >> p >> q >> r;
int m = max(p, max(q, r));
int ans = p + q + r - m;
cout << ans << endl;
}
| #include <bits/stdc++.h>
using namespace std;
//#define LOCAL
#define fastIO ios::sync_with_stdio(0), cin.tie(0)
#define endl '\n'
#define forn(i,a,b) for(ll i=a;i<b;i++)
#define ft first
#define sd second
#define sz size()
#define pb push_back
#define pob pop_back()
#define pf push_front
#define pof pop_front()
#define all(x) (x).begin(), (x).end()
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<char,char> pcc;
typedef pair<double,double> pdd;
typedef pair<long long,long long> pll;
//cout << fixed << setprecision(12) <<x<<endl;
int main(){
fastIO;
#ifdef LOCAL
freopen("in.txt", "r", stdin);
#endif
int a[3];
int sum=0;
forn(i,0,3){ cin>>a[i];
sum+=a[i];
}
sort(a,a+3);
cout<<sum-a[2]<<endl;
}
| 1 |
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define repi(i,a,b) for(ll i=(a);i<(b);++i)
#define rep(i,a) repi(i,0,a)
#define repdi(i,a,b) for(ll i=(a)-1;i>=(b);--i)
#define repd(i,a) repdi(i,a,0)
#define itr(it,a) for( auto it = (a).begin(); it != (a).end(); ++it )
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
using ll = long long;
using P = std::pair<ll, ll>;
constexpr ll INF = 1ll<<60;
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; }
template<class S, class T>
std::ostream& operator<< ( std::ostream& out, const std::pair<S,T>& a )
{ std::cout << '(' << a.first << ", " << a.second << ')'; return out; }
template<class T>
std::ostream &operator<< ( std::ostream& out, const std::vector<T>& a )
{ std::cout << '['; rep( i, a.size() ){ std::cout << a[i]; if( i != a.size()-1 ) std::cout << ", "; } std::cout << ']'; return out; }
ll A, B, M;
ll a[100010], b[100010];
ll mi = INF;
std::vector<P> cost[100010];
int main()
{
std::cin >> A >> B >> M;
rep( i, A )
std::cin >> a[i];
rep( i, B )
std::cin >> b[i], chmin( mi, b[i] );
rep( i, M ) {
ll x, y, c;
std::cin >> x >> y >> c;
--x; --y;
cost[x].emplace_back( y, c );
}
ll ans = INF;
rep( i, A ) {
chmin( ans, a[i]+mi );
for( auto p : cost[i] )
chmin( ans, a[i]+b[p.first]-p.second );
}
std::cout << ans << std::endl;
return 0;
} | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
#define int long long
int hmt() {int x=0;int c=getchar(),n=0;for(;!isdigit(c);c=getchar()) n=(c=='-');for(;isdigit(c);c=getchar()) x=x*10+c-'0';if(n) x=-x;return x;}
#define in hmt()
#define ins ({string x;char c=getchar();for(;c==' '||c=='\n';c=getchar());for(;c!=' '&&c!='\n';c=getchar()) x+=c;x;})
#define forinc(i,a,b) for(int i=a,_b=b;i<=_b;++i)
#define fordec(i,a,b) for(int i=a;i>=b;--i)
#define forb(i,BS) for(int i=BS._Find_first();i< BS.size();i = BS._Find_next(i))
#define forv(a,b) for(auto &a:b)
#define pb push_back
#define pii pair<int,int>
#define fi first
#define se second
#define all(a) a.begin(),a.end()
#define reset(f,x) memset(f,x,sizeof(f))
#define bit(x,i) ((x>>(i-1))&1)
#define onbit(x,i) (x|(1<<(i-1)))
#define offbit(x,i) (x&~(1<<(i-1)))
const int N=200010;
int n,Q,A,B,a[N],oo,s[N],f[N],ans;
struct bit
{
int t[N];
void rs()
{
reset(t,127);oo=t[0];
}
void upd(int i,int x)
{
for(;i<=n;i+=i&-i) t[i]=min(t[i],x);
}
int get(int i)
{
int g=oo;
for(;i;i-=i&-i) g=min(g,t[i]);
return g;
}
}T[2];
void add(int i,int x)
{
T[0].upd(i,x-i);
T[1].upd(n-i+1,i+x);
}
main()
{
//freopen("C.inp","r",stdin);
n=in,Q=in,A=in,B=in;
forinc(i,1,Q) a[i]=in;
forinc(i,2,Q) s[i]=s[i-1]+abs(a[i]-a[i-1]);
T[0].rs();T[1].rs();
add(B,abs(A-a[1]));
add(A,abs(B-a[1]));
ans=s[Q]+min(abs(A-a[1]),abs(B-a[1]));
forinc(i,2,Q)
{
f[i]=min(T[0].get(a[i])+a[i],T[1].get(n-a[i]+1)-a[i])+s[i-1];
add(a[i-1],f[i]-s[i]);
ans=min(ans,f[i]+s[Q]-s[i]);
}
cout<<ans<<"\n";
}
| 0 |
#include <bits/stdc++.h>
#include <iostream>
#include <ctime>
using namespace std;
#define _LL long long
#define rep(i, n) for (_LL i = 0; i < (_LL)(n); i++)
#define vecrep(itr, v) for (auto itr = (v).begin(); itr != (v).end(); itr++)
#define SEARCHED_NODE 2
#define START_NODE 1
#define ROUTE_NODE 1
#define INIT_NODE 0
int _flag[1000];
vector<vector<int>> *_edge;
vector<int> *_invloop;
vector<int> *_nextinvloop;
int _startnode;
bool search(int c, int p)
{
if( _flag[c] == SEARCHED_NODE) return false;
_flag[c] = ROUTE_NODE;
vecrep(itr, (*_edge)[c])
{
if( _flag[*itr] == ROUTE_NODE )
{
_flag[*itr] = START_NODE;
_invloop->push_back(c);
return true;
}
}
vecrep(itr, (*_edge)[c])
{
if( search(*itr, c) )
{
if( _flag[*itr] != ROUTE_NODE )
{
_flag[*itr] = INIT_NODE;
}
else
{
_invloop->push_back(c);
}
return true;
}
}
_flag[c] = SEARCHED_NODE;
return false;
}
pair<int, int> checkloop()
{
int ls = _invloop->size();
rep(i, ls)
{
int next = i - 1;
if( next < 0 ) next = ls + next;
int node = (*_invloop)[i];
int nextnode = (*_invloop)[next];
vecrep(itr, (*_edge)[node])
{
if( _flag[*itr] == ROUTE_NODE && *itr != nextnode ) return make_pair(node, *itr);
}
}
return make_pair(-1, -1);
}
void resetflag(int n)
{
rep(j, n) _flag[j] = 0;
vecrep(itr, (*_invloop)) _flag[*itr] = ROUTE_NODE;
}
void newloop(int s, int e)
{
int loopindex = 0;
while((*_invloop)[loopindex] != s ) loopindex++;
_nextinvloop->clear();
while((*_invloop)[loopindex] != e )
{
_nextinvloop->push_back((*_invloop)[loopindex]);
loopindex = (loopindex + 1) % _invloop->size();
}
_nextinvloop->push_back(e);
swap(_invloop, _nextinvloop);
}
int main()
{
int n, m; cin >> n >> m;
vector<vector<int>> edge(n);
_edge = &edge;
#if 1
rep(i, m)
{
int a, b; cin >> a >> b; a--; b--;
edge[a].push_back(b);
}
#else
rep(i, m)
{
int a, b; cin >> a >> b; a--; b--;
edge[0].push_back(i + 1);
}
#endif
vector<int> invloop; _invloop = &invloop;
vector<int> nextinvloop; _nextinvloop = &nextinvloop;
rep(j, n) _flag[j] = INIT_NODE;
rep(i, n)
{
if( search(i, -1) )
{
while( true )
{
resetflag(n);
pair<int, int> ret = checkloop();
if( ret.first < 0 ) break;
newloop(ret.first, ret.second);
}
sort(_invloop->begin(), _invloop->end());
cout << _invloop->size() << endl;
vecrep(itr, *_invloop) cout << *itr + 1 << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
} | #include <stdio.h>
#include <algorithm>
#include <tuple>
#include <vector>
#include <queue>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int n, m;
vector<int> e[1010];
int v[1010], last[1010];
vector<int> r(2000, 0);
void bfs(int node) {
queue<int> q;
for (int x : e[node])
q.emplace(x), v[x] = last[x] = node;
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int x : e[cur])
if (v[x] != node)
q.emplace(x), v[x] = node, last[x] = cur;
}
if (v[node] != node)
return;
int pop = node;
vector<int> path;
path.emplace_back(node);
while (last[pop] != node) {
path.emplace_back(last[pop]);
pop = last[pop];
}
if (path.size() < r.size())
r.swap(path);
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d %d", &a, &b);
e[a].emplace_back(b);
}
for (int i = 1; i <= n; i++)
bfs(i);
if (n < r.size())
printf("-1\n");
else {
printf("%d\n", r.size());
for (int v : r)
printf("%d\n", v);
}
} | 1 |
#include<iostream>
#include<stdio.h>
#include<string>
#include<math.h>
#include<iomanip>
#include<algorithm>
#include<string.h>
#include<cctype>
#include<map>
#include<set>
#include<vector>
#include<sstream>
#include<stack>
#include<queue>
#include<deque>
#include<functional>
#include<utility>
using namespace std;
const int MAX_V=100+5;
const int INF=100000000;
int main()
{
int graph[2][MAX_V][MAX_V];
int path,V;
while(cin>>path>>V&&(path||V))
{
for(int m=0;m<2;m++)
{
for(int i=0;i<V;i++)
{
for(int j=0;j<V;j++)
{
if(i==j) graph[m][i][j]=0;
else graph[m][i][j]=INF;
}
}
}
while(path--)
{
int p,q;
int cost,time;
cin>>p>>q>>cost>>time;
graph[0][p-1][q-1]=cost;
graph[1][p-1][q-1]=time;
graph[0][q-1][p-1]=cost;
graph[1][q-1][p-1]=time;
}
for(int m=0;m<2;m++)
{
for(int k=0;k<V;k++)
{
for(int i=0;i<V;i++)
{
for(int j=0;j<V;j++)
{
graph[m][i][j]=min(graph[m][i][j],graph[m][i][k]+graph[m][k][j]);
}
}
}
}
int que;
cin>>que;
while(que--)
{
int start,end,type;
cin>>start>>end>>type;
cout<<graph[type][start-1][end-1]<<endl;
}
}
//while(1);
return 0;
}
| #include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int n,m;
for(;;){
scanf("%d%d",&n,&m);
if(n==0&&m==0)break;
vector<int> ns(n+1);
for(int i=0;i<n;i++){
scanf("%d",&ns[i]);
}
ns[n]=0;
vector<int> ntwos;
for(int i=0;i<n+1;i++){
for(int j=i;j<n+1;j++){
ntwos.push_back(ns[i]+ns[j]);
}
}
sort(ntwos.begin(),ntwos.end());
int ma=0;
for(int i=0;i<ntwos.size();i++){
vector<int>::iterator it;
if((it=upper_bound(ntwos.begin(),ntwos.end(),m-ntwos[i]))!=ntwos.begin()){
ma=max(ma,ntwos[i]+*(it-1));
}
}
printf("%d\n",ma);
}
} | 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;
auto const inf = numeric_limits<ll>::max()/4;
using Weight = ll;
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>;
vector<Weight> dijkstra(const Graph &g, int s){
const Weight inf = numeric_limits<Weight>::max()/4;
typedef tuple<Weight,int> State;
priority_queue<State> q;
vector<Weight> dist(g.size(), inf);
dist[s] = 0; q.emplace(0,s);
while (q.size()) {
Weight d; int v;
tie(d,v) = q.top(); q.pop(); d *= -1;
/* if(v == t) return d; */
if (dist[v] < d) continue;
for(auto & e : g[v]){
if (dist[e.dst] > dist[v] + e.weight) {
dist[e.dst] = dist[v] + e.weight;
q.emplace(-dist[e.dst], e.dst);
}
}
}
return dist;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(0);
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);
}
vector<Weight> dist = dijkstra(g,r);
for(int i = 0; i < (int)dist.size(); i++){
if(dist[i] == inf) cout << "INF";
else cout << dist[i];
cout << endl;
}
}
} |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,x) for(int i = 0;i < x;++i)
#define FOR(i,x,y) for(int i = x;i < y;++i)
#define ALL(a) a.begin(),a.end()
using ll = long long;
int v,e,r;
struct edge
{
int to,cost;
};
vector<edge>graph[114514];
using P = pair<int,int>;
const int INF = 1234567890;
int dist[114514];
void dijkstra()
{
fill(dist,dist+114514,INF);
dist[r] = 0;
priority_queue<P,vector<P>,greater<P>>que;
que.push({0,r});
while(!que.empty())
{
P p = que.top(); que.pop();
int ds = p.first;
int now = p.second;
if(dist[now] < ds)continue;
for(auto& ed : graph[now])
{
if(dist[ed.to] > dist[now] + ed.cost)
{
dist[ed.to] = dist[now] + ed.cost;
que.push({dist[ed.to],ed.to});
}
}
}
}
int main()
{
cin >> v >> e >> r;
REP(i,e)
{
int s,t,d;
cin >> s >> t >> d;
graph[s].push_back({t,d});
}
dijkstra();
REP(i,v)
{
int dd = dist[i];
if(dd >= INF)
{
cout << "INF" << endl;
}
else
{
cout << dd << endl;
}
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
typedef int64_t Int;
#define all(x) (x).begin(), (x).end()
const double EPS = 1e-10;
const Int INF = 1e18;
const int inf = 1e9;
const Int mod = 1e9+7;
bool print_space_enable = false;
void print() {
cout << '\n';
print_space_enable = false;
}
template <class Head, class... Tail>
void print(Head&& head, Tail&&... tail) {
if (print_space_enable) cout << " ";
cout << fixed << setprecision(15) << head;
print_space_enable = true;
print(std::forward<Tail>(tail)...);
}
template<typename T>
void print(vector<T> v) {
for (size_t i = 0; i < v.size(); i++) {
if (i > 0) std::cout << " ";
std::cout << v[i];
}
std::cout << std::endl;
}
int main() {
Int n, m, q;
cin >> n >> m >> q;
vector<pair<Int, Int>> a(m);
for (Int i = 0; i < m; i++) {
cin >> a[i].first >> a[i].second;
a[i].first--, a[i].second--;
}
vector<pair<Int, Int>> b(q);
for (Int i = 0; i < q; i++) {
cin >> b[i].first >> b[i].second;
b[i].first--, b[i].second--;
}
vector<vector<Int>> v(n);
for (Int i = 0; i < m; i++) {
v[a[i].first].push_back(a[i].second);
}
for (Int i = 0; i < n; i++) {
sort(all(v[i]));
v[i].push_back(INF);
}
for (Int i = 0; i < q; i++) {
Int res = 0;
for (Int j = 0; j < n; j++) {
if (j < b[i].first) continue;
if (b[i].second < j) break;
res += upper_bound(all(v[j]), b[i].second) - v[j].begin();
}
print(res);
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
template<typename T>
struct Dijkstra {
explicit Dijkstra(size_t size) : size(size), G(size) {}
struct edge {
edge(int to, T cost) : to(to), cost(cost) {}
int to;
T cost;
};
using P = pair<T, int>;
const T inf = numeric_limits<T>::max();
size_t size;
vector<vector<edge>> G;
vector<T> d;
void add_edge(int u, int v, T c) {
G[u].push_back(edge(v, c));
}
void build(int s) {
d.assign(size, inf);
priority_queue<P, vector<P>, greater<>> q;
d[s] = 0;
q.push(P(0, s));
while (!q.empty()) {
P p = q.top();
q.pop();
int v = p.second;
if (d[v] < p.first) continue;
for (auto &e : G[v])
if (d[e.to] > p.first + e.cost) {
d[e.to] = p.first + e.cost;
q.push(P(d[e.to], e.to));
}
}
}
T operator[](int v) {
return d[v];
}
};
int main() {
int V, E, r;
cin >> V >> E >> r;
auto g = Dijkstra<int>(V);
for (int i = 0; i < E; ++i) {
int s, t, c;
cin >> s >> t >> c;
g.add_edge(s, t, c);
}
g.build(r);
for (int i = 0; i < V; ++i) {
if (g[i] != g.inf) {
cout << g[i] << endl;
} else {
cout << "INF" << endl;
}
}
return 0;
}
| 0 |
#include <iostream>
#include <stdio.h>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <queue>
#include <algorithm>
#include <set>
#include <math.h>
#include <utility>
#include <stack>
#include <string.h>
using namespace std;
typedef pair<int,int> P;
const int INF = ~(1<<31) / 2;
int c[100][100];
int t[100][100];
int n,m,k;
int main(){
while(1){
scanf("%d %d",&n,&m);
if(n==0) break;
for(int i=0;i<m;i++){
for(int j=0;j<m;j++){
c[i][j] = 1000000;
t[i][j] = 1000000;
}
}
for(int i=0;i<n;i++){
int a,b,co,ti;
scanf("%d %d %d %d",&a,&b,&co,&ti);
a--;b--;
c[a][b] = co;
c[b][a] = co;
t[a][b] = ti;
t[b][a] = ti;
}
for(int k=0;k<m;k++){
for(int i=0;i<m;i++){
for(int j=0;j<m;j++){
c[i][j] = min(c[i][j],c[i][k]+c[k][j]);
t[i][j] = min(t[i][j],t[i][k]+t[k][j]);
}
}
}
scanf("%d",&k);
for(int i=0;i<k;i++){
int p,q,r;
scanf("%d %d %d",&p,&q,&r);
p--;q--;
if(r)printf("%d\n",t[p][q]);
else printf("%d\n",c[p][q]);
}
}
return 0;
} | #include <iostream>
#define MX 1000000000
using namespace std;
int M[100][100],N; //M[i][j]:i©çjÜÅÌRXg
int dijkstra(int s , int g){
bool visited[100];
int d[100];
for(int i=0;i < N;i++) d[i] = MX , visited[i] = false;
d[s] = 0;
while(1){
int u;
int mincost = MX;
for(int i=0;i<N;i++)if(!visited[i] && d[i] < mincost) mincost = d[i] , u = i;
if(mincost == MX) break;
visited[u] = true;
for(int v=0;v<N;v++){
if(visited[v] || M[u][v] == MX) continue;
if(d[v] > d[u] + M[u][v]) d[v] = d[u] + M[u][v];
}
}
return d[g];
}
int main(){
int k;
while(cin >> N >> k){
for(int i=0;i<N;i++)for(int j=0;j<N;j++) M[i][j] = MX;
while(k--){
int x,a,b,c;
cin >> x;
if(!(x)){
int cost;
cin >> a >> b;
cost = dijkstra(a-1,b-1);
if(cost == MX) cout << "-1" << endl;
else cout << cost << endl;
}
else {
cin >> a >> b >> c;
if(M[a-1][b-1] > c && M[b-1][a-1] > c) M[a-1][b-1] = M[b-1][a-1] = c;
}
}
}
return 0;
} | 0 |
#include <iostream>
#include <fstream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <cstring>
#include <cassert>
#include <utility>
#include <iomanip>
#include <chrono>
#include <random>
#include <bitset>
using namespace std;
#define sz(x) (int) x.size()
#define unique(x) x.erase(unique(x.begin(), x.end()), x.end())
#define all(a) a.begin(), a.end()
#define sqr(x) ((x) * (x))
#define y1 aksjdaskdjksjfksdjf
#define left kdnvldvoiwejifejg
#define right lkdsjflksdjfdjfk
#define prev asdasfsadjkjsdfjs
#define tm aklsjdasjdasjdkdjjf
#define lcm hddalkwjeidjjhasda
#define random_shuffle asdasdd
const int MAXN = 2 * 105000;
const long long INF = 1e15;
int n;
int a[MAXN];
// long long dpl[MAXN], dpr[MAXN];
// pair<long long, long long> pl[MAXN], pr[MAXN];
long long sum;
long long total;
multiset <long long> st1, st2;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
total += a[i];
}
for (int i = n - 1; i > 0; i--) {
sum += a[i];
st2.insert(sum);
}
sum = 0;
long long ans = INF;
for (int i = 0; i + 1 < n; i++) {
sum += a[i];
if (st2.find(total - sum) != st2.end()) {
st2.erase(st2.find(total - sum));
}
if (sz(st1) && sz(st2)) {
vector<long long> v1, v2;
auto it = st1.lower_bound(sum / 2);
if (it != st1.end()) {
v1.push_back(*it);
}
if (it != st1.begin()) {
it--;
v1.push_back(*it);
}
it = st2.lower_bound((total - sum) / 2);
if (it != st2.end()) {
v2.push_back(*it);
}
if (it != st2.begin()) {
it--;
v2.push_back(*it);
}
for (auto x : v1) {
for (auto y : v2) {
long long mn = min(x, y);
long long mx = max(x, y);
mn = min(mn, min(sum - x, total - sum - y));
mx = max(mx, max(sum - x, total - sum - y));
ans = min(ans, mx - mn);
}
}
}
st1.insert(sum);
}
// for (int i = 0; i < n; i++) {
// sum += a[i];
// dpl[i] = INF;
// if (sz(st)) {
// auto it = st.lower_bound(sum / 2);
// if (it != st.end()) {
// long long cur = *it;
// dpl[i] = min(dpl[i], abs(cur - (sum - cur)));
// }
// if (it != st.begin()) {
// it--;
// long long cur = *it;
// dpl[i] = min(dpl[i], abs(cur - (sum - cur)));
// }
// }
// st.insert(sum);
// }
// st.clear();
// sum = 0;
// for (int i = n - 1; i >= 0; i--) {
// sum += a[i];
// dpr[i] = INF;
// if (sz(st)) {
// auto it = st.lower_bound(sum / 2);
// if (it != st.end()) {
// long long cur = *it;
// dpr[i] = min(dpr[i], abs(cur - (sum - cur)));
// }
// if (it != st.begin()) {
// it--;
// long long cur = *it;
// dpr[i] = min(dpr[i], abs(cur - (sum - cur)));
// }
// }
// st.insert(sum);
// }
// for (int i = 0; i < n; i++) {
// cerr << dpl[i] << " ";
// }
// cerr << endl;
/* long long ans = INF;
for (int i = 1; i + 2 < n; i++) {
ans = min(ans, max(dpl[i], dpr[i + 1]));
} */
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
multiset<int> se;
int main()
{
// freopen("powers.in", "r", stdin);
// freopen("powers.out", "w", stdout);
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
{
int x;
scanf("%d", &x);
se.insert(x);
}
int answer = 0;
while (!se.empty())
{
multiset<int>::iterator it = se.end();
it--;
int back = *it;
se.erase(it);
int i = 1;
for (; i <= back; i <<= 1)
;
if (se.find(i - back) != se.end())
{
se.erase(se.find(i - back));
answer++;
}
}
printf("%d\n", answer);
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
// template {{{ 0
// using {{{ 1
using ll = long long int;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vii = vector<pii>;
using vll = vector<pll>;
// }}} 1
// definition {{{ 1
// scaning {{{ 2
#define Scd(x) scanf("%d", &x)
#define Scd2(x,y) scanf("%d%d", &x, &y)
#define Scd3(x,y,z) scanf("%d%d%d", &x, &y, &z)
#define Scll(x) scanf("%lld", &x)
#define Scll2(x,y) scanf("%lld%lld", &x, &y)
#define Scll3(x,y,z) scanf("%lld%lld%lld", &x, &y, &z)
#define Scc(c) scanf("%c", &c);
#define Scs(s) scanf("%s", s);
#define Scstr(s) scanf("%s", &s);
// }}} 2
// constants {{{ 2
#define EPS (1e-7)
#define INF (2e9)
#define PI (acos(-1))
// }}} 2
// systems {{{ 2
#define Repe(x,y,z) for(ll x = z; x < y; x++)
#define Rep(x,y) Repe(x,y,0)
#define RRepe(x,y,z) for(ll x = y-z-1; x >= 0; x--)
#define RRep(x,y) RRepe(x,y,0)
// }}} 2
// output {{{ 2
#define YesNo(a) (a)?printf("Yes\n"):printf("No\n")
#define YESNO(a) (a)?printf("YES\n"):printf("NO\n")
// }}} 2
// }}} 1
// input {{{ 1
// }}} 1
// }}} 0
int main() {
int N,K;
char S[322];
Scs(S);
N = strlen(S);
Scd(K);
if( K >= N/2 ) {
printf ("%d\n", N);
return 0;
}
static int dp[301][301][302] = {};
Rep(ni,N) Rep(mi,N) {
int mir = N-1-mi;
bool same = S[ni] == S[mir];
RRep(ki,K+1){
// 無変換
dp[ni+1][mi+1][ki] = max( dp[ni][mi+1][ki], dp[ni+1][mi+1][ki] );
dp[ni+1][mi+1][ki] = max( dp[ni+1][mi][ki], dp[ni+1][mi+1][ki] );
dp[ni+1][mi+1][ki] = max( dp[ni][mi][ki]+same, dp[ni+1][mi+1][ki] );
// 変換
dp[ni+1][mi+1][ki+1] = max( dp[ni][mi][ki]+1, dp[ni+1][mi+1][ki+1] );
}
}
// Rep(ki,K+1){
// Rep(ni,N+1) Rep(mi,N+1){
// printf ("%d%s", dp[ni][mi][ki], mi!=N?",":"\n" );
// }
// printf ("---\n");
// }
int ans = 0;
Rep(ni,N+1) Rep(mi,N+1){
if( ni + mi > N ) break;
Rep(ki,K+1){
ans = max( dp[ni][mi][ki]*2+(ni+mi<N), ans );
}
}
printf ("%d\n", ans );
return 0;
}
/**
atcodergrandcontest
atcoder
g
atsetnocdn
*
*/
| /*** author: yuji9511 ***/
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using lpair = pair<ll, ll>;
const ll MOD = 1e9+7;
const ll INF = 1e18;
#define rep(i,m,n) for(ll i=(m);i<(n);i++)
#define rrep(i,m,n) for(ll i=(m);i>=(n);i--)
#define printa(x,n) for(ll i=0;i<n;i++){cout<<(x[i])<<" \n"[i==n-1];};
void print() {}
template <class H,class... T>
void print(H&& h, T&&... t){cout<<h<<" \n"[sizeof...(t)==0];print(forward<T>(t)...);}
int dp[301][301][301] = {};
string S;
int calc(ll i, ll j, ll k){
int &res = dp[i][j][k];
if(~res) return res;
if(j - i == 0){
return res = 0;
}else if(j - i == 1){
return res = 1;
}
res = 0;
if(S[i] == S[j-1]){
res = 2 + calc(i+1, j-1, k);
}else{
if(k > 0){
res = 2 + calc(i+1, j-1, k-1);
}
}
res = max(res, calc(i, j-1, k));
res = max(res, calc(i+1, j, k));
return res;
}
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cin >> S;
ll K;
cin >> K;
memset(dp, -1, sizeof(dp));
ll N = S.size();
ll ans = calc(0,N,K);
print(ans);
} | 1 |
#include <iostream>
#include <map>
#include <algorithm>
#include <vector>
#include <iomanip>
#include <sstream>
#include <cmath>
#include <math.h>
#include <string>
#include <set>
#include <queue>
#include <utility>
using namespace std;
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int a , b;
cin >> a >> b;
cout << max( a + b , max( a - b , a * b ) );
}
| #include <iostream>
#include <vector>
#include <cstdio>
#include <algorithm>
#include <queue>
#include <cstring>
using namespace std;
typedef long long ll;
const ll maxn = 1e6+10;
const ll inf = 1e16;
int N,K;
int main(){
// freopen("in.txt", "r", stdin);
cin>>N>>K;
cout<<N-K+1<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
//#include "atcoder/all"
typedef long long int ll;
using namespace std;
// using namespace atcoder;
#define MAXN 300001
#define mod 1000000007
ll a[MAXN];
int main() {
int n;
cin >> n;
ll co[60];
for (int i = 0; i < 60; i++) co[i] = 0;
for (int i = 1; i <= n; i++) {
ll a;
cin >> a;
int count = 0;
while (a) {
co[count]+= a % 2;
a /= 2;
count++;
}
}
ll ret = 0;
int now = 1;
for (int i = 0; i < 60; i++) {
ret = (ret + (now * co[i] % mod) * (n - co[i])) % mod;
now = now * 2 % mod;
}
cout << ret << endl;
return 0;
} | #include <cstdio>
#include <algorithm>
using namespace std;
typedef long long ll;
const int N = 5050;
const ll INF = 0x3f3f3f3f;
ll dp[N][N];
int n, w[N], h[N], a[N], ans;
bool cmp(int A,int B){
return w[A] + h[A] < w[B] + h[B];
}
int main(){
scanf("%d", &n);
for(int i = 0;i<n;i++){
scanf("%d%d", h + i, w + i);a[i] = i;
}
sort(a, a + n, cmp);
for(int i = 0;i<=n;i++){
dp[0][i] = INF * INF;
dp[i][0] = 0;
}
dp[0][1] = w[a[0]];
for(int i = 1;i<n;i++){
for(int j = 1;j<=n;j++){
dp[i][j] = dp[i - 1][j];
if(h[a[i]] >= dp[i - 1][j - 1])
dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] + w[a[i]]);
}
}
ans = n;
while(dp[n - 1][ans] == INF * INF) ans--;
printf("%d\n", ans);
}
| 0 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include<numeric>
#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 INF 2e9
#define ALL(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
bool compare(P a,P b){
if(a.first == b.first) return a.second < b.second;
return a.first < b.first;
}
int main(){
//cin.tie(nullptr);
ios_base::sync_with_stdio(false);
//cout << fixed << setprecision(15);
int n;cin>>n;
vector<int> perm(8);
REP(i,8){
perm[i] = i;
}
vector<P> xy(n);
REP(i,n){
int x,y; cin >> x >> y;
xy[i] = P(x,y);
}
sort(ALL(xy),compare);
do{
vector<P> permutation(8);
REP(i,8){
permutation[i] = P(i,perm[i]);
}
bool flag1 = true;
REP(i,n){
if(!binary_search(ALL(permutation),xy[i], compare)) {
flag1 = false; break;
}
}
if(!flag1) continue;
bool flag = true;
REP(i,7){
FOR(k,i+1,8){
if(abs(k-i) == abs(perm[k]-perm[i])){
flag = false; break;
}
}
if(!flag) break;
}
if(flag == true){
REP(i,8){
REP(k,8){
if(binary_search(ALL(permutation),P(i,k),compare)){
cout<<'Q';
}
else cout<<'.';
}
cout<<endl;
}
return 0;
}
}while(next_permutation(ALL(perm)));
}
| #include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<cassert>
#define ll long long
using namespace std;
inline ll read(){
ll re=0,flag=1;char ch=getchar();
while(ch>'9'||ch<'0'){
if(ch=='-') flag=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9') re=(re<<1)+(re<<3)+ch-'0',ch=getchar();
return re*flag;
}
ll d,len,ans=0,mi[20],me[20],cur[20];
void dfs(ll n,ll val,ll tmp){
// cout<<"dfs "<<n<<' '<<val<<' '<<tmp<<' '<<d<<' '<<mi[len-n-1]<<' '<<mi[n-1]<<'\n';
if(n>(len/2-1)){
if(len%2) tmp*=10;
if(val==d) ans+=tmp;
return;
}
ll i=-9;
while(i<=9&&i*(mi[len-n-1]-mi[n])+val<=d) i++;
i--;cur[n]=i;
dfs(n+1,val+i*(mi[len-n-1]-mi[n]),tmp*(me[i+10]-(n==0&&i>=0)));
if(i==9) return;
i++;cur[n]=i;
dfs(n+1,val+i*(mi[len-n-1]-mi[n]),tmp*(me[i+10]-(n==0&&i>=0)));
}
int main(){
d=read();ll i,j;
mi[0]=1;
for(i=1;i<=18;i++) mi[i]=mi[i-1]*10;
for(i=0;i<=9;i++) for(j=0;j<=9;j++) me[i-j+10]++;
for(len=0;len<=19;len++) dfs(0,0,1);
printf("%lld\n",ans);
// system("pause");
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<ll, ll> pll;
typedef vector<ld> vd;
typedef vector<ll> vll;
typedef vector<string> vstr;
typedef vector<vll> vvll;
typedef vector<vvll> vvvll;
typedef vector<pair<ll, ll>> vpll;
typedef priority_queue<ll, vector<ll>, greater<ll>> spqll; // 小さい順に取り出し
typedef priority_queue<ll, vector<ll>, less<ll>> bpqll; // 大きい順に取り出し
#define REP(i, n) for (ll i = 0; i < (ll)(n); i++)
#define FOR(i, a, b) for (ll i = (ll)a; i < (ll)b; i++)
#define IREP(i, v) for (auto i = (v).begin(); i != (v).end(); ++i)
#define FI first
#define SE second
#define MP make_pair
#define MT make_tuple
#define PB push_back
#define TS to_string
#define NP next_permutation
#define ALL(v) (v).begin(), (v).end()
#define SZ(x) (ll) x.size()
#define endl "\n"
ll INF = 1e9;
ll MOD = 1000000007;
ll LINF = 1e18;
ld EPS = 1e-9;
ld PI = M_PI;
vll dx = {1, 0, -1, 0, 1, -1, -1, 1};
vll dy = {0, 1, 0, -1, 1, 1, -1, -1};
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a;} //最大公約数
ll lcm(ll a, ll b) { return a / gcd(a, b) * b;} //最小公倍数
void yes(){ cout << "Yes" << endl;}
void no(){ cout << "No" << endl;}
//-----------------------------------------
ll timer;
vll pre, par, low, seen;
vvll graph;
void init(ll N){
pre.resize(N); par.resize(N);
low.resize(N); seen.resize(N,0);
graph.resize(N,vll());
timer = 1;
}
void dfs(ll cur, ll pas){
pre[cur] = low[cur] = timer;
timer++;
seen[cur] = 1;
for(ll i=0;i<graph[cur].size();i++){
ll next = graph[cur][i];
if(!seen[next]){
par[next] = cur;
dfs(next, cur);
low[cur] = min(low[cur], low[next]);
}
else if(next != pas){
low[cur] = min(low[cur], pre[next]);
}
}
}
void art_point(ll N, set<ll> &arp){
seen.resize(N,0);
timer = 1;
dfs(0,-1);
ll np = 0;
for(ll i=1;i<N;i++){
ll p = par[i];
if(p == 0) np++;
else if(pre[p] <= low[i]) arp.insert(p);
}
if(np > 1) arp.insert(0);
}
//-----------------------------------------
int main(){
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
ll v, e;
cin >> v >> e;
init(v);
REP(i,e){
ll a, b;
cin >> a >> b;
graph[a].push_back(b);
graph[b].push_back(a);
}
set<ll> st;
art_point(v,st);
IREP(i,st) cout << (*i) <<endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using i64 = int64_t;
const i64 MOD = 1e9 + 7;
struct LowLink{
vector<vector<int>>& edges;
// 関節点
vector<int> art;
vector<pair<int,int>> bridge;
vector<int> used, ord, low;
int k;
void dfs(int idx, int par){
ord[idx] = k++;
low[idx] = ord[idx];
bool is_art = false;
int cnt = 0;
for(auto& to : edges[idx]){
if(ord[to] == -1){
++cnt;
dfs(to, idx);
low[idx] = min(low[idx], low[to]);
is_art |= par != -1 && low[to] >= ord[idx];
if(ord[idx] < low[to])
bridge.emplace_back(idx, to);
}else if(to != par)
low[idx] = min(low[idx], ord[to]);
}
is_art |= (par == -1 && cnt > 1);
if(is_art)
art.emplace_back(idx);
}
LowLink(vector<vector<int>>& edges) :
edges(edges),
ord(edges.size(), -1),
low(edges.size(), 0),
k(0)
{
for(int i = 0; i < edges.size(); ++i)
if(ord[i] == -1)
dfs(i, -1);
for(auto& b : bridge)
b = make_pair(min(b.first, b.second), max(b.first, b.second));
sort(art.begin(), art.end());
sort(bridge.begin(), bridge.end());
}
};
signed main(){
int n, m;
cin >> n >> m;
vector<pair<int,int>> v(m);
vector<vector<int>> edges(n);
for(int i = 0; i < m; ++i){
vector<int> l(2);
for(auto& x : l)
cin >> x;
sort(l.begin(), l.end());
v[i] = make_pair(l.front(), l.back());
edges[l[0]].emplace_back(l[1]);
edges[l[1]].emplace_back(l[0]);
}
LowLink ll(edges);
for(auto& x : ll.art)
cout << x << endl;
}
| 1 |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
using ll = int64_t;
#define rep(i, j, n) for (int i = j; i < (int)n; ++i)
constexpr ll MOD = 1000000007;
int main() {
ll n;
cin >> n;
ll a;
vector<ll> one(60);
rep(i, 0, n) {
cin >> a;
rep(j, 0, 60) if (a >> j & 1) one[j]++;
}
ll ans = 0;
rep(i, 0, 60) ans =
(ans + (1ll << i) % MOD * one[i] % MOD * (n - one[i]) % MOD) % MOD;
cout << ans << endl;
return 0;
}
| #include <iostream>
#include<time.h>
#include<string>
#include<cstring>
#include <cstdio>
#include<utility>
#include<algorithm>
#include<vector>
#include<cmath>
#include<map>
#include<bitset>
#include<queue>
#include<stack>
#include<set>
#include <limits>
#include <climits>
#include <numeric>
#include<cassert>
#include<cctype>
#include<iterator>
#include<unordered_map>
#include <cassert>
#include <bit>
#include <cstdint>
using namespace std;
typedef long long ll;
typedef unsigned long long LL;
typedef vector<ll>VI;
typedef vector<bool>VB;
typedef pair<ll,ll>P;
typedef pair<double,double>P_D;
#define VV(T) vector<vector<T>>
#define PI 3.1415926535897932384626433832795
#define rep(i, n) for (ll i = 0; i < (ll)n; i++)
#define reprev(i, n) for (ll i = (ll)n - 1; i >= 0; i--)
#define bitrep(bit,A) for(int bit=A; ;bit=(bit-1)&A)
#define ALL(a) (a).begin(),(a).end()
#define SZ(a) (ll)((a).size())
#define c_max(a, b) (((ll)a)>((ll)b)?(a):(b))
#define c_min(a,b) (((ll)a)<((ll)b)?(a):(b))
#define chmax(x,a) x=c_max(x,a)
#define chmin(x,a) x=c_min(x,a)
#define vmax(v) *max_element(ALL(v))
#define vmin(v) *min_element(ALL(v))
#define SORT(c) stable_sort(ALL(c))
#define $(x) {cout<<#x<<" = " <<(x)<<endl;}
#define fi first
#define se second
#define MAX 100100//5
#define MAX2 200100
#define MAX_6 1001001//6
#define MAX_7 10010010//7
#define SENTINEL 2000000000//9
#define NIL -1
const int MOD = 1000000007;
#define INF 1<<30
#define INFTY 1LL<<61
#define MAX_INT INT_MAX
#define Endl '\n'
#define greater greater<int>()
inline ll GCD(ll a,ll b){return b?GCD(b,a%b):a;}
inline ll lcm(ll a,ll b){return a*b/GCD(a,b);}
using Edge=pair<int,ll>;
using Graph=vector<vector<ll> >;//ll or Edge
using Edge=pair<int,ll>;
//const int dx[4]={1,0,-1,0},dy[4]={0,1,0,-1};
// g++ -o a a.cpp -Wall -lm -std=c++17
inline ll mod_pow(ll x,ll n,ll mod=(ll)MOD){ll res=1;while(n>0){
if(n&1)res=res*x%mod;
x=x*x%mod;n>>=1;}return res;}//x^n%mod
int main(){
ll n;
ll a[MAX*3];
cin>>n;
rep(i,n)cin>>a[i];
ll sum=0;
ll two_factors=1;
rep(d,60){
ll p=0,q=0;
rep(i,n){
if(a[i] & (1LL<<d))p++;
else q++;
}
sum=(sum+(p*q)%MOD*two_factors%MOD)%MOD;
two_factors=two_factors*2%MOD;
}
cout<<sum<<endl;
} | 1 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <cstring>
#include <sstream>
#include <map>
#include <set>
#include <cmath>
#include <queue>
#include <stack>
#include <list>
#include <numeric>
#include <bitset>
#include <ext/algorithm>
#include <ext/numeric>
#define ffor(_a,_f,_t) for(int _a=(_f),__t=(_t);_a<__t;_a++)
#define all(_v) (_v).begin() , (_v).end()
#define SZ(x) ((int)(x).size())
#define pb push_back
#define eb emplace_back
#define SET(__set, val) memset(__set, val, sizeof(__set))
#define FOR(__i, __n) ffor (__i, 0, __n)
typedef long long LL; using namespace std;
int N, M;
const int OFFSET = 2000;
LL dp[6001][8001];
LL memo(int total, int dif) {
if (dif < 0)
return 0LL;
if (!total)
return dif >= OFFSET;
LL &ret = dp[total][dif];
if (ret != -1)
return ret;
ret = 0LL;
if (total >= 3)
ret += (total - 1LL) * (total - 2LL) * memo(total - 3, dif);
if (total >= 2)
ret += (total - 1LL) * memo(total - 2, dif - 1);
ret += memo(total - 1, dif + 1);
ret %= M;
return ret;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
cin >> N >> M;
SET(dp, 255);
cout << memo(3 * N, OFFSET) << endl;
return 0;
} | #include<set>
#include<map>
#include<stack>
#include<ctime>
#include<cstdio>
#include<queue>
#include<cmath>
#include<vector>
#include<cstring>
#include<climits>
#include<iostream>
#include<algorithm>
using namespace std;
#define LL long long
int read(){
int f=1,x=0;char c=getchar();
while(c<'0'||'9'<c){if(c=='-')f=-1;c=getchar();}
while('0'<=c&&c<='9'){x=x*10+c-'0';c=getchar();}
return f*x;
}
#define MAXN 12000
#define INF 0x3f3f3f3f
int Mod;
int Pow(int x,int y){
int ret=1;
while(y){
if(y&1) ret=1ll*ret*x%Mod;
x=1ll*x*x%Mod,y>>=1;
}
return ret;
}
int f[MAXN+5][MAXN+5],inv[MAXN+5];
int main(){
int n=read(),O=3*n;
Mod=read();
for(int i=1;i<=3*n;i++)
inv[i]=Pow(i,Mod-2);
f[0][O]=1;
for(int i=1;i<=3*n;i++)
for(int j=0;j<=6*n;j++){
f[i][j]+=f[i-1][j-1];
if(f[i][j]>=Mod) f[i][j]-=Mod;
if(i>=2)
f[i][j]+=f[i-2][j+1];
if(f[i][j]>=Mod) f[i][j]-=Mod;
if(i>=3)
f[i][j]+=f[i-3][j];
if(f[i][j]>=Mod) f[i][j]-=Mod;
f[i][j]=1ll*f[i][j]*inv[i]%Mod;
}
int ans=0,n3=1;
for(int i=1;i<=3*n;i++)
n3=1ll*n3*i%Mod;
for(int i=O;i<=6*n;i++)
ans=(ans+1ll*n3*f[3*n][i]%Mod)%Mod;
printf("%d\n",ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define str to_string
#define endl "\n"
#define PI 3.141592653589
using namespace std;
using lint = long long;
template <class T>ostream &operator<<(ostream &o,const vector<T>&v)
{o<<"{";for(int i=0;i<(int)v.size();i++)o<<(i>0?", ":"")<<v[i];o<<"}";return o;}
int main(){
string s;cin>>s;
s[3]='8';
cout<<s<<endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long lol;
//マクロ
//forループ関係
//引数は、(ループ内変数,動く範囲)か(ループ内変数,始めの数,終わりの数)、のどちらか
//Dがついてないものはループ変数は1ずつインクリメントされ、Dがついてるものはループ変数は1ずつデクリメントされる
#define REP(i,n) for(lol i=0;i<lol(n);i++)
#define REPD(i,n) for(lol i=n-1;i>=0;i--)
#define FOR(i,a,b) for(lol i=a;i<=lol(b);i++)
#define FORD(i,a,b) for(lol i=a;i>=lol(b);i--)
//xにはvectorなどのコンテナ
#define ALL(x) x.begin(),x.end() //sortなどの引数を省略したい
#define SIZE(x) lol(x.size()) //sizeをsize_tからllに直しておく
//定数
#define PI 3.1415926535897932385 //pi
#define INF 1000000000000 //10^12:極めて大きい値,∞
#define MOD 1000000007 //10^9+7:合同式の法
#define MAXR 100000 //10^5:配列の最大のrange(素数列挙などで使用)
//最大値最小値
template<class T>bool chmax(T &a, const T &b) { if (a<b) { a=b; return 1; } return 0; }
template<class T>bool chmin(T &a, const T &b) { if (b<a) { a=b; return 1; } return 0; }
int gcd(int a,int b){return b?gcd(b,a%b):a;}
int main()
{
double result{0};
double n; cin >> n;
//lol k; cin >> k;
/*
vector<lol> a(n);
REP(i, n)
{
cin >> a[i];
}
*/
result = 2*n*PI;
cout << result << endl;
return 0;
} | 0 |
Subsets and Splits