solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int a[1000010], b[1000010];
const long long inf = 1ll << 60;
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= m; ++i) {
scanf("%d", &b[i]);
}
long long ans = 0, bns = inf;
for (int i = 1; i <= n; ++i) {
ans = -inf;
for (int j = 1; j <= n; ++j) {
if (i != j) {
for (int k = 1; k <= m; ++k) {
ans = max(ans, 1ll * a[j] * b[k]);
}
}
}
bns = min(bns, ans);
}
printf("%lld", bns);
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,b;
cin>>n>>b;
cout<<(n+b)%24<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int mod = 1e9 + 7;
const int inf = 1061109567;
const int dir[][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
string a, b;
int main() {
cin >> a >> b;
int i, j;
for (i = 0, j = 0; i < b.size(); i++) {
if (a[j] == b[i]) {
j++;
}
if (j == a.size()) break;
}
if (j != a.size()) {
cout << "0" << endl;
return 0;
}
int k;
j = a.size() - 1;
for (k = b.size() - 1; k >= 0; k--) {
if (b[k] == a[j]) {
j--;
}
if (j == -1) break;
}
if (j != -1) {
cout << "0" << endl;
return 0;
}
if (k <= i) {
cout << "0" << endl;
} else {
cout << k - i << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 303, M = 18;
mt19937 gen(time(NULL));
template <typename T = int>
inline T read() {
T val = 0, sign = 1;
char ch;
for (ch = getchar(); ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') sign = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) val = val * 10 + ch - '0';
return sign * val;
}
int n, m, k;
vector<int> zf(string s, string t) {
s = t + '#' + s;
vector<int> z(n + m + 1);
int l = 0, r = 1;
for (int i = 1; i <= n + m; i++) {
if (i < r) z[i] = min(z[i - l], r - i);
while (i + z[i] <= n + m && s[i + z[i]] == s[z[i]]) z[i]++;
if (i + z[i] > r) tie(l, r) = make_pair(i, i + z[i]);
}
vector<int> ret_z(n);
for (int i = 0; i < n; i++) ret_z[i] = z[i + m + 1];
return ret_z;
}
vector<int> pos(string s, string t) {
vector<int> pos(m + 1, -1);
auto z = zf(s, t);
vector<vector<int>> ord(m + 1);
for (int i = 0; i < n; i++) ord[z[i]].push_back(i);
set<int> st;
for (int i = m; i > 0; i--) {
for (const int v : ord[i]) st.insert(v);
auto it = st.lower_bound(k - i);
if (it == st.end()) continue;
pos[i] = *it;
}
return pos;
}
void solve() {
n = read(), m = read(), k = read();
string s, t;
cin >> s >> t;
auto z = zf(s, t);
for (int i = 0; i < n; i++)
if (z[i] >= m) {
puts("Yes");
int L = min(i + 1, n - 2 * k + 1);
int R = L + k;
printf("%d %d\n", L, R);
return;
}
auto lpos = pos(s, t);
reverse((s).begin(), (s).end()), reverse((t).begin(), (t).end());
auto rpos = pos(s, t);
reverse((s).begin(), (s).end());
for (int i = 1; i <= min(m - 1, k); i++) {
if (m - i > k) continue;
if (lpos[i] == -1 || rpos[m - i] == -1) continue;
int L = lpos[i] + i - 1, R = rpos[m - i] + (m - i) - 1;
if (L + R >= n - 1) continue;
puts("Yes");
printf("%d %d\n", lpos[i] + i - (k - 1), n - rpos[m - i] - ((m - i) - 1));
return;
}
puts("No");
}
void precalc() {}
signed main() {
int t = 1;
precalc();
while (t--) {
clock_t z = clock();
solve();
fprintf(stderr, "Total Time: %.3f\n",
(double)(clock() - z) / CLOCKS_PER_SEC),
fflush(stderr);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i = 0; i < (int)n; i++)
using ll = long long;
const ll mod = 1e9+7;
int main(){
ll h, w, k;
cin >> h >> w >> k;
k--;
vector<vector<ll>> dp(h+1,vector<ll>(w,0));
dp[0][0] = 1;
rep(i,h) {
rep(j,w) {
rep(k,1<<(w-1)) {
bool can = true;
rep(l,w-2) {
if((k&(1<<l)) && (k&(1<<(l+1)))) can = false;
}
if(can) {
if(j-1 >= 0 && (k&(1<<(j-1)))) (dp[i+1][j] += dp[i][j-1]) %= mod;
if(j < w-1 && (k&(1<<j))) (dp[i+1][j] += dp[i][j+1]) %= mod;
if(!(k&(1<<j)) && !(k&(1<<(j-1)))) (dp[i+1][j] += dp[i][j]) %= mod;
}
}
}
}
cout << dp[h][k] << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long dcsum(long long x) { return x * (x + 1ll) / 2ll; }
int main() {
long long m, b;
cin >> m >> b;
long long maxv = 0;
for (long long x = b * m; x >= 0; x -= m) {
long long y = b - x / m;
maxv = max(maxv, (y + 1ll) * dcsum(x) + (x + 1ll) * dcsum(y));
}
cout << maxv << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, l, r, s;
cin >> n >> l >> r >> s;
vector<int> x;
for (int i = 1; i <= r - l + 1; i++)
x.push_back(i);
int s1 = accumulate(x.begin(), x.end(), 0ll);
if (s1 > s) {
cout << -1 << '\n';
continue;
}
for (int i = x.size() - 1; i >= 0 && s1 < s; i--) {
int b = min(s - s1, n - ((int) x.size() - i - 1) - x[i]);
x[i] += b;
s1 += b;
}
if (s1 != s) {
cout << -1 << '\n';
continue;
} else {
vector<int> ans(n);
vector<bool> can(n + 1, 1);
for (int i = 0; i < x.size(); i++) {
ans[i + l - 1] = x[i];
can[x[i]] = false;
}
queue<int> q;
for (int i = 1; i <= n; i++) if (can[i]) q.push(i);
for (int i = 0; i < n; i++) {
if (!ans[i]) {
ans[i] = q.front();
q.pop();
}
}
for (int i : ans)
cout << i << ' ';
cout << '\n';
}
}
} | 5 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ld long double
const ll mod=1e9+7;
void solve()
{
ll n, k; cin>>n>>k;
ll a[n];
for(ll i=0; i<n; i++) cin>>a[i];
if(n==k) { cout<<1<<endl; return; }
vector<ll>go(n, 0);
ll ans=0;
for(ll i=1; i<n; i++)
{
if(a[i]>a[i-1]) go[i]=go[i-1]+1;
else { go[i]=0; }
if(go[i] >= k-1) ans=1;
}
set<ll>v;
for(ll i=0; i<k; i++) v.insert(a[i]);
if(go[k-1]!=k-1) ans++;
for(ll i=k; i<n; i++)
{
v.insert(a[i]);
ll st=*v.begin();
ll en=*v.rbegin();
if(st != a[i-k] or en != a[i])
{
if(go[i] < k-1) ans++;
}
v.erase(a[i-k]);
}
cout<<ans<<endl;
}
int main() {
ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
ll T = 1;
//cin>>T;
while(T--)
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n;
cin >> n;
int t = 0;
int h = 0;
for (int i = 0; i < n; i++){
string T;
string H;
cin >> T >> H;
if (T > H){
t += 3;
} else if (T < H){
h += 3;
} else {
t++;
h++;
}
}
cout << t << ' ' << h << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 1e5 + 5;
int n, m, ans;
int num[MAX_N];
pair<int, pair<int, int> > edge[MAX_N];
bool MARK[MAX_N];
int upd[MAX_N];
int UPD[MAX_N];
int dis[MAX_N];
vector<pair<int, pair<int, int> > > G[MAX_N];
int Arr[MAX_N + MAX_N];
int L, R;
int K[MAX_N];
vector<pair<int, pair<int, int> > > EDGE;
bool cmp(int a1, int a2) { return dis[a1] < dis[a2]; }
void bfs(int v) {
memset(dis, 127, sizeof dis);
dis[v] = 0;
Arr[R++] = v;
while (L < R) {
int u = Arr[L++];
for (int i = 0; i < G[u].size(); i++)
if (1 + dis[u] < dis[G[u][i].first]) {
dis[G[u][i].first] = 1 + dis[u];
Arr[R++] = G[u][i].first;
}
}
for (int i = 0; i < n; i++) K[i] = i;
memset(num, -1, sizeof num);
sort(K, K + n, cmp);
for (int i = 0; i < n; i++) {
int u = K[i];
for (int j = 0; j < G[u].size(); j++)
if (dis[u] + 1 == dis[G[u][j].first] &&
num[G[u][j].first] <= num[u] + G[u][j].second.first) {
num[G[u][j].first] = num[u] + G[u][j].second.first;
upd[G[u][j].first] = G[u][j].second.second;
UPD[G[u][j].first] = u;
}
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int v, u, w;
cin >> v >> u >> w;
edge[i] = {v, {u, w}};
v--;
u--;
G[v].push_back({u, {w, i}});
G[u].push_back({v, {w, i}});
}
bfs(0);
int ind = n - 1;
while (ind) {
MARK[upd[ind]] = true;
ind = UPD[ind];
}
for (int i = 0; i < m; i++) {
if ((MARK[i] && !edge[i].second.second) ||
(!MARK[i] && edge[i].second.second)) {
ans++;
EDGE.push_back(
{edge[i].first, {edge[i].second.first, !edge[i].second.second}});
}
}
cout << ans << "\n";
for (int i = 0; i < EDGE.size(); i++)
cout << EDGE[i].first << " " << EDGE[i].second.first << " "
<< EDGE[i].second.second << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 3e5 + 10;
const long long mod = 1e9 + 7;
const int base = 131;
const double pi = acos(-1);
const double eps = 1e-8;
long long vis[N], num[N], n, m, k, x, y, z;
long long a[N], b[N];
long long cx, cy, cnt, ans, sum, flag, t, ff, res;
long long ex, ey;
vector<int> v[N];
map<long long, long long> mp;
set<int> sa, sb;
pair<int, int> p[N];
string s, ss;
;
int tree[N << 2];
queue<int> q[N];
void update(int pos, int val, int l, int r, int rt) {
if (l == r) {
tree[rt] = val;
return;
}
int mid = l + r >> 1;
if (mid >= pos)
update(pos, val, l, mid, rt << 1);
else
update(pos, val, mid + 1, r, rt << 1 | 1);
tree[rt] = min(tree[rt << 1], tree[rt << 1 | 1]);
}
int query(int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) return tree[rt];
int mid = l + r >> 1;
int ans = inf;
if (mid >= L) ans = min(ans, query(L, R, l, mid, rt << 1));
if (mid < R) ans = min(ans, query(L, R, mid + 1, r, rt << 1 | 1));
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> t;
while (t--) {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i], q[a[i]].push(i), update(i, a[i], 1, n, 1);
for (int i = 1; i <= n; i++) cin >> b[i];
flag = 1;
for (int i = 1; i <= n; i++) {
if (!q[b[i]].empty()) {
int pos = q[b[i]].front();
q[b[i]].pop();
if (query(1, pos, 1, n, 1) < b[i]) {
flag = 0;
break;
} else
update(pos, inf, 1, n, 1);
} else {
flag = 0;
break;
}
}
for (int i = 1; i <= n; i++) {
while (q[a[i]].size()) q[a[i]].pop();
}
if (flag)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct line {
int s, t;
long long dis;
bool operator<(line y) const { return dis < y.dis; }
} e[4000001];
struct point {
long long x, y;
} a[2001];
long long c[2001];
long long k[2001];
int tot = 0;
int fa[2005];
inline int findx(int x) {
if (fa[x] != x) fa[x] = findx(fa[x]);
return fa[x];
}
int tot1, tot2;
int ans1[10001], ans2[100001];
inline long long dist(int x, int y) {
return abs(a[x].x - a[y].x) + abs(a[x].y - a[y].y);
}
int main() {
int n;
scanf("%d", &n);
int i, j;
for (i = 1; i <= n; i++) scanf("%lld%lld", &a[i].x, &a[i].y);
for (i = 1; i <= n; i++) scanf("%lld", &c[i]);
for (i = 1; i <= n; i++) scanf("%lld", &k[i]);
for (i = 1; i <= n; i++) {
for (j = i + 1; j <= n; j++) {
tot++;
e[tot].s = i + 1;
e[tot].t = j + 1;
e[tot].dis = (k[i] + k[j]) * dist(i, j);
}
}
for (i = 1; i <= n; i++) {
tot++;
e[tot].s = 1;
e[tot].t = i + 1;
e[tot].dis = c[i];
}
sort(e + 1, e + 1 + tot);
for (i = 1; i <= n + 1; i++) fa[i] = i;
int s = 0;
long long ans = 0;
for (i = 1; i <= tot; i++) {
int fx = findx(e[i].s);
int fy = findx(e[i].t);
if (fx != fy) {
fa[fx] = fy;
s++;
ans += e[i].dis;
if (e[i].s == 1) {
tot1++;
ans1[tot1] = e[i].t - 1;
} else {
tot2++;
ans2[tot2] = i;
}
}
}
cout << ans << endl;
cout << tot1 << endl;
for (i = 1; i <= tot1; i++) cout << ans1[i] << " ";
cout << endl;
cout << tot2 << endl;
for (i = 1; i <= tot2; i++)
cout << e[ans2[i]].s - 1 << " " << e[ans2[i]].t - 1 << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class L, class R>
ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class T>
ostream &operator<<(ostream &os, vector<T> V) {
os << "[";
for (auto vv : V) os << vv << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, map<L, R> M) {
os << "[";
for (auto pr : M) os << pr.first << "->" << pr.second << ",";
return os << "]";
}
template <class L, class R>
ostream &operator<<(ostream &os, unordered_map<L, R> M) {
os << "[";
for (auto pr : M) os << pr.first << "->" << pr.second << ",";
return os << "]";
}
mt19937_64 mt(time(0));
struct Matrix {
vector<vector<int>> data;
int r, c;
Matrix(int row, int col, bool identity = false) : r(row), c(col) {
data.assign(row, vector<int>(col, 0));
if (identity) {
for (int i = 0; i < r; ++i) {
data[i][i] = 1;
}
}
}
Matrix operator*(Matrix &other) {
int m = r, n = c, p = other.c;
Matrix res(m, p);
for (int i = 0; i < m; ++i) {
for (int j = 0; j < p; ++j) {
for (int k = 0; k < n; ++k) {
res.data[i][j] += data[i][k] * other.data[k][j];
}
}
}
return res;
}
};
vector<int> extendGcd(int a, int b) {
if (b == 0) {
return {1, 0, a};
} else {
vector<int> tmp = extendGcd(b, a % b);
return {tmp[1], tmp[0] - (a / b) * tmp[1], tmp[2]};
}
}
Matrix matrix_power(Matrix base, long long exp) {
int n = base.r;
Matrix res(n, n, true);
while (exp) {
if (exp & 1) {
res = res * base;
}
base = base * base;
exp >>= 1;
}
return res;
}
int n, k;
int r[200010], res[200010];
vector<int> foo;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(10);
cout << fixed;
cin >> n >> k;
for (int i = 1; i <= n; ++i) {
cin >> r[i];
foo.push_back(r[i]);
}
sort((foo).begin(), (foo).end());
for (int i = 1; i <= n; ++i) {
res[i] = lower_bound((foo).begin(), (foo).end(), r[i]) - foo.begin();
}
int u, v;
for (int i = 1; i <= k; ++i) {
cin >> u >> v;
if (r[u] > r[v]) {
res[u]--;
} else if (r[u] < r[v]) {
res[v]--;
}
}
for (int i = 1; i <= n; ++i) {
cout << res[i] << " \n"[i == n];
}
return 0;
}
| 6 |
#include<iostream>
#include<algorithm>
using namespace std;
#define REP(i,b,n) for(int i=b;i<n;i++)
#define rep(i,n) REP(i,0,n)
const int inf = ( 1 << 28);
int dp[20001][256];
int solve(int n,int m,int *cbook,int *in){
rep(i,n+1)rep(j,256)dp[i][j]=inf;
dp[0][128]=0;
rep(i,n){
rep(j,256){
if (dp[i][j] == inf)continue;
rep(k,m){
int next=j+cbook[k];
if (next<0)next=0;
else if (next>255)next=255;
dp[i+1][next]=min(dp[i+1][next],dp[i][j]+(next-in[i])*(next-in[i]));
}
}
}
int ans = inf;
rep(i,256)ans=min(ans,dp[n][i]);
return ans;
}
int main(){
int n,m;
int in[20000],cbook[200];
while(scanf("%d%d",&n,&m) && n){
rep(i,m)scanf("%d",&cbook[i]);
rep(i,n)scanf("%d",&in[i]);
cout << solve(n,m,cbook,in) << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int ar[1000005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, m, k, c = 0, f = 0, i, x;
cin >> n >> m >> k;
for (i = 0; i < m; i++) {
cin >> x;
mp[x] = 1;
}
int a = 1;
if (mp[1] == 1) {
cout << 1;
return 0;
}
for (i = 0; i < k; i++) {
int p, q;
cin >> p >> q;
if (p == a || q == a) {
if (p == a && mp[p] == 1) {
cout << p;
return 0;
}
if (q == a && mp[q] == 1) {
cout << q;
return 0;
}
if (p == a) {
a = q;
if (mp[q] == 1) {
cout << q;
return 0;
}
} else if (q == a) {
a = p;
if (mp[p] == 1) {
cout << p;
return 0;
}
}
}
}
cout << a;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int c[30];
int L;
char t[100010];
char s[100010];
int A, C;
int main() {
scanf("%s", t + 1);
L = strlen(t + 1);
for (int i = 1; i <= L; i++) c[t[i] - 'a']++;
for (int i = 1; i <= L; i++) {
A++;
s[A] = t[i];
c[s[A] - 'a']--;
while (C < 26 && !c[C]) C++;
while (A && s[A] - 'a' <= C) {
putchar(s[A]);
A--;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(NULL);
int n, f = 0, z = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (x == 5)
f++;
else
z++;
}
if (z < 1)
cout << -1;
else {
int req = (f / 9) * 9;
if (req > 0) {
for (int i = 0; i < req; i++) cout << 5;
for (int i = 0; i < z; i++) cout << 0;
} else
cout << 0;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int father[N];
vector<int> v[N], tree[N], dis[N], g[N];
int n, m, q;
set<int> st;
map<int, int> mp;
int tr[N];
int treenum = 0;
int L, R, nowdep;
int c[N], f[N], d_max[N];
map<pair<int, int>, double> ans;
map<pair<int, int>, int> flag;
int getfather(int x) {
return father[x] ? father[x] = getfather(father[x]) : x;
}
void dfs(int x, int fa, int dep) {
f[x] = max(f[x], dep);
for (auto u : v[x]) {
if (u == fa) continue;
dfs(u, x, dep + 1);
}
}
void dfs1(int x, int fa, int dep) {
if (dep > nowdep) {
L = x;
;
nowdep = dep;
}
for (auto u : v[x]) {
if (u == fa) continue;
dfs1(u, x, dep + 1);
}
}
void dfs2(int x, int fa, int dep) {
if (dep > nowdep) {
R = x;
nowdep = dep;
}
for (auto u : v[x]) {
if (u == fa) continue;
dfs2(u, x, dep + 1);
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
memset(father, 0, sizeof father);
for (int i(1); i <= (m); ++i) {
int x, y;
scanf("%d%d", &x, &y);
v[x].push_back(y);
v[y].push_back(x);
int fa = getfather(x), fb = getfather(y);
if (fa != fb) father[fa] = fb;
}
for (int i(1); i <= (n); ++i) {
int x = getfather(i);
st.insert(x);
}
for (auto u : st) {
mp[u] = ++treenum;
tr[treenum] = u;
}
for (int i(1); i <= (n); ++i) {
int x = getfather(i);
tree[mp[x]].push_back(i);
c[i] = mp[x];
}
memset(f, 0, sizeof f);
for (int i(1); i <= (treenum); ++i) {
L = 0;
nowdep = -1;
dfs1(tree[i][0], 0, 0);
R = 0, nowdep = -1;
dfs2(L, 0, 0);
dfs(L, 0, 0);
dfs(R, 0, 0);
for (auto u : tree[i]) dis[i].push_back(f[u]);
sort(dis[i].begin(), dis[i].end());
for (int j(0); j <= ((int)tree[i].size() - 1); ++j) {
if (j == 0)
g[i].push_back(dis[i][j]);
else
g[i].push_back(g[i][j - 1] + dis[i][j]);
}
d_max[i] = dis[i][(int)tree[i].size() - 1];
}
ans.clear();
flag.clear();
for (; q--;) {
int x, y;
scanf("%d%d", &x, &y);
if (c[x] == c[y]) {
puts("-1");
continue;
}
int na = c[x], nb = c[y];
if ((int)tree[na].size() > (int)tree[nb].size()) swap(na, nb);
if (flag[{na, nb}]) {
printf("%.12f\n", ans[{na, nb}]);
continue;
}
long long X = 0;
long long Y = (long long)tree[na].size() * tree[nb].size();
long long Z = max(d_max[na], d_max[nb]);
for (auto u1 : tree[na]) {
long long A = lower_bound(dis[nb].begin(), dis[nb].end(), Z - 1 - f[u1]) -
dis[nb].begin();
X += (long long)A * Z +
(long long)(g[nb][(int)tree[nb].size() - 1] + (int)tree[nb].size() -
A - (A ? g[nb][A - 1] : 0)) +
(f[u1]) * ((long long)tree[nb].size() - A);
}
printf("%.12f\n", (double)X / (double)Y);
flag[{na, nb}] = 1;
ans[{na, nb}] = (double)X / (double)Y;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1.0);
double sqr(double x) { return x * x; }
int main() {
double xp, yp, vp, R;
double x, y, v, r;
scanf("%lf%lf%lf %lf%lf%lf%lf", &xp, &yp, &vp, &x, &y, &v, &r);
R = sqrt(sqr(xp) + sqr(yp));
double R2 = sqrt(sqr(x) + sqr(y));
double theta1 = atan2(yp, xp);
double theta2 = atan2(y, x);
double mid, low, high;
for (low = 0.0, high = 2 * PI + R2 / v * vp / R;
R * (high - low) / vp > 1e-7;) {
mid = (low + high) / 2;
double theta = theta1 + mid;
double t1 = R * mid / vp;
double delta = abs(theta - theta2);
while (delta >= 2 * PI) delta -= 2 * PI;
if (delta > PI) delta = 2 * PI - delta;
double aa = acos(r / R2);
double bb = acos(r / R);
double t2;
if (aa + bb < delta) {
t2 = (delta - aa - bb) * r + sqrt(sqr(R2) - sqr(r)) +
sqrt(sqr(R) - sqr(r));
} else {
t2 = sqrt(sqr(R * cos(theta) - x) + sqr(R * sin(theta) - y));
}
t2 /= v;
if (t2 < t1)
high = mid;
else
low = mid;
}
printf("%.10f\n", R * high / vp);
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int n, i, j, m, s = 0;
scanf("%d %d", &n, &m);
int arr1[m + 1];
for (i = 0; i <= m; i++) {
arr1[i] = 0;
}
for (i = 0; i < n; i++) {
scanf("%d", &j);
arr1[j]++;
}
for (i = 1; i < m; i++) {
for (j = i + 1; j <= m; j++) {
s += arr1[i] * arr1[j];
}
}
printf("%d\n", s);
return 0;
}
| 2 |
#include<iostream>
using namespace std;
int main(){
int a, b, c;
cin >>a >> b >>c;
cout<< min(a+ b, min(b+c, a+c));
return 0;
} | 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
inline long long rd() {
long long x = 0, f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -1;
for (; isdigit(c); c = getchar()) x = (x << 1) + (x << 3) + (c ^ 48);
return x * f;
}
inline void write(long long x) {
if (x < 0) x = -x, putchar('-');
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
inline void writeln(long long x) {
write(x);
puts("");
}
char s[42];
int n, m, nxt[42], fail[42];
long long dp[42][42][2], ans;
int main() {
n = rd();
scanf("%s", s);
m = strlen(s);
nxt[0] = 0;
for (int i = 1, k = 0; i < m; ++i) {
while (k && s[i] != s[k]) k = nxt[k - 1];
if (s[i] == s[k]) k++;
nxt[i] = k;
}
for (register int i = (0); i < int(m); ++i) {
int j = i;
while (j && s[i] == s[j]) j = nxt[j - 1];
if (s[i] == s[j])
fail[i] = 0;
else
fail[i] = j + 1;
}
ans = 0;
for (int x = 0; x < m; ++x) {
int k = 0;
for (int i = 0; i < x; ++i) {
if (s[m - x + i] == s[k])
k++;
else
k = fail[k];
}
memset(dp, 0, sizeof(dp));
dp[x][k][0] = 1;
for (register int i = (x); i <= int(n); ++i) {
for (register int j = (0); j <= int(m); ++j) {
dp[i + 1][j][1] += dp[i][j][1] * 2;
if (j == m) continue;
dp[i + 1][j + 1][(j + 1) == m] += dp[i][j][0];
dp[i + 1][fail[j]][0] += dp[i][j][0];
}
}
if (x == 0)
ans += dp[n][m][1];
else {
for (int i = 0; i < m; ++i) {
bool flag = true;
k = i;
for (int j = 0; j < x; ++j) {
if (k == m) {
flag = false;
break;
}
if (s[m - x + j] == s[k])
k++;
else
k = fail[k];
}
if (flag && k == m) {
ans += dp[n][i][0];
}
}
}
}
writeln(ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int modulo = 1e9 + 9;
int n, m;
int pare[1000000];
int identificador(int u) {
if (pare[u] == 0) return u;
int idpareu = identificador(pare[u]);
pare[u] = idpareu;
return idpareu;
}
int main() {
cin >> n >> m;
long long int sol = 1;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
int idu = identificador(u);
int idv = identificador(v);
if (idu == idv)
sol = (2 * sol) % modulo;
else
pare[idu] = idv;
cout << (sol + modulo - 1) % modulo << endl;
}
}
| 5 |
#include<bits/stdc++.h>
#define ll long long
#define mp make_pair
using namespace std;
const int mxn=1e3+3;
ll a[mxn][mxn],n,m;
ll sum[mxn],squsum[mxn];
pair<int,int> delta[mxn];
int err;
ll sumdelta,squsumdelta;
ll orgsum,orgsqusum;
ll sumchange,squsumchange;
ll deltasqusumchange,basesqusumchange;
ll ans;
inline void solve(){
cin>>n>>m;
for(int i=1;i<=m;++i)for(int j=1;j<=n;++j)cin>>a[i][j],sum[i]+=a[i][j],squsum[i]+=a[i][j]*a[i][j];
for(int i=1;i<m;++i)delta[i].first=sum[i+1]-sum[i],delta[i].second=i;
sort(delta+1,delta+m);
sumdelta=delta[2].first;
if(delta[1].second<delta[m-1].second)err=delta[m-1].second;
else err=delta[1].second;
if(err==2){
deltasqusumchange=((squsum[5]-squsum[4])-(squsum[4]-squsum[3]));
basesqusumchange=(squsum[5]-squsum[4])-deltasqusumchange*3;
}else{
basesqusumchange=squsum[2]-squsum[1];
if(err==3)deltasqusumchange=((squsum[5]-squsum[4])-(squsum[2]-squsum[1]))/3;
else deltasqusumchange=((squsum[3]-squsum[2])-(squsum[2]-squsum[1]));
}
orgsum=sum[err-1]+sumdelta;
sumchange=orgsum-sum[err];
orgsqusum=squsum[err-1]+basesqusumchange+deltasqusumchange*(err-2);
squsumchange=orgsqusum-squsum[err];
ans=(squsumchange-sumchange*sumchange)/2/sumchange;
cout<<err-1<<' '<<ans+sumchange<<'\n';
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0),cout.tie(0);
int T;T=1;
// cin>>T;
for(;T--;)solve();
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
int x, y;
cin >> a >> b;
cin >> x >> y;
if (a > b) swap(a, b);
if (x > y) swap(x, y);
if ((b != y) || (a + x != b))
cout << "NO\n";
else
cout << "YES\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int t1, t2, x1, x2, t0;
double best = 0x3f3f3f3f, t;
pair<int, int> ans;
int main() {
cin >> t1 >> t2 >> x1 >> x2 >> t0;
double y1 = x1, y2 = x2;
while (y1 >= 0 && y2 >= 0) {
t = double(t1 * y1 + t2 * y2) / (y1 + y2);
if (t < t0) {
y1--;
continue;
}
if (t - t0 < best) best = t - t0, ans.first = y1, ans.second = y2;
y2--;
}
cout << ans.first << ' ' << ans.second << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<long long, long long> a[200100];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < (n); i++) cin >> a[i].first;
for (int i = 0; i < (n); i++) cin >> a[i].second;
sort(a, a + n);
multiset<long long> s;
long long last = 0;
long long sum = 0;
long long ans = 0;
for (int i = 0; i < n; i++) {
while (a[i].first > last && !s.empty()) {
auto it = s.end();
it--;
long long x = *it;
last++;
sum -= x;
s.erase(it);
ans += sum;
}
last = a[i].first;
s.insert(a[i].second);
sum += a[i].second;
}
while (!s.empty()) {
auto it = s.end();
it--;
long long x = *it;
last++;
sum -= x;
s.erase(it);
ans += sum;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.1415926535;
string x;
int n, t, k;
int MOD = 1000000007;
int main() {
cin >> x;
n = x.length();
for (int i = 0; i < n; ++i) {
t <<= 1;
t += x[i] - '0';
t %= MOD;
}
for (int i = 0; i < n - 1; ++i) {
t <<= 1;
t %= MOD;
}
cout << t;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000;
int n;
long long int sum, wanted;
int vol[N];
void read() {
cin >> n >> wanted;
for (int i = 0; i < n; i++) cin >> vol[i];
}
void init() {
for (int i = 0; i < n; i++) sum += vol[i];
}
int ans() {
for (int i = 1; i < n; i++) {
int dif = vol[i] - vol[0];
if (wanted <= dif) return vol[0];
wanted -= dif;
vol[i] = vol[0];
}
long long int q;
if (wanted % n == 0)
q = wanted / n;
else
q = (wanted / n) + 1;
return vol[0] - q;
}
int main() {
read();
init();
sort(vol, vol + n);
if (sum < wanted)
cout << -1 << endl;
else
cout << ans() << endl;
return 0;
}
| 2 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<tuple>
using namespace std;
class QuickUnionFind {
private:
int size_; std::vector<int> g; std::vector<std::vector<int> > v;
public:
QuickUnionFind() : size_(0), g(std::vector<int>()), v(std::vector<std::vector<int> >()) {};
QuickUnionFind(int size__) : size_(size__) {
g.resize(size_); v.resize(size_);
for (int i = 0; i < size_; i++) g[i] = i, v[i] = { i };
};
int size() { return size_; }
int root(int x) { return g[x]; }
int size(int x) { return v[x].size(); }
bool same(int x, int y) { return g[x] == g[y]; }
void unite(int x, int y) {
x = g[x], y = g[y];
if (x == y) return;
if (v[x].size() < v[y].size()) std::swap(x, y);
v[x].insert(v[x].end(), v[y].begin(), v[y].end());
for (auto &e : v[y]) g[e] = x;
v[y].clear();
}
std::vector<int> connected(int x) { return v[g[x]]; }
bool operator==(const QuickUnionFind& u) { return g == u.g; }
bool operator!=(const QuickUnionFind& u) { return g != u.g; }
};
long long n, a[2000000], b[200000], c[200000], ret;
vector<tuple<int, int, int>>tup;
int main() {
cin >> n; for (int i = 0; i < n - 1; i++) { cin >> a[i] >> b[i] >> c[i]; tup.push_back(make_tuple(c[i], a[i], b[i])); }
sort(tup.begin(), tup.end()); QuickUnionFind UF(n);
for (int i = 0; i < tup.size(); i++) {
long long a1 = get<0>(tup[i]), a2 = get<1>(tup[i]), a3 = get<2>(tup[i]);
ret += 1LL * a1*UF.size(UF.root(a2))*UF.size(UF.root(a3)); UF.unite(a2, a3);
}
cout << ret << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long f[205];
void init() {
f[0] = 0;
f[1] = 1;
for (int i = 2; i <= 90; i++) {
f[i] = f[i - 1] + f[i - 2];
}
}
int main() {
long long n;
while (~scanf("%lld", &n)) {
init();
long long ans = 0;
for (int i = 1; i <= 200; i++) {
if (f[i] <= n) {
ans = i;
} else {
break;
}
}
printf("%lld\n", ans - 2);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 12345678910;
const long double EPS = 1e-13;
const int INF = INT_MAX;
string s[1010];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
if (n == 1) {
cout << 6 << endl;
return 0;
}
int ans = 10000001;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
int k = 0;
for (int h = 0; h < 6; h++)
if (s[i][h] != s[j][h]) k++;
if (k % 2 != 0)
k /= 2, k++;
else
k /= 2;
ans = min(ans, k);
}
if (ans - 1 < 0)
cout << 0 << endl;
else
cout << ans - 1 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int mexx[100001];
int now[1000];
int minn[1000];
int mini[100001];
int main() {
int n;
scanf("%d", &n);
mexx[1] = 0;
mexx[2] = 0;
mexx[3] = 1;
mini[3] = 2;
int k;
int cnt = 0;
int de = 0;
int p = 0;
int j1;
for (int i = 0; i < 100000; i++) {
if (i < 4) continue;
mini[i] = 100000;
k = ((int)sqrt(i)) + 2;
cnt = 0;
for (int j = 0; j < k; j++) {
if (j < 2) continue;
if (i % j == 0) {
de = i / j;
if (j % 2 == 1) {
p = j / 2;
if (p < de) {
now[cnt] = 0;
for (int s = de - p; s <= de + p; s++) {
now[cnt] = now[cnt] ^ mexx[s];
}
if (now[cnt] == 0) {
if ((2 * p + 1) < mini[i]) mini[i] = 2 * p + 1;
}
cnt++;
}
if (de <= p) {
now[cnt] = 0;
for (int s = p - de + 1; s <= p + de; s++) {
now[cnt] = now[cnt] ^ mexx[s];
}
if (now[cnt] == 0) {
if ((2 * de) < mini[i]) mini[i] = 2 * de;
}
cnt++;
}
}
j1 = de;
de = j;
if (j1 % 2 == 1) {
p = j1 / 2;
if (p < de) {
now[cnt] = 0;
for (int s = de - p; s <= de + p; s++) {
now[cnt] = now[cnt] ^ mexx[s];
}
if (now[cnt] == 0) {
if ((2 * p + 1) < mini[i]) mini[i] = 2 * p + 1;
}
cnt++;
}
if (de <= p) {
now[cnt] = 0;
for (int s = p - de + 1; s <= p + de; s++) {
now[cnt] = now[cnt] ^ mexx[s];
}
if (now[cnt] == 0) {
if ((2 * de) < mini[i]) mini[i] = 2 * de;
}
cnt++;
}
}
}
}
if (i % 2 == 1) {
now[cnt] = 0;
p = i / 2;
now[cnt] = mexx[p] ^ mexx[p + 1];
if (now[cnt] == 0) {
mini[i] = 2;
}
cnt++;
}
for (int s = 0; s < cnt + 3; s++) minn[s] = 0;
for (int s = 0; s < cnt; s++) {
if (now[s] < 1000) minn[now[s]] = 1;
}
p = 0;
while (minn[p] == 1) p++;
mexx[i] = p;
}
if (mexx[n] > 0) {
printf("%d", mini[n]);
} else {
printf("-1");
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
const int N=1e6+5,mod=1e9+7;
typedef long long ll;
ll inv(ll x){return x==1?x:(mod-mod/x)*inv(mod%x)%mod;}
ll f[N],invf[N],s[N];
ll C(int n,int m)
{
return f[n]*invf[n-m]%mod*invf[m]%mod;
}
int main()
{
f[0]=invf[0]=f[1]=invf[1]=1;
for(int i=2;i<N;i++) f[i]=f[i-1]*i%mod,invf[i]=(mod-mod/i)*invf[mod%i]%mod;
for(int i=2;i<N;i++) invf[i]=invf[i-1]*invf[i]%mod;
int n;scanf("%d",&n);
ll ans=0;
for(int k=(n+1)/2;k<n;k++)
s[k]=C(k-1,n-k-1)*f[k]%mod*f[n-1-k]%mod;
for(int k=(n+1)/2;k<n;k++)
ans=(ans+(s[k]-s[k-1])*k)%mod;
ans=(ans+mod)%mod;
printf("%lld\n",ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
const int INF = 1e9 + 7;
long long x[N];
long long sum[N];
long long c[N], v[N];
int main() {
ios::sync_with_stdio(false);
int n, k, s, t;
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) cin >> c[i] >> v[i];
for (int i = 0; i < k; i++) cin >> x[i];
sort(x, x + k);
x[k] = s;
for (int i = k; i > 0; i--) x[i] -= x[i - 1];
sort(x, x + k + 1);
for (int i = 0; i <= k; i++) sum[i + 1] = sum[i] + x[i];
long long ans = INF;
for (int i = 0; i < n; i++) {
if (x[k] > v[i]) continue;
long long tm = 2 * s;
long long pos = upper_bound(x, x + k + 1, v[i] / 2) - x;
tm -= sum[pos];
tm -= (k + 1 - pos) * v[i] - (sum[k + 1] - sum[pos]);
if (tm <= t) ans = min(ans, c[i]);
}
if (ans == INF)
cout << "-1\n";
else
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n;
cin >> k;
vector<long long> a;
unordered_map<long long, long long> counts;
for (long long i = 0; i < n; ++i) {
long long v;
cin >> v;
a.push_back(v);
counts[v] += 1;
}
vector<long long> after;
vector<long long> before;
for (long long i = 0; i < n; ++i) {
counts[a[i]] -= 1;
long long nextVal = a[i] * k;
long long nextCounts = 0;
auto it = counts.find(nextVal);
if (it != counts.end()) {
nextCounts = it->second;
}
after.push_back(nextCounts);
}
counts.clear();
for (long long i = 0; i < a.size(); ++i) {
long long prevCounts = 0;
if (a[i] % k == 0) {
long long prevVal = a[i] / k;
auto it = counts.find(prevVal);
if (it != counts.end()) {
prevCounts = it->second;
}
}
before.push_back(prevCounts);
counts[a[i]] += 1;
}
long long res = 0;
for (long long i = 0; i < a.size(); ++i) {
res += after[i] * before[i];
}
cout << res << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << setprecision(numeric_limits<long double>::digits10 + 1);
int n = 1;
for (long long i = 0; i < n; ++i) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
vector<unsigned long long> ans(n);
n *= 2;
vector<pair<unsigned long long, unsigned long long>> a(n);
for (int i = 0; i < n; i += 2) {
cin >> a[i].first;
a[i].second = 1;
cin >> a[i + 1].first;
a[i + 1].first++;
a[i + 1].second = -1;
}
sort(a.begin(), a.end());
unsigned long long now = 0;
for (long long i = 0; i < n - 1; i++) {
now += a[i].second;
if (now > 0) {
ans[now - 1] += (a[i + 1].first - a[i].first);
}
}
n /= 2;
for (long long i = 0; i < n; i++) {
cout << ans[i] << ' ';
}
}
| 3 |
#include <bits/stdc++.h>
const int inf = 0x7FFFFFFF;
double eps = 1e-5;
using namespace std;
double k, b, N, T;
int main() {
cin >> k >> b >> N >> T;
long long C1 = -b + 1 - k;
long long C2 = -b + T * (1.0 - k);
long long beishu = 1;
int ans = 0;
if (!C1 || !C2) {
while (1)
;
} else if (C1 == C2) {
int ans = ceil((N * b + 1.0 - T) / b);
if (ans <= 0) ans = 0;
printf("%d\n", ans);
} else {
C1 = -C1, C2 = -C2;
while (true) {
if (C1 * beishu > C2)
break;
else
beishu *= k;
ans++;
}
ans--;
ans = N - ans;
ans = max(0, ans);
printf("%d\n", ans);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
string s;
cin >> s;
vector<int> p(3);
p[0] = 0;
p[1] = 1;
p[2] = 2;
long long ans = 1e9, cnt = 0;
string tmp, c = "GBR", ans1;
do {
tmp = "";
cnt = 0;
for (int i = 0; i < n; i++) {
tmp += c[p[i % 3]];
if (tmp[i] != s[i]) cnt++;
}
if (cnt < ans) {
ans = cnt;
ans1 = tmp;
}
} while (next_permutation(p.begin(), p.end()));
cout << ans << endl << ans1;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long int n;
cin >> n;
string s;
cin >> s;
long long int one = 0, zero = 0;
for (long long int i = 0; i < n; i++) {
if (s[i] == '1')
one++;
else
zero++;
}
cout << n - 2 * min(one, zero);
}
| 1 |
#include <bits/stdc++.h>
int k, b, n, a[100001];
std::unordered_map<int, int> mp;
int main(int argc, char const *argv[]) {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.tie(nullptr);
std::cin >> k >> b >> n;
for (int i = 1; i <= n; i++) {
std::cin >> a[i];
}
int cnt = 0;
long long ans0 = 0LL, ans = 0LL, sum = 0LL;
mp[0] = 1;
for (int i = 1; i <= n; i++) {
if (a[i]) {
cnt = 0;
} else {
cnt++;
}
ans0 += cnt;
sum += a[i];
ans += mp[(sum - b + k - 1) % (k - 1)];
mp[sum % (k - 1)]++;
}
if (!b) {
std::cout << ans0;
} else if (b == k - 1) {
std::cout << ans - ans0;
} else {
std::cout << ans;
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> PA;
const int INF = (1<<30)-1;
int main(){
int n,m,a,b,c,sum,ma,hiku;
priority_queue<PA,vector<PA>,greater<PA> > pq;
while(cin >> n >> m,n!=0||m!=0){
sum = 0;
vector<PA> vec[100];
for(int i=0;i<m;i++){
cin >> a >> b >> c;
vec[a].push_back(PA(c,b));
vec[b].push_back(PA(c,a));
sum += c;
}
bool town[100]={false};
hiku = 0;
pq.push(PA(0,0));
while(!pq.empty()){
PA p = pq.top();
pq.pop();
if(town[p.second]) continue;
hiku += p.first;
town[p.second] = true;
for(int i=0;i<vec[p.second].size();i++){
int to = vec[p.second][i].second;
if(!town[to]) pq.push(PA(vec[p.second][i].first,to));
}
}
printf("%d\n",hiku);
}
return(0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int SZ = 100333;
int N, M, Q;
vector<int> adj[SZ];
bool vis[SZ];
int height[SZ];
int getHeight(int u) {
if (vis[u]) return -1;
vis[u] = true;
int h = 0;
for (int v : adj[u]) h = max(h, 1 + getHeight(v));
return height[u] = h;
}
int g[SZ];
vector<int> fs[SZ];
vector<long long> acc[SZ];
int id;
bool vis2[SZ];
void go(int u, int upPath = 0) {
if (vis2[u]) return;
vis2[u] = true;
g[u] = id;
fs[id].push_back(max(height[u], upPath));
multiset<int> s;
s.insert(1 + upPath);
for (int v : adj[u])
if (vis2[v] == false) s.insert(2 + height[v]);
for (int v : adj[u])
if (vis2[v] == false) {
s.erase(s.find(2 + height[v]));
go(v, *s.rbegin());
s.insert(2 + height[v]);
}
}
unordered_map<int, double> query[SZ];
int main() {
scanf("%d%d%d", &N, &M, &Q);
for (int zz = 0; zz < (M); zz++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
for (int u = 1; u <= N; u++)
if (vis[u] == false) {
id++;
getHeight(u);
go(u);
sort(fs[id].begin(), fs[id].end());
for (int f : fs[id]) acc[id].push_back(f);
for (int i = int(acc[id].size()) - 2; i >= 0; i--)
acc[id][i] += acc[id][i + 1];
}
while (Q--) {
int u, v;
scanf("%d%d", &u, &v);
u = g[u];
v = g[v];
if (u == v) {
puts("-1");
continue;
}
if (fs[u].size() > fs[v].size()) swap(u, v);
if (query[u][v] != 0) {
printf("%.10lf\n", query[u][v]);
continue;
}
int base = max(fs[u].back(), fs[v].back());
double ans = 0;
for (int f : fs[u]) {
int L =
lower_bound(fs[v].begin(), fs[v].end(), base - f - 1) - fs[v].begin();
ans += (long long)base * L;
ans += acc[v][L] + (long long)(f + 1) * (fs[v].size() - L);
}
ans /= fs[u].size() * fs[v].size();
printf("%.10lf\n", ans);
query[u][v] = ans;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
int A[10];
int B[10];
int Acopy[10];
int Bcopy[10];
int solve() {
for (int i = 0; i < 10; i++) {
Acopy[i] = A[i];
Bcopy[i] = B[i];
}
int res = 0;
for (int i = 0; i < 10; i++) {
int mx = min(Acopy[i], Bcopy[10 - i - 1]);
res += mx;
Acopy[i] -= mx;
Bcopy[10 - i - 1] -= mx;
}
return res + min(Acopy[0], Bcopy[0]);
}
void make_answer(int u) {
vector<int> a;
vector<int> b;
if (A[u] > 0) {
a.push_back(u);
A[u]--;
}
if (B[(10 - u) % 10] > 0) {
b.push_back((10 - u) % 10);
B[(10 - u) % 10]--;
}
for (int i = 0; i < 10; i++) {
int mx = min(A[i], B[10 - i - 1]);
for (int j = 0; j < mx; j++) {
a.push_back(i);
b.push_back(10 - i - 1);
}
A[i] -= mx;
B[10 - i - 1] -= mx;
}
int maxnull = min(A[0], B[0]);
A[0] -= maxnull;
B[0] -= maxnull;
for (int t1 = 0; t1 < 10;) {
for (; A[t1] > 0; A[t1]--) cout << t1;
t1++;
}
for (int i = int(a.size()) - 1; i >= 0; i--) cout << a[i];
for (int i = 0; i < maxnull; i++) cout << 0;
cout << endl;
for (int t1 = 0; t1 < 10;) {
for (; B[t1] > 0; B[t1]--) cout << t1;
t1++;
}
for (int i = int(b.size()) - 1; i >= 0; i--) cout << b[i];
for (int i = 0; i < maxnull; i++) cout << 0;
cout << endl;
}
int main() {
cin >> s;
for (int i = 0; i < s.size(); i++) {
A[s[i] - '0']++;
B[s[i] - '0']++;
}
int maxi = -2147483647;
int maxinum = -1;
for (int i = 1; i <= 9; i++) {
if (A[i] > 0 && A[10 - i] > 0) {
A[i]--;
B[(10 - i) % 10]--;
int sl = solve();
if (sl > maxi) {
maxi = sl;
maxinum = i;
}
A[i]++;
B[(10 - i) % 10]++;
}
}
int maxnull = min(A[0], B[0]);
if (maxinum == -1) {
for (int t1 = 1; t1 < 10;) {
for (; A[t1] > 0; A[t1]--) cout << t1;
t1++;
}
for (int i = 0; i < maxnull; i++) cout << 0;
cout << endl;
for (int t1 = 1; t1 < 10;) {
for (; B[t1] > 0; B[t1]--) cout << t1;
t1++;
}
for (int i = 0; i < maxnull; i++) cout << 0;
cout << endl;
return 0;
}
make_answer(maxinum);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int ctor(char n) {
switch (n) {
case '^':
return 0;
case '>':
return 1;
case 'v':
return 2;
case '<':
return 3;
}
}
int main() {
ios_base::sync_with_stdio(false);
string a, b;
int t;
cin >> a >> b >> t;
t %= 4;
if (t == 0 || t == 2) {
cout << "undefined" << endl;
} else if (t == 1) {
if (ctor(a[0]) == (ctor(b[0]) + 1) % 4) {
cout << "ccw" << endl;
} else {
cout << "cw" << endl;
}
} else if (t == 3) {
if (ctor(a[0]) == (ctor(b[0]) + 1) % 4) {
cout << "cw" << endl;
} else {
cout << "ccw" << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int re_ad() {
int x = 0, f = 1;
char ch = getchar();
while (ch > '9' || ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + (ch ^ 48), ch = getchar();
return x * f;
}
int n, k, q;
int a[200010], b[200010], c[200010];
int sum[200010], id[200010], L[200010], f[200010], cnt;
int num[1010][16500], ans, tot;
const int K = 400;
inline void change1(int p, int v) {
register int i;
if (!v) return;
for (i = p; i <= n; i += k) {
sum[i] ^= v;
if (sum[i] == 0) --ans;
if (sum[i] == v) ++ans;
}
i = p % k + ((n - p % k) / k) * k;
if (sum[i] == 0) --tot;
if (sum[i] == v) ++tot;
}
inline void change2(int p, int v) {
register int i;
if (!v) return;
for (i = p; id[i] == id[p]; i += k) {
if ((sum[i] ^ f[id[p]]) == 0) ++ans;
--num[id[p]][sum[i]];
sum[i] ^= v;
++num[id[p]][sum[i]];
if ((sum[i] ^ f[id[p]]) == 0) --ans;
}
for (i = id[p] + 1; i <= cnt && L[i] % k == p % k; ++i) {
ans += num[i][f[i]];
f[i] ^= v;
ans -= num[i][f[i]];
}
i = p % k + ((n - p % k) / k) * k;
if ((sum[i] ^ f[id[i]]) == 0) --tot;
if ((sum[i] ^ f[id[i]]) == v) ++tot;
}
inline void change(int pla, int nu) {
if (n / k < K)
change1(pla, nu ^ c[pla]);
else
change2(pla, nu ^ c[pla]);
c[pla] = nu;
}
int main() {
register int i, j;
char s[5];
n = re_ad();
k = re_ad();
q = re_ad();
for (i = 1; i <= n; ++i) a[i] = re_ad();
for (i = 1; i <= n; ++i) b[i] = re_ad();
++n;
if (n / k >= K) {
for (i = 1; i <= k; ++i)
for (j = i; j <= n; j += k) {
if (((j - 1) / k + 1) % K == 1) {
L[++cnt] = j;
num[cnt][0] = min(K, (n - j) / k + 1);
}
id[j] = cnt;
}
}
for (i = 1; i <= n; ++i) change(i, a[i] ^ a[i - 1] ^ b[i] ^ b[i - 1]);
if (tot)
puts("-1");
else
printf("%d\n", ans);
while (q--) {
scanf("%s", s + 1);
i = re_ad();
j = re_ad();
if (s[1] == 'a')
a[i] = j;
else
b[i] = j;
change(i, a[i] ^ a[i - 1] ^ b[i] ^ b[i - 1]);
if (i != n) ++i, change(i, a[i] ^ a[i - 1] ^ b[i] ^ b[i - 1]);
if (tot)
puts("-1");
else
printf("%d\n", ans);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
int n, m;
cin >> n >> m;
if (n == 1) {
cout << "0\n";
return 0;
}
vector<int> a(m);
for (int i = 0; i < m; ++i) {
cin >> a[i];
--a[i];
}
map<int, int> goL;
vector<int> whereL(m);
for (int i = m - 1; i >= 0; --i) {
if (goL.count(a[i] + i)) {
whereL[i] = goL[a[i] + i];
} else {
whereL[i] = max(0, a[i] - (m - 1 - i));
}
goL[a[i] + i - 1] = whereL[i];
}
map<int, int> goR;
vector<int> whereR(m);
for (int i = m - 1; i >= 0; --i) {
if (goR.count(a[i] - i)) {
whereR[i] = goR[a[i] - i];
} else {
whereR[i] = min(n - 1, a[i] + (m - 1 - i));
}
goR[a[i] - i + 1] = whereR[i];
}
goL.clear(), goR.clear();
for (int i = m - 1; i >= 0; --i) {
goR[a[i] - i - 1] = whereR[i];
}
for (int i = m - 1; i >= 0; --i) {
goL[a[i] + i + 1] = whereL[i];
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
int l = i, r = i;
if (goL.count(i)) {
l = goL[i];
} else {
l -= m + 1;
}
if (goR.count(i)) {
r = goR[i];
} else {
r += m + 1;
}
l = max(l, 0);
r = min(r, n - 1);
ans += r - l + 1;
}
cout << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
cin >> str;
int count = 0;
int n = str.size();
int temp[26] = {0};
for (int i = 0; i < n; i++) {
temp[str[i] - 'a']++;
}
for (int i = 0; i < 26; i++) {
if (temp[i] > 0) count++;
}
if (count % 2 == 0)
cout << "CHAT WITH HER!";
else
cout << "IGNORE HIM!";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int dx[4] = {-1, 0, 1, 0};
long long int dy[4] = {0, 1, 0, -1};
bool visited[1005][1005];
long long int n, m;
char a[1005][1005];
void dfs(long long int x, long long int y) {
visited[x][y] = 1;
for (long long int i = 0; i < 4; i++) {
long long int nx = x + dx[i];
long long int ny = y + dy[i];
if (1 <= nx <= n && 1 <= ny <= m) {
if (!visited[nx][ny] && a[nx][ny] == 'B') {
dfs(nx, ny);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
char ch;
cin >> ch;
a[i][j] = ((ch == '#') ? 'B' : 'W');
}
}
bool flgr = 0;
long long int cntwr = 0;
for (long long int i = 1; i <= n; i++) {
long long int j = 1;
while (j <= m && a[i][j] == 'W') {
j++;
}
bool temp = 0;
while (j <= m && a[i][j] == 'B') {
j++;
temp = 1;
}
while (j <= m && a[i][j] == 'W') {
j++;
}
if (j <= m && a[i][j] == 'B') {
flgr = 1;
break;
}
if (temp == 0) {
cntwr++;
}
}
if (flgr) {
cout << "-1"
<< "\n";
return 0;
}
bool flgc = 0;
long long int cntwc = 0;
for (long long int j = 1; j <= m; j++) {
long long int i = 1;
while (i <= n && a[i][j] == 'W') {
i++;
}
bool temp = 0;
while (i <= n && a[i][j] == 'B') {
i++;
temp = 1;
}
while (i <= n && a[i][j] == 'W') {
i++;
}
if (i <= n && a[i][j] == 'B') {
flgc = 1;
break;
}
if (temp == 0) {
cntwc++;
}
}
if (flgc) {
cout << "-1"
<< "\n";
return 0;
}
if (cntwr > 0 && cntwc == 0) {
cout << "-1";
return 0;
}
if (cntwc > 0 && cntwr == 0) {
cout << "-1";
return 0;
}
long long int res = 0;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 1; j <= m; j++) {
if (!visited[i][j] && a[i][j] == 'B') {
dfs(i, j);
res++;
}
}
}
cout << res << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void outsource(bool tell) {
if (tell) freopen("input.txt", "r", stdin);
}
bool check(long long int x1, long long int x2, long long int temp) {
if (x1 <= temp && temp <= x2) {
return true;
}
return false;
}
int main() {
int t;
cin >> t;
while (t--) {
long long int a, b, c, d;
cin >> a >> b >> c >> d;
long long int hor = (b - a);
long long int ver = (d - c);
long long int x, y;
cin >> x >> y;
long long int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x += hor;
y += ver;
if ((x1 == x2 && (a || b)) || (y1 == y2 && (c || d))) {
cout << "No\n";
} else if (check(x1, x2, x) && check(y1, y2, y)) {
cout << "Yes\n";
} else
cout << "No\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void CyBerForCe() {
long long a, b, c, d;
cin >> a >> b >> c >> d;
cout << (((a ^ b) & (c | d)) ^ ((b & c) | (a ^ d))) << "\n";
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
CyBerForCe();
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
int64_t t, n, m, k, a[1000005];
void solve(){
int odd = 0, even = 0;
for(int i = 1; i <= n + n; i++){
if(a[i] % 2 == 0) even++;
else odd++;
}
if(even == odd) cout << "Yes" << "\n";
else cout << "No" << "\n";
}
int main(){
ios_base::sync_with_stdio(NULL); cin.tie(NULL); cout.tie(NULL);
cin >> t;
while(t--){
cin >> n;
for(int i = 1; i <= n + n; i++) cin >> a[i];
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[1100], b[1100];
int main() {
int n, k, d, i, tmp, cnt, j;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) scanf("%d", b + i);
for (i = 0; i < k; i++) a[i] = n - k + i + 1;
int kol = k;
for (cnt = n - k; cnt > 0; cnt--) {
for (j = 0, tmp = 0; tmp < b[cnt]; j++)
if (a[j] >= cnt + k) tmp++;
for (i = kol; i >= j; i--) a[i] = a[i - 1];
a[j] = cnt;
kol++;
}
for (i = 0; i < n; i++) printf("%d ", a[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const int MAXN = 1e6 + 5, inf = 1e9;
const ll INF = 1e18;
const ld PI = 3.1415926535897932384626433832795;
ll a[MAXN], b[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << setprecision(13) << fixed;
int n;
cin >> n;
vector<pair<int, int>> V = {{0, 0}};
for (int i = 1; i <= n; i++) {
int a, b;
cin >> a >> b;
V.push_back({a, b});
}
V.erase(unique(V.begin(), V.end()), V.end());
if (V.size() == 1) {
cout << 1 << "\n";
return 0;
}
vector<pair<int, int>> v;
for (int i = 1; i < V.size(); i++) {
ll x = max(V[i - 1].first, V[i - 1].second);
ll y = min(V[i].first, V[i].second);
if (x > y) {
continue;
}
v.push_back({x, y});
}
int last = 0;
ll res = 1;
for (auto i : v) {
res += (i.second - i.first + 1);
if (i.first == last) {
res--;
}
last = i.second;
}
cout << res << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
string ans = s;
int l = s.size();
stack<int> ss;
for (int i = 0; i < l; i++) {
if (s[i] == '0' && !ss.empty()) {
ss.pop();
} else if (s[i] == '1') {
ss.push(i);
}
}
while (!ss.empty()) {
ans[ss.top()] = '0';
ss.pop();
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = acos((long double)-1);
const int inf = (int)1.01e9;
const long double eps = 1e-12;
vector<int> v;
vector<int> vv;
priority_queue<pair<long long int, int> > q;
int id[100002];
int im[100002];
void calc(int n, int r, vector<int> &vc) {
memset(im, 0, sizeof(im));
for (int i = 0; i < n; i++) {
if (i + r <= n) {
im[i]++;
}
if (i) {
im[i] += im[i - 1];
}
}
for (int i = 0; i < n; i++) {
int rg = i - r;
int nw = im[i];
if (rg >= 0) {
nw -= im[rg];
}
vc.push_back(nw);
}
}
int main() {
int n;
int m;
int r;
int k;
cin >> n >> m >> r >> k;
calc(n, r, v);
calc(m, r, vv);
sort(v.begin(), v.end(), greater<int>());
sort(vv.begin(), vv.end(), greater<int>());
int idx = 0;
long long int ans = 0;
int cnt = 0;
int tmp = k;
for (int i = 0; i < v.size(); i++) {
q.push(make_pair(v[i] * vv[0], i));
id[i]++;
}
while (k--) {
auto t = q.top();
q.pop();
ans += t.first;
if (id[t.second] < vv.size()) {
q.push(make_pair(v[t.second] * vv[id[t.second]], t.second));
id[t.second]++;
}
}
long long int all = (long long int)(n - r + 1) * (long long int)(m - r + 1);
double ou = ans;
ou /= (double)(all);
printf("%.16f\n", ou);
return 0;
}
| 4 |
#include<iostream>
#include<queue>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define MAX 15
#define rep(i,n) for(int i=0;i<int(n);i++)
int nn,m;
vector<int> g[MAX],r[MAX];
bool used[1<<MAX][MAX];
struct Q{
bool is_move;
bool is_on;
int s;
bool operator<(const Q& q)const{return s<q.s;}
Q(){}
Q(bool i,bool o,int s_):is_move(i),is_on(o),s(s_){}
};
struct P{
int u,n;
vector<Q> v;
P(int u_,int n_,const vector<Q>& v_):u(u_),n(n_),v(v_){}
};
void solve(int u)
{
memset(used,0,sizeof(used));
queue<P> q;
vector<Q> v;
q.push( P(u,0,vector<Q>()) );
used[u][0]=true;
bool can=false,all=false;
if( !(u&1) )goto END;
while( !q.empty() ){
P p=q.front(); q.pop();
int n=p.n;
u=p.u;
if( n==nn-1 ){
can=true;
if( u==(1<<(nn-1)) ){
all=true;
v=p.v;
goto END;
}
}
//move
rep(i,g[n].size()){
//printf("%d -> %d %d\n",n,g[n][i],i);
if( u&(1<<g[n][i]) && !used[u][g[n][i]] ){
used[u][g[n][i]]=true;
v=p.v;
v.push_back( Q(true,false,g[n][i]) );
q.push( P(u,g[n][i],v) );
}
}
//switch
rep(i,r[n].size()){
bool is_on=!(u&(1<<r[n][i]));
int uu=u^(1<<r[n][i]);
if( !used[uu][n] ){
used[uu][n]=true;
v=p.v;
v.push_back( Q(false,is_on,r[n][i]) );
q.push( P(uu,n,v) );
}
}
}
END:;
if( !can ){
puts("Help me!");
} else if( !all ){
puts("You can not switch off all lights.");
} else {
printf("You can go home in %d steps.\n",v.size());
for(vector<Q>::iterator it=v.begin();it!=v.end();++it){
if(!it->is_move){
vector<Q>::iterator iit;
for(iit=it;iit+1!=v.end() && !iit->is_move;++iit);
sort(it,iit);
it=iit;
}
}
rep(i,v.size()){
Q& q=v[i];
if(q.is_move){
printf("Move to room %d.\n",q.s+1);
} else {
printf("Switch %s room %d.\n",q.is_on?"on":"off",q.s+1);
}
}
}
}
int main(void)
{
for(;;){
scanf("%d%d",&nn,&m); if(!nn)break;
int s,t;
rep(i,m){
scanf("%d%d",&s,&t);
s--; t--;
g[s].push_back(t);
g[t].push_back(s);
}
int a,u=0;
rep(i,nn){
scanf("%d",&a);
u|=a<<i;
}
int k,l;
rep(i,nn){
scanf("%d",&k);
rep(j,k){
scanf("%d",&l); l--;
if(l==i)continue;
r[i].push_back(l);
}
sort(r[i].begin(),r[i].end());
sort(g[i].begin(),g[i].end());
}
solve(u);
rep(i,nn)g[i].clear();
rep(i,nn)r[i].clear();
}
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
struct tree {
pair<int, int> x;
int upd;
tree* left;
tree* right;
tree(int l, int r) {
this->x = {0, l};
this->upd = 0;
this->left = nullptr;
this->right = nullptr;
}
};
struct dot {
tree* root;
dot() { root = new tree(1, 1); }
void push(tree* root, int l, int r) {
if (l > r) return;
if (l == r) {
if (root->upd) {
root->x.first += root->upd;
root->upd = 0;
}
return;
}
int m = (l + r) / 2;
if (root->left == nullptr) root->left = new tree(l, m);
if (root->right == nullptr) root->right = new tree(m + 1, r);
if (root->upd) {
root->left->upd += root->upd;
root->right->upd += root->upd;
root->x.first += root->upd;
root->upd = 0;
}
}
void upd(tree* root, int l, int r, int l1, int r1, int x) {
push(root, l, r);
if (l > r || l1 > r || r1 < l) return;
if (l == l1 && r == r1) {
root->upd += x;
push(root, l, r);
return;
}
int m = (l + r) / 2;
upd(root->left, l, m, l1, min(r1, m), x);
upd(root->right, m + 1, r, max(m + 1, l1), r1, x);
if (root->left->x.first > root->right->x.first)
root->x = root->left->x;
else
root->x = root->right->x;
}
pair<int, int> mx(tree* root, int l, int r, int l1, int r1) {
push(root, l, r);
if (l > r || l1 > r || r1 < l) return {-1, -1};
if (l == l1 && r == r1) return root->x;
int m = (l + r) / 2;
pair<int, int> x = mx(root->left, l, m, l1, min(r1, m));
pair<int, int> y = mx(root->right, m + 1, r, max(m + 1, l1), r1);
if (x.first > y.first) return x;
return y;
}
};
const int maxn = 2e5 + 113;
bool used[maxn];
void solve(vector<pair<pair<int, int>, int>> in, dot& ms) {
vector<pair<int, int>> te;
for (int i = 0; i < in.size(); i++) {
te.push_back({in[i].first.first, i});
te.push_back({in[i].second + 1, i});
}
sort(te.begin(), te.end());
reverse(te.begin(), te.end());
int ans = 0;
int L, R;
for (int le = 1; le <= 3e5; le++) {
while (te.size() && te.back().first == le) {
if (!used[te.back().second]) {
used[te.back().second] = 1;
ms.upd(ms.root, 1, 3e5, in[te.back().second].second,
in[te.back().second].first.second, 1);
} else {
used[te.back().second] = 0;
ms.upd(ms.root, 1, 3e5, in[te.back().second].second,
in[te.back().second].first.second, -1);
}
te.pop_back();
}
pair<int, int> t = ms.mx(ms.root, 1, 3e5, 1, 3e5);
if (ans < t.first) {
ans = t.first;
L = le, R = t.second;
}
if (!te.size()) break;
}
cout << ans << "\n";
for (int i = 0; i < in.size(); i++) {
if (in[i].first.first <= L && in[i].first.second >= R &&
in[i].second >= L && in[i].second <= R)
cout << i + 1 << " ";
}
return;
}
signed main() {
srand(1337);
ios_base::sync_with_stdio(false);
cin.tie(NULL);
vector<pair<pair<int, int>, int>> in;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b, c;
cin >> a >> b >> c;
in.push_back({{a, c}, b});
}
dot ms;
solve(in, ms);
return 0;
}
| 4 |
#include <algorithm>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <queue>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
template<class T> inline void chmin(T& a, const T& b) { if(b < a) a = b; }
typedef int weight;
struct edge {
int to;
weight cost;
edge(int t, weight c):to(t), cost(c){}
};
typedef pair<weight, int> P;
constexpr int INF = 0xfffffff;
vector<int> dijkstra(int s, int cap, const vector<vector<edge>>& es) {
priority_queue<P, vector<P>, greater<P> > que;
vector<int> dist(es.size(), INF);
que.push(P(0, s));
dist[s] = 0;
while(!que.empty()) {
const P p = que.top();
que.pop();
const int v = p.second;
if(dist[v] < p.first)
continue;
for(int i = 0; i < (int)es[v].size(); ++i) {
const edge& e = es[v][i];
const weight next_dist = dist[v] + e.cost;
if(next_dist > cap * 10) continue;
if(dist[e.to] > next_dist) {
dist[e.to] = next_dist;
que.push(P(dist[e.to], e.to));
}
}
}
return dist;
}
unordered_map<string, int> en;
inline int encode(const string& s) {
if(!en.count(s)) en.insert(make_pair(s, en.size()));
return en[s];
}
inline int input_city() {
string s;
cin >> s;
return encode(s);
}
inline int calc_nearest_city(const vector<int>& LPG, const vector<int>& dist) {
int idx = LPG[0];
for(int i = 1; i < (int)LPG.size(); ++i) {
if(dist[idx] > dist[LPG[i]]) idx = LPG[i];
}
return idx;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
for(int n, m, cap; cin >> n >> m >> cap && n;) {
en.clear();
const int s = input_city();
const int t = input_city();
vector<tuple<int, int, int>> edges;
edges.reserve(n);
for(int i = 0; i < n; ++i) {
const int a = input_city();
const int b = input_city();
int cost;
cin >> cost;
edges.emplace_back(a, b, cost);
}
vector<int> LPG(m);
for(int i = 0; i < m; ++i) {
LPG[i] = input_city();
}
const int number_of_city = static_cast<int>(en.size());
vector<vector<edge>> es(number_of_city);
for(int i = 0; i < n; ++i) {
int a, b, cost;
tie(a, b, cost) = edges[i];
es[a].emplace_back(b, cost);
es[b].emplace_back(a, cost);
}
vector<int> dist = dijkstra(s, cap, es);
for(int i = 0; i < m; ++i) {
const int next = calc_nearest_city(LPG, dist);
LPG.erase(remove(LPG.begin(), LPG.end(), next), LPG.end());
vector<int> tmp = dijkstra(next, cap, es);
for(int i = 0; i < number_of_city; ++i) {
chmin(dist[i], dist[next] + tmp[i]);
}
}
cout << (dist[t] == INF ? -1 : dist[t]) << endl;
}
return EXIT_SUCCESS;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int T, N, aux;
int dp[200];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cin >> T;
dp[0] = 1;
for (int i = 3; i <= 100; i++)
if (dp[i - 3]) dp[i] = true;
for (int i = 7; i <= 100; i++)
if (dp[i - 7]) dp[i] = true;
while (T--) {
cin >> aux;
if (dp[aux])
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c = getchar(), f = 0;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = 1;
for (; c >= '0' && c <= '9'; c = getchar())
x = (x << 1) + (x << 3) + (c ^ 48);
if (f) x = -x;
}
int n, Q, K[100005], R[100005], id[100005];
struct data {
long long k, b;
inline data operator+(data x) const { return (data){k + x.k, b + x.b}; }
};
struct node {
int ls, rs;
data vl;
} T[2000005];
int tt, rt[100005];
inline void pushup(int x) { T[x].vl = T[T[x].ls].vl + T[T[x].rs].vl; }
inline void build(int &x, int l, int r) {
int md = (l + r) >> 1;
x = ++tt;
if (l == r) return T[x].vl = (data){K[l], 0}, void();
build(T[x].ls, l, md), build(T[x].rs, md + 1, r), pushup(x);
}
inline void modif(int &x, int y, int l, int r, int dw) {
T[x = ++tt] = T[y];
if (l == r) return T[x].vl = (data){0, R[l]}, void();
if (dw <= ((l + r) >> 1))
modif(T[x].ls, T[y].ls, l, (l + r) >> 1, dw), pushup(x);
else
modif(T[x].rs, T[y].rs, ((l + r) >> 1) + 1, r, dw), pushup(x);
}
inline data query(int x, int l, int r, int dl, int dr) {
if (l > dr || dl > r)
return (data){0, 0};
else if (dl <= l && r <= dr)
return T[x].vl;
return query(T[x].ls, l, (l + r) >> 1, dl, dr) +
query(T[x].rs, ((l + r) >> 1) + 1, r, dl, dr);
}
struct Chtholly {
int l, r;
mutable double v;
char operator<(Chtholly b) const { return l < b.l; }
};
set<Chtholly> S;
inline set<Chtholly>::iterator split(int wh) {
set<Chtholly>::iterator it = S.lower_bound((Chtholly){wh, 114, 514});
if (it != S.end() && it->l == wh)
return it;
else
it--;
int l = it->l, r = it->r;
double v = it->v;
S.erase(it);
return S.insert((Chtholly){l, wh - 1, v}),
S.insert((Chtholly){wh, r, v}).first;
}
inline data calc(double vl, int l, int r) {
int le = 1, ri = n, rs = 0;
while (le <= ri) {
int md = (le + ri) >> 1;
if (R[id[md]] <= vl * K[id[md]])
rs = md, le = md + 1;
else
ri = md - 1;
}
return query(rt[rs], 1, n, l, r);
}
set<pair<int, int> > s;
inline char cmp(int a, int b) { return 1ll * R[a] * K[b] < 1ll * R[b] * K[a]; }
int main() {
read(n);
for (int i = 1, x; i <= n; i++) {
read(x), read(R[i]), read(K[i]), id[i] = i;
if (!R[i] && !K[i]) R[i] = 1;
if (K[i])
S.insert((Chtholly){i, i, -1.0 * x / K[i]});
else
S.insert((Chtholly){i, i, 0}), s.insert(make_pair(i, x));
}
s.insert(make_pair(n + 1, 0)), build(rt[0], 1, n),
sort(id + 1, id + n + 1, cmp);
for (int i = 1; i <= n; i++) modif(rt[i], rt[i - 1], 1, n, id[i]);
for (read(Q); Q--;) {
set<pair<int, int> >::iterator it;
int t, l, r;
long long res = 0;
read(t), read(l), read(r);
while (s.size() > 1ull && (it = s.lower_bound(make_pair(l, 0)))->first <= r)
res += it->second, s.erase(it);
set<Chtholly>::iterator ir = split(r + 1), il = split(l);
for (set<Chtholly>::iterator i = il; i != ir; i++) {
data x = calc(t - i->v, i->l, i->r);
res += x.b + (long long)(x.k * (t - i->v) + 0.5);
}
S.erase(il, ir), S.insert((Chtholly){l, r, 1.0 * t}), printf("%lld\n", res);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
pair<int, int> v[300111];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
int dir = 0;
for (int i = 0; i < n + 1; i++) {
cin >> v[i].first >> v[i].second;
}
for (int i = 0; i < n; i++) v[i + n] = v[i];
int ans = 0;
for (int i = 0; i < n; i++) {
pair<int, int> A = pair<int, int>(v[i + 1].first - v[i].first,
v[i + 1].second - v[i].second);
pair<int, int> B = pair<int, int>(v[i + 2].first - v[i + 1].first,
v[i + 2].second - v[i + 1].second);
int dot = A.first * B.second - A.second * B.first;
if (dot > 0) ans++;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int t, tot, ans1, ans2, lim;
int vis1[300050], vis2[300050];
struct node {
int a, b, sit;
} in[300050], temp[300050], temp2[300050];
bool mycmp(node x, node y) { return x.b > y.b; }
bool mycmp2(node x, node y) { return x.b < y.b; }
int main() {
scanf("%d", &t);
for (int i = 1; i <= t; ++i) scanf("%d%d", &in[i].a, &in[i].b), in[i].sit = i;
for (int i = 1; i <= t; ++i)
if (in[i].a < in[i].b) temp[++tot] = in[i];
sort(temp + 1, temp + tot + 1, mycmp);
lim = 0x3f3f3f3f;
for (int i = 1; i <= tot; ++i) {
if (lim < temp[i].a)
continue;
else
lim = temp[i].b, ans1++, vis1[i] = 1;
}
tot = 0;
for (int i = 1; i <= t; ++i)
if (in[i].a > in[i].b) temp2[++tot] = in[i];
sort(temp2 + 1, temp2 + tot + 1, mycmp2);
lim = 0;
for (int i = 1; i <= tot; ++i) {
if (lim > temp2[i].a)
continue;
else
lim = temp2[i].b, ans2++, vis2[i] = 1;
}
if (ans1 >= ans2) {
printf("%d\n", ans1);
for (int i = 1; i <= t; ++i)
if (vis1[i]) printf("%d ", temp[i].sit);
} else {
printf("%d\n", ans2);
for (int i = 1; i <= tot; ++i)
if (vis2[i]) printf("%d ", temp2[i].sit);
}
return 0;
}
| 4 |
#include <iostream>
using namespace std;
int main()
{
int n;
cin >> n;
int ans = 0, top = 0;
for(auto i = 0; i < n; ++i){
int h;
cin >> h;
if(h >= top){
++ans;
top = h;
}
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q;
int s[1050][1050];
int x[2], y[2], l, r;
int a, b, c, d, e, f;
int ri[2050050];
int dw[2050050];
template <typename T>
void read(T &x) {
x = 0;
char c = getchar();
for (; !isdigit(c); c = getchar())
;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
}
int gt(int x, int y) { return x * 1050 + y; }
int find(int x, int y) {
int u = 0;
while (x--) u = dw[u];
while (y--) u = ri[u];
return u;
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) scanf("%d", &s[i][j]);
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= m; ++j) {
ri[gt(i, j)] = gt(i, j + 1);
dw[gt(i, j)] = gt(i + 1, j);
}
while (q--) {
read(x[0]);
read(y[0]);
read(x[1]);
read(y[1]);
read(l);
read(r);
a = find(x[0] - 1, y[0] - 1);
b = find(x[1] - 1, y[1] - 1);
c = find(x[0] + l - 1, y[0]);
d = find(x[1] + l - 1, y[1]);
e = find(x[0], y[0] + r - 1);
f = find(x[1], y[1] + r - 1);
for (int i = 1, ta = dw[a], tb = dw[b]; i <= l;
++i, ta = dw[ta], tb = dw[tb])
swap(ri[ta], ri[tb]);
for (int i = 1, ta = ri[a], tb = ri[b]; i <= r;
++i, ta = ri[ta], tb = ri[tb])
swap(dw[ta], dw[tb]);
for (int i = 1, ta = e, tb = f; i <= l; ++i, ta = dw[ta], tb = dw[tb])
swap(ri[ta], ri[tb]);
for (int i = 1, ta = c, tb = d; i <= r; ++i, ta = ri[ta], tb = ri[tb])
swap(dw[ta], dw[tb]);
}
for (int i = 1, ta = dw[1]; i <= n; ++i, ta = dw[ta]) {
for (int j = 1, tb = ta; j <= m; ++j, tb = ri[tb])
printf("%d ", s[tb / 1050][tb % 1050]);
printf("\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
string s[111];
vector<int> a[1000];
int vis[111];
bool hasCycle;
int Int[1000], Ext[1000];
int graph[100][100];
int answer[1000];
int cnt;
void createGraph(int x, int y) {
int pos = 0;
bool found = false;
while (pos < s[x].size() && pos < s[y].size() && !found) {
if (s[x][pos] != s[y][pos]) {
int s1Val = s[x][pos] - 'a';
int s2Val = s[y][pos] - 'a';
a[s1Val].push_back(s2Val);
graph[s1Val][s2Val] = 1;
found = true;
Int[s2Val]++;
Ext[s1Val]++;
}
pos++;
}
if (found == false && s[x].size() >= s[y].size()) {
hasCycle = true;
}
}
void DFS2(int x) {
vis[x] = 1;
for (int i = 0; i < a[x].size(); ++i) {
int p = a[x][i];
if (vis[p] == 0) {
DFS2(p);
} else {
hasCycle = true;
}
}
}
bool checkForCycle() {
for (int i = 0; i <= 'z' - 'a'; ++i) {
for (int j = i + 1; j <= 'z' - 'a'; ++j) {
if (graph[answer[i]][answer[j]] == 1) {
hasCycle = true;
}
}
}
if (cnt != 'z' - 'a' + 1) {
hasCycle = true;
}
}
void DFS(int x) {
vis[x] = 1;
for (int i = 0; i < a[x].size(); ++i) {
int p = a[x][i];
if (vis[p] == 0) {
DFS(p);
}
}
answer[cnt] = x;
cnt++;
}
int main() {
hasCycle = false;
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> s[i];
}
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (s[i] != s[j]) {
createGraph(i, j);
}
}
}
if (hasCycle) {
cout << "Impossible";
return 0;
}
for (int i = 0; i <= 'z' - 'a'; ++i) {
if (vis[i] == 0 && Int[i] == 0) {
DFS(i);
}
}
checkForCycle();
if (hasCycle) {
cout << "Impossible";
return 0;
}
for (int i = 0; i < cnt; ++i) {
cout << char(answer[cnt - i - 1] + 'a');
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
string mat[n];
int arr[n];
for (int i = 0; i < n; i++) {
cin >> mat[i];
arr[i] = 0;
}
int ans = 0;
int i, j;
for (i = 0; i < m; i++) {
vector<int> vec;
for (j = 1; j < n; j++) {
if (arr[j] == 0) {
if (mat[j][i] < mat[j - 1][i]) {
ans++;
break;
}
}
if (mat[j][i] > mat[j - 1][i]) {
vec.push_back(j);
}
}
if (j == n) {
for (int k = 0; k < vec.size(); k++) {
arr[vec[k]] = 1;
}
}
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, r;
cin >> n >> r;
double each = ((n - 2) * 180) / n;
double a1, b;
a1 = each / 2;
b = 180 - each;
a1 = a1 * 3.14159265358979323846 / 180;
b = b * 3.14159265358979323846 / 180;
cout << fixed << setprecision(7) << (r * sin(b)) / (2 * sin(a1) - sin(b))
<< endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 1;
const long long nol = 0;
long long n, a, cnt, ans;
deque<string> v;
map<string, long long> mp;
string g, s, h;
void vkoshp() {
cin >> n;
for (long long i = 0; i < n; i++) {
cin >> g >> s;
if (i != n - 1) cin >> h;
reverse(s.begin(), s.end());
h = g + s;
if (mp[h] != 0) {
mp[h]++;
continue;
}
g.clear();
g += h[1];
g += h[2];
g += h[3];
g += h[0];
long long sum = 0;
while (g != h) {
if (mp[g] != 0) {
sum = 1;
break;
}
char e = g[0];
g.erase(g.begin());
g += e;
}
if (sum == 1)
mp[g]++;
else
v.push_back(g), mp[g]++;
}
cout << v.size() << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) vkoshp();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
float n, i, s = 0, a;
float p;
cin >> n;
for (i = 1; i != n + 1; i++) {
cin >> a;
s += a;
}
p = s / n;
cout << fixed << setprecision(12) << p;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 444;
vector<int> g[NMAX];
int n, m;
int d[NMAX][NMAX];
void bfs(int s) {
for (int i = 1; i <= n; i++) d[s][i] = -1;
d[s][s] = 0;
queue<int> q;
q.push(s);
while (!q.empty()) {
int here = q.front();
q.pop();
for (int there : g[here]) {
if (d[s][there] == -1) {
d[s][there] = d[s][here] + 1;
q.push(there);
}
}
}
}
double p[NMAX];
double q[NMAX];
double f2(const vector<int>& targets) {
double ret = 0;
for (int i = 1; i <= n; i++) {
for (int t : targets) q[d[i][t]] = max(q[d[i][t]], p[t]);
double here = 0;
for (int t : targets) {
here += q[d[i][t]];
q[d[i][t]] = 0;
}
ret = max(ret, here);
}
return ret;
}
bool visited[NMAX];
pair<int, double> f1(int s, int k) {
vector<int> v;
for (int i = 1; i <= n; i++)
if (d[s][i] == k) v.push_back(i);
if (v.empty()) return {0, 0};
double ret = 1. / v.size();
for (int i = 1; i <= n; i++) p[i] = visited[i] = 0;
vector<int> targets;
for (int x : v) {
for (int y : g[x]) {
p[y] += 1. / (v.size() * g[x].size());
if (!visited[y]) {
targets.push_back(y);
visited[y] = true;
}
}
}
ret = max(ret, f2(targets));
return {v.size(), ret};
}
double f0() {
for (int i = 1; i <= n; i++) bfs(i);
double ret = 0;
for (int i = 1; i <= n; i++) {
double here = 0;
for (int j = 0; j <= n - 1; j++) {
auto f = f1(i, j);
here += f.second * f.first / n;
}
ret = max(here, ret);
}
return ret;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y), g[y].push_back(x);
}
printf("%.10f", f0());
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
for (int i = 0; i < s.size();) {
int j = i + 1;
for (; j < s.size(); j++) {
if (s[i] != s[j]) break;
}
if ((j - i) % 2) {
for (int k = i + 1; k < j; k += 2) {
s[k] = s[i] == 'a' ? 'b' : 'a';
}
} else {
char c = 'a';
char l = i ? s[i - 1] : 0;
char r = i + 1 == s.size() ? 0 : s[i + 1];
while (c == l || c == r) {
c++;
if (c > 'z') c -= 26;
}
for (int k = i; k < j; k += 2) {
s[k] = c;
}
}
i = j;
}
cout << s << endl;
}
| 3 |
#include <cmath>
#include <vector>
#include <iomanip>
#include <iostream>
#include <queue>
#include <map>
#include <set>
#include <string>
#include <algorithm>
#include <limits>
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef long long ll;
typedef pair<int, int> PII;
typedef vector<PII> VP;
typedef vector<ll> VL;
typedef vector<VL> VVL;
string s;
int n;
VVI pal_len;
VVL short_num;
void calc_len() {
pal_len = VVI(n, VI(n, 1 << 25));
for (int i = 0; i < n; ++i) {
pal_len[i][i] = 1;
if (i+1 < n) pal_len[i][i+1] = (s[i] == s[i+1]) ? 2 : 3;
}
for (int dist = 2; dist < n; ++dist) {
for (int i = 0, j = dist; j < n; ++i, j++) {
if (s[i] == s[j]) pal_len[i][j] = 2 + pal_len[i+1][j-1];
else pal_len[i][j] = 2 + min(pal_len[i+1][j], pal_len[i][j-1]);
}
}
}
void calc_num() {
short_num = VVL(n, VL(n, 0));
for (int i = 0; i < n; ++i) {
short_num[i][i] = 1;
if (i+1 < n && s[i] == s[i+1]) short_num[i][i+1] = 1;
if (i+1 < n && s[i] != s[i+1]) short_num[i][i+1] = 2;
}
for (int dist = 2; dist < n; ++dist) {
for (int i = 0, j = dist; j < n; ++i, j++) {
if (s[i] == s[j]) short_num[i][j] = short_num[i+1][j-1];
else if (pal_len[i+1][j] == pal_len[i][j-1]) {
short_num[i][j] = short_num[i+1][j] + short_num[i][j-1];
short_num[i][j] = min(short_num[i][j], 1LL << 61);
} else
short_num[i][j] = (pal_len[i+1][j] < pal_len[i][j-1]) ?
short_num[i+1][j] : short_num[i][j-1];
}
}
}
void solve(int i, int j, ll k, string& sol) {
if (i == j) { sol = s[i]; return; }
if (i+1 == j && s[i] == s[j]) { sol = string(2, s[i]); return; }
if (i+1 == j) {
vector<string> pos;
pos.push_back(string(1, s[i]) + string(1, s[j]) + string(1, s[i]));
pos.push_back(string(1, s[j]) + string(1, s[i]) + string(1, s[j]));
sort(pos.begin(), pos.end());
if (k == 1) sol = pos[0];
else sol = pos[1];
return;
}
if (s[i] == s[j]) {
solve(i+1, j-1, k, sol);
if (sol.size() != 0) sol = s[i] + sol + s[j];
return;
}
if (pal_len[i+1][j] < pal_len[i][j-1] ||
(pal_len[i+1][j] == pal_len[i][j-1] && s[i] < s[j] && k <= short_num[i+1][j])) {
solve(i+1, j, k, sol);
if (sol.size() != 0) sol = s[i] + sol + s[i];
return;
}
if (pal_len[i+1][j] > pal_len[i][j-1] ||
(pal_len[i+1][j] == pal_len[i][j-1] && s[i] > s[j] && k <= short_num[i][j-1])) {
solve(i, j-1, k, sol);
if (sol.size() != 0) sol = s[j] + sol + s[j];
return;
}
if (s[i] < s[j]) {
solve(i, j-1, k-short_num[i+1][j], sol);
if (sol.size() != 0) sol = s[j] + sol + s[j];
return;
}
solve(i+1, j, k-short_num[i][j-1], sol);
if (sol.size() != 0) sol = s[i] + sol + s[i];
return;
}
int main() {
ios::sync_with_stdio(false);
ll k;
while (cin >> s) {
cin >> k;
n = s.size();
calc_len();
calc_num();
if (short_num[0][n-1] < k) { cout << "NONE\n"; continue; }
string sol = "";
solve(0, n-1, k, sol);
cout << sol << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, a[100005], b[100005], za[100005], zb[100005];
long long num, den, z;
const long long pri = 1e9 + 7;
long long myPow(long long a, long long b) {
long long ret = 1;
while (b != 0) {
if (b % 2 != 0) {
ret = (ret * a) % pri;
}
b /= 2;
a = (a * a) % pri;
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
long long precision = numeric_limits<long double>::digits10;
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 0) {
z++;
za[i] = 1;
}
}
for (long long i = 1; i <= n; i++) {
cin >> b[i];
if (b[i] == 0) {
z++;
zb[i] = 1;
}
}
for (long long i = 1; i <= n; i++) {
za[i] += za[i - 1];
zb[i] += zb[i - 1];
}
long long numWays = 1;
for (long long i = 1; i <= n; i++) {
if (a[i] == 0 && b[i] == 0) {
long long tem = (m * (m - 1ll)) / 2ll;
tem %= pri;
tem *= numWays;
tem %= pri;
tem *= myPow(m, za[n] + zb[n] - za[i] - zb[i]);
tem %= pri;
num += tem;
num %= pri;
numWays *= m;
numWays %= pri;
} else if (a[i] != 0 && b[i] == 0) {
long long tem = a[i] - 1;
tem *= numWays;
tem %= pri;
tem *= myPow(m, za[n] + zb[n] - za[i] - zb[i]);
tem %= pri;
num += tem;
num %= pri;
} else if (a[i] == 0 && b[i] != 0) {
long long tem = m - b[i];
tem *= numWays;
tem %= pri;
tem *= myPow(m, za[n] + zb[n] - za[i] - zb[i]);
tem %= pri;
num += tem;
num %= pri;
} else if (a[i] != 0 && b[i] != 0) {
if (a[i] == b[i]) {
} else if (a[i] < b[i]) {
break;
} else {
long long tem = numWays;
tem *= myPow(m, za[n] + zb[n] - za[i] - zb[i]);
tem %= pri;
num += tem;
num %= pri;
break;
}
}
}
den = myPow(m, z);
long long temp = myPow(den, pri - 2);
cout << (num * temp) % pri;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 2e5 + 9;
const long long INF = 1e12;
long long N, M, f, s, res;
signed main() {
ios_base::sync_with_stdio(false);
cin >> N >> M;
for (int A = 1; A <= M; A++) {
for (int B = 1; B <= M; B++) {
if (((A * A) % M + (B * B) % M) % M) continue;
if (N - A < 0 or N - B < 0) continue;
f = (N - A) / M + 1;
s = (N - B) / M + 1;
res += f * s;
}
}
cout << res;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<pair<int, int> > v;
map<char, int> m, n;
string s;
int x, y;
scanf("%d %d", &x, &y);
cin >> s;
for (int i = 0; i < s.length(); i++) {
if (m[s[i]] == 0) {
m[s[i]] = 1;
v.push_back(make_pair(i, 1));
}
}
for (int i = s.length() - 1; i >= 0; i--) {
if (n[s[i]] == 0) {
n[s[i]] = 1;
v.push_back(make_pair(i, 2));
}
}
sort(v.begin(), v.end());
int tamu = 0;
bool banyak = false;
for (int i = 0; i < v.size(); i++) {
if (v[i].second == 1) tamu++;
if (v[i].second == 2) tamu--;
if (tamu > y) banyak = true;
}
if (banyak)
printf("YES\n");
else
printf("NO\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int id, to;
long long weight;
edge() {}
edge(int i, int t, long long w) : id(i), to(t), weight(w) {}
bool operator<(const edge& rhs) const { return weight > rhs.weight; }
};
const int N = 3e5 + 5;
int n, m, k;
long long dis[N];
vector<edge> edges[N];
set<int> ans;
void dijkstra(int src = 1) {
priority_queue<edge> q;
q.push(edge(0, src, 0));
memset(dis, 0x3F, sizeof(dis));
while (q.size()) {
int u = q.top().to;
int e = q.top().id;
long long w = q.top().weight;
q.pop();
if (dis[u] <= w) {
ans.erase(e);
continue;
}
dis[u] = w;
for (auto& p : edges[u]) {
if (w + p.weight < dis[p.to]) {
q.push(edge(p.id, p.to, w + p.weight));
}
}
}
}
void dfs(int cur = 1, int eId = 0) {
for (auto& e : edges[cur]) {
if (e.id != eId && ans.count(e.id)) {
dfs(e.to, e.id);
}
}
if (ans.size() > k) {
ans.erase(eId);
}
}
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= m; ++i) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
edges[u].push_back(edge(i, v, w));
edges[v].push_back(edge(i, u, w));
ans.insert(i);
}
dijkstra();
dfs();
cout << ans.size() << endl;
for (int e : ans) {
printf("%d ", e);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, x, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
ans += x * i;
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct Universe {
vector<T> o;
void push(const T &x) { o.push_back(x); }
int build() {
sort(o.begin(), o.end());
o.resize(unique(o.begin(), o.end()) - o.begin());
return o.size();
}
int find(const T &x) {
auto it = lower_bound(o.begin(), o.end(), x);
return (it == o.end() || x < *it ? -1 : it - o.begin() + 1);
}
T &operator[](int i) { return o[i - 1]; }
};
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
vector<pair<int, int> > in;
Universe<int> cc;
for (int i = 0; i < n; i++) {
int l, r;
scanf("%d %d", &l, &r);
cc.push(l);
cc.push(r);
in.push_back({l, r});
}
int m = (cc.build() << 1) + 5;
vector<int> open(m), close(m);
for (int i = 0; i < n; i++) {
open[cc.find(in[i].first) << 1]++;
close[cc.find(in[i].second) << 1]++;
}
vector<int> freq(m);
for (int i = 0, total = 0; i < m; i++) {
total += open[i];
freq[i] = total;
total -= close[i];
}
vector<int> left(m);
for (int i = 1; i < m; i++) {
if (freq[i] == 1) {
left[i] = left[i - 1];
} else {
left[i] = freq[i];
}
}
vector<int> right(m);
for (int i = m - 2; i >= 0; i--) {
if (freq[i] == 1) {
right[i] = right[i + 1];
} else {
right[i] = freq[i];
}
}
vector<bool> loose(m);
open.assign(m, 0);
close.assign(m, 0);
int all = 0;
for (int i = 1; i < m - 1; i++) {
if (freq[i] == 1) {
if (left[i] == 0 && right[i] == 0) {
loose[i] = true;
} else if (left[i] > 0 && right[i] > 0) {
if (freq[i - 1] > 0) {
open[i]++;
} else if (freq[i + 1] > 0) {
close[i]++;
}
}
} else if (freq[i] == 0 && freq[i - 1] > 0) {
all++;
}
open[i] += open[i - 1];
close[i] += close[i - 1];
}
int global = 0;
for (int i = 0; i < n; i++) {
int l = cc.find(in[i].first) << 1;
int r = cc.find(in[i].second) << 1;
int add;
if (loose[l] && loose[r]) {
add = -1;
} else {
add = max(open[r] - open[l - 1], close[r] - close[r - 1]);
}
global = max(global, all + add);
}
printf("%d\n", global);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2, s;
cin >> s1 >> s2;
int i = 0;
int k = 0;
while (i < s1.size()) {
if (s1[i] != s2[i]) {
k++;
if (k & 1)
if (s1[i] == '1')
s += "0";
else
s += "1";
else if (s2[i] == '1')
s += "0";
else
s += "1";
} else
s += s1[i];
i++;
}
if (k % 2 != 0)
cout << "impossible";
else
cout << s;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
double s[450][450], f[450];
int n, m, a, b, c, d, su;
void pivot(int n, int m, int x, int y) {
double tp = s[y][x];
s[y][x] = -1;
for (int i = 1; i <= m + 1; i++) s[y][i] /= -tp;
for (int i = 1; i <= n; i++)
if (i != y) {
double tp = s[i][x];
s[i][x] = 0;
for (int j = 1; j <= m + 1; j++) s[i][j] += tp * s[y][j];
}
tp = f[x];
f[x] = 0;
for (int j = 1; j <= m + 1; j++) f[j] += tp * s[y][j];
}
double LP(int n, int m) {
while (1) {
int sp = 0;
for (int i = 1; i <= m; i++)
if (f[i] > 0) sp = i;
if (sp == 0) return f[m + 1];
int mn = 1e9, as = 0;
for (int i = 1; i <= n; i++) {
if (s[i][sp] >= -1e-10) continue;
double tp = s[i][m + 1] / -s[i][sp];
if (mn > tp) mn = tp, as = i;
}
if (as == 0) return 1e100;
pivot(n, m, sp, as);
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d%d%d", &a, &b, &c, &d);
su += d;
f[i] = 1;
f[m + i] = f[m * 2 + i] = -1;
s[a][i]++;
s[a][m + i]++;
s[n + a][i]--;
s[n + a][m + i]--;
s[b][i]--;
s[b][m + i]--;
s[n + b][i]++;
s[n + b][m + i]++;
s[n * 2 + i][i] = -1;
s[n * 2 + i][m + i] = -1, s[n * 2 + i][m * 2 + i] = 1;
s[n * 2 + i][m * 3 + 1] = c;
s[n * 2 + m + i][i] = -1;
s[n * 2 + m + i][m * 3 + 1] = d;
}
for (int i = 1; i <= m * 3 + 1; i++)
s[1][i] = s[n][i] = s[n + 1][i] = s[n + n][i] = 0;
printf("%d\n", (int)(-LP(n * 2 + m * 2, m * 3) + su + 0.1));
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
long long n, a[100069];
int main() {
long long i, e;
pair<long long, long long> mne = {inf, -1};
scanf("%lld", &n);
for (i = 1; i <= n; i++) {
scanf("%lld", a + i);
}
for (i = 1; i <= n; i++) {
mne = min(mne, {abs(a[i] - a[i % n + 1]), i});
}
e = mne.second;
printf("%lld %lld\n", e, e % n + 1);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
while (a && b) {
if (a < b) swap(a, b);
a = a % b;
}
return a + b;
}
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
long long p, q, b;
for (int i = 0; i < n; i++) {
cin >> p >> q >> b;
long long t = gcd(b, q);
do {
t = gcd(t, q);
q /= t;
} while (t != 1);
if (p % q == 0)
cout << "Finite" << endl;
else
cout << "Infinite" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int id[200005], A[200005];
vector<int> v;
void init() {
for (int i = 0; i < 200005; ++i) {
id[i] = i;
}
}
int root(int x) {
while (x != id[x]) {
id[x] = id[id[x]];
x = id[x];
}
return x;
}
void union1(int x, int y) {
int p = root(x);
int q = root(y);
id[p] = q;
}
int main() {
init();
int n, ans = 0, rt;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> A[i];
if (A[i] == i) v.push_back(i);
}
if ((int)v.size() > 0)
rt = v[0];
else
rt = 0;
for (int i = 1; i < (int)v.size(); ++i) {
A[v[i]] = v[0];
ans++;
}
for (int i = 1; i <= n; ++i) {
if (root(i) != root(A[i]))
union1(i, A[i]);
else if (i != rt) {
if (rt == 0) {
A[i] = i;
rt = i;
} else {
A[i] = rt;
}
ans++;
}
}
cout << ans << "\n";
for (int i = 1; i <= n; ++i) {
cout << A[i] << " ";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n, a, b, p, c, d, e, f, g, h, hh, i, j;
cin >> t;
while (t--) {
cin >> a >> b >> p;
string s;
cin >> s;
vector<long long> v;
vector<long long> ans;
long long k = 0;
for (i = 0; i < s.length();) {
j = i;
while (i < s.length() && s[i] == s[j]) i++;
if (i == s.length()) break;
if (i) {
if (s[i - 1] == 'B') {
v.push_back(j + 1);
ans.push_back(b);
} else {
v.push_back(j + 1);
ans.push_back(a);
}
}
}
d = s.length();
if (s.length() > 1 && s[d - 1] == s[d - 2]) {
j = d - 1;
while (j >= 0 && s[j] == s[d - 1]) j--;
if (s[j + 1] == 'A') {
v.push_back(j + 2);
ans.push_back(a);
} else {
v.push_back(j + 2);
ans.push_back(b);
}
}
long long ansi = d;
long long sum = 0;
for (i = ans.size() - 1; i >= 0; i--) {
sum += ans[i];
if (sum > p)
break;
else
ansi = v[i];
}
cout << ansi << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int ex[3];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
ex[i % 3] += x;
}
if (ex[0] > ex[1] && ex[0] > ex[2])
printf("chest\n");
else if (ex[1] > ex[0] && ex[1] > ex[2])
printf("biceps\n");
else
printf("back\n");
return 0;
}
| 1 |
#include <iostream>
int main(){
int a,b;
std::cin >> a >> b;
printf("%d",a*b/2);
} | 0 |
#include<stdio.h>
typedef long long ll;
const int N=500005,P=998244353;
int fexp(int a,int b)
{
ll x=1,o=a;
for(;b;b>>=1,o=o*o%P)
if(b&1)x=x*o%P;
return x;
}
int n,m,ans,fac[N],ifac[N];
int C(int n,int m){return 1ll*fac[n]*ifac[n-m]%P*ifac[m]%P;}
int main()
{
scanf("%d%d",&n,&m);
if(n<m){
int t=n;
n=m;
m=t;
}
fac[0]=1;
for(int i=1; i<=n; i++)fac[i]=1ll*fac[i-1]*i%P;
ifac[n]=fexp(fac[n],P-2);
for(int i=n-1; ~i; i--)ifac[i]=1ll*ifac[i+1]*(i+1)%P;
for(int k=0; k<=m; k++){
int f=1ll*C(n,k)*C(m,k)%P*fac[k]%P*fexp(m+1,n-k)%P*fexp(n+1,m-k)%P;
if(k&1)ans=(ans+P-f)%P;else ans=(ans+f)%P;
}
printf("%d",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
int x = max(a, b);
int y = min(a, b);
if (!y)
return x;
else
return gcd(y, x % y);
}
int main() {
int num, temp, mx = -1;
cin >> num;
int tk = 0;
for (int i = 0; (i) < (num); i++) {
cin >> temp;
tk = gcd(tk, temp);
mx = max(mx, temp);
}
mx /= tk;
int res = mx - num;
if (res % 2)
cout << "Alice\n";
else
cout << "Bob\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s;
int z[1000001];
void zAlgo() {
int L = 0, R = 0;
for (int i = 1; i < s.length(); i++) {
if (i > R) {
L = R = i;
while (R < s.length() && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
} else {
int k = i - L;
if (z[k] < R - i + 1)
z[i] = z[k];
else {
L = i;
while (R < s.length() && s[R - L] == s[R]) R++;
z[i] = R - L;
R--;
}
}
}
}
void solution() {
cin >> s;
zAlgo();
int maxz = 0, res = 0;
for (int i = 1; i < s.length(); i++) {
int n = s.length();
if (z[i] == s.length() - i && maxz >= s.length() - i) {
res = s.length() - i;
break;
}
maxz = max(maxz, z[i]);
}
res ? cout << s.substr(0, res) : cout << "Just a legend";
}
int main() {
double beg = clock();
ios::sync_with_stdio(false);
solution();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
while(1){
int n; string s; cin >> n; if(n==0) return 0; cin >> s;
int dp[(1<<10)+5]={};
int cur = 0;
for(int i=0;i<n;i++){
if(s[i] == 'u'){
cur = 0;
}
else{
dp[cur] |= (1<<(s[i]-'0')); //cout << cur << " " << (1<<(s[i]-'0'));
cur |= (1<<(s[i]-'0'));
}
}
int dp2[(1<<10)+5]={};
for(int i=0;i<(1<<10);i++){
dp2[i] = dp[i];
//if(i<8) cout << i <<" " << dp[i] << endl;
}
for(int R=0;R<9;R++){
for(int i=0;i<(1<<10);i++){
for(int j=0;j<(1<<10);j++){
if( (i&j) != j ) continue;
if(!dp2[i-j] || !dp[j]) continue;
dp2[i] |= dp2[i-j];
dp2[i] |= dp[j];
}
}
}
for(int i=0;i<(1<<10);i++){
if( dp2[i] != 0 && (dp2[i]&i) == dp2[i] ){
//if(n==8) cout << i << " " << dp2[i] << endl;
puts("UNSAFE"); goto ok;
}
}
puts("SAFE"); ok:;
}
} | 0 |
#include<iostream>
using namespace std;
int n,a[100010],b[100010];
int main()
{
long long cnt=0;
cin>>n;
for(int i=0;i<=n;i++)
cin>>b[i];
for(int i=0;i<n;i++)
cin>>a[i];
for(int i=n-1;i>=0;i--)
{
if(a[i]>b[i+1])
{
cnt+=b[i+1];
a[i]-=b[i+1];
b[i+1]=0;
if(a[i]>b[i])
cnt+=b[i],b[i]=0;
else
cnt+=a[i],b[i]-=a[i];
}
else
cnt+=a[i],b[i+1]-=a[i];
}
cout<<cnt;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
unsigned long long ModPow(unsigned long long base, unsigned long long exp,
unsigned long long m) {
unsigned long long r = 1, p;
base %= m;
while (exp) {
if (exp & 1) r = (r * base) % m;
exp = exp >> 1;
base = (base * base) % m;
}
return r;
}
int main() {
unsigned long long n;
cin >> n;
unsigned long long a[n + 1], b[n / 2 + 1];
for (int i = 1; i <= n / 2; i++) cin >> b[i];
a[1] = 0;
a[n] = b[1];
unsigned long long mx = b[1], mn = 0;
for (int i = 2; i <= n / 2; i++) {
if (b[i] - mn <= mx) {
a[i] = mn;
a[n - i + 1] = b[i] - a[i];
mx = a[n - i + 1];
} else {
a[n - i + 1] = mx;
a[i] = b[i] - a[n - i + 1];
mn = a[i];
}
}
for (int i = 1; i <= n; i++) cout << a[i] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353ll;
int N, T;
int sol[307];
int otherVal;
int sum = 0;
int main() {
scanf("%d %d", &N, &T);
otherVal = T;
for (int i = N - 1; i >= 1; i--) {
for (int j = 0; j < 20; j++) {
printf("? %d %d\n", 1, i);
printf("? %d %d\n", 1, i);
fflush(stdout);
int val;
scanf("%d", &val);
scanf("%d", &val);
if (val != T) {
if (val > otherVal) {
sol[i + 1] = 0;
} else {
sol[i + 1] = 1;
sum++;
}
otherVal = val;
while (val != T) {
printf("? %d %d\n", 1, i);
printf("? %d %d\n", 1, i);
fflush(stdout);
scanf("%d", &val);
scanf("%d", &val);
}
goto nextVal;
}
}
if (otherVal > T) {
sol[i + 1] = 1;
sum++;
} else {
sol[i + 1] = 0;
}
otherVal = T;
nextVal:;
}
if (sum < T) {
printf("! 1");
} else {
printf("! 0");
}
for (int i = 2; i <= N; i++) {
printf("%d", sol[i]);
}
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int h1, h2;
int a, b;
scanf("%d%d", &h1, &h2);
scanf("%d%d", &a, &b);
if (a <= b && h1 + a * 8 < h2) {
printf("-1\n");
} else {
int cnt = 0;
int now = h1 - 4 * a;
while (now + a * 12 < h2) {
now += a * 12;
now -= b * 12;
cnt++;
}
printf("%d\n", cnt);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
long long cnt = 0, i, ans = 0, d;
cin >> a;
if (a.size() == 1) ans--;
do {
cnt = 0;
for (i = 0; i < a.size(); i++) cnt += a[i] - 48;
d = cnt;
a = "";
while (d > 0) {
a += d % 10 + 48;
d /= 10;
}
ans++;
} while (cnt > 9);
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
char s[200];
node* nxt[200];
int son, f;
node() {
son = 0;
f = 0;
}
} * p;
char path[200][200];
int n, file;
void insert(char ss[]) {
int i;
for (i = 0; i < p->son; i++) {
if (strcmp(ss, p->nxt[i]->s) == 0) {
p = p->nxt[i];
p->f++;
if (p->f > file) file = p->f;
return;
}
}
p->son++;
p->nxt[i] = new node;
p = p->nxt[i];
p->f++;
if (p->f > file) file = p->f;
strcpy(p->s, ss);
}
int dfs(node* pp) {
if (pp->son == 0) return 1;
int i, sum = 1;
for (i = 0; i < pp->son; i++) sum += dfs(pp->nxt[i]);
return sum;
}
int work(char c) {
int i, j, k, sum = 0, t;
node root;
char ss[200];
for (i = 0; i < n; i++)
if (path[i][0] == c) {
p = &root;
j = 3;
while (1) {
for (k = j; path[i][k] && path[i][k] != '\\'; k++)
;
if (!path[i][k]) {
break;
}
path[i][k] = 0;
strcpy(ss, &path[i][j]);
insert(ss);
j = k + 1;
}
}
for (i = 0; i < root.son; i++) {
t = dfs(root.nxt[i]) - 1;
if (sum < t) sum = t;
}
return sum;
}
int main() {
int i, j;
char s[1000];
n = 0;
while (scanf("%s", path[n]) != EOF) {
for (i = 0; i < n; i++)
if (strcmp(path[i], path[n]) == 0) break;
if (i == n) n++;
}
int ans = 0;
char c;
file = 0;
for (c = 'C'; c <= 'G'; c++) {
i = work(c);
if (i > ans) ans = i;
}
printf("%d %d\n", ans, file);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vector<int>> vvi;
typedef vector<vector<ll>> vvl;
int n;
vector<vector<pair<int, ll>>> ps;
vector<map<int, ll>> memo, memo2;
ll dfs2(int i, int from);
ll dfs(int i, int from) {
if (memo[i].find(from) != memo[i].end()) {
return memo[i][from];
}
if ((from == -1 && ps[i].size() == 0) || (from != -1 && ps[i].size() == 1)) {
return memo[i][from] = 0;
}
memo[i][from] = 0;
for (auto &v : ps[i]) {
if (v.first == from)
continue;
ll d = dfs(v.first, i);
if (d == 0) {
memo[i][from] += v.second;
} else {
memo[i][from] += d + v.second * 3;
}
}
return memo[i][from];
}
ll dfs2(int i, int from) {
if (memo2[i].find(from) != memo2[i].end()) {
return memo2[i][from];
}
if ((from == -1 && ps[i].size() == 0) || (from != -1 && ps[i].size() == 1)) {
return memo2[i][from] = 0;
}
memo2[i][from] = 0;
vector<pair<ll, ll>> cs;
for (auto &v : ps[i]) {
if (v.first == from)
continue;
ll d1 = dfs(v.first, i);
ll d2 = dfs2(v.first, i);
if (d1 == 0) {
memo2[i][from] += v.second;
cs.push_back(make_pair(v.second, v.second));
} else {
memo2[i][from] += d1 + 3 * v.second;
cs.push_back(make_pair(d1 + 3 * v.second, d2 + 2 * v.second));
}
}
ll diff = 0;
for (auto &v : cs) {
diff = max(diff, v.first - v.second);
}
memo2[i][from] -= diff;
return memo2[i][from];
}
int main() {
while (true) {
cin >> n;
if (n == 0) {
break;
}
vector<ll> p(n), d(n);
ps.clear();
ps.resize(n);
for (int i = 1; i < n; i++) {
cin >> p[i];
p[i]--;
}
for (int i = 1; i < n; i++) {
cin >> d[i];
}
for (int i = 1; i < n; i++) {
ps[p[i]].push_back(make_pair(i, d[i]));
ps[i].push_back(make_pair(p[i], d[i]));
}
memo.clear();
memo.resize(n);
memo2.clear();
memo2.resize(n);
ll ans = dfs2(0, -1);
for (int i = 1; i < n; i++) {
ans = min(ans, dfs2(i, -1));
}
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200;
const int M = 2e5 + 10;
char ch[N], p[N], s[M], a[10], b[10];
int main() {
int n, m;
while (~scanf("%d %d", &n, &m)) {
for (int i = 'a'; i <= 'z'; i++) {
ch[i] = i;
}
scanf("%s", s);
while (m--) {
scanf("%s %s", a, b);
swap(ch[a[0]], ch[b[0]]);
}
for (int i = 'a'; i <= 'z'; i++) p[ch[i]] = i;
for (int i = 0; i < n; i++) {
putchar(p[s[i]]);
}
putchar('\n');
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mxN = 3e3 + 4;
long long int dp[mxN][mxN], ar[mxN], br[mxN];
int main() {
int n, m, a, i, j;
cin >> n;
for (i = 1; i <= n; i++) cin >> ar[i], ar[i] -= i, br[i] = ar[i];
sort(br + 1, br + n + 1);
for (i = 1; i <= n; i++) {
dp[i][1] = dp[i - 1][1] + abs(ar[i] - br[1]);
for (j = 2; j <= n; j++)
dp[i][j] = min(dp[i][j - 1], dp[i - 1][j] + abs(ar[i] - br[j]));
}
cout << dp[n][n] << "\n";
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.