solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <iostream>
using namespace std;
int main(void){
int x1 , x2;
cin >> x1 >> x2;
if(x1 < x2) cout<< x2 - x1<< endl;
else
cout<< x1 - x2<< endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long temp = 0, r, ans = 0, l, z, w, k = 0, m1, e, p, q, k1 = 0, k2 = 0,
d = 0, a = 0, b = 0, s = 0, x, y, min1 = 1000000010, max1 = 0, m = 0,
c = 0, t = 0, i, n, c1 = 0, tot = 0, t1, k4 = 0, c2 = 0, j = 0,
k3 = 0;
char ch, ch1, ch2;
string s2, s3;
const long long N = 5000010;
vector<long long> v(N, 0);
vector<long long> graph[N];
signed main() {
cin >> n >> k;
if (n < 2 * k + 1) {
cout << -1;
return 0;
}
cout << n * k << "\n";
for (i = 0; i < n; i++) {
for (j = 0; j < k; j++) {
k1 = (i + j + 1) % n;
cout << i + 1 << " " << k1 + 1 << "\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int break_point() {
char c;
while ((c = getchar()) != '\n')
;
return 0;
}
template <typename T>
void read_integer(T &r) {
bool sign = 0;
r = 0;
char c;
while (1) {
c = getchar();
if (c == '-') {
sign = 1;
break;
}
if (c != ' ' && c != '\n') {
r = c - '0';
break;
}
}
while (1) {
c = getchar();
if (c == ' ' || c == '\n') break;
r = r * 10 + (c - '0');
}
if (sign) r = -r;
}
long long binpowmod(long long a, long long b, long long mod) {
if (b == 0) return 1;
long long c = binpowmod(a, b >> 1, mod);
return (((c * c) % mod) * (b & 1 ? a : 1)) % mod;
}
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long c = binpow(a, b >> 1);
return c * c * (b & 1 ? a : 1);
}
inline int getbit(int x, int b) { return (x >> b) & 1; }
inline int setbit(int x, int b) { return x | (1 << b); }
inline void _setbit(int &x, int b) { x = setbit(x, b); }
inline long long setbit(long long x, int b) { return x | (1ll << b); }
inline void _setbit(long long &x, int b) { x = setbit(x, b); }
inline int unsetbit(int x, int b) { return x & (INT_MAX - (1 << b)); }
inline void _unsetbit(int &x, int b) { x = unsetbit(x, b); }
inline int countbit(int x) {
x = x - ((x >> 1) & 0x55555555);
x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
return ((x + (x >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}
inline long long countbit(long long x) {
return countbit(int(x & INT_MAX)) + countbit(int(x >> 32) & INT_MAX);
}
inline void printbit(int x, int len) {
for (int i = len - 1; i >= 0; i--) printf("%d", getbit(x, i));
}
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
template <typename A, typename B>
ostream &operator<<(ostream &stream, const pair<A, B> &p) {
stream << "{" << p.first << "," << p.second << "}";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const vector<A> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A, typename B>
ostream &operator<<(ostream &stream, const map<A, B> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const set<A> &v) {
stream << "[";
for (auto itr = v.begin(); itr != v.end(); itr++) stream << *itr << " ";
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const stack<A> &v) {
stack<A> st;
stream << "[";
while (!st.empty()) {
stream << st.top() << " ";
st.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const priority_queue<A> &v) {
priority_queue<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.top() << " ";
q.pop();
}
stream << "]";
return stream;
}
template <typename A>
ostream &operator<<(ostream &stream, const queue<A> &v) {
queue<A> q = v;
stream << "[";
while (!q.empty()) {
stream << q.front() << " ";
q.pop();
}
stream << "]";
return stream;
}
void run();
int main() {
srand(time(NULL));
do {
run();
if (0) {
0 ? printf("-------------------------------\n") : 0;
0 ? printf("-------------------------------\n") : 0;
}
} while (0);
return 0;
}
template <typename T>
struct min_queue {
stack<T> push_st, pop_st;
queue<T> q;
T min_push;
void push(T v) {
if (push_st.empty())
min_push = v;
else
min_push = (v.second < min_push.second ? v : min_push);
push_st.push(v);
q.push(v);
}
void refill() {
while (!push_st.empty()) {
pop_st.push(pop_st.empty() || push_st.top().second < pop_st.top().second
? push_st.top()
: pop_st.top());
push_st.pop();
}
}
T front() { return q.front(); }
void pop() {
if (pop_st.empty()) refill();
if (!pop_st.empty()) pop_st.pop();
q.pop();
}
bool empty() { return push_st.empty() && pop_st.empty(); }
int size() { return int(pop_st.size()) + int(push_st.size()); }
T get_min() {
if (pop_st.empty())
return min_push;
else if (push_st.empty())
return pop_st.top();
else {
if (min_push.second < pop_st.top().second)
return min_push;
else
return pop_st.top();
}
}
};
pair<int, int> gs[200005];
void run() {
int n, d, m;
scanf("%d%d%d", &d, &n, &m);
for (int i = 0; i < m; i++) scanf("%d%d", &gs[i].first, &gs[i].second);
gs[m] = {d, 0};
sort(gs, gs + m);
long long res = 0;
min_queue<pair<int, int> > q;
int p = 1;
int b = n;
for (int i = 0; i < m; i++) {
b -= gs[i].first - (i == 0 ? 0 : gs[i - 1].first);
while (!q.empty() && q.front().first <= i) q.pop();
while (p <= m && gs[p].first <= gs[i].first + n) {
q.push({p, gs[p].second});
p++;
}
if (b < 0 || q.empty()) {
printf("-1\n");
return;
}
pair<int, int> mn = q.get_min();
if (mn.second > gs[i].second) {
res += 1ll * (n - b) * gs[i].second;
b = n;
} else {
while (q.front().second > gs[i].second) q.pop();
mn = q.front();
int need = max(0, min(n - b, gs[mn.first].first - gs[i].first - b));
res += 1ll * need * gs[i].second;
b += need;
}
}
printf("%lld", res);
putchar('\n');
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 10;
string s;
int n, avg;
int c[4];
deque<int> g[4];
int main() {
cin >> n >> s;
avg = n / 3;
for (int i = 0; i < n; i++) {
g[s[i] - '0'].push_back(i);
c[s[i] - '0']++;
}
while (c[0] > avg) {
if (c[2] < avg) {
int pos = g[0].back();
g[0].pop_back();
s[pos] = '2';
c[2]++;
} else if (c[1] < avg) {
int pos = g[0].back();
g[0].pop_back();
s[pos] = '1';
c[1]++;
}
c[0]--;
}
while (c[1] > avg) {
if (c[0] < avg) {
int pos = g[1].front();
g[1].pop_front();
s[pos] = '0';
c[0]++;
} else if (c[2] < avg) {
int pos = g[1].back();
g[1].pop_back();
s[pos] = '2';
c[2]++;
}
c[1]--;
}
while (c[2] > avg) {
if (c[0] < avg) {
int pos = g[2].front();
g[2].pop_front();
s[pos] = '0';
c[0]++;
} else if (c[1] < avg) {
int pos = g[2].front();
g[2].pop_front();
s[pos] = '1';
c[1]++;
}
c[2]--;
}
cout << s << endl;
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define LL long long
const int N=2e5+5;
int n;
LL a[90][40];
LL ans;
int main()
{
cin>>n;
while(n--)
{
string s;
cin>>s;
LL y=0;
int u=s.size();
for(int i=0;i<s.size();i++)
if(s[i]=='.') u=i;
if(u==s.size()) s+=".";
for(int i=s.size()-u;i<=9;i++) s+="0";
for(int i=0;i<s.size();i++)
if(s[i]!='.') y=y*10+s[i]-'0';
int z1=0,z2=0;
while(y%2==0) y/=2,z1++;
while(y%5==0) y/=5,z2++;
a[z1+36][z2+11]++;
}
for(int i=0;i<90;i++)
for(int j=0;j<40;j++)
for(int k=90-i;k<90;k++)
for(int l=40-j;l<40;l++)
ans+=a[i][j]*a[k][l];
for(int i=45;i<90;i++)
for(int j=20;j<40;j++)
ans-=a[i][j];
cout<<ans/2<<'\n';
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 712, SQ = 550;
long long n, q, a[N], ls;
long long ps[N], ans[N];
long long A[N], B[N], qu[N];
bool cmp(long long f, long long s) { return B[f] < B[s]; }
int32_t main() {
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i];
cin >> q;
for (long long i = 0; i < q; i++) {
cin >> A[i] >> B[i];
qu[i] = i;
}
sort(qu, qu + q, cmp);
for (long long ii = 0; ii < q; ii++) {
long long i = qu[ii];
if (B[i] < SQ) {
if (B[i] != ls) {
for (long long j = n; j; j--) ps[j] = ps[j + B[i]] + a[j];
ls = B[i];
}
ans[i] = ps[A[i]];
} else {
long long ret = 0;
for (; A[i] <= n; A[i] += B[i]) ret += a[A[i]];
ans[i] = ret;
}
}
for (long long i = 0; i < q; i++) cout << ans[i] << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, fh = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') fh = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * fh;
}
const int maxn = 2005, yrz = 1e9 + 7;
int dp[maxn][maxn], arr[maxn], n, m, d[maxn][2];
int main() {
n = m = read();
for (register int i = 1; i <= n; ++i) arr[i] = read();
for (register int i = 1; i <= n; ++i)
if (arr[i] != -1) d[i][0] = d[arr[i]][1] = 1;
int t = n;
for (register int i = 1; i <= t; ++i)
if (d[i][0]) --n;
t = m;
for (register int i = 1; i <= t; ++i)
if (d[i][1] | d[i][0]) --m;
dp[0][0] = 1;
for (register int i = 1; i <= n; ++i) {
dp[i][0] = 1ll * dp[i - 1][0] * i % yrz;
for (register int j = 1; j <= m; ++j)
dp[i][j] = (1ll * (j >= 2) * dp[i - 1][j - 2] * (j - 1) +
1ll * (i - j) * dp[i - 1][j - 1]) %
yrz;
}
cout << dp[n][m];
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool bl[103][103][103];
int main() {
int x, y, z;
scanf("%d%d%d\n", &x, &y, &z);
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
for (int k = 0; k < z; k++) {
char q;
scanf("%c", &q);
if (q == '1')
bl[i][j][k] = true;
else
bl[i][j][k] = false;
}
scanf("\n");
}
scanf("\n\n");
}
int ans = 0;
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
for (int k = 0; k < z; k++) {
if (bl[i][j][k]) {
if (i && bl[i - 1][j][k]) {
if (i < x - 1 && bl[i + 1][j][k]) {
ans++;
continue;
}
if (k < z - 1 && bl[i][j][k + 1] && !bl[i - 1][j][k + 1]) {
ans++;
continue;
}
if (j < y - 1 && bl[i][j + 1][k] && !bl[i - 1][j + 1][k]) {
ans++;
continue;
}
}
if (j && bl[i][j - 1][k]) {
if (j < y - 1 && bl[i][j + 1][k]) {
ans++;
continue;
}
if (k < z - 1 && bl[i][j][k + 1] && !bl[i][j - 1][k + 1]) {
ans++;
continue;
}
if (i < x - 1 && bl[i + 1][j][k] && !bl[i + 1][j - 1][k]) {
ans++;
continue;
}
}
if (k && bl[i][j][k - 1]) {
if (k < z - 1 && bl[i][j][k + 1]) {
ans++;
continue;
}
if (i < x - 1 && bl[i + 1][j][k] && !bl[i + 1][j][k - 1]) {
ans++;
continue;
}
if (j < y - 1 && bl[i][j + 1][k] && !bl[i][j + 1][k - 1]) {
ans++;
continue;
}
}
}
}
}
}
printf("%d", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string chek;
list<string> prices;
double sum = 0;
cin >> chek;
for (int i = 0; i < chek.length(); ++i) {
if (isdigit(chek[i]) || (chek[i] == '.')) {
if (!isdigit(chek[i - 1]) && !(chek[i - 1] == '.')) {
prices.push_back("");
}
prices.back() += chek[i];
}
}
for (string p : prices) {
while (p.find('.') < (p.length() - 3)) {
p = p.replace(p.find("."), 1, "");
}
sum += stod(p);
}
string res = to_string(sum);
res = res.substr(0, res.find_last_of('.') + 3);
if (res.substr(res.length() - 2, 2) == "00") {
res = res.substr(0, res.find_last_of('.'));
for (int i = res.length() - 4; i >= 0; i -= 3) {
res = res.substr(0, i + 1) + '.' + res.substr(i + 1);
}
} else {
for (int i = res.find_last_of('.') - 4; i >= 0; i -= 3) {
res = res.substr(0, i + 1) + '.' + res.substr(i + 1);
}
}
cout << res;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
#define pb push_back
ll mod = 1e9+7;
void solve(){
int t;
cin>>t;
while((--t)>=0)
{
int n,m,x;
cin>>n>>m>>x;
vector<int>v(n);
map<int,vector<int>>mp;
for(int i=0;i<n;++i){
cin>>v[i];
mp[v[i]].push_back(i);
}
int c=0;
vector<int>res(n,0);
for(auto itr=mp.begin();itr!=mp.end();itr++){
int si = itr->second.size();
for(int j=0;j<si;++j){
res[itr->second[j]]=c%m+1;
c++;
}
}
cout<<"YES\n";
for(int x:res){
cout<<x<<" ";
}
cout<<"\n";
}
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
clock_t begin = clock();
solve();
clock_t end = clock();
double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
//cout<<"Time : "<<time_spent<<endl;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
using namespace std;
vector<int> G[100100];
int vis[100100], c[700][700], tp, tp2, tg[100100], f[100100];
int d[100100], ans, fa2[100100], ti[100100], a[100100], e[100100], n,
fa[100100];
int top[100100], dfn[100100], tim, dep[100100], b[100100], son[100100], m,
q[100100];
int pre(int u) {
int s, mxsize = 0, sz = 1;
for (auto p : G[u]) {
s = pre(p), sz += s;
if (mxsize < s) mxsize = s, son[u] = p;
}
return sz;
}
void pre2(int u, int tp) {
dep[u] = dep[fa[u]] + 1;
top[u] = tp, dfn[u] = ++tim;
if (son[u]) pre2(son[u], tp);
for (auto p : G[u])
if (p != son[u]) pre2(p, p);
}
int lca(int u, int v) {
while (top[u] != top[v])
dep[top[u]] < dep[top[v]] ? v = fa[top[v]] : u = fa[top[u]];
return dep[u] < dep[v] ? u : v;
}
void build() {
n = 1e5, m = 1e5;
freopen("out.txt", "w", stdout);
for (int i = 1; i <= n; ++i) {
if (i > 1) fa[i] = rand() % (i - 1) + 1;
ti[i] = rand() % 5;
G[fa[i]].push_back(i);
}
for (int i = 1; i <= m; ++i) a[i] = rand() % n + 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 2; i <= n; ++i) scanf("%d", &fa[i]), G[fa[i]].push_back(i);
for (int i = 1; i <= n; ++i) scanf("%d", &ti[i]);
for (int i = 1; i <= m; ++i) scanf("%d", &a[i]);
pre(1), pre2(1, 1);
int blk = (int)sqrt(m) + 1, l = 0, r = 0;
q[r++] = 1;
while (l < r) {
int u = q[l++];
for (auto p : G[u]) q[r++] = p;
}
for (int i = 0; i <= m / blk; ++i) {
int L = i * blk + 1, R = min(m, (i + 1) * blk);
for (int j = 1; j <= n; ++j) f[j] = tg[j] = vis[j] = 0;
ans = tp = tp2 = 0;
for (int j = 1; j < L; ++j) {
vis[abs(a[j])] ^= 1;
f[abs(a[j])] += (a[j] > 0 ? 1 : -1);
}
for (int i = n - 1; i >= 0; --i) {
int u = q[i];
ans += vis[u] == 0 && f[u] > ti[u];
f[fa[u]] += f[u];
}
for (int j = L; j <= R; ++j) b[++tp] = abs(a[j]);
sort(b + 1, b + tp + 1, [](int x, int y) { return dfn[x] < dfn[y]; });
for (int j = 1, k = tp; j < k; ++j) b[++tp] = lca(b[j], b[j + 1]);
sort(b + 1, b + tp + 1, [](int x, int y) { return dfn[x] < dfn[y]; });
static int sta[100100];
int id = 0;
for (int j = 1, lst = 0; j <= tp; ++j)
if (lst != b[j] || j == 1) {
while (tp2 && lca(sta[tp2], b[j]) != sta[tp2]) tp2--;
if (tp2)
fa2[b[j]] = sta[tp2];
else
fa2[b[j]] = 0;
sta[++tp2] = b[j], tg[b[j]] = 1, d[lst = b[j]] = ++id, b[id] = lst;
}
for (int j = 1; j <= id; ++j) {
e[j] = 0;
for (int k = -blk; k <= blk; ++k) c[j][k + blk] = 0;
for (int k = fa[b[j]]; k && !tg[k]; k = fa[k])
if (abs(f[k] - ti[k] - 1) <= blk && !vis[k])
c[j][f[k] - ti[k] - 1 + blk]++;
for (int k = blk - 1; k >= -blk; --k) c[j][k + blk] += c[j][k + blk + 1];
}
for (int j = L; j <= R; ++j) {
int x = abs(a[j]), dta = a[j] > 0 ? 1 : -1;
for (; x; x = fa2[x]) {
ans -= vis[x] == 0 && f[x] > ti[x];
f[x] += dta, vis[x] ^= x == abs(a[j]) ? 1 : 0;
ans += vis[x] == 0 && f[x] > ti[x];
ans -= c[d[x]][-e[d[x]] + blk];
e[d[x]] += dta;
ans += c[d[x]][-e[d[x]] + blk];
}
printf("%d ", ans);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, h;
int lh = 0, lm = 0;
int nh, nm;
bool judge() {
int res = nm - lm + (nh - lh) * 60;
if (res >= 2 * h + 2) {
return true;
}
return false;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> h;
bool flag = false;
cin >> lh >> lm;
if (lm + lh * 60 >= h + 1) {
flag = true;
cout << 0 << " " << 0 << endl;
return 0;
}
for (int i = 1; i < n; i++) {
cin >> nh >> nm;
if (judge()) {
flag = true;
break;
}
lh = nh;
lm = nm;
}
nm = lm + h + 1;
nh = nm / 60 + lh;
nm %= 60;
cout << nh << " " << nm << endl;
return 0;
}
| 1 |
#include <iostream>
#include <math.h>
using namespace std;
typedef long long ll;
int main(){
int b;
while(cin >> b){
if(b == 0) break;
int ans1 = b, ans2 = 1;
for(int n = 2; n < 100000; ++n){
ll sm = 1*n*(n+1)/2;
if(b < sm) break;
int d = b - sm;
if(d % n == 0){
ans1 = d/n+1;
ans2 = n;
}
}
cout << ans1 << " " << ans2 << endl;
}
return 0;
}
| 0 |
#include<cstdio>
#include<iostream>
using namespace std;
int a[200001],b[200001],c[200001];
int main(void){
int n,m,k,root[100001],size[100001],bu[100001],i,j,gyo,x,y;
cin>>n>>m>>k;
for(i=1;i<=n;i++){
root[i]=i; size[i]=1; bu[i]=0;
}
for(i=1;i<=k;i++) cin>>a[i]>>b[i]>>c[i];
gyo=0;
for(i=1;i<=k;i++){
if(a[i]==1){
x=root[b[i]]; y=root[c[i]];
while(root[x]!=x) x=root[x];
while(root[y]!=y) y=root[y];
if(bu[x]!=bu[y]&&bu[x]!=0&&bu[y]!=0){
// cout<<"1 "<<i<<endl;
gyo=i;
break;
}
else if(x!=y){
if(size[x]>size[y]){
root[y]=x;
if(bu[y]!=0) bu[x]=bu[y];
}
else if(size[x]<size[y]){
root[x]=y;
if(bu[x]!=0) bu[y]=bu[x];
}
else {
root[x]=y;
size[y]++;
if(bu[x]!=0) bu[y]=bu[x];
}
}
}
if(a[i]==2){
x=root[b[i]];
while(root[x]!=x) x=root[x];
if(bu[x]==0) bu[x]=c[i];
else if(bu[x]!=c[i]){
// cout<<"2 "<<i<<endl;
gyo=i;
break;
}
}
}
cout<<gyo<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, T;
int main() {
int last, i, t;
scanf("%d", &T);
while (T--) {
bool flag = true;
scanf("%d", &n);
scanf("%d", &last);
for (i = 1; i < n; i++) {
scanf("%d", &t);
if (t != last) flag = false;
last = t;
}
if (flag)
printf("%d\n", n);
else
printf("1\n");
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
const int N=15;
typedef long long ll;
int gi() {
int x=0,o=1;char ch=getchar();
while(!isdigit(ch)&&ch!='-') ch=getchar();
if(ch=='-') o=-1,ch=getchar();
while(isdigit(ch)) x=x*10+ch-'0',ch=getchar();
return x*o;
}
const int a[]={0,1,2,4,7,12,20,29,38,52,73};
int n,p[N];
ll G[N][N];
int main() {
cin>>n;ll m=0;
for(int i=2;i<=n;i++) {
for(int j=1;j<i;j++) G[i][j]=G[j][i]=(m+1)*a[j];
if(i==n) break;
for(int j=1;j<=i;j++) p[j]=j;
do {
ll sum=0;
for(int j=1;j<i;j++) sum+=G[p[j]][p[j+1]];
m=max(m,sum);
} while(next_permutation(p+1,p+i+1));
}
for(int i=1;i<=n;i++,cout<<'\n')
for(int j=1;j<=n;j++) cout<<G[i][j]<<' ';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> points(5, vector<int>(5));
int checkScore(vector<int> s) {
int score = 0;
score += points[s[0] - 1][s[1] - 1] + points[s[1] - 1][s[0] - 1] +
points[s[2] - 1][s[3] - 1] + points[s[3] - 1][s[2] - 1];
score += points[s[1] - 1][s[2] - 1] + points[s[2] - 1][s[1] - 1] +
points[s[3] - 1][s[4] - 1] + points[s[4] - 1][s[3] - 1];
score += points[s[2] - 1][s[3] - 1] + points[s[3] - 1][s[2] - 1];
score += points[s[3] - 1][s[4] - 1] + points[s[4] - 1][s[3] - 1];
return score;
}
int main() {
vector<int> numbers = {1, 2, 3, 4, 5};
int i = 0;
vector<vector<int>> permutations(120, vector<int>(5));
do {
for (int j = 0; j < 5; j++) permutations[i][j] = numbers[j];
i++;
} while (next_permutation(numbers.begin(), numbers.end()));
for (int j = 0; j < 5; j++)
for (int k = 0; k < 5; k++) cin >> points[j][k];
int maxScore = -1;
for (int j = 0; j < 120; j++) {
int temp = checkScore(permutations[j]);
if (temp > maxScore) {
maxScore = temp;
}
}
cout << maxScore;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const int MAXN = 1000086;
long long f[MAXN];
long long k, w;
long long expow(long long x, long long e) {
long long ret(1);
while (e) {
if (e & 1) ret = ret * x % MOD;
e >>= 1;
x = x * x % MOD;
}
return ret;
}
long long ex_gcd(long long a, long long b, long long *x, long long *y) {
long long r, ra, rb, aa = 1, ab = 0, ba = 0, bb = 1;
while (b) {
r = a % b, ra = aa - a / b * ba, rb = ab - a / b * bb;
a = b, aa = ba, ab = bb;
b = r, ba = ra, bb = rb;
}
*x = aa, *y = ab;
return a;
}
long long rev(long long a, long long m) {
long long x, y;
ex_gcd(a, m, &x, &y);
if (x < 0) x += m;
return x;
}
long long A(long long n, long long m) {
if (n == 0) return 1;
return f[n] * rev(f[n - m], MOD) % MOD;
}
void init() {
f[0] = 1;
for (long long i = 1; i <= k; ++i) f[i] = (f[i - 1] * i) % MOD;
}
int main() {
long long i, j;
long long tot(0);
long long s, t;
long long cc;
scanf("%I64d %I64d", &k, &w);
if (w == 1) {
puts("0");
return 0;
}
init();
for (i = 1; i <= k; ++i) {
if (i == w) {
cc = 2 * A(k, w) * w % MOD;
cc = cc * A(k - 1, w - 1) % MOD;
s = A(k - 1, w - 1);
s = ((s * s % MOD) * (k % MOD)) % MOD;
t = A(k - 2, w - 2);
t = ((t * t % MOD) * ((w - 1) * (w - 1) % MOD)) % MOD;
t = t * A(k, 2) % MOD;
cc = (cc - s - t) % MOD;
tot = (tot + cc) % MOD;
} else if (i < w) {
s = i * A(k - 1, i - 1) % MOD, t = A(k, i);
cc = s * expow(k, w - i) % MOD;
cc = cc * ((2 * t - s) % MOD) % MOD;
tot = (tot + cc) % MOD;
} else {
cc = 2 * (A(k, i) * w % MOD) * A(k - i + w - 1, w - 1) % MOD;
s = A(k - i + w - 1, w - 1);
s = s * s % MOD;
s = s * A(k, i - w + 1) % MOD;
t = (w - 1) * A(k - i + w - 2, w - 2) % MOD;
t = t * t % MOD;
t = t * A(k, i - w + 2) % MOD;
cc = (cc - s - t) % MOD;
if (cc < 0) cc += MOD;
tot = (tot + cc) % MOD;
}
if (tot < 0) tot += MOD;
}
printf("%I64d\n", tot);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
string s;
cin >> s;
string b = s;
sort(b.begin(), b.end());
int k = 0;
for (int i = 0; i < n; i++) {
if (s[i] == b[i]) k++;
}
cout << n - k << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 2;
cin >> n;
int st[n];
int stdr[n];
for (int i = 0; i < n; i++) {
cin >> st[i];
}
for (int i = 0; i < n; i++) {
cin >> stdr[i];
}
bool ans = true;
int m = 0;
if (st[0] == 0) m = 1;
for (int i = 0; i < n; i++) {
if (st[m] == stdr[i]) {
int o = i;
int s = m;
for (int j = 0; j < n - 1; j++) {
o += 1;
s += 1;
if (o >= n) o = 0;
if (s >= n) s = 0;
if (st[s] == 0) s += 1;
if (stdr[o] == 0) o += 1;
if (o >= n) o = 0;
if (s >= n) s = 0;
if (st[s] == 0) s += 1;
if (stdr[o] == 0) o += 1;
if (!(st[s] == stdr[o])) ans = false;
}
}
}
if (ans == false)
cout << "NO";
else
cout << "YES";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int sum = 0, A[110];
bool ok(int n, int got) {
int ret = sum;
for (int i = 100; i >= 0; i--) {
if (A[i] >= n) {
ret -= n * i;
break;
} else {
ret -= A[i] * i;
n -= A[i];
}
}
return (ret <= got);
}
int main() {
int n, m, x;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x;
int lo = 0, hi = i, got = m - x;
while (lo <= hi) {
int m = (lo + hi) / 2;
if (ok(m, got))
hi = m - 1;
else
lo = m + 1;
}
cout << lo << ' ';
sum += x;
A[x]++;
}
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 5;
const int M = 0;
const int INF = 1000000000 + 7;
const long long int LLINF = 1000000000000000000LL + 7;
int n, m;
char used[N];
int ans[N], v[N];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; ++i) scanf("%d", &v[i]);
for (int i = 0; i <= n; ++i) ans[i] = 0, used[i] = false;
for (int i = 1; i < m; ++i) {
int current = (n - v[i - 1] + v[i]);
if (current > n) current %= n;
if ((!ans[v[i - 1]] and used[current]) or
(ans[v[i - 1]] and ans[v[i - 1]] != current)) {
puts("-1");
return 0;
}
used[current] = true;
ans[v[i - 1]] = current;
}
for (int i = 1; i <= n; ++i) {
if (!ans[i]) {
for (int j = 1; j <= n; ++j) {
if (!used[j]) {
ans[i] = j, used[j] = true;
break;
}
}
}
printf("%d%c", ans[i], (i == n) ? '\n' : ' ');
}
return 0;
}
| 2 |
//https://codeforces.com/problemset/problem/1514/D
//离线思路可以参考https://www.luogu.com.cn/blog/nizhuan/solution-p3709
/**
* 设[l,r]的长度为len,众数个数为cnt,那么非众数个数x=len-cnt.
* x个非众数可以和x+1个众数放在一起,满足条件,
* 多出来的众数只能一个一个放了,个数为cnt-(x+1).
* 因此需要的总个数为cnt-(len-cnt+1)+1=cnt*2-len.
* 利用莫队求区间众数
**/
#include <iostream>
#include <algorithm>
#include <cstring>
#include <cmath>
using namespace std;
const int N = 2e6 + 100;
struct Question
{
int l, r, qid;
}Q[N];
int arr[N], res[N], cnt[N], cnt1[N];
int n, q, blo,ans;
bool cmp(const Question &a, const Question &b)
{
if ((a.l - 1) / blo == (b.l - 1) / blo) return a.r < b.r;
return (a.l - 1) / blo < (b.l - 1) / blo ;
// if(a.l/blo!=b.l/blo)return a.l<b.l;
// return a.r<b.r;
}
void add(int x)
{
cnt[arr[x]]++;
cnt1[cnt[arr[x]]]++;
if (cnt[arr[x]] > ans) ans = cnt[arr[x]];
}
void del(int x)
{
/**
删除操作要考虑删掉的 x 出现次数是不是会影响答案。
分类讨论
1. 当出现次数小于当前 ans ，对答案没有影响；
2.当出现次数等于当前 ans ，且只有这个数出现了 ans 次， ans 减一；
3.当出现次数等于当前 ans ，且不止一个数出现了 ans 次，对答案没有影响。
**/
if (cnt1[cnt[arr[x]]] == 1 && ans == cnt[arr[x]]) ans--;
cnt1[cnt[arr[x]]]--;
cnt[arr[x]]--;
}
void Solve()
{
int l = 1, r = 0;
sort(Q + 1, Q + q + 1, cmp);
for (int i = 1; i <= q; i++) {
while (l > Q[i].l) add(--l);
while (r < Q[i].r) add(++r);
while (l < Q[i].l) del(l++);
while (r > Q[i].r) del(r--);
int len = Q[i].r - Q[i].l + 1;
int t = (len + 1) / 2;
if (ans <= t) res[Q[i].qid] = 1;
else res[Q[i].qid] = 2 * ans - len;
}
for (int i = 1; i <= q; i++) cout << res[i] << endl;
}
int main()
{
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> q;
blo = sqrt(n);
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i <= q; i++) {
cin >> Q[i].l >> Q[i].r;
Q[i].qid = i;
}
Solve();
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
#define MAXN 500020
int rangetree[MAXN*4][3];
void push(int curr) {
if (rangetree[curr][2]) {
rangetree[curr][2] = 0;
rangetree[2*curr][0] = max(rangetree[2*curr][0], rangetree[2*curr][1]+1);
rangetree[2*curr][2] = 1;
rangetree[2*curr+1][0] = max(rangetree[2*curr+1][0], rangetree[2*curr+1][1]+1);
rangetree[2*curr+1][2] = 1;
}
}
void updatelz(int s, int e, int curr = 1, int cstart = 0, int cend = MAXN) {
if (s <= cstart && cend <= e) {
rangetree[curr][0] = max(rangetree[curr][0], rangetree[curr][1]+1);
rangetree[curr][2] = 1;
return;
}
push(curr);
int mid = (cstart+cend)/2;
if (e <= mid) updatelz(s, e, 2*curr, cstart, mid);
else if (s > mid) updatelz(s, e, 2*curr+1, mid+1, cend);
else {
updatelz(s, e, 2*curr, cstart, mid);
updatelz(s, e, 2*curr+1, mid+1, cend);
}
rangetree[curr][0] = max(rangetree[2*curr][0], rangetree[2*curr+1][0]);
rangetree[curr][1] = max(rangetree[2*curr][1], rangetree[2*curr+1][1]);
}
void update(int node, int val, int type, int curr = 1, int cstart = 0, int cend = MAXN) {
if (cstart == cend) {
if (type == -1) rangetree[curr][0] = rangetree[curr][1] = rangetree[curr][2] = val;
else rangetree[curr][type] = max(rangetree[curr][type], val);
return;
}
push(curr);
int mid = (cstart+cend)/2;
if (node <= mid) update(node, val, type, 2*curr, cstart, mid);
else update(node, val, type, 2*curr+1, mid+1, cend);
rangetree[curr][0] = max(rangetree[2*curr][0], rangetree[2*curr+1][0]);
rangetree[curr][1] = max(rangetree[2*curr][1], rangetree[2*curr+1][1]);
}
int query(int s, int e, int type, int curr = 1, int cstart = 0, int cend = MAXN) {
if (s <= cstart && cend <= e) return rangetree[curr][type];
push(curr);
int mid = (cstart+cend)/2;
if (e <= mid) return query(s, e, type, 2*curr, cstart, mid);
else if (s > mid) return query(s, e, type, 2*curr+1, mid+1, cend);
else return max(query(s, e, type, 2*curr, cstart, mid), query(s, e, type, 2*curr+1, mid+1, cend));
}
void reset(int n) {
for (int i = 0; i <= n; i++) {
update(i, 0, -1);
}
}
int n, a[MAXN];
int main() {
int t;
scanf("%d", &t);
for (int CASE = 1; CASE <= t; CASE++) {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) {
int qfir = query(0, a[i], 0);
int qsec = query(0, a[i], 1);
updatelz(0, a[i]);
update(a[i], qsec+1, 1);
update(a[i], qfir+1, 1);
}
printf("%d\n", max(rangetree[1][0], rangetree[1][1]));
reset(n);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 4e3 + 10;
long long sum(long long n) { return n * (n + 1) / 2; }
long long check(long long n) {
long long l = 1, r = INF * 2;
long long ret = 1;
while (l <= r) {
long long mid = (l + r) / 2;
if (sum(mid) <= n)
ret = mid, l = mid + 1;
else
r = mid - 1;
}
return ret;
}
int main() {
long long n, h;
cin >> n >> h;
long long x = check(n);
if (x <= h) {
printf("%lld\n", x + (n - sum(x) > 0));
return 0;
}
long long l = h, r = INF * 2;
long long key = h;
while (l <= r) {
long long mid = (l + r) / 2;
if (sum(mid - 1) - sum(h - 1) + sum(mid) <= n)
key = mid, l = mid + 1;
else
r = mid - 1;
}
long long rest = -(sum(key - 1) - sum(h - 1) + sum(key) - n);
printf("%lld\n", key - h + key + (rest - 1 + key) / key);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x = 0;
string s;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < s.size(); j++) {
if (s[j] == '+') {
x++;
break;
} else if (s[j] == '-') {
x--;
break;
}
}
}
cout << x;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > V;
vector<long long int> Ans;
int main() {
long long int n, k;
scanf("%lld %lld", &n, &k);
for (long long int i = 0; i < n; i++) {
long long int st, ed;
scanf("%lld %lld", &st, &ed);
V.push_back(pair<long long int, long long int>(st, 0));
V.push_back(pair<long long int, long long int>(ed, 1));
}
sort(V.begin(), V.end());
long long int c = 0;
long long int siz = V.size();
long long int st = -1, ed = -1;
for (long long int i = 0; i < siz; i++) {
if (V[i].second == 0) {
c++;
if (c == k) {
ed = V[i].first;
Ans.push_back(ed);
}
} else {
if (c == k) {
ed = V[i].first;
Ans.push_back(ed);
}
c--;
}
}
long long int l = Ans.size();
c = l;
printf("%lld\n", c / 2);
for (long long int i = 0; i < c; i = i + 2)
printf("%lld %lld\n", Ans[i], Ans[i + 1]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#define int long long
#define N 100010
#define S str[pos]
#define Sp str[pos++]
using namespace std;
const int INF = 1LL<<55;
const int mod = (1e9)+7;
const double EPS = 1e-8;
int Max(int &a,int b){return a=max(a,b);}
int Min(int &a,int b){return a=min(a,b);}
typedef complex<double> P;
typedef pair<P,P> L;
string str;
int pos;
double dot(P a, P b){ return real(conj(a)*b); }
double cross(P a, P b){ return imag(conj(a)*b); }
P proj(P p, L l){return l.first + dot(p - l.first, l.second - l.first) / norm(l.second - l.first) * (l.second - l.first);}
P reflect(P p, L l){return p + (proj(p,l) - p) * 2.0;}
P crossPoint(L l, L m){
double A = cross(l.second - l.first, m.second - m.first);
double B = cross(l.second - l.first, l.second - m.first);
if(fabs(A) < EPS && fabs(B) < EPS) return m.first;
else if(fabs(A) >= EPS) return m.first + B / A * (m.second - m.first);
}
bool isPoint(L a){return a.first == a.second;}
double getNumber(){
assert(S == '-' || isdigit(S));
double res=0,f = 1;
if(S == '-') pos++,f = -1;
while(isdigit(S)) res = res * 10 + Sp - '0';
return f * res;
}
P getPoint(){
assert(Sp == '(' && (isdigit(S) || S=='-'));
double real = getNumber();assert(Sp == ',');
double imag = getNumber();assert(Sp == ')');
return P(real,imag);
}
L expression();
L calc(){
P a;
L res;
if(S == '(' && (isdigit(str[pos+1]) || str[pos+1] == '-'))a = getPoint(),res = L(a,a);
else if(S == '(' && str[pos+1] == '(')pos++,res = expression(),pos++;
else assert(!"calc error");
return res;
}
L calc(L a,L b){
if(isPoint(a) && isPoint(b)) return L(a.first,b.first);
if(!isPoint(a) && !isPoint(b))return L(crossPoint(a,b),crossPoint(a,b));
if(isPoint(a)) return L(reflect(a.first,b),reflect(a.first,b));
if(isPoint(b)) return L(reflect(b.first,a),reflect(b.first,a));
assert(!"@ calc error");
}
L expression(){
L res = calc();
while(pos < (int)str.size()){
if(S == '@')pos++,res = calc(res,calc());
else if(S == ')') break;
else assert(!"expression error");
}
return res;
}
signed main(){
while(1){
cin>>str;
if(str == "#") break;
pos = 0;
L ans = expression();
printf("%f %f\n",ans.first.real(),ans.first.imag());
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct Flow {
int n;
vector<vector<int> > graph;
vector<int> st, en, back;
vector<long long> f, c;
vector<int> par;
Flow(int n) : n(n), graph(n), par(n) {}
void add_edge(int u, int v, int cap) {
int id1 = st.size();
int id2 = id1 + 1;
st.push_back(u);
st.push_back(v);
en.push_back(v);
en.push_back(u);
back.push_back(id2);
back.push_back(id1);
f.push_back(0);
f.push_back(0);
c.push_back(cap);
c.push_back(0);
graph[u].push_back(id1);
graph[v].push_back(id2);
}
void add(int id1, int v) {
f[id1] += v;
c[id1] -= v;
f[back[id1]] -= v;
c[back[id1]] += v;
}
long long maxflow(int s, int t) {
long long ans = 0;
vector<int> bfs;
if (s == t) return ans;
while (1) {
for (int i = 0; i < n; i++) par[i] = -1;
bfs.clear();
bfs.push_back(s);
par[s] = -2;
int cur = 0;
while (cur < bfs.size()) {
int u = bfs[cur];
cur++;
for (int i = 0; i < graph[u].size(); i++) {
int id = graph[u][i];
if (c[id] == 0) continue;
if (par[en[id]] != -1) continue;
par[en[id]] = id;
bfs.push_back(en[id]);
}
}
if (par[t] == -1) break;
long long send = 4e18;
int curv = t;
while (par[curv] != -2) {
send = min(send, c[par[curv]]);
curv = st[par[curv]];
}
curv = t;
while (par[curv] != -2) {
add(par[curv], send);
curv = st[par[curv]];
}
ans += send;
}
return ans;
}
};
int ok[110][110];
int r[110][110];
int fataleagle[110][110];
int main() {
int n, m, s, t;
cin >> n >> m >> s >> t;
s--;
t--;
vector<int> u, v, g;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
ok[i][j] = 1e7;
r[i][j] = 0;
fataleagle[i][j] = -1;
}
ok[i][i] = 0;
}
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
u.push_back(a);
v.push_back(b);
g.push_back(c);
if (c) ok[a][b] = 1;
}
for (int a = 0; a < n; a++) {
fataleagle[a][a] = a;
for (int i = 0; i < n; i++) {
for (int fuckthisproblem = 0; fuckthisproblem < m; fuckthisproblem++) {
if (g[fuckthisproblem] == 0) continue;
int derpy1 = u[fuckthisproblem];
int derpy2 = v[fuckthisproblem];
if (ok[derpy1][derpy2] == 1 && fataleagle[a][derpy1] >= 0 &&
fataleagle[a][derpy2] == -1) {
fataleagle[a][derpy2] = derpy1;
}
}
}
}
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
ok[i][j] = min(ok[i][j], ok[i][k] + ok[k][j]);
}
}
}
Flow codeforces(n);
for (int i = 0; i < m; i++) {
if (g[i] == 1) {
codeforces.add_edge(u[i], v[i], 1);
codeforces.add_edge(v[i], u[i], 1e8);
} else {
codeforces.add_edge(u[i], v[i], 1e8);
}
}
long long ans = codeforces.maxflow(s, t);
cout << ans << endl;
Flow f2(n);
for (int i = 0; i < m; i++) {
if (g[i] == 0) {
} else {
if (codeforces.par[u[i]] != -1 && codeforces.par[v[i]] == -1) {
f2.add_edge(u[i], v[i], 1);
} else {
f2.add_edge(u[i], v[i], 1e8);
}
}
}
f2.maxflow(s, t);
for (int i = 0; i < f2.graph.size(); i++) {
for (int j = 0; j < f2.graph[i].size(); j++) {
int id = f2.graph[i][j];
if (f2.f[id] + f2.c[id] == 0) continue;
r[f2.st[id]][f2.en[id]] += f2.f[id];
}
}
for (int i = 0; i < m; i++) {
if (g[i] == 0) continue;
int a = u[i];
int b = v[i];
if (r[a][b] > 0) continue;
r[a][b]++;
if (fataleagle[s][a] >= 0 && fataleagle[b][t] >= 0) {
if (1) {
int yy = s;
int zz = a;
while (zz != yy) {
int nzz = fataleagle[yy][zz];
r[nzz][zz]++;
zz = nzz;
}
}
if (1) {
int yy = b;
int zz = t;
while (zz != yy) {
int nzz = fataleagle[yy][zz];
r[nzz][zz]++;
zz = nzz;
}
}
} else {
if (1) {
int yy = b;
int zz = a;
while (zz != yy) {
int nzz = fataleagle[yy][zz];
r[nzz][zz]++;
zz = nzz;
}
}
}
}
for (int i = 0; i < m; i++) {
if (g[i] == 0) {
cout << 0 << " " << 1 << endl;
} else {
if (codeforces.par[u[i]] != -1 && codeforces.par[v[i]] == -1) {
cout << r[u[i]][v[i]] << " " << r[u[i]][v[i]] << endl;
} else {
cout << r[u[i]][v[i]] << " " << r[u[i]][v[i]] + 1 << endl;
}
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
namespace Solve {
const int MAXN = 100010;
struct Edge {
int y;
Edge *next, *opt;
bool flag;
Edge(int y, Edge *next, bool f = false) : y(y), next(next), flag(f) {}
} * a[MAXN];
inline int ScanInt(void) {
int r = 0, c, d;
while (!isdigit(c = getchar()) && c != '-')
;
if (c != '-') r = c - '0';
d = c;
while (isdigit(c = getchar())) r = r * 10 + c - '0';
return d == '-' ? -r : r;
}
int n, m, c[MAXN], d[MAXN];
bool vis1[MAXN], vis2[MAXN];
inline void Bfs(int u, bool vis[], bool f) {
int head = 1, tail = 1;
d[1] = u;
vis[u] = true;
while (head <= tail) {
int now = d[head++];
if (f == false && c[now] == 1) continue;
for (Edge *p = a[now]; p; p = p->next)
if (p->flag == f)
if (!vis[p->y]) vis[d[++tail] = p->y] = true;
}
}
inline void solve(void) {
n = ScanInt(), m = ScanInt();
for (int i = 1; i <= n; i++) scanf("%d", c + i);
while (m--) {
int x = ScanInt(), y = ScanInt();
a[x] = new Edge(y, a[x], true);
a[y] = new Edge(x, a[y]);
a[x]->opt = a[y];
a[y]->opt = a[x];
}
for (int i = 1; i <= n; i++)
if (c[i] == 1 && !vis1[i]) Bfs(i, vis1, true);
for (int i = 1; i <= n; i++)
if (c[i] == 2 && !vis2[i]) Bfs(i, vis2, false);
for (int i = 1; i <= n; i++) {
if (vis1[i] && vis2[i])
puts("1");
else
puts("0");
}
}
} // namespace Solve
int main(void) {
Solve::solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
const int N = 1e6 + 10;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n, m;
cin >> n >> m;
int g[n];
for (int i = 0; i < n; ++i) cin >> g[i];
sort(g, g + (sizeof(g) / sizeof(*g)));
long long d[n];
fill(d, d + (sizeof(d) / sizeof(*d)), 0);
for (int i = m; i < n; ++i) d[i] = g[i - m] + d[i - m];
long long sm = 0;
for (int i = 0; i < n; ++i) {
sm += g[i] + d[i];
cout << sm << " ";
}
return 0;
}
| 3 |
#include <iostream>
#include <vector>
#include <bitset>
#include <string>
#include <array>
#include <random>
#include <chrono>
#include <algorithm>
uint64_t mod = 1000 * 1000 * 1000 + 7;
static int pow(uint64_t x, uint64_t n){
uint64_t ans=1;
while(n){
if(n%2){
ans *= x;
ans %= mod;
n-=1;
}
x *= x;
x %= mod;
n/=2;
}
return ans;
}
int main(void){
uint64_t n, m, k;
std::cin >> n >> m >> k;
uint64_t sq = n * m;
uint64_t combination = 1;
uint64_t x = 0;
for(int i=1;i<n;i++){
x+=m * m * (n-i)*i;
x %=mod;
}
for(int i=1;i<m;i++){
x+=n*n*(m-i)*i;
x %= mod;
}
uint64_t C = 1, O=1, M=1;
for(int i=1;i<=n*m-2;i++){
C *= i;
C %= mod;
}
for(int i=1;i<=k-2;i++){
O*=i;
O %= mod;
}
O = pow(O, mod - 2);
for(int i=1;i<=n*m - k;i++){
M *= i;
M %= mod;
}
M = pow(M, mod - 2);
x*=C;
x %= mod;
x*= O;
x %= mod;
x*= M;
x %= mod;
std::cout << x << std::endl;
}
| 0 |
#include <iostream>
#include <vector>
using namespace std;
const int MAXN = 300001;
int X[MAXN];
int Y[MAXN];
int XS[MAXN];
int YS[MAXN];
int main()
{
int W, H, M;
cin >> W >> H >> M;
int xmax = 0, ymax = 0;
for (int i=0;i<M;++i)
{
cin >> X[i] >> Y[i];
xmax = max(xmax, ++XS[X[i]]);
ymax = max(ymax, ++YS[Y[i]]);
}
int xn = 0, yn = 0;
for (int x=0;x<=W;++x) { if (XS[x] == xmax) { ++xn; } }
for (int y=0;y<=H;++y) { if (YS[y] == ymax) { ++yn; } }
int zn = 0;
for (int i=0;i<M;++i) { if (XS[X[i]] == xmax && YS[Y[i]] == ymax) { ++zn; } }
cout << xmax + ymax - (zn == xn * yn ? 1 : 0) << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, n1, n2;
string s1;
string s2;
int result_1[1000001];
int result_2[1000001];
string TMP = "RSPR";
int whoLoss(char c1, char c2) {
for (int i = 0; i < 3; i++) {
if (c1 == TMP[i] && c2 == TMP[i + 1]) return 2;
if (c2 == TMP[i] && c1 == TMP[i + 1]) return 1;
}
return 0;
}
int main() {
ios ::sync_with_stdio(false);
cin >> n;
cin >> s1 >> s2;
n1 = s1.length();
n2 = s2.length();
int cycle = n1 * n2;
int cnt1 = 0, cnt2 = 0;
for (int i = 0; i < cycle; i++) {
int res = whoLoss(s1[i % n1], s2[i % n2]);
result_1[i] = (res == 1);
result_2[i] = (res == 2);
cnt1 += result_1[i];
cnt2 += result_2[i];
}
int nCycle = n / cycle;
int ans1 = nCycle * cnt1;
int ans2 = nCycle * cnt2;
for (int i = 0; i < (n - nCycle * cycle); i++) {
ans1 += result_1[i];
ans2 += result_2[i];
}
cout << ans1 << " " << ans2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int ans, ans1;
int a[100005];
int i, j, k, l, s, m, n;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
for (i = n; i >= 1; i--) {
if (i % 2 == n % 2) ans = ans + (a[i] * a[i] - a[i - 1] * a[i - 1]);
}
printf("%.8lf", ans * 3.1415926535);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C& a4, C b4) {
a4 = min(a4, b4);
}
template <class C>
void maxi(C& a4, C b4) {
a4 = max(a4, b4);
}
template <class T1, class T2>
ostream& operator<<(ostream& out, pair<T1, T2> pair) {
return out << "(" << pair.first << ", " << pair.second << ")";
}
const int N = 55;
int arr[N][N];
int arr2[N][N];
int per[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < (n); ++i) {
per[i] = 0;
for (int j = 0; j < (n); ++j) {
scanf("%d", &arr[i][j]);
if (i == j) continue;
arr2[i][arr[i][j]]++;
}
}
int ff = n - 1;
for (int i = 0; i < (n); ++i) {
for (int j = 0; j < (n); ++j) {
if (arr2[i][j] > 1) per[i] = j;
}
if (per[i] == 0) per[i] = ff++;
printf("%d ", per[i]);
}
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int p[1000010], n;
long long hold[1000010], sum, res, ind;
int main() {
sum = ind = res = 0;
memset(hold, 0, sizeof(hold));
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", p + i);
if (p[i] > i) {
hold[1]--;
hold[p[i] - i + 1] += 2;
hold[p[i] - i + 1 + n - p[i]]--;
hold[p[i] - i + 1 + n - p[i] + 1]--;
sum += ((long long)p[i] - (long long)i);
} else {
hold[1]++;
hold[n - i + 1]--;
hold[n - i + 2]--;
hold[n - i + 2 + p[i] - 1] += 2;
sum += ((long long)i - (long long)p[i]);
}
}
res = sum;
ind = 0;
for (int i = 1; i <= n; i++) {
hold[i] += hold[i - 1];
}
hold[n] = 0;
for (int i = 1; i < n; i++) {
sum += hold[i];
sum += (p[n - i + 1] - 1 - abs(p[n - i + 1] - n));
if (sum < res) {
res = sum;
ind = i;
}
}
printf("%lld %lld", res, ind);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[10];
char mid, star, fina;
long long x, y, n, judge1, judge2;
gets(s);
star = s[0];
fina = s[2];
scanf("%lld", &n);
judge1 = 0;
judge2 = 0;
if (star == 'v')
x = 1;
else if (star == '<')
x = 2;
else if (star == '^')
x = 3;
else if (star == '>')
x = 4;
if (fina == 'v')
y = 1;
else if (fina == '<')
y = 2;
else if (fina == '^')
y = 3;
else if (fina == '>')
y = 4;
long long temp = n % 4;
long long xx = x + temp;
if (xx > 4) xx -= 4;
if (y == xx) judge1 = 1;
if (x > temp) {
if (y == x - temp) judge2 = 1;
} else {
long long tt = temp - x + 1;
tt = 4 - tt + 1;
if (tt == y) judge2 = 1;
}
if (judge1 && judge2)
printf("undefined\n");
else if (judge1)
printf("cw\n");
else
printf("ccw\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct Matrix {
long long m[7][7];
Matrix() { memset(m, 0, sizeof(m)); }
inline void init() {
m[1][1] = 2, m[1][2] = 1, m[1][3] = 1, m[1][4] = 0, m[1][5] = 1,
m[1][6] = 2;
m[2][1] = 1, m[2][2] = 2, m[2][3] = 0, m[2][4] = 1, m[2][5] = 1,
m[2][6] = 2;
m[3][1] = 1, m[3][2] = 1, m[3][3] = 1, m[3][4] = 0, m[3][5] = 1,
m[3][6] = 2;
m[4][1] = 1, m[4][2] = 1, m[4][3] = 0, m[4][4] = 1, m[4][5] = 1,
m[4][6] = 2;
m[5][1] = 0, m[5][2] = 0, m[5][3] = 0, m[5][4] = 0, m[5][5] = 1,
m[5][6] = 1;
m[6][1] = 0, m[6][2] = 0, m[6][3] = 0, m[6][4] = 0, m[6][5] = 0,
m[6][6] = 1;
}
inline void reset() {
m[1][1] = m[2][2] = m[3][3] = 1;
m[4][4] = m[5][5] = m[6][6] = 1;
}
inline long long *operator[](long long x) { return m[x]; }
inline const long long *operator[](long long x) const { return m[x]; }
};
long long n, x, y, dx, dy, t;
inline long long read() {
long long x = 0;
long long f = 1;
char ch = getchar();
while (!isdigit(ch)) {
ch == '-' && (f = -1);
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline Matrix operator*(const Matrix &a, const Matrix &b) {
Matrix x;
for (long long i = 1; i <= 6; i++)
for (long long j = 1; j <= 6; j++)
for (long long k = 1; k <= 6; k++)
x[i][j] += (a[i][k] * b[k][j]) % n, x[i][j] += n, x[i][j] %= n;
return x;
}
inline Matrix qpow(const Matrix &x, long long y) {
Matrix r, k = x;
r.reset();
while (y) {
if (y & 1) r = r * k;
k = k * k, y >>= 1;
}
return r;
}
signed main() {
n = read(), x = read(), y = read(), dx = read(), dy = read(), t = read();
Matrix A, B;
A.init();
A = qpow(A, t);
B[1][1] = x - 1, B[2][1] = y - 1, B[3][1] = dx, B[4][1] = dy, B[5][1] = 0,
B[6][1] = 1;
B = A * B;
printf("%lld %lld\n", B[1][1] + 1, B[2][1] + 1);
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
const int MOD=1e9+7;
int f[2010];
int main()
{
int n;
cin>>n;
for(int i=3;i<=2001;i++)
{
f[i]=1;
if(i-3>=3)
{
for(int j=3;j<=i-3;j++)
{
f[i]=(f[i]+f[j]%MOD)%MOD;
}
}
}
cout<<f[n];
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[2222], now[2222];
vector<int> ans;
void rev(int n) {
reverse(a + 1, a + n + 1);
for (int i = 1; i <= n; i++) now[a[i]] = i;
}
void f(int n) {
if (n == 1) return;
if (a[n] == n && a[n - 1] == n - 1) return f(n - 2);
ans.push_back(now[n]);
rev(now[n]);
ans.push_back(now[n - 1] - 1);
rev(now[n - 1] - 1);
ans.push_back(now[n - 1] + 1);
rev(now[n - 1] + 1);
ans.push_back(3);
rev(3);
ans.push_back(n);
rev(n);
f(n - 2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int T;
cin >> T;
while (T--) {
int i, N, flag = 0;
cin >> N;
for (i = 1; i <= N; i++) {
cin >> a[i];
now[a[i]] = i;
flag |= (a[i] - i) & 1;
}
if (flag) {
cout << -1 << "\n";
continue;
}
ans.clear();
f(N);
cout << ans.size() << "\n";
for (i = 0; i < ans.size(); i++) cout << ans[i] << " ";
cout << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
class Graph {
public:
struct Edge {
int next, to;
};
vector<int> head;
int eidx;
int N, M;
Edge* E;
Graph(int N_, int M_) : N(N_), M(M_) {
head.resize(N);
eidx = 0;
for (int i = 0; i < N; i++) {
head[i] = -1;
}
E = new Edge[M]{};
}
~Graph() { delete[] E; }
void addEdge(int u, int v) {
E[eidx].to = v;
E[eidx].next = head[u];
head[u] = eidx++;
}
};
const int MAXN = 10010;
int depth[MAXN];
bool vis[MAXN];
int Co, Ce;
int So[MAXN], Se[MAXN];
void dfs(const Graph& g, int u, int fa, int d) {
vis[u] = true;
depth[u] = d;
for (int eidx = g.head[u]; ~eidx; eidx = g.E[eidx].next) {
int v = g.E[eidx].to;
if (v == fa) continue;
if (!vis[v]) {
dfs(g, v, u, d + 1);
} else if (depth[u] > depth[v]) {
int len = depth[u] - depth[v] + 1;
if (len & 1) {
Co++;
So[u]++;
So[v]--;
} else {
Ce++;
Se[u]++;
Se[v]--;
}
}
}
}
void dfs2(const Graph& g, int u) {
vis[u] = true;
for (int eidx = g.head[u]; ~eidx; eidx = g.E[eidx].next) {
int v = g.E[eidx].to;
if (!vis[v]) {
dfs2(g, v);
So[u] += So[v];
Se[u] += Se[v];
}
}
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
Graph g(n, 2 * m);
vector<pair<int, int>> edges;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
g.addEdge(u, v);
g.addEdge(v, u);
edges.push_back(make_pair(u, v));
}
for (int i = 0; i < n; i++) {
if (!vis[i]) dfs(g, i, -1, 0);
}
memset(vis, 0, n * sizeof(bool));
for (int i = 0; i < n; i++) {
if (!vis[i]) dfs2(g, i);
}
vector<int> ret;
for (int i = 0; i < m; i++) {
int u, v;
tie(u, v) = edges[i];
if (depth[u] < depth[v]) swap(u, v);
bool oc = ((depth[u] - depth[v] + 1) & 1);
bool ot = (depth[u] == depth[v] + 1);
if (Co == 0 || (Co == 1 && oc) || (ot && So[u] == Co && Se[u] == 0)) {
ret.push_back(i);
}
}
printf("%d\n", (int)ret.size());
for (int i = 0; i < (int)ret.size(); i++) {
printf("%d%c", ret[i] + 1, i == (int)ret.size() - 1 ? '\n' : ' ');
}
return 0;
}
| 5 |
#include <iostream>
#include <vector>
#include <map>
using namespace std;
#define MAX_N 100000
typedef pair<char, int> card;
card A[MAX_N];
// NOTE: used for storing order of card.
map<int, vector<char> > orders;
map<int, int> indices;
#define SWAP(X, Y) do { \
card tmp = X; \
X = Y; \
Y = tmp; \
} while(0)
int Partition(int p, int r) {
card x = A[r];
int i = p - 1;
for (int j = p; j < r; ++j) {
if (A[j].second <= x.second) {
i = i + 1;
SWAP(A[i], A[j]);
}
}
SWAP(A[i+1], A[r]);
return i + 1;
}
void Quicksort(int p, int r) {
if (p < r) {
int q = Partition(p, r);
Quicksort(p, q - 1);
Quicksort(q + 1, r);
}
}
int main(int argc, char** argv) {
int n;
cin >> n;
for(int i = 0; i < n; ++i) {
cin >> A[i].first;
cin >> A[i].second;
int n = A[i].second;
orders[n].push_back(A[i].first);
indices[n] = 0;
}
Quicksort(0, n - 1);
int stable = true;
for(int i = 0; i < n; ++i) {
int n = A[i].second;
if (orders[n][indices[n]] != A[i].first) {
stable = false;
}
indices[n] += 1;
}
if (stable) {
cout << "Stable" << endl;
} else {
cout << "Not stable" << endl;
}
for(int i = 0; i < n; ++i) {
cout << A[i].first << " " << A[i].second << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, i, counter;
vector<int> slimes;
int insert_or_sum(int number) {
if (!slimes.empty() && slimes.back() == number) {
slimes.pop_back();
return insert_or_sum(++number);
} else if (slimes.empty() || slimes.back() != number) {
slimes.push_back(number);
return 1;
}
}
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
insert_or_sum(1);
}
for (i = 0; i < slimes.size(); i++) {
cout << slimes.at(i) << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007LL, INF = 1e9, LINF = 1e18;
const long double Pi = 3.141592653589793116, EPS = 1e-9;
const long long dx[4] = {0, 1, 0, -1};
const long long dy[4] = {1, 0, -1, 0};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n;
cin >> n;
string str;
cin >> str;
long long can = (n - 11) / 2;
long long can2 = can;
long long p = count(str.begin(), str.end(), '8');
if (p <= can)
cout << "NO\n";
else {
long long vis[100003] = {0};
for (long long i = 0; can; i++) {
if (str[i] == '8') {
vis[i] = 1;
can--;
}
}
long long ct = 0;
long long idx;
for (long long i = 0; i < (long long)((str).size()); i++) {
if (str[i] == '8' && vis[i] == 0) {
idx = i;
break;
}
if (str[i] != '8') ct++;
}
if (ct <= can2)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 6e5 + 5;
const int M = 35;
const int mod = 998244353;
int n, m;
int cnt0;
long long a[N];
long long wB[N];
long long wA[19][N];
long long ans[N];
long long qpow(long long a, long long b) {
long long r = 1;
while (b) {
if (b & 1) r = r * a % mod;
b >>= 1;
a = a * a % mod;
}
return r;
}
long long popcount(long long x) {
int r = 0;
for (int i = 0; i < m; ++i)
if (x & 1ll << i) {
r++;
}
return r;
}
struct Basis {
long long a[M];
bool insert(long long x) {
for (int i = m - 1; ~i; --i)
if (x & 1ll << i) {
x ^= a[i];
}
for (int i = m - 1; ~i; --i)
if ((x & 1ll << i) && !a[i]) {
a[i] = x;
for (int j = m - 1; j > i; --j)
if (a[j] & 1ll << i) {
a[j] ^= x;
}
return 1;
}
return 0;
}
} T;
void dfs(vector<long long> A, int x, long long w, bool type) {
if (x == A.size()) {
if (!type) {
++wB[w];
} else {
int cnt = popcount(w ^ (w & ((1ll << m / 2) - 1)));
++wA[cnt][w & ((1ll << m / 2) - 1)];
}
return;
}
dfs(A, x + 1, w, type);
dfs(A, x + 1, w ^ A[x], type);
}
struct FWT {
int n;
void prepare(int len) {
for (n = 1; n <= len; n <<= 1)
;
}
void fwt(long long *a, int f) {
long long rev = 1;
if (f == -1) rev = qpow(2, mod - 2);
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j += i << 1) {
for (int k = 0; k < i; ++k) {
long long x = a[j + k], y = a[j + k + i];
a[j + k] = (x + y) * rev % mod;
a[j + k + i] = (x - y + mod) * rev % mod;
}
}
}
}
} F;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
for (int i = 1; i <= n; ++i)
if (!T.insert(a[i])) {
cnt0++;
}
vector<long long> A, B;
for (int i = 0; i < m / 2; ++i)
if (T.a[i]) B.push_back(T.a[i]);
for (int i = m / 2; i < m; ++i)
if (T.a[i]) A.push_back(T.a[i]);
dfs(B, 0, 0, 0);
dfs(A, 0, 0, 1);
F.prepare((1ll << 17) - 1);
F.fwt(wB, 1);
for (int i = 0; i <= 18; ++i) {
F.fwt(wA[i], 1);
for (int j = 0; j < F.n; ++j) wA[i][j] = wA[i][j] * wB[j] % mod;
F.fwt(wA[i], -1);
for (int j = 0; j < F.n; ++j) {
int cnt = popcount(j);
(ans[cnt + i] += wA[i][j]) %= mod;
}
}
for (int i = 0; i <= m; ++i) {
ans[i] = ans[i] * qpow(2, cnt0) % mod;
printf("%lld ", ans[i]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int first = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) {
if (ch == '-') f = -1;
}
for (; isdigit(ch); ch = getchar()) {
first = first * 10 + ch - 48;
}
return first * f;
}
const int mxN = 5e5;
int n, m, nn;
pair<int, int> a[mxN + 3];
long double d[mxN + 3], w[mxN + 3];
int cnt[mxN + 3], p[mxN + 3], f[mxN + 3];
map<pair<int, int>, int> id;
vector<int> vec[mxN + 3];
bool cmp_dis(int first, int second) { return d[first] < d[second]; }
bool cmp_cnt(int first, int second) {
return cnt[first] * d[first] > cnt[second] * d[second];
}
int gcd(int first, int second) {
return second == 0 ? first : gcd(second, first % second);
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) {
a[i].first = read(), a[i].second = read();
d[i] =
sqrt(1.0 * a[i].first * a[i].first + 1.0 * a[i].second * a[i].second);
int g = gcd(abs(a[i].first), abs(a[i].second));
if (g == 0) {
continue;
}
pair<int, int> tmp = make_pair(a[i].first / g, a[i].second / g);
if (!id[tmp]) {
id[tmp] = ++nn;
}
vec[id[tmp]].push_back(i);
}
for (int i = 1; i <= nn; i++) {
sort(vec[i].begin(), vec[i].end(), cmp_dis);
for (int j = 0; j < vec[i].size(); j++) {
cnt[vec[i][j]] = vec[i].size() - 1 - j;
}
}
for (int i = 1; i <= n; i++) {
w[i] = d[i] * (m - 1 - 2 * cnt[i]);
}
sort(w + 1, w + n + 1);
long double ans = 0.0;
for (int i = n; i > n - m; i--) {
ans += w[i];
}
int mx = 0;
for (int i = 1; i <= nn; i++) {
if (vec[i].size() >= n - (m + 1) / 2) {
mx = i;
break;
}
}
if (mx) {
long double ans2 = 0.0;
int tot = m - 1;
for (int i = 1; i <= nn; i++) {
if (i != mx) {
for (int j = vec[i].size() - 1, first = 0; j >= 0; j--) {
int u = vec[i][j];
ans2 += d[u] * (m - 1 - 2 * first);
first++;
tot--;
}
}
}
int first = 0;
for (int j = vec[mx].size() - 1; first < m / 2; j--) {
int u = vec[mx][j];
ans2 += d[u] * (m - 1 - 2 * first);
first++;
tot--;
}
for (int j = tot - 1; j >= 0; j--) {
int u = vec[mx][j];
ans2 += d[u] * (m - 1 - 2 * first);
first++;
tot--;
}
ans = max(ans, ans2);
}
printf("%.12Lf\n", ans);
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb push_back
#define all(v) (v).begin(),(v).end()
#define fi first
#define se second
typedef vector<int>vint;
typedef pair<int,int>pint;
typedef vector<pint>vpint;
template<typename A,typename B>inline void chmin(A &a,B b){if(a>b)a=b;}
template<typename A,typename B>inline void chmax(A &a,B b){if(a<b)a=b;}
const double INF=1e12;
int N,M,P;
int A[111111],B[111111],L[111111];
double C[111111];
double dp[1111][222];
double x[222];
signed main(){
cin>>N>>M>>P;
rep(i,M){
cin>>A[i*2]>>B[i*2];
A[i*2]--;B[i*2]--;
int x,y;
cin>>x>>y;
C[i*2]=1.0*y/x;
L[i*2]=x;
A[i*2+1]=B[i*2];
B[i*2+1]=A[i*2];
C[i*2+1]=C[i*2];
L[i*2+1]=L[i*2];
}
M*=2;
fill_n(*dp,1111*222,-INF);
dp[0][0]=0;
for(int i=0;i<P;i++){
for(int j=0;j<M;j++){
if(i+L[j]>P)continue;
chmax(dp[i+L[j]][B[j]],dp[i][A[j]]+L[j]*C[j]);
}
}
rep(i,M)chmax(x[A[i]],C[i]);
double ans=0;
rep(i,N){
for(int j=0;j<=P;j++){
for(int k=0;j+k<=P;k++){
chmax(ans,dp[j][i]+dp[k][i]+(P-j-k)*x[i]);
}
}
}
printf("%.20f\n",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int char_to_int(char c) {
int x = c - 48;
return x;
}
char int_to_char(int x) {
int c = x + 48;
return c;
}
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
map<int, int> mp;
vector<int> v;
map<int, vector<int> > G;
map<int, int> visited;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
struct node {
int roll;
node *next;
};
int main() {
fast();
int tst;
cin >> tst;
while (tst--) {
long long a, b, c;
cin >> a >> b >> c;
long long check = abs(a - b);
check *= 2;
if (a > check || b > check || c > check) {
cout << -1 << endl;
} else if (check / 2 + c <= check) {
cout << check / 2 + c << endl;
} else if (c - check / 2 > 0) {
cout << c - check / 2 << endl;
} else
cout << -1 << endl;
}
return 0;
}
| 2 |
#include <cmath>
#include <cstdio>
#include <algorithm>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
const double PI=acos(-1);
// whether (hx, hy) is covered by the sector (tx,ty,w,a)
bool check(int hx,int hy,int tx,int ty,double d,double w,int a){
int x=hx-tx,y=hy-ty;
if(sqrt(x*x+y*y)>a) return false;
double phi=atan2(y,x);
if(w>PI) w-=2*PI; // -PI < w <= PI
return min(min(abs(phi-w),abs(phi-w+2*PI)),abs(phi-w-2*PI))<d/2;
}
int main(){
for(int h,r;scanf("%d%d",&h,&r),h;){
int hx[100],hy[100];
rep(i,h) scanf("%d%d",hx+i,hy+i);
int nu,nm,ns;
double du,dm,ds;
scanf("%d%d%d",&nu,&nm,&ns);
scanf("%lf%lf%lf",&du,&dm,&ds);
du*=PI/180;
dm*=PI/180;
ds*=PI/180;
int ux[10],uy[10],mx[10],my[10],sx[10],sy[10];
rep(i,nu) scanf("%d%d",ux+i,uy+i);
rep(i,nm) scanf("%d%d",mx+i,my+i);
rep(i,ns) scanf("%d%d",sx+i,sy+i);
double w[100];
int a[100];
rep(i,r){
scanf("%lf%d",w+i,a+i);
w[i]*=PI/180;
}
int cnt[100]={};
rep(i,h) rep(j,r) {
bool ok=check(hx[i],hy[i],0,0,du,w[j],a[j]);
rep(k,nu) if(check(hx[i],hy[i],ux[k],uy[k],du,w[j],a[j])) ok=false;
rep(k,nm) if(check(hx[i],hy[i],mx[k],my[k],dm,w[j],a[j])) ok=false;
rep(k,ns) if(check(hx[i],hy[i],sx[k],sy[k],ds,w[j],a[j])) ok=false;
if(ok) cnt[i]++;
}
int maxi=*max_element(cnt,cnt+h);
if(maxi==0){ puts("NA"); continue; }
int num=0;
rep(i,h) if(cnt[i]==maxi) {
printf("%s%d",num>0?" ":"",i+1);
num++;
}
puts("");
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define endl "\n"
#define int long long
#define fast ios::sync_with_stdio(0); cin.tie(0);
int mod = 1000000007;
int32_t main()
{
fast;
int t;
cin>>t;
while(t--){
int n;
cin>>n;
map<int,int>mp;
for(int i=0 ; i<n ; i++){
int x;
cin>>x;
mp[x-(i+1)]++;
}
int ans(0);
for(auto it : mp){
int y=(it.second)*(it.second-1);
y/=2;
ans+=y;
}
cout<<ans<<endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double a, b, c, x, y, r;
scanf("%lf%lf%lf%lf%lf%lf", &a, &b, &c, &x, &y, &r);
if (r > b - a) {
printf("-1\n");
return 0;
}
double yw = c - r;
double y1 = a + r;
double y2 = b;
y = 2 * yw - y;
double k = (y - y1) / x;
double ans = (yw - y1) / k;
double dis = (y2 - y1) / sqrt(k * k + 1);
if (dis < r)
printf("-1\n");
else
printf("%.10f\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, num;
vector<long long int> odd, even;
cin >> n;
even.push_back(0);
odd.push_back(0);
bool f = 1;
while (n--) {
cin >> num;
if (f) {
even.push_back(even[even.size() - 1] + num);
odd.push_back(odd[odd.size() - 1]);
} else {
odd.push_back(odd[odd.size() - 1] + num);
even.push_back(even[even.size() - 1]);
}
f = !f;
}
long long int ans = 0;
for (int i = 1; i < even.size(); i++) {
long long int a = even[i - 1] + (odd[odd.size() - 1] - odd[i]);
long long int b = odd[i - 1] + (even[even.size() - 1] - even[i]);
if (a == b) ans++;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define MAX 51
#define MAX_M 5001
typedef pair<int,int> pii;
int main(){
int X,Y,Z,N,E,A;
while(cin >> X >> Y >> Z, X){
pii M[MAX];
vector<int> V(X);
for(int i = 0 ; i < X ; i++){
cin >> V[i];
}
for(int i = 0 ; i < MAX ; i++){
M[i] = pii(-1,-1);
}
for(int i = 0 ; i < Z ; i++){
cin >> N >> E >> A;
M[N] = pii(E,A);
}
double dp[MAX][MAX_M] = {{0}};
dp[0][0] = 1;
for(int i = 0 ; i < Y ; i++){
for(int j = 0 ; j < MAX_M ; j++){
if(dp[i][j] == 0) continue;
for(int k = 0 ; k < X ; k++){
int next = min(i+V[k], Y);
int v = M[next].first;
int v2 = M[next].second;
if(v == -1){
dp[next][j] += dp[i][j]/X;
}else if(v == 2){
dp[next][min(j+v2,MAX_M-1)] += dp[i][j]/X;
}else if(v == 3){
dp[next][max(j-v2,0)] += dp[i][j]/X;
}else{
next = min(next+v2,Y);
dp[next][j] += dp[i][j]/X;
}
}
}
}
double res = 0;
for(int i = 0 ; i < MAX_M ; i++){
res += i*dp[Y][i];
}
cout << (int)res << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename T1>
T amax(T &a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T amin(T &a, T1 b) {
if (b < a) a = b;
return a;
}
const int mod = 1000000000 + 7;
const int N = 1000000 + 6;
const int maxn = 1e5 + 5;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
string s[n];
for (int i = 0; i < n; i++) cin >> s[i];
map<string, int> m;
for (int i = 0; i < n; i++) m[s[i]] = i;
sort(s, s + n);
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string t = "";
bool bo = true;
for (int z = 0; z < k; z++) {
if (s[i][z] == s[j][z]) {
t += s[i][z];
} else {
int temp = s[i][z] + s[j][z];
t += 'S' + 'E' + 'T' - temp;
}
}
if (bo) {
int temp = lower_bound(s + j + 1, s + n, t) - s;
if (s[temp] == t) ans++;
}
}
}
cout << ans;
}
| 2 |
// compile in C++11. use -std=c++11.
#include <iostream>
#include <iomanip>
#include <vector>
#include <valarray>
#include <map>
#include <set>
#include <list>
#include <queue>
#include <stack>
#include <bitset>
#include <utility>
#include <numeric>
#include <algorithm>
#include <functional>
#include <complex>
#include <string>
#include <sstream>
#include <cstdio>
#include <cstdlib>
#include <cctype>
#include <cstring>
// this require C++11
#include <unordered_set>
#include <unordered_map>
#include <random>
using namespace std;
#define all(c) c.begin(),c.end()
#define repeat(i,n) for(int i=0;i<static_cast<int>(n);i++)
#define debug(x) #x << "=" << (x)
#define dump(x) cerr << debug(x) << " (L:" << __LINE__ << ")"<< endl
typedef complex<double> point;
template<typename T>
ostream& operator<<(ostream& os,const vector<T>& vec){
os << "[";
for(const auto& v : vec){
os << v << ",";
}
os << "]";
return os;
}
template<typename T>
T input(){
T t;cin >> t;
return t;
}
template<typename T>
vector<T> input(const int N){
vector<T> v(N);
repeat(i,N) cin >> v[i];
return v;
}
const double EPS = 1e-7;
int solve(vector<point> ps){
int n = ps.size();
int ret = 1;
for(int apple=0;apple<n;apple++){
for(int banana=0;banana<n;banana++){
if(apple == banana) continue;
int cur = 0;
point a = ps[apple];
point b = ps[banana];
point vec = a - b;
point unit_vec = vec / (abs(vec)+EPS);
point check = b + unit_vec;
for(const point& p : ps){
if(abs(check-p) <= 1 + EPS){
cur++;
}
}
ret = max(ret,cur);
}
}
return ret;
}
int main(){
while(true){
int n = input<int>();
if(n == 0) break;
vector<point> ps;
repeat(apple,n){
double x,y;
char c;
cin >> x >> c >> y;
ps.push_back(point(x,y));
}
cout << solve(ps) << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
int c = 0, d = 0;
set<string> set = {"ABSINTH", "BEER", "BRANDY", "CHAMPAGNE", "GIN", "RUM",
"SAKE", "TEQUILA", "VODKA", "WHISKEY", "WINE"};
for (int i = 0; i < n; i++) {
cin >> s;
if (set.find(s) != set.end())
c++;
else if (isdigit(s[0])) {
d = stoi(s, nullptr, 10);
if (d < 18) c++;
}
}
cout << c << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s1[1010], s2[1010];
int cnt1, cnt2, y;
int main() {
scanf("%s %s", s1, s2);
int len = strlen(s1);
int l = strlen(s2);
for (int i = 0; i < len; i++)
if (s1[i] == '1') cnt1++;
for (int i = 0; i < l; i++)
if (s2[i] == '1') cnt2++;
if (cnt2 > cnt1 && !(cnt1 % 2 && cnt2 - cnt1 == 1)) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
int main() {
int ans = inf;
int n, m;
cin >> n;
m = (n + 1) / 2;
map<int, int> fr;
map<int, int> bc;
map<int, int>::iterator it;
for (int i = 0; i < n; ++i) {
int tfr;
int tbc;
cin >> tfr >> tbc;
fr[tfr]++;
if (tfr != tbc) bc[tbc]++;
}
for (it = fr.begin(); it != fr.end(); ++it) {
int a = it->second;
int b = bc[it->first];
if (a >= m) {
ans = 0;
cout << ans;
return 0;
} else if (b >= m - a) {
ans = min(ans, m - a);
}
}
for (it = bc.begin(); it != bc.end(); ++it) {
int b = it->second;
if (b >= m) ans = min(ans, m);
}
cout << (ans == inf ? -1 : ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e) {
cout << e << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
long long sqr(long long n) { return n * n; }
double LOG(long long a, long long b) { return (log(a) / log(b)); }
long long GCD(long long a, long long b) {
if (a < 0) return GCD(-a, b);
if (b < 0) return GCD(a, -b);
return (!b) ? a : GCD(b, a % b);
}
long long LCM(long long a, long long b) {
if (a < 0) return LCM(-a, b);
if (b < 0) return LCM(a, -b);
return (a * (b / GCD(a, b)));
}
long long BigMod(long long B, long long P, long long M) {
if (!P) return 1;
if (!(P % 2)) return sqr(BigMod(B, P / 2, M)) % M;
return (B % M) * (BigMod(B, P - 1, M)) % M;
}
int main(void) {
double hC = 360.0 / 12.0;
double mC = 360.0 / 60.0;
int h, m;
scanf("%d:%d", &h, &m);
if (h >= 12) h -= 12;
double resH = hC * h;
if (m) resH += hC * (m / 60.0);
double resM = mC * m;
deb(resH, resM);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct pos {
int x, y;
};
int dx[] = {-1, 0, 1, 0, 0};
int dy[] = {0, 1, 0, -1, 0};
int n, m, w, size, x, y, itr, mx;
int v[1000][1000], u[1000][1000];
pos q[2][1000 * 1000];
int main() {
scanf("%d%d", &n, &m);
v[500][500] = n;
if (n >= 4) {
q[0][0] = (pos){500, 500};
size = 1;
}
while (size) {
++itr;
int t = 0;
for (int j = (0); j < (size); j++) {
x = q[w][j].x;
y = q[w][j].y;
if (u[x][y] == itr) continue;
u[x][y] = itr;
v[x][y] -= 4;
for (int k = (0); k < (4); k++) v[x + dx[k]][y + dy[k]]++;
}
++itr;
for (int j = (0); j < (size); j++) {
x = q[w][j].x;
y = q[w][j].y;
for (int k = (0); k < (5); k++) {
if (v[x + dx[k]][y + dy[k]] >= 4 && u[x + dx[k]][y + dy[k]] != itr) {
q[w ^ 1][t++] = (pos){x + dx[k], y + dy[k]};
u[x + dx[k]][y + dy[k]] = itr;
mx = max(mx, x + dx[k]);
}
}
}
size = t;
w ^= 1;
}
while (m--) {
scanf("%d%d", &x, &y);
x += 500, y += 500;
if (x < 0 || y < 0 || x >= 1000 || y >= 1000)
puts("0");
else
printf("%d\n", v[x][y]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, poz, cate;
int a[1000005];
long long sum[1000005];
long double Sol = -1;
inline long double Val(int p, int mij) {
return (long double)(sum[p] - sum[p - mij - 1] + sum[n] - sum[n - mij]) /
(1 + 2 * mij);
}
inline void Solve(int p) {
int st = 0, dr = min(p - 1, n - p), mij1, mij2;
for (int step = 1; step <= 200; ++step) {
if (st == dr) break;
if (dr - st == 1) {
if (Val(p, st) < Val(p, dr))
++st;
else
--dr;
break;
}
mij1 = st + (dr - st + 1) / 3 - 1;
mij2 = dr - (dr - st + 1) / 3 + 1;
if (Val(p, mij1) < Val(p, mij2))
st = mij1 + 1;
else
dr = mij2 - 1;
}
if (Sol < Val(p, st) - a[p]) {
Sol = Val(p, st) - a[p];
poz = p;
cate = st;
}
}
int main() {
int i, j;
cin.sync_with_stdio(0);
cin >> n;
for (i = 1; i <= n; ++i) cin >> a[i];
sort(a + 1, a + n + 1);
for (i = 1; i <= n; ++i) sum[i] = sum[i - 1] + a[i];
for (i = 1; i <= n; ++i) Solve(i);
cout << 2 * cate + 1 << "\n";
for (i = poz - cate; i <= poz; ++i) cout << a[i] << " ";
for (i = n - cate + 1; i <= n; ++i) cout << a[i] << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 2; i <= n; i++) {
while (n % i == 0) {
cout << i;
n /= i;
}
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "URDL";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 1000000007) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 1000000007) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
vector<int> mp[300135];
char s[300135];
string S = "AGCT";
int r[300135][2][4], col[300135][2][4];
int ans[4], id[4], A;
int gid(char x) {
for (int(i) = 0; (i) < (int)(4); (i)++)
if (S[i] == x) return i;
return -1;
}
int cal(int a, int b, int c, int d, bool fg) {
int t1 = 0, t2 = 0;
for (int(i) = 1; (i) <= (int)(n); (i)++) {
if (i % 2 == 1)
t1 += max(r[i][0][a] + r[i][1][b], r[i][0][b] + r[i][1][a]);
else
t1 += max(r[i][0][c] + r[i][1][d], r[i][0][d] + r[i][1][c]);
}
if (fg && t1 == A) {
for (int(i) = 1; (i) <= (int)(n); (i)++) {
if (i % 2 == 1) {
if (r[i][0][a] + r[i][1][b] < r[i][0][b] + r[i][1][a]) {
for (int(j) = 1; (j) <= (int)(m); (j)++)
printf("%c", j % 2 == 1 ? S[a] : S[b]);
} else
for (int(j) = 1; (j) <= (int)(m); (j)++)
printf("%c", j % 2 == 1 ? S[b] : S[a]);
} else {
if (r[i][0][c] + r[i][1][d] < r[i][0][d] + r[i][1][c]) {
for (int(j) = 1; (j) <= (int)(m); (j)++)
printf("%c", j % 2 == 1 ? S[c] : S[d]);
} else
for (int(j) = 1; (j) <= (int)(m); (j)++)
printf("%c", j % 2 == 1 ? S[d] : S[c]);
}
puts("");
}
exit(0);
}
for (int(j) = 1; (j) <= (int)(m); (j)++) {
if (j % 2 == 1) {
t2 += max(col[j][0][a] + col[j][1][c], col[j][0][c] + col[j][1][a]);
} else {
t2 += max(col[j][0][b] + col[j][1][d], col[j][0][d] + col[j][1][b]);
}
}
if (fg) {
assert(t2 == A);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
for (int(j) = 1; (j) <= (int)(m); (j)++) {
if (j % 2 == 1) {
if (col[j][0][a] + col[j][1][c] < col[j][0][c] + col[j][1][a]) {
printf("%c", i & 1 ? S[a] : S[c]);
} else
printf("%c", i & 1 ? S[c] : S[a]);
} else {
if (col[j][0][b] + col[j][1][d] < col[j][0][d] + col[j][1][b]) {
printf("%c", i & 1 ? S[b] : S[d]);
} else
printf("%c", i & 1 ? S[d] : S[b]);
}
}
puts("");
}
}
return max(t1, t2);
}
void fmain(int tid) {
scanf("%d%d", &n, &m);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
mp[i].resize(m + 5, -1);
scanf("%s", s + 1);
for (int(j) = 1; (j) <= (int)(m); (j)++) {
mp[i][j] = gid(s[j]);
}
for (int(j) = 1; (j) <= (int)(m); (j)++) {
r[i][j % 2][mp[i][j]]++;
col[j][i % 2][mp[i][j]]++;
}
}
for (int(i) = 0; (i) < (int)(4); (i)++) id[i] = i;
do {
int tt = cal(id[0], id[1], id[2], id[3], 0);
if (tt > A) {
A = tt;
for (int(i) = 0; (i) < (int)(4); (i)++) ans[i] = id[i];
}
} while (next_permutation(id, id + 4));
cal(ans[0], ans[1], ans[2], ans[3], 1);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (1ll << 62) - 1;
const long long MOD = 998244353;
const int MAX = 2e9 + 10;
const long long int N = 3e5 + 10;
using namespace std;
int bPow(int a, int b) {
int res = 1;
while (b) {
if (b & 1ll) {
res = 1ll * res * a % MOD;
}
b >>= 1;
a = 1ll * a * a % MOD;
}
return res;
}
void solve() {
int n, s;
cin >> n >> s;
vector<int> deg(n + 1, 0);
for (int i = 0; i < n - 1; ++i) {
int a, b;
cin >> a >> b;
deg[a]++, deg[b]++;
}
int leafNodes = 0;
for (int i : deg) {
leafNodes += (i == 1);
}
double ans = 2.0 * s / (double)leafNodes;
cout << fixed << setprecision(12) << ans;
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const char IO_MODE = 3;
inline long long ReadInt() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
inline void WriteInt(long long x) {
char CH[20];
if (x < 0) {
putchar('-');
x = -x;
}
int Num = 0;
if (!x) {
putchar('0');
return;
}
while (x > 0) CH[++Num] = x % 10, x /= 10;
while (Num) putchar(CH[Num--] + 48);
}
inline void out(int x) {
if (IO_MODE & 1)
WriteInt(x);
else
printf("%i", x);
}
template <typename... Args>
inline void out(int x, Args... args) {
out(x);
putc(' ', stdout);
out(args...);
}
inline void in(int &x) {
if (IO_MODE & 2)
x = ReadInt();
else
scanf("%i", &x);
}
template <typename... Args>
inline void in(int &x, Args &...args) {
in(x);
in(args...);
}
inline void outll(long long x) {
if (IO_MODE & 1)
WriteInt(x);
else
printf("%I64d", x);
}
template <typename... Args>
inline void outll(long long x, Args... args) {
outll(x);
putc(' ', stdout);
outll(args...);
}
inline void inll(long long &x) {
if (IO_MODE & 2)
x = ReadInt();
else
scanf("%I64d", &x);
}
template <typename... Args>
inline void inll(long long &x, Args &...args) {
inll(x);
inll(args...);
}
int aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, mm, nn, oo, pp, qq, rr, ss, tt,
uu, vv, ww, xx, yy, zz;
int tc;
int n, q, p, mask;
int A[1 << 22];
long long Ans[22];
long long More[2][22];
inline long long build(int l, int r, int lev) {
if (l == r) return 0;
long long L_ans = build(l, l + r >> 1, lev - 1);
long long R_ans = build((l + r >> 1) + 1, r, lev - 1);
long long ans = 0, L_more = 0, R_more = 0;
int tmp[r - l + 1];
int i = 0, j = 0, k = 0;
int *L = &A[l];
int *R = &A[(l + r >> 1) + 1];
int N = r - l + 1 >> 1;
while (k < N << 1) {
if (i == N)
while (j < N) tmp[k++] = R[j++], R_more += i;
else if (j == N)
while (i < N) tmp[k++] = L[i++], L_more += j;
else if (L[i] < R[j])
while (i < N && L[i] < R[j]) tmp[k++] = L[i++], L_more += j;
else if (L[i] > R[j])
while (j < N && L[i] > R[j]) tmp[k++] = R[j++], R_more += i;
else {
int pre_i = i;
int pre_j = j;
int pre_k = k;
int val = L[i];
while (i < N && L[i] == val) tmp[k++] = L[i++], L_more += pre_j;
while (j < N && R[j] == val) tmp[k++] = R[j++], R_more += pre_i;
}
}
N <<= 1;
for (int i = 0; i < N; i++) L[i] = tmp[i];
ans += L_ans + R_ans + L_more;
Ans[lev] += ans;
More[0][lev] += L_more;
More[1][lev] += R_more;
return ans;
}
int main() {
in(n);
for (int i = 0; i < 1 << n; i++) in(A[i]);
build(0, (1 << n) - 1, n);
in(q);
while (q--) {
in(p);
mask ^= (1 << p + 1) - 1;
for (int i = 1; i <= n; i++)
Ans[i] = Ans[i - 1] + More[!!(mask & 1 << i)][i];
outll(Ans[n]);
putc('\n', stdout);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-8;
const int MX = 1e5 + 5;
const int mod = 1e9 + 7;
char str[MX];
int main() {
scanf("%s", str);
int len = strlen(str);
long long ans = 1, num = 1;
for (int i = 0; i < len; i++) {
if (str[i] == 'a')
num++;
else if (str[i] == 'b') {
ans = ans * num % mod;
num = 1;
}
}
ans = ans * num % mod;
ans -= 1;
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500050 + 1;
const int DELTA = 200020 + 1;
pair<int, int> a, b;
int cnt[MAXN], sum[MAXN];
int main() {
scanf("%d%d", &a.second, &a.first);
scanf("%d%d", &b.second, &b.first);
if (a > b) swap(a, b);
for (int i = b.second; i > 0; i--) {
cnt[b.first - i + 1 + DELTA]++;
cnt[b.first + i + 1 + DELTA]--;
}
partial_sum(cnt, cnt + MAXN, sum);
long long res =
1 - sum[MAXN - 1] + sum[max(a.first + a.second, b.first) + 1 + DELTA];
for (int i = a.second; i > 0; i--) {
res +=
max((sum[a.first + i + DELTA] - sum[a.first - i + 1 + DELTA]) << 1, 1);
}
printf("%lld\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, c;
string a1 = "", b1 = "", c1 = "";
cin >> a >> b >> c;
for (int i = 0; i < a.size(); i++) {
if (a[i] != ';' && a[i] != '-' && a[i] != '_') {
if (a[i] >= 'a' && a[i] <= 'z') a[i] = a[i] - 32;
a1 += a[i];
}
}
for (int i = 0; i < b.size(); i++) {
if (b[i] != ';' && b[i] != '-' && b[i] != '_') {
if (b[i] >= 'a' && b[i] <= 'z') b[i] = b[i] - 32;
b1 += b[i];
}
}
for (int i = 0; i < c.size(); i++) {
if (c[i] != ';' && c[i] != '-' && c[i] != '_') {
if (c[i] >= 'a' && c[i] <= 'z') c[i] = c[i] - 32;
c1 += c[i];
}
}
int n;
cin >> n;
string* m = new string[n];
string* m1 = new string[n];
for (int i = 0; i < n; i++) {
cin >> m[i];
}
for (int j = 0; j < n; j++) {
for (int i = 0; i < m[j].size(); i++) {
if (m[j][i] != ';' && m[j][i] != '-' && m[j][i] != '_') {
if (m[j][i] >= 'a' && m[j][i] <= 'z') m[j][i] = m[j][i] - 32;
m1[j] += m[j][i];
}
}
}
string* s = new string[6];
s[0] = a1 + b1 + c1;
s[1] = a1 + c1 + b1;
s[2] = b1 + a1 + c1;
s[3] = b1 + c1 + a1;
s[4] = c1 + a1 + b1;
s[5] = c1 + b1 + a1;
bool r;
for (int i = 0; i < n; i++) {
r = false;
for (int j = 0; j < 6 && !r; j++)
if (m1[i] == s[j]) r = true;
if (r)
cout << "ACC" << endl;
else
cout << "WA" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int n, m, dir = 1, now = 1;
char s[105][10005];
long long ans;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
for (int i = 1; i < n; i++) {
int l = now - 1, r = now + 1;
if (s[i + 1][now] == '.') {
ans++;
continue;
}
now = -1;
while (l && s[i][l] != '#' || r <= m && s[i][r] != '#')
if (dir) {
ans += r - l - 2;
while (r <= m && s[i + 1][r] != '.' && s[i][r] == '.') r++, ans++;
if (s[i][r] == '.' && s[i + 1][r] == '.') {
now = r;
break;
}
dir = 0;
ans++;
if (s[i][r] == '+') s[i][r] = '.';
} else {
ans += r - l - 2;
while (l && s[i + 1][l] != '.' && s[i][l] == '.') l--, ans++;
if (s[i][l] == '.' && s[i + 1][l] == '.') {
now = l;
break;
}
dir = 1;
ans++;
if (s[i][l] == '+') s[i][l] = '.';
}
if (now < 0) {
printf("Never\n");
return 0;
}
ans += 2;
}
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') positive = 0;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline char RC() {
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
return c;
}
inline long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline long long lcm(long long a, long long b, long long MOD) {
return a / gcd(a, b) * b % MOD;
}
inline long long Sub(long long x, long long y, long long mod) {
long long res = x - y;
while (res < 0) res += mod;
return res;
}
inline long long Add(long long x, long long y, long long mod) {
long long res = x + y;
while (res >= mod) res -= mod;
return res;
}
inline long long POW_MOD(long long x, long long y, long long mod) {
long long ret = 1;
while (y > 0) {
if (y & 1) ret = ret * x % mod;
x = x * x % mod;
y >>= 1;
}
return ret;
}
const int N = 6005;
const int inf = 2100000000;
const long long INF = 1LL << 62;
const double PI = 3.14159265358;
int n, m;
int dis[N][N];
vector<pair<int, int> > fr[N], to[N];
vector<int> e[N];
bool vis[N];
void spfa(int u) {
memset(vis, false, sizeof(vis));
queue<int> q;
q.push(u);
vis[u] = true;
dis[u][u] = 0;
while (q.size()) {
int cur = q.front();
q.pop();
vis[cur] = false;
for (int i = 0; i < e[cur].size(); ++i) {
int v = e[cur][i];
if (dis[u][v] > dis[u][cur] + 1) {
dis[u][v] = dis[u][cur] + 1;
if (!vis[v]) {
q.push(v);
}
}
}
}
}
void init() {
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= n; ++j) {
dis[i][j] = inf;
}
}
}
bool judge(int a, int b, int c, int d) {
if (a == b || a == c || a == d || b == c || b == d || c == d) return false;
return true;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
e[u].push_back(v);
}
init();
for (int i = 1; i <= n; ++i) {
spfa(i);
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (dis[i][j] == inf) continue;
fr[i].push_back(make_pair(dis[i][j], j));
to[j].push_back(make_pair(dis[i][j], i));
}
sort(fr[i].begin(), fr[i].end());
}
for (int i = 1; i <= n; ++i) sort(to[i].begin(), to[i].end());
int ans = 0;
int a, b, c, d;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (i == j || dis[i][j] == inf) continue;
for (int p = to[i].size() - 1; p >= max(0, (int)to[i].size() - 1 - 3);
--p) {
for (int q = fr[j].size() - 1; q >= max(0, (int)fr[j].size() - 4);
--q) {
int ii = to[i][p].second, jj = fr[j][q].second;
if (judge(ii, i, j, jj)) {
long long temp = dis[ii][i] + dis[i][j] + dis[j][jj];
if (temp > ans) {
ans = temp;
a = ii, b = i, c = j, d = jj;
}
}
}
}
}
}
cout << a << " " << b << " " << c << " " << d << endl;
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
signed main(){
int x,t;
cin>>x>>t;
cout<<max(0,x-t)<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool not_there(int temp[], int x, int length) {
for (int i = 0; i < length; i++) {
if (temp[i] == x) return false;
}
return true;
}
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int temp[n];
for (int i = 0; i < n; i++) {
temp[i] = 0;
}
temp[n] = a[n];
for (int i = n - 1; i >= 0; i--) {
if (not_there(temp, a[i], n)) {
temp[i] = a[i];
}
}
int counter = 0;
for (int i = 0; i < n; i++) {
if (temp[i] != 0) counter++;
}
cout << counter << endl;
for (int i = 0; i < n; i++) {
if (temp[i] != 0) cout << temp[i] << " ";
}
return 0;
}
| 1 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cctype>
#include <cstdio>
using namespace std;
typedef long long ll;
typedef string::const_iterator State;
#define rep(i,n) for(int i=0;i<(n);i++)
class Parser{
public:
int expression(State &begin){
int ret = term(begin);
for(;;){
if(*begin == '+'){
begin++;
ret += term(begin);
}else if(*begin == '-'){
begin++;
ret -= term(begin);
}else{
break;
}
}
return ret;
}
int term(State &begin){
int ret = factor(begin);
for(;;){
if(*begin == '*'){
begin++;
ret *= factor(begin);
}else if(*begin == '/'){
begin++;
ret /= factor(begin);
}else{
break;
}
}
return ret;
}
int factor(State &begin){
int ret;
if(*begin == '('){
begin++;//'('?????????
ret = expression(begin);
begin++;//')'?????????
}else{
ret = number(begin);
}
return ret;
}
int number(State &begin){
int ret = 0;
while(isdigit(*begin)){
ret *= 10;
ret += *begin - '0';
begin++;
}
return ret;
}
};
int main(void){
int n; cin >> n;
rep(i, n){
Parser ps;
string s; cin >> s;
string tmp = s.substr(0, s.size() - 1);
// cout << tmp << endl;
State begin = s.begin();
int ret = ps.expression(begin);
printf("%d\n", ret);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C& a, C b) {
a = min(a, b);
}
template <class C>
void maxi(C& a, C b) {
a = max(a, b);
}
const long long mod = 1e9 + 7;
struct nodo {
void upd(int val, int x, int y) { v = val; }
nodo comb(nodo& izq, nodo& der) {
v = max(izq.v, der.v);
return *this;
}
int v;
};
struct segmentTreeLazy {
segmentTreeLazy(int _n) {
n = _n;
tree = vector<nodo>(4 * n);
}
void upd(int i, int val) { upd(i, val, 1, 0, n); }
void upd(int i, int val, int v, int x, int y) {
if (i < x or y <= i) return;
if (x + 1 == y) {
tree[v].upd(val, x, y);
return;
}
int m = (x + y) / 2;
upd(i, val, 2 * v, x, m);
upd(i, val, 2 * v + 1, m, y);
tree[v].comb(tree[2 * v], tree[2 * v + 1]);
}
nodo get(int l, int r) { return get(l, r, 1, 0, n); }
nodo get(int l, int r, int v, int x, int y) {
if (r <= x or l >= y) return nodo();
if (l <= x and r >= y) return tree[v];
int m = (x + y) / 2;
nodo izq = get(l, r, 2 * v, x, m);
nodo der = get(l, r, 2 * v + 1, m, y);
return nodo().comb(izq, der);
}
int trav(int l, int x) { return trav(l, x, 1, 0, n); }
int trav(int l, int k, int v, int x, int y) {
if (y <= l) return n;
if (tree[v].v < k) return n;
if (x + 1 == y) return x;
int m = (x + y) / 2;
int izq = trav(l, k, 2 * v, x, m);
if (izq != n) return izq;
return trav(l, k, 2 * v + 1, m, y);
}
vector<nodo> tree;
int n;
};
void controversial_rounds() {
int n;
string s;
cin >> n >> s;
segmentTreeLazy st(n);
vector<int> nxt1(n + 1), nxt0(n + 1);
nxt1[n] = n;
nxt0[n] = n;
for (int(i) = n - 1; i >= 0; i--) {
if (s[i] == '1')
nxt1[i] = i;
else
nxt1[i] = nxt1[i + 1];
}
for (int(i) = n - 1; i >= 0; i--) {
if (s[i] == '0')
nxt0[i] = i;
else
nxt0[i] = nxt0[i + 1];
}
for (int i = 0; i < n; i++) st.upd(i, max(nxt1[i], nxt0[i]) - i);
vector<int> res(n + 1);
for (int(x) = 1; x <= n; x++) {
int l = 0;
l = st.trav(l, x);
while (l < n) {
l += x;
l = st.trav(l, x);
res[x]++;
}
}
for (int(i) = 1; i <= n; i++) cout << res[i] << ' ';
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
controversial_rounds();
}
| 6 |
//神题
#include<cstdio>
#include<cstring>
#include<algorithm>
#define N 1000010
using namespace std;
int n, ff, op, cl, d[N], ans, L, R, now;
char s1[N], s2[N];
int main(){
scanf("%d%s%s", &n, s1+1, s2+1); s2[0]='$';
ff=1; for(int i=1; i<=n; i++)if(s1[i]!=s2[i]){ff=0; break;}
if(ff){printf("0"); return 0;}
now=n; R=n;
op=1; cl=ans=0;
for(int i=n-1; i>=0; i--)if(s2[i]!=s2[i+1]){
L=i+1;
while(now&&(now>L||s1[now]!=s2[L]))now--;
if(!now){printf("-1"); return 0;}
while(op<=cl&&R<d[op]-(cl-op))op++;
d[++cl]=now;
ans=max(ans, cl-op+1);
now--; R=i;
}
printf("%d", ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 200100;
const long long MAXK = 16000000;
const long long INF = 1e9;
const long long MOD = 1e9 + 7;
int A[MAXN];
int sz[MAXN];
int N, K, a, b;
int R;
vector<long long> V[MAXN];
int p[MAXN];
int par(int x) { return (p[x] == x) ? x : p[x] = par(p[x]); }
int main() {
cin >> N >> K;
for (int i = 1; i <= N; ++i) {
cin >> A[i];
sz[A[i]]++;
V[A[i]].emplace_back(i);
}
R = N - 1;
for (int i = 1; i < N; ++i)
if (A[i] == A[i + 1]) --R;
cout << R << '\n';
for (int i = 1; i <= K; ++i) p[i] = i;
for (int i = 1; i < K; ++i) {
cin >> a >> b;
a = par(a);
b = par(b);
if (sz[a] < sz[b]) swap(a, b);
for (auto i : V[b]) {
if (A[i + 1] == a) --R;
if (A[i - 1] == a) --R;
}
for (auto i : V[b]) {
V[a].emplace_back(i);
A[i] = a;
}
p[b] = a;
sz[a] = sz[b] = sz[a] + sz[b];
cout << R << '\n';
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s, a = "", b;
cin >> s;
unordered_map<string, int> m;
m[s]++;
for (int i = s.length() - 1; i >= 0; i--) {
a += s[i];
b = a;
reverse(b.begin(), b.end());
m[b + s.substr(0, i)]++;
}
cout << m.size() << endl;
}
int main() {
{ solve(); }
return 0;
}
| 1 |
#include <stdio.h>
#include <algorithm>
using namespace std;
int n, m, t, i, j, k;
long long p[100005], x=1000000;
struct AB{
int a, b, i;
bool operator < (const AB &A) const{
if(a != A.a) return a < A.a;
return b < A.b;
}
} d[100005];
int main(){
scanf("%d%d", &m, &n);
for(i=1; i<=n; i++){
scanf("%d%d", &d[i].a, &d[i].b);
d[i].i = i;
}
sort(d+1, d+n+1);
for(i=1; i<=n; i++){
if(d[i].a != d[i-1].a) j = 0;
p[d[i].i] = d[i].a * x + (++j);
}
for(i=1; i<=n; i++){
printf("%012lld\n", p[i]);
}
return 0;
} | 0 |
#include<cstdio>
int main(){
int N;scanf("%d",&N);
int mx=0,mxc,mn=N,mnc;
for(int i=0,a;i<N;i++){
scanf("%d",&a);
a>mx?mx=a,mxc=1:a==mx?mxc++:1;
a<mn?mn=a,mnc=1:a==mn?mnc++:1;
}
puts(mx==mn&&(mx==N-1||mx<=N/2)||mx==mn+1&&mx-mnc>0&&mx-mnc<=mxc/2?"Yes":"No");
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[11], b[11];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
a[i] = x;
}
for (int i = 0; i < m; i++) {
int x;
cin >> x;
b[x]++;
}
for (int i = 0; i < n; i++) {
if (b[a[i]]) cout << a[i] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[200005];
void solve() {
int n, k, d;
cin >> n >> k >> d;
int ans = n + 7;
for (int i = 1; i <= n; ++i) cin >> a[i];
set<int> T;
map<int, int> cnt;
for (int i = 1; i <= n; ++i) {
T.insert(a[i]);
cnt[a[i]]++;
if (i >= d) {
ans = min(ans, (int)T.size());
cnt[a[i - d + 1]]--;
if (cnt[a[i - d + 1]] == 0) T.erase(a[i - d + 1]);
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
long long cnt1, cnt2, cnt3, cnt4;
cnt1 = cnt2 = cnt3 = cnt4 = 0;
string str1, str2;
scanf("%d", &n);
getchar();
cin >> str1 >> str2;
for (int i = 0; str1[i] != '\0'; i++) {
if (str1[i] == '0' && str2[i] == '1')
cnt1++;
else if (str1[i] == '1' && str2[i] == '1')
cnt2++;
else if (str1[i] == '0' && str2[i] == '0')
cnt3++;
else if (str1[i] == '1' && str2[i] == '0')
cnt4++;
}
long long sum = cnt4 * cnt1 + cnt2 * cnt3 + cnt4 * cnt3;
printf("%I64d", sum);
return 0;
}
| 2 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
int N,A[200100];
signed main(){
cin>>N;
for(int i=0;i<N;i++){
int a;
cin>>a;
A[a]=i;
}
A[0]=N;
A[N+1]=-1;
int ans=0,cnt=0;
for(int i=1;i<=N+1;i++){
if(A[i]<A[i-1])ans=max(ans,cnt),cnt=1;
else cnt++;
}
cout<<N-ans<<endl;
} | 0 |
#include <cstdio>
#include <iostream>
#include <vector>
#include <list>
#include <cmath>
#include <fstream>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <complex>
#include <iterator>
#include <cstdlib>
#include <cstring>
#include <sstream>
using namespace std;
const double EPS=(1e-10);
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<pii,int> pag;
typedef pair<pag,pag> sit;
bool EQ(double a,double b){
return abs((a)-(b))<EPS;
}
void fast_stream(){
std::ios_base::sync_with_stdio(0);
}
// »ÝÌÊu©çßéÆ«ÉAæè¤éOÌêðñ
vector<pag> backTable[2][4][16][64];
// »ÝÌÊu©çiÞÆ«ÉAæè¤éÌê
pag goTable[2][4][16][64];
// ·ÅÉÊßµ½ê
bool vis[4][16][64][4][16][64];
// ¡ÌóÔ©çS[Ößêé©
bool isGoal[4][16][64];
bool used[4][101][101];
int H,W;
char field[101][101];
int sx,sy;
int sag;
int gx,gy;
int gag;
const int dy[]={-1,0,1,0};
const int dx[]={0,1,0,-1};
void calcGoAndBackTable(){
for(int i=0;i<H;i++){
for(int j=0;j<W;j++){
if(field[i][j]=='#')continue;
for(int k=0;k<4;k++){
// ¶©EÉûü]·µÄAOiµ½ ÆÌêðßé
// ¶
{
int nag=(k-1+4)%4;
int ny=i;
int nx=j;
while(ny>=0&&nx>=0&&ny<H&&nx<W&&field[ny][nx]!='#'){
ny+=dy[nag];
nx+=dx[nag];
}
ny-=dy[nag];
nx-=dx[nag];
goTable[0][k][i][j]=pag(pii(ny,nx),nag);
}
// E
{
int nag=(k+1+4)%4;
int ny=i;
int nx=j;
while(ny>=0&&nx>=0&&ny<H&&nx<W&&field[ny][nx]!='#'){
ny+=dy[nag];
nx+=dx[nag];
}
ny-=dy[nag];
nx-=dx[nag];
goTable[1][k][i][j]=pag(pii(ny,nx),nag);
}
// »ÝÌü«Ì½ÎÖßÁ½ãûü]··é
int backAg=(k+2)%4;
int ny=i;
int nx=j;
while(ny>=0&&nx>=0&&ny<H&&nx<W&&field[ny][nx]!='#'){
// ±±Å¶ÉûüðϦéêÆEÉûüðϦéêÅêí¯
// ¶
{
int nag=(k-1+4)%4;
// ¡ü¢Ä¢éûüÉǪ êÎAXgÉÇÁ
if(field[ny+dy[nag]][nx+dx[nag]]=='#')backTable[0][k][i][j].push_back(pag(pii(ny,nx),nag));
}
// E
{
int nag=(k+1)%4;
// ¡ü¢Ä¢éûüÉǪ êÎAXgÉÇÁ
if(field[ny+dy[nag]][nx+dx[nag]]=='#')backTable[1][k][i][j].push_back(pag(pii(ny,nx),nag));
}
ny+=dy[backAg];
nx+=dx[backAg];
}
}
}
}
}
// X^[gn_©çÔÉvZµÄ¢
int bfs(int psx,int psy,int pang){
int res=0;
// ·ÅÉS[Â\
if(gy==psy&&gx==psx)return 2;
for(int cnt=0;cnt<4;cnt++){
memset(vis,0,sizeof(vis));
priority_queue<sit> pq;
// X^[gn_ðpush
pq.push(sit(pag(pii(psy,psx),pang),pag(pii(sy,sx),(cnt))));
vis[pang][psy][psx][sag][sy][sx]=true;
while(pq.size()){
sit cur=pq.top();pq.pop();
// »ÝÌóÔðæ¾
int gpx=cur.first.first.second;
int gpy=cur.first.first.first;
int gang=cur.first.second;
int bpx=cur.second.first.second;
int bpy=cur.second.first.first;
int bang=cur.second.second;
// S[ȏ
if(gpy==gy&&gpx==gx){
res=max(res,1);
if(isGoal[bang][bpy][bpx]){
res=max(res,2);
}
}
// ̽ßðǤ·é©
for(int i=0;i<2;i++){
// Ìs«æ
pag ngpag=goTable[i][gang][gpy][gpx];
// ßéÓ¾¯vZ
for(int j=0;j<backTable[i][bang][bpy][bpx].size();j++){
pag nbpag=backTable[i][bang][bpy][bpx][j];
// ngpagÆnbpagÌîñ©çÉ¢¯éê
if(vis[ngpag.second][ngpag.first.first][ngpag.first.second][nbpag.second][nbpag.first.first][nbpag.first.second])
continue;
vis[ngpag.second][ngpag.first.first][ngpag.first.second][nbpag.second][nbpag.first.first][nbpag.first.second]=true;
pq.push(sit(ngpag,nbpag));
}
}
}
}
// 3ÂÌÇÌóÔÉÈé©`FbN
return res;
}
bool bfs2(int psx,int psy,int pang){
int res=0;
// ·ÅÉS[Â\
if(gy==psy&&gx==psx)return true;
memset(used,0,sizeof(used));
priority_queue<pag> pq;
// X^[gn_ðpush
pq.push(pag(pii(psy,psx),pang));
used[pang][psy][psx]=true;
while(pq.size()){
pag cur=pq.top();pq.pop();
// »ÝÌóÔðæ¾
int gpx=cur.first.second;
int gpy=cur.first.first;
int gang=cur.second;
// S[ȏ
if(gpy==gy&&gpx==gx){
return true;
}
// ̽ßðǤ·é©
for(int i=0;i<2;i++){
// Ìs«æ
pag ngpag=goTable[i][gang][gpy][gpx];
if(used[ngpag.second][ngpag.first.first][ngpag.first.second])
continue;
used[ngpag.second][ngpag.first.first][ngpag.first.second]=true;
pq.push(ngpag);
}
}
return false;
}
void input(){
// startÆgoalÌÊuðè
for(int i=0;i<H;i++)
for(int j=0;j<W;j++)
cin>>field[i][j];
for(int i=0;i<H;i++){
for(int j=0;j<W;j++){
if(field[i][j]=='K'){
field[i][j]='.';
sy=i;sx=j;
for(int k=0;k<4;k++){
int ny=i+dy[k];
int nx=j+dx[k];
if(field[ny][nx]=='.')sag=k;
}
}
else if(field[i][j]=='M'){
field[i][j]='.';
gy=i;gx=j;
for(int k=0;k<4;k++){
int ny=i+dy[k];
int nx=j+dx[k];
if(field[ny][nx]=='.')gag=k;
}
}
}
}
}
void init(){
memset(isGoal,0,sizeof(isGoal));
for(int i=0;i<2;i++)for(int j=0;j<4;j++)
for(int k=0;k<16;k++)for(int l=0;l<64;l++)
backTable[i][j][k][l].clear();
}
int main(){
while(cin>>W>>H&&(W|H)){
// ú»
init();
input();
calcGoAndBackTable();
// S[ÖßêéêðvZ
{
int cy=gy;
int cx=gx;
int cag=gag;
isGoal[cag][cy][cx]=true;
while(field[cy][cx]!='#'){
//isGoal[cag][cy][cx]=true;
cy+=dy[gag];
cx+=dx[gag];
}
cy-=dy[gag];
cx-=dx[gag];
isGoal[cag][cy][cx]=true;
}
// startn_©ç··ßĨ
int psy=sy;
int psx=sx;
int pang=sag;
while(psy>=0&&psx>=0&&psy<H&&psx<W&&field[psy][psx]!='#'){
psy+=dy[sag];
psx+=dx[sag];
}
// ß·
psy-=dy[sag];
psx-=dx[sag];
int res=bfs(psx,psy,pang);
res=max(res,(int)bfs2(psx,psy,pang));
if(res==0)
cout<<"He cannot bring tea to his master."<<endl;
else if(res==1)
cout<<"He cannot return to the kitchen."<<endl;
else if(res==2)
cout<<"He can accomplish his mission."<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 150005;
int n, m;
set<long long> st;
long long a[N], b[N];
int main() {
int i, j;
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i] >> b[i];
for (i = 2; i * i <= a[1]; i++) {
if (a[1] % i == 0) st.insert(i);
while (a[1] % i == 0) a[1] /= i;
}
if (a[1] > 1) st.insert(a[1]);
for (i = 2; i * i <= b[1]; i++) {
if (b[1] % i == 0) st.insert(i);
while (b[1] % i == 0) b[1] /= i;
}
if (b[1] > 1) st.insert(b[1]);
set<long long>::iterator it;
for (i = 2; i <= n; i++) {
for (it = st.begin(); it != st.end();) {
long long x = (*it);
if ((a[i] % x) && (b[i] % x))
st.erase(it++);
else
it++;
}
}
if (st.size() == 0)
cout << -1;
else
cout << (*st.begin());
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main(){
int n;cin>>n;
int sm = 0;
for(int i = 0; n > i; i++){
int tmp;cin>>tmp;
sm += tmp-1;
}
cout << sm << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int f[200005][3];
vector<int> tree[200005];
void dfs(int node) {
if (tree[node].size() == 0) {
f[node][2] = 1;
return;
}
int f_total = 1;
f[node][0] = 1;
for (int i = 0; i < tree[node].size(); i++) {
int child = tree[node][i];
dfs(child);
f_total = (((long long)(f_total) *
(long long)((f[child][0] + f[child][2]) % 998244353 +
(f[child][1] + f[child][2]) % 998244353)) %
998244353);
f[node][0] =
(((long long)(f[node][0]) * (long long)(f[child][0] + f[child][2])) %
998244353);
}
vector<int> pprod(tree[node].size()), sprod(tree[node].size());
int tmp = 1;
for (int i = 0; i < tree[node].size(); i++) {
int child = tree[node][i];
pprod[i] = tmp;
tmp = (((long long)(tmp) * (long long)(f[child][0] + f[child][2])) %
998244353);
}
tmp = 1;
for (int i = (int)(tree[node].size()) - 1; i >= 0; i--) {
int child = tree[node][i];
sprod[i] = tmp;
tmp = (((long long)(tmp) * (long long)(f[child][0] + f[child][2])) %
998244353);
}
for (int i = 0; i < tree[node].size(); i++) {
int child = tree[node][i];
(f[node][1]) +=
((((long long)(f[child][1] + f[child][2]) *
(long long)((((long long)(pprod[i]) * (long long)(sprod[i])) %
998244353))) %
998244353));
if ((f[node][1]) >= 998244353) (f[node][1]) -= 998244353;
}
f[node][2] = f_total;
(f[node][2]) -= (f[node][0]);
if ((f[node][2]) < 0) (f[node][2]) += 998244353;
(f[node][2]) -= (f[node][1]);
if ((f[node][2]) < 0) (f[node][2]) += 998244353;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int p;
scanf("%d", &p);
tree[p].push_back(i);
}
dfs(1);
printf("%d", (f[1][0] + f[1][2]) % 998244353);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ans[200010];
int tab[200010];
int last[200010];
int ix[200010];
bool cmp(int a, int b) { return a > b; }
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> tab[i];
int mx = 0;
for (int i = 1; i <= m; i++) {
int ask, a;
cin >> ask >> a;
last[a] = ask;
ix[a] = i;
mx = max(mx, a);
}
for (int i = mx; i >= 1; i--)
if (!last[i] || ix[i] < ix[i + 1]) {
last[i] = last[i + 1];
ix[i] = ix[i + 1];
}
for (int i = mx + 1; i <= n; i++) ans[i] = tab[i];
if (last[mx] == 2)
sort(tab + 1, tab + mx + 1, cmp);
else
sort(tab + 1, tab + mx + 1);
ans[mx] = tab[mx];
int kiri = 1;
int kanan = mx - 1;
for (int i = mx - 1; i >= 1; i--) {
if (last[i] == last[mx]) {
ans[i] = tab[kanan--];
} else {
ans[i] = tab[kiri++];
}
}
for (int i = 1; i <= n; i++) {
if (i == n)
cout << ans[i] << "\n";
else
cout << ans[i] << " ";
}
}
| 3 |
#pragma GCC optimize("O3")
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
#include<map>
#include<unordered_set>
#include<map>
#include<algorithm>
#include<queue>
#include<stack>
#include<cstdio>
#include<cassert>
#include<sstream>
#include<random>
#include<deque>
#include<set>
#include<unordered_map>
#include<list>
#define int long long int
using namespace std;
signed main(){
int t; cin >> t;
while (t--) {
int n, m; cin >> n >> m;
vector<vector<int>> a(n, vector<int>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
char c; cin >> c;
a[i][j] = (c == '*');
}
}
vector<vector<int>> dpL(n, vector<int>(m)), dpR(n, vector<int>(m));
for (int i = 0; i < m; ++i) dpL[0][i] = dpR[0][i] = a[0][i];
for (int i = 0; i < n; ++i) dpL[i][0] = a[i][0];
for (int i = 0; i < n; ++i) dpR[i][m - 1] = a[i][m - 1];
for (int i = 1; i < n; ++i) {
for (int j = 1; j < m; ++j) {
if (a[i][j] == 0) dpL[i][j] = 0;
else dpL[i][j] = min(dpL[i][j - 1], dpL[i - 1][j]) + 1;
}
}
for (int i = 1; i < n; ++i) {
for (int j = m - 2; j >= 0; --j) {
if (a[i][j] == 0) dpR[i][j] = 0;
else dpR[i][j] = min(dpR[i][j + 1], dpR[i - 1][j]) + 1;
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) ans += min(dpL[i][j], dpR[i][j]);
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 400002;
int n, b[N];
long long a[N];
int main() {
scanf("%d", &n);
bool zero = true;
for (int(i) = (1); (i) <= (int)(n); (i)++)
scanf("%d", &b[i]), b[i + n] = b[i], zero &= !b[i];
if (zero) {
printf("YES\n");
for (int(i) = (1); (i) <= (int)(n); (i)++) printf("1 ");
printf("\n");
return 0;
}
for (int(i) = (2 * n); (i) >= (n + 1); --(i))
if (b[i] > b[i - 1]) {
a[i] = b[i];
for (int(j) = (i - 1); (j) >= (1); --(j)) {
if (a[j + 1] > b[j])
a[j] = b[j];
else {
a[j + 1] += ((b[j] - a[j + 1]) / a[j + 2] + 1) * a[j + 2];
a[j] = b[j];
}
}
a[1] = a[n + 1];
printf("YES\n");
for (int(i) = (1); (i) <= (int)(n); (i)++) printf("%lld ", a[i]);
printf("\n");
return 0;
}
printf("NO\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool satr[200002], col[200];
int dif(int a, int b) {
if (a < 13 && b < 13) return abs(a - b);
if (a >= 13 && b >= 13)
return abs(a - b);
else {
if (a <= b) {
int c = a;
a = b;
b = c;
}
if (a >= 13)
return min(a - b, 26 - (a - b));
else
return min(a - b, 26 - (b - a));
}
}
int main() {
long long a1, b1, c1, a2, b2, c2, m, n, n3, m3 = n3 = 0, p, q = 0;
cin >> n >> p;
string s;
cin >> s;
bool khar = false;
for (int i = 0; i < s.size() / 2; i++) {
if (dif(s[i] - 'a', s[s.size() - i - 1] - 'a') != 0) {
m = i;
if (!khar) {
n = i;
khar = true;
}
}
q += dif(s[i] - 'a', s[s.size() - i - 1] - 'a');
}
if (p > s.size() / 2) {
p = s.size() - p;
} else
p--;
{
if (q == 0) {
cout << q;
return 0;
}
if (abs(m - p) < abs(n - p))
q += abs(m - p) + abs(m - n);
else
q += abs(n - p) + abs(m - n);
}
cout << q;
return 0;
}
| 3 |
#include <iostream>
#include <string>
using namespace std;
int main()
{
int t;
cin >> t;
while (t--)
{
int o = 0, c = 0, q = 0, test = 0;
string s;
cin >> s;
if ((s.size()) % 2 != 0)
test = 1;
else if ((s.size()) % 2 == 0)
{
int flag = 0;
for (auto it = s.begin(); it != s.end(); it++)
{
if (c > o&&q<1)
{
test = 1;
break;
}
if ((*it) == '(')
{
// if (flag == 0)
// {
// test = 1;
// break;
// }
// else
// flag = 1;
o++;
}
else if ((*it) == ')')
{
c++;
// if (c < o)
// flag = 0;
// else
// flag = 1;
}
else if((*it)=='?')
q++;
}
}
auto i=s.end();
i--;
if((*i)=='(')
test=1;
if (test == 0)
cout << "YES\n";
else if (test == 1)
cout << "NO\n";
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main() {
ll h, e, ans;
cin >> h >> e;
if((h==1)||(e==1)) ans=1;
else ans=(h*e+1)/2;
cout <<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100002;
int arr[N], tree[4 * N][20], lazy[4 * N];
bool GetBit(int num, int idx) { return ((num >> idx) & 1); }
long long SUM(int a[20]) {
long long ret = 0, r = 1;
for (int i = 0; i < 20; i++, r = (r << 1)) ret += a[i] * r;
return ret;
}
void Build(int p, int l, int r) {
lazy[p] = 0;
if (l == r) {
for (int i = 0; i < 20; i++) tree[p][i] = GetBit(arr[l], i);
return;
}
int mid = (l + r) / 2;
Build(2 * p, l, mid);
Build(2 * p + 1, mid + 1, r);
for (int i = 0; i < 20; i++) tree[p][i] = tree[2 * p][i] + tree[2 * p + 1][i];
}
void Propagate(int p, int l, int r) {
if (lazy[p]) {
for (int i = 0; i < 20; i++)
if (GetBit(lazy[p], i)) tree[p][i] = (r - l + 1) - tree[p][i];
if (l != r) {
lazy[2 * p] ^= lazy[p];
lazy[2 * p + 1] ^= lazy[p];
}
lazy[p] = 0;
}
}
void Update(int p, int l, int r, int s, int e, int x) {
Propagate(p, l, r);
if (l > e || r < s) return;
if (l >= s && r <= e) {
lazy[p] = x;
Propagate(p, l, r);
return;
}
int mid = (l + r) / 2;
Update(2 * p, l, mid, s, e, x);
Update(2 * p + 1, mid + 1, r, s, e, x);
for (int i = 0; i < 20; i++) tree[p][i] = tree[2 * p][i] + tree[2 * p + 1][i];
}
long long Query(int p, int l, int r, int s, int e) {
Propagate(p, l, r);
if (l > e || r < s) return 0;
if (l >= s && r <= e) return SUM(tree[p]);
int mid = (l + r) / 2;
long long q1 = Query(2 * p, l, mid, s, e);
long long q2 = Query(2 * p + 1, mid + 1, r, s, e);
return (q1 + q2);
}
int main() {
int n, k, t, l, r, x;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &arr[i]);
Build(1, 1, n);
scanf("%d", &k);
while (k--) {
scanf("%d %d %d", &t, &l, &r);
if (2 - t) {
printf("%I64d\n", Query(1, 1, n, l, r));
} else {
scanf("%d", &x);
Update(1, 1, n, l, r, x);
}
}
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
int t, n, m;
vector<pair<int, int> > graph[102];
int dp[102][102][27];
int dfs(int u, int v, int c) {
if (dp[u][v][c] != -1) return dp[u][v][c];
for (pair<int, int> e : graph[u]) {
if (e.second >= c) {
if (!dfs(v, e.first, e.second)) {
return dp[u][v][c] = 1;
}
}
}
return dp[u][v][c] = 0;
}
void solve() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int c = 0; c < 26; c++) {
dp[i][j][c] = -1;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cout << (dfs(i, j, 0) == 1 ? "A" : "B");
}
cout << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
int u, v;
char w;
for (int i = 0; i < m; i++) {
cin >> u;
cin >> v;
cin >> w;
graph[u].push_back(make_pair(v, w - 'a'));
}
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, p, q, r;
cin >> n >> p >> q >> r;
int ar[n];
for (int i = 0; i < n; i++) cin >> ar[i];
long long mxr[n];
mxr[n - 1] = ((long long)r) * ar[n - 1];
for (int i = n - 2; i >= 0; i--) {
long long res = ((long long)r) * ar[i];
if (res > mxr[i + 1]) {
mxr[i] = res;
} else {
mxr[i] = mxr[i + 1];
}
}
long long mx = ((long long)p) * ar[0];
long long ans = LLONG_MIN;
for (int i = 0; i < n; i++) {
long long cr = ((long long)p) * ar[i];
if (cr > mx) mx = cr;
long long res = mx + ((long long)q) * ar[i] + mxr[i];
if (res > ans) ans = res;
}
cout << ans << endl;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N, M, A, K, ans=0;
cin >> N >> M;
vector<int> tmp(M, 0);
for(int i=0; i<N; ++i){
cin >> K;
for(int j=0; j<K; ++j){
cin >> A;
tmp[A-1]++;
}
}
for(int i=0; i<M; ++i) ans += (tmp[i]==N);
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
int c = 0;
for (int i = 0; i < n; i++) {
if (arr[i] % 2 != 0) {
if (c == 0) {
cout << (arr[i] + 1) / 2 << endl;
} else {
cout << (arr[i] - 1) / 2 << endl;
}
c ^= 1;
} else {
cout << (arr[i]) / 2 << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, K;
cin >> n >> K;
vector<int> a(n);
for (int i = 0; i < (int)n; ++i) cin >> a[i];
int ans = -100000;
for (int i = 0; i < (int)n; ++i)
for (int j = i + 1; j <= n; ++j) {
vector<int> cur;
int sum = 0;
for (int k = i; k < j; ++k) cur.push_back(a[k]);
vector<int> tmp;
for (int k = 0; k < i; ++k) tmp.push_back(a[k]);
for (int k = j; k < n; ++k) tmp.push_back(a[k]);
sort(tmp.rbegin(), tmp.rend());
int l = min((int)tmp.size(), K);
for (int k = 0; k < (int)l; ++k) cur.push_back(tmp[k]);
sort(cur.rbegin(), cur.rend());
for (int k = 0; k < (int)j - i; ++k) sum += cur[k];
ans = max(ans, sum);
}
cout << ans << endl;
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.