solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
bool a = false, b = false, c = false, d = false;
char str[110];
scanf("%s", &str);
int len = strlen(str);
a = (len >= 5);
for (int i = 0; i < len; i++) {
b = b || (str[i] >= 'A' && str[i] <= 'Z');
c = c || (str[i] >= 'a' && str[i] <= 'z');
d = d || (str[i] >= '0' && str[i] <= '9');
}
(a && b && c && d) ? puts("Correct") : puts("Too weak");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int ans(long long int n) {
long long int a = 0;
for (long long int i = 2; (long long int)(i * i * i) <= n; i++) {
a += n / ((long long int)(i * i * i));
}
return a;
}
int main() {
std::ios::sync_with_stdio(false);
long long int n;
cin >> n;
long long int l = 0;
long long int r = 8 * (1e15);
long long int m;
while (l < r) {
m = (l + r) / 2;
if (ans(m) < n)
l = m + 1;
else
r = m;
}
if (ans(m) < n) {
m++;
}
if (ans(m) > n) {
m--;
}
if (ans(m) == n)
cout << m;
else
cout << "-1";
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int Mod = (int)1e9 + 7;
const int MX = 1073741822;
const long long MXLL = 9223372036854775807;
const int Sz = 1110111;
using namespace std;
inline void Read_rap() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
inline void randomizer3000() {
unsigned int seed;
asm("rdtsc" : "=A"(seed));
srand(seed);
}
int n;
int a[Sz];
int main() {
Read_rap();
cin >> n;
for (int i = 1; i <= 2 * n; i++) cin >> i[a];
sort(a + 1, a + 2 * n + 1);
if (a[n] == a[n + 1])
cout << "NO";
else
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void gn(T &x) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), x = 0; c >= '0' && c <= '9';
c = getchar())
x = (x << 1) + (x << 3) + c - '0';
if (sg) x = -x;
}
template <class T>
inline void print(T x) {
if (x < 0) {
putchar('-');
return print(-x);
}
if (x < 10) {
putchar('0' + x);
return;
}
print(x / 10);
putchar(x % 10 + '0');
}
char s[2222][2222], t[2222][2222];
int ans[2222][2222];
int n, m, k;
int flag;
int st[2222];
int good() {
puts("YES");
if (flag)
for (int i = 0; i < m; i++, puts(""))
for (int j = 0; j < n; j++, putchar(' ')) print(ans[j][i] + 1);
else
for (int i = 0; i < n; i++, puts(""))
for (int j = 0; j < m; j++, putchar(' ')) print(ans[i][j] + 1);
exit(0);
}
int bad() {
puts("NO");
exit(0);
}
int solve1() {
int tot = 0, yes = 0;
for (int i = 0; i < 2 * n - 1; i++) {
for (int j = 0; s[i][j]; j++) {
if (s[i][j] == 'E') yes++;
tot++;
}
}
if (4 * yes < tot * 3) return bad();
good();
}
int calc(int u, char C) {
if (C == 'E')
return u;
else
return u ^ 1;
}
void tryout(int u, int v) {
int res = 0;
for (int i = 0; i < m; i++) {
if (!i)
ans[v][0] = ans[u][0];
else
ans[u][i] = calc(ans[u][i - 1], s[u * 2][i - 1]),
ans[v][i] = calc(ans[v][i - 1], s[v * 2][i - 1]);
if (calc(ans[u][i], s[u * 2 + 1][i]) == ans[v][i]) res++;
}
if (res * 2 < m) {
for (int i = 0; i < m; i++) ans[v][i] ^= 1;
}
}
int jiejue() {
ans[0][0] = 0;
for (int i = 1; i < m; i++) ans[0][i] = calc(ans[0][i - 1], s[0][i - 1]);
for (int i = 0; i < n - 1; i++) {
tryout(i, i + 1);
}
return good();
;
}
int solve() {
gn(n);
gn(m);
gn(k);
for (int i = 0; i < 2 * n - 1; i++) scanf("%s", s[i]);
if (k == 1) return solve1();
if (n <= m) return jiejue();
for (int i = 0; i < 2 * n - 1; i += 2) {
for (int j = 0; j < m - 1; j++) t[j * 2 + 1][i / 2] = s[i][j];
}
for (int i = 1; i < 2 * n - 1; i += 2) {
for (int j = 0; j < m; j++) t[j * 2][i / 2] = s[i][j];
}
swap(n, m);
for (int i = 0; i < n * 2 - 1; i++) {
t[i][m + (i & 1) - 1] = 0;
for (int j = 0; t[i][j]; j++) s[i][j] = t[i][j];
s[i][m + (i & 1) - 1] = 0;
}
flag = 1;
return jiejue();
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long t;
cin >> t;
while (t--) {
long a, b, c, d;
cin >> a >> b >> c >> d;
long x, y, x1, y1, x2, y2;
cin >> x >> y >> x1 >> y1 >> x2 >> y2;
x -= a - b, y -= c - d;
if ((x1 < x2 || !(a + b)) && (y1 < y2 || !(c + d)) && x1 <= x && x <= x2 &&
y1 <= y && y <= y2)
cout << "Yes\n";
else
cout << "No\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int x[N], y[N];
int main() {
int n;
scanf("%d", &n);
long long sumx = 0, sqx = 0, sumy = 0, sqy = 0;
for (int i = 0; i < n; ++i) {
scanf("%d%d", x + i, y + i);
sumx += x[i];
sqx += 1LL * x[i] * x[i];
sumy += y[i];
sqy += 1LL * y[i] * y[i];
}
long long ans = 0;
for (int i = 0; i < n; ++i) {
ans += sqx;
ans += n * 1LL * x[i] * x[i];
ans -= 2 * x[i] * sumx;
ans += sqy;
ans += n * 1LL * y[i] * y[i];
ans -= 2 * y[i] * sumy;
}
printf("%I64d\n", ans / 2);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200004;
long long power(long long a, long long n) {
if (n == 0) return 1;
long long ans = 1;
long long val = a;
while (n) {
if (n % 2) {
ans *= val;
ans %= 1000000007;
}
val *= val;
val %= 1000000007;
n /= 2;
}
return ans;
}
string s;
vector<int> v[maxn];
int dp[maxn];
int ans[maxn];
int a[maxn];
void dfs(int node, int par) {
dp[node] = a[node];
for (auto it : v[node]) {
if (it != par) {
dfs(it, node);
dp[node] += max(0, dp[it]);
}
}
}
void dfs2(int node, int par) {
ans[node] = dp[node];
for (auto it : v[node]) {
if (it != par) {
dp[node] -= max(0, dp[it]);
dp[it] += max(0, dp[node]);
dfs2(it, node);
dp[it] -= max(0, dp[node]);
dp[node] += max(0, dp[it]);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long i, j, k, l, m, n, q;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] == 0) a[i] = -1;
}
for (i = 1; i < n; i++) {
cin >> j >> k;
v[j].push_back(k);
v[k].push_back(j);
}
dfs(1, 0);
dfs2(1, 0);
for (i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string st;
cin >> st;
int f = 0, s = 0;
for (int i = 0; i < st.size(); i++) {
if (st[i] == '7')
s++;
else if (st[i] == '4')
f++;
}
if (s == 0 && f == 0) {
cout << "-1";
return 0;
;
} else if (f >= s)
cout << "4";
else
cout << "7";
}
| 2 |
#include <bits/stdc++.h>
const long long mod = 1000000007;
const long long Inf = 2 * 1e9;
using namespace std;
int toint(string s) {
long long ans = 0;
for (int(i) = 0; (i) < s.length(); (i)++) ans = ans * 10 + (s[i] - '0');
return ans;
}
vector<int> a;
vector<pair<int, int>> pr;
int main() {
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
a.resize(n);
for (int(i) = 0; (i) < n; (i)++) cin >> a[i];
long long r = 0, ch = 0, pos = 1, count = 0, nn = n;
while (1) {
bool flag = false;
for (int(i) = pos + 1; (i) < n; (i)++) {
r = ch - (i - 1 - count) * (n - i) * a[i - 1];
ch += (i - 1 - count) * a[i - 1];
if (r < k) {
cout << i << endl;
pos = i;
ch -= (i - 1 - count) * a[i - 1];
count++;
flag = true;
break;
}
}
if (!flag) break;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000000;
const int mod = 1000000007;
const int N = 200005;
int n;
int a[N];
int solve(int cur) {
int tmp = cur;
int mx = 0;
while (tmp <= a[n - 1]) {
tmp += cur;
int ind = lower_bound(a, a + n, tmp) - a;
--ind;
if (ind >= 0) {
if (a[ind] > cur) {
mx = max(mx, a[ind] % cur);
}
}
}
return mx;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
sort(a, a + n);
int cur = 1;
for (int i = 1; i < n; ++i) {
if (a[cur - 1] != a[i]) a[cur++] = a[i];
}
n = cur;
int ans = 0;
for (int i = 0; i < n; ++i) {
int dp = solve(a[i]);
ans = max(dp, ans);
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
x = 0;
int p = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') p = -p;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 1) + (x << 3) + (ch - '0'), ch = getchar();
x = x * p;
}
const int maxn = 200005;
int n, w[maxn], head[maxn], cnt, siz[maxn], vis[maxn], son[maxn], root, maxson;
int ansu;
double res, dao[maxn], totdao, nowres;
struct edge {
int to, next, v;
} e[maxn << 1];
void add(int x, int y, int z) {
e[cnt].to = y;
e[cnt].v = z;
e[cnt].next = head[x];
head[x] = cnt++;
}
void getsiz(int u, int pre) {
siz[u] = 1;
for (int i = head[u]; i; i = e[i].next) {
if (e[i].to == pre || vis[e[i].to]) continue;
getsiz(e[i].to, u);
siz[u] += siz[e[i].to];
}
}
void getson(int u, int pre) {
son[u] = 0;
for (int i = head[u]; i; i = e[i].next) {
if (e[i].to == pre || vis[e[i].to]) continue;
getson(e[i].to, u);
son[u] = max(son[u], siz[e[i].to]);
}
son[u] = max(son[u], maxson - siz[u]);
if (son[root] > son[u]) root = u;
}
void getdao(int u, int pre, long long d) {
dao[u] = 0.0;
for (int i = head[u]; i; i = e[i].next) {
if (e[i].to == pre) continue;
getdao(e[i].to, u, d + e[i].v);
dao[u] += dao[e[i].to];
}
dao[u] += 1.5 * w[u] * sqrt(d);
nowres += 1.0 * w[u] * pow(d, 1.5);
}
void solve(int u) {
getsiz(u, 0);
root = 0;
maxson = siz[u];
getson(u, 0);
u = root;
vis[u] = 1;
totdao = 0.0;
nowres = 0.0;
for (int i = head[u]; i; i = e[i].next) {
getdao(e[i].to, u, e[i].v);
totdao += dao[e[i].to];
}
if (nowres < res) res = nowres, ansu = u;
for (int i = head[u]; i; i = e[i].next) {
if (vis[e[i].to]) continue;
double x = totdao - 2.0 * dao[e[i].to];
if (x < 0) {
solve(e[i].to);
return;
}
}
}
int main() {
ansu = 0;
res = 1e20;
son[0] = 1061109567;
read(n);
cnt = 1;
for (int i = 1; i <= n; ++i) read(w[i]);
for (int i = 1; i < n; ++i) {
int x, y, z;
read(x);
read(y);
read(z);
add(x, y, z);
add(y, x, z);
}
solve(1);
printf("%d %.10f\n", ansu, res);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> arr;
long long n, k, a, b;
long long reccc(long long l, long long r) {
long long c = lower_bound(arr.begin(), arr.end(), r) -
lower_bound(arr.begin(), arr.end(), l);
if (c == 0) {
return a;
}
if (r == l + 1) {
return b * c;
}
long long mid = (l + r) / 2;
long long t1 = reccc(l, mid);
long long t2 = reccc(mid, r);
return min(b * (r - l) * c, t1 + t2);
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k >> a >> b;
arr.resize(k);
for (long long i = 0; i < k; i++) {
cin >> arr[i];
arr[i]--;
}
sort(arr.begin(), arr.end());
cout << reccc(0, 1 << n) << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
int n;
long long a[N], b[N], r[N], sum[N], mx;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
}
for (int i = 0; i < n; ++i) {
cin >> b[i];
}
set<pair<int, int>> s;
for (int i = n - 1; i >= 0; --i) {
r[i] = mx;
int pos = b[i];
pair<int, int> cur = {pos, pos};
auto f = s.lower_bound(cur);
if (f != s.end()) {
if (f->first == pos + 1) {
cur = {pos, f->second};
s.erase(f);
}
}
auto w = s.lower_bound(cur);
if (w != s.begin()) {
--w;
if (w->second == pos - 1) {
cur = {w->first, cur.second};
s.erase(w);
}
}
mx = max(mx, sum[cur.second] - sum[cur.first - 1]);
s.insert(cur);
}
for (int i = 0; i < n; ++i) {
cout << r[i] << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
char a;
cin>>a;
if(a<=90){cout<<"A"<<endl;}
else{cout<<"a"<<endl;}
} | 0 |
#include <bits/stdc++.h>
inline int gi() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * f;
}
int a[101][101], num[101][101], cnt, o[101][101], S, T;
int fir[6000], dis[1000010], nxt[1000010], w[1000010], cost[100010], id = 1;
inline void link(int a, int b, int c) {
nxt[++id] = fir[a], fir[a] = id, dis[id] = b, w[id] = 1, cost[id] = c;
nxt[++id] = fir[b], fir[b] = id, dis[id] = a, cost[id] = -c;
}
inline bool Mincost(int& total) {
static int dist[6000], lst[6000], inq[6000], que[6000], hd, tl;
hd = tl = 0;
memset(dist, 63, 4 * (cnt + 1));
dist[S] = 0;
inq[S] = 1;
que[tl++] = S;
while (hd ^ tl) {
int x = que[hd];
for (int i = fir[x]; i; i = nxt[i])
if (w[i] && dist[dis[i]] > dist[x] + cost[i]) {
dist[dis[i]] = dist[x] + cost[i];
lst[dis[i]] = i;
if (!inq[dis[i]]) {
inq[dis[i]] = 1, que[tl++] = dis[i];
if (tl == 6000) tl = 0;
}
}
++hd;
if (hd == 6000) hd = 0;
inq[x] = 0;
}
if (dist[T] == dist[0]) return 0;
for (int i = lst[T]; i; i = lst[dis[i ^ 1]])
w[i] = 0, w[i ^ 1] = 1, total += cost[i];
return 1;
}
int main() {
int n = gi(), m = gi(), u, v;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) a[i][j] = 2;
while (m--) u = gi(), v = gi(), a[u][v] = 1, a[v][u] = 0;
cnt = n;
S = ++cnt, T = ++cnt;
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j) {
num[i][j] = ++cnt;
if (a[i][j] == 0)
link(S, i, 0);
else if (a[i][j] == 1)
link(S, j, 0);
else
link(S, num[i][j], 0), o[i][j] = id + 1, link(num[i][j], i, 0),
link(num[i][j], j, 0);
}
for (int i = 1; i <= n; ++i)
for (int j = n; j; --j) link(i, T, j - 1);
int ans = 0;
while (Mincost(ans))
;
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j)
if (a[i][j] == 2) a[i][j] = w[o[i][j]], a[j][i] = !a[i][j];
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) printf("%d", a[i][j] == 2 ? 0 : a[i][j]);
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,n) for(ll (i) = (0);(i) < (n);++i)
#define REV(i,n) for(ll (i) = (n) - 1;(i) >= 0;--i)
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v,n) {REP(WW,n)cerr << v[WW] << ' ';cerr << endl << endl;}
#define SHOW2d(v,WW,HH) {REP(W_,WW){REP(H_,HH)cerr << v[W_][H_] << ' ';cerr << endl;}cerr << endl;}
#define ALL(v) v.begin(),v.end()
#define Decimal fixed<<setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
#define MOD 1000000007
typedef long long ll;
typedef pair<ll,ll> P;
/*
0-index
functionの中を書いて使う
宣言の時に単位元を書く
*/
template<typename T>
struct segtree{
int n;
vector<T> dat;
T ZERO;
function<T(T,T)> func;
segtree(int n_, function<T(T,T)> func_, T zero):func(func_), ZERO(zero){
n = 1;
while(n < n_)n*=2;
dat.resize(2*n);
for(int i = 0;i < 2*n;i++)dat[i] = ZERO;
}
void update(int k, T a){
k += n - 1;dat[k] = a;
while(k > 0){
k = (k-1)/2;
dat[k] = func(dat[k*2+1],dat[k*2+2]);
}
}
void set(int k, T a) {
k += n - 1;dat[k] = a;
}
void build(){
for(int i = n - 2;i >= 0;i--){
dat[i] = func(dat[2 * i + 1], dat[2 * i + 2]);
}
}
T get(int k){return dat[k+n-1];}
T que(int a,int b){
T L = ZERO,R = ZERO;
int A = a + n - 1;
int B = b + n - 1;
while(A < B){
if((A & 1) == 0)L = func(L,dat[A++]);
if((B & 1) == 0)R = func(dat[--B],R);
A = A >> 1;
B = B >> 1;
}
return func(L,R);
}
};
int getmin(string str){
char c = str[0];
bool isFirst = true;
int cou = 0;
int ret = INF;
REP(i, str.size()){
if(str[i] == c)cou++;
else {
if(isFirst && cou % 2 == 0)cou++;
if(cou % 2)ret = min(ret, cou);
isFirst = false;
cou = 0;
}
}
return ret;
}
ll n, m, k, ans;
string str;
bool oneKind(string str){
REP(i, str.size())if(str[0] != str[i])return false;
return true;
}
void solveA(){
ll ans = 0;
segtree<ll> seg(n, [](ll a, ll b){return (a + b) % MOD;}, 0);
seg.update(0, 1);
for(ll i = 2;i < n;i++){
ll l = max(0LL, i - k - 1);
ll r = i - 1;
seg.update(i, seg.que(l, r));
}
REP(i, n-1){
if(n - (i + 1) <= k){
//cout << "pass " << seg.get(i) * (n - i) % MOD << endl;
ans = (ans + seg.get(i) * (n - i) % MOD) % MOD;
}
}
ans = (ans + 1) % MOD;
cout << ans << endl;
}
void solveB(){
ll ans = 0;
segtree<ll> seg(n, [](ll a, ll b){return (a + b) % MOD;}, 0);
seg.update(0, 1);
for(ll i = 2;i < n;i++){
if(i % 2)continue;
ll l = max(0LL, i - k - 1);
ll r = i - 1;
seg.update(i, seg.que(l, r));
}
//REP(i, n)cout << seg.get(i) << " ";cout << endl;
REP(i, n-1){
if(n - (i + 1) <= k && ((n - (i + 1)) % 2)){
//cout << "pass " << seg.get(i) * (n - i) % MOD << endl;
ans = (ans + seg.get(i) * (n - i) % MOD) % MOD;
}
}
cout << ans << endl;
}
int main(){
cin.tie(0);cout.tie(0);ios::sync_with_stdio(false);
cin >> n >> m >> str;
k = getmin(str);
if(oneKind(str)){
solveA();
}
else {
solveB();
}
return 0;
}
| 0 |
#include <iostream>
#include <cmath>
using namespace std;
int main(){
double x, q;
while(cin >> q, q != -1.0){
x = q / 2.0;
while(abs(x*x*x-q) >= 0.00001*q){
x = x-(x*x*x-q)/(3*x*x);
}
printf("%.6f\n", x);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, a, j, b, c, d, x, y;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a >> b >> x >> y;
c = max((x * b), ((a - 1 - x) * b));
d = max((a * y), (a * (b - 1 - y)));
cout << (max(c, d)) << endl;
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
string s;
int ans=0;
int main(){
cin>>s;
char now=s[0];
for (int i=1;i<s.size();i++)
if (s[i]==now) ans++,now=s[i]=='0'?'1':'0';
else now=s[i];
printf("%d",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[702], g[702][702];
int f[702][702][2];
int gcd(int x, int y) {
if (!y)
return x;
else
return gcd(y, x % y);
}
bool dfs(int l, int r, int x) {
int t;
if (l > r) return 1;
if (x == 0)
t = l - 1;
else
t = r + 1;
if (t < 1 || t > n) return 0;
if (f[l][r][x] >= 0) return f[l][r][x];
for (int i = l; i <= r; ++i)
if (g[t][i] > 1 && dfs(l, i - 1, 1) && dfs(i + 1, r, 0))
return f[l][r][x] = 1;
return f[l][r][x] = 0;
}
int main() {
scanf("%d\n", &n);
memset(f, -1, sizeof(f));
for (int i = 1; i <= n; ++i) scanf("%d", a + i);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) g[i][j] = gcd(a[i], a[j]);
for (int i = 1; i <= n; ++i)
if (dfs(1, i - 1, 1) && dfs(i + 1, n, 0)) {
printf("Yes");
return 0;
}
printf("No");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int n, m, d[100][100], f[20][100], pos[100], ans;
vector<int> p[2];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) scanf("%d", &d[i][j]);
int T = 8000;
ans = INF;
while (T--) {
p[0].clear();
p[1].clear();
int x;
for (int i = 1; i <= n; i++) {
x = i == 1 ? 0 : rand() % 2;
p[x].push_back(i);
pos[i] = x;
}
memset(f, 0x3f, sizeof(f));
f[m][1] = 0;
for (int i = m - 1; i >= 1; i--)
for (auto j : p[i % 2]) {
f[i][j] = INF;
for (auto k : p[1 - pos[j]])
f[i][j] = min(f[i][j], f[i + 1][k] + d[j][k]);
}
for (auto k : p[1]) ans = min(ans, f[1][k] + d[1][k]);
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <iostream>
#include <cmath>
using namespace std;
int main() {
int d[4];
int e, f;
int sum = 0;
int MIN = 1000;
for (int i = 0; i < 4; i++) {
cin >> d[i];
sum += d[i];
MIN = min(MIN, d[i]);
}
cin >> e >> f;
sum += max(e, f);
cout << sum-MIN << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, id;
};
bool cmp(const node &a, const node &b) { return a.x < b.x; }
node a[100010];
int from[100010];
int main() {
int n, m;
while (scanf("%d%d", &n, &m) == 2) {
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].x);
a[i].id = i;
}
if (n == 1 || n == 2) {
printf("0\n");
for (int i = 0; i < n; i++) printf("1 ");
puts("");
continue;
}
sort(a, a + n, cmp);
int ans1 = (a[n - 1].x + a[n - 2].x - a[0].x - a[1].x);
int ans2, maxx, minn;
maxx = a[n - 1].x + a[n - 2].x;
maxx = max(maxx, a[0].x + a[n - 1].x + m);
minn = a[0].x + a[1].x + m;
minn = min(a[1].x + a[2].x, minn);
ans2 = maxx - minn;
if (ans1 <= ans2) {
printf("%d\n", ans1);
for (int i = 0; i < n; i++) printf("1 ");
puts("");
} else {
printf("%d\n", ans2);
from[a[0].id] = 2;
for (int i = 1; i < n; i++) from[a[i].id] = 1;
printf("%d", from[0]);
for (int i = 1; i < n; i++) printf(" %d", from[i]);
puts("");
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 10;
set<pair<int, int>> bridges;
int asdadsa, low[N], dis[N], dsuParent[N], dfsParent[N];
int n, m, a, b;
vector<int> g[N];
vector<pair<int, int>> edges;
set<pair<int, int>> directed_edges;
bool comp(const int &a, const int &b) { return dsuParent[a] < dsuParent[b]; }
int findParent(int x) {
if (dsuParent[x] < 0) return x;
dsuParent[x] = findParent(dsuParent[x]);
return dsuParent[x];
}
void join(int a, int b) {
a = findParent(a);
b = findParent(b);
if (a == b) return;
if (dsuParent[a] < dsuParent[b]) swap(a, b);
dsuParent[b] += dsuParent[a];
dsuParent[a] = b;
}
void dfs(int s = 1, int p = -1) {
dis[s] = low[s] = ++asdadsa;
dfsParent[s] = p;
for (int &i : g[s]) {
if (i == p) continue;
if (!low[i]) dfs(i, s);
if (dis[s] < low[i]) {
bridges.insert(make_pair(s, i));
bridges.insert(make_pair(i, s));
}
low[s] = min(low[s], low[i]);
}
}
void assignOrientation(int s, int p = -1) {
low[s] = ++asdadsa;
for (int &i : g[s]) {
if (i == p) continue;
if (bridges.count(make_pair(i, s))) directed_edges.insert(make_pair(i, s));
if (directed_edges.count(make_pair(i, s)) == 0)
directed_edges.insert(make_pair(s, i));
if (!low[i]) {
assignOrientation(i, s);
}
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &a, &b);
g[a].emplace_back(b);
g[b].emplace_back(a);
edges.emplace_back(a, b);
}
for (int i = 1; i <= n; ++i)
if (!low[i]) dfs(i);
memset(dsuParent, -1, sizeof(dsuParent));
for (auto &i : edges) {
if (!bridges.count(i)) join(i.first, i.second);
}
vector<int> nodesOrder;
for (int i = 1; i <= n; ++i) {
nodesOrder.emplace_back(i);
}
sort(nodesOrder.begin(), nodesOrder.end(), comp);
asdadsa = 0;
memset(low, 0, sizeof(low));
for (int i = 0; i < n; ++i)
if (!low[nodesOrder[i]]) assignOrientation(nodesOrder[i]);
for (auto &i : edges) {
if (directed_edges.count(i) == 0) swap(i.first, i.second);
}
int ans = 0;
for (int i = 1; i <= n; ++i) ans = max(ans, -dsuParent[i]);
printf("%d\n", ans);
for (auto &i : edges) printf("%d %d\n", i.first, i.second);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> erat;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long nd(long long a) {
map<long long, long long> m;
while (a != 1) {
++m[erat[a]];
a /= erat[a];
}
long long count = 1;
for (auto e : m) count *= e.second + 1;
return count;
}
int main() {
vector<vector<vector<bool> > > count(
8, vector<vector<bool> >(8, vector<bool>(8, true)));
count[1][7][6] = false;
count[3][7][6] = false;
count[5][3][6] = false;
count[5][3][7] = false;
count[5][7][6] = false;
count[7][2][5] = false;
count[7][3][4] = false;
count[7][3][5] = false;
count[7][3][6] = false;
count[7][3][7] = false;
count[7][6][5] = false;
count[7][7][5] = false;
count[7][7][6] = false;
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
erat = vector<long long>(1e5 + 1, 1);
erat[0] = erat[1] = 1;
for (long long i = 2; i <= 1e5; ++i) {
if (erat[i] == 1) {
erat[i] = i;
for (long long j = i * i; j <= 1e5; j += i) {
if (erat[j] == 1) erat[j] = i;
}
}
}
long long t;
cin >> t;
while (t--) {
long long a, b, c;
cin >> a >> b >> c;
long long d = gcd(a, b);
long long e = gcd(a, c);
long long f = gcd(b, c);
long long g = gcd(d, c);
a = nd(a);
b = nd(b);
c = nd(c);
d = nd(d);
e = nd(e);
f = nd(f);
g = nd(g);
d -= g, e -= g, f -= g;
a -= d + e + g, b -= d + f + g, c -= e + f + g;
vector<long long> v(8);
v[1] = a, v[2] = b, v[3] = d, v[4] = c, v[5] = e, v[6] = f, v[7] = g;
long long total = 0;
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
for (int k = 0; k < 4; ++k) {
int l = 2 * i + 1;
int m = 2 + j;
if (j >= 2) m += 2;
int p = 4 + k;
if (count[l][m][p]) {
if (l == m) {
if (m == p)
total += v[l] * (v[m] + 1) * (v[p] + 2) / 6;
else
total += v[l] * (v[m] + 1) * v[p] / 2;
} else if (l == p or m == p)
total += v[l] * v[m] * (v[p] + 1) / 2;
else
total += v[l] * v[m] * v[p];
}
}
}
}
cout << total << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, d, tot, now, last, p[1000039], pl[1000039];
long long q[1000039], k, x, y, z, ans, pus;
struct yyy {
int to;
long long w;
int z;
};
struct ljb {
int head, h[1000039];
yyy f[2000039];
inline void add(int x, int y, long long z) {
f[++head] = (yyy){y, z, h[x]};
h[x] = head;
}
} s;
struct tree {
int l, r, f;
} f[2][1000039];
static char buf[1000000], *p1 = buf, *p2 = buf;
inline void read(long long &x) {
char s =
p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
x = 0;
while (s < '0' || s > '9')
s = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
while (s >= '0' && s <= '9')
x = x * 10 + s - 48,
s = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline void dfs(int x, int last) {
int cur = s.h[x];
yyy tmp;
while (cur != -1) {
tmp = s.f[cur];
if (tmp.to != last) q[tmp.to] = q[x] ^ tmp.w, dfs(tmp.to, x);
cur = tmp.z;
}
}
int main() {
memset(s.h, -1, sizeof(s.h));
register int i;
scanf("%d%lld", &n, &k);
k = (long long)n * n + 1 - k;
for (i = 2; i <= n; i++) read(x), read(z), s.add(x, i, z), s.add(i, x, z);
dfs(1, 0);
d = 62;
for (i = 1; i <= n; i++) p[i] = 1, pl[i] = 1;
while (d != -1) {
last = now;
now = last ^ 1;
tot = 0;
for (i = 1; i <= n; i++) f[now][i].l = f[now][i].r = f[now][i].f = 0;
for (i = 1; i <= n; i++) {
if (!(q[i] & (1ll << d))) {
if (!f[last][p[i]].l) f[last][p[i]].l = ++tot;
p[i] = f[last][p[i]].l;
f[now][p[i]].f++;
} else {
if (!f[last][p[i]].r) f[last][p[i]].r = ++tot;
p[i] = f[last][p[i]].r;
f[now][p[i]].f++;
}
}
ans = 0;
for (i = 1; i <= n; i++) {
if (q[i] & (1ll << d))
ans += f[now][f[last][pl[i]].l].f;
else
ans += f[now][f[last][pl[i]].r].f;
}
if (ans >= k) {
pus ^= (1ll << d);
for (i = 1; i <= n; i++) {
if (q[i] & (1ll << d))
pl[i] = f[last][pl[i]].l;
else
pl[i] = f[last][pl[i]].r;
}
} else {
k -= ans;
for (i = 1; i <= n; i++) {
if (q[i] & (1ll << d))
pl[i] = f[last][pl[i]].r;
else
pl[i] = f[last][pl[i]].l;
}
}
d--;
}
printf("%lld\n", pus);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
long long n=2,m=1;
for(int i=0;i<N;i++){
m=n+m;
n=m-n;
}
cout << n << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 26];
int main()
{
int bit = 0;
string S;
fill_n(dp, 1 << 26, 1 << 27);
dp[0] = 0;
cin >> S;
for(int i = 0; i < S.size(); i++) {
bit ^= (1 << (S[i] - 'a'));
for(int j = 0; j < 26; j++) {
dp[bit] = min(dp[bit], dp[bit ^ (1 << j)] + 1);
}
}
cout << dp[bit] + (dp[bit] == 0) << endl;
return (0);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int Q;
bool vis[41];
int C;
map<string, int> msi;
int n, Max;
long long v[41], deg[41];
void update_maximum(long long R) {
int Size = 0;
while (R) {
if (R & 1) Size++;
R >>= 1;
}
Max = max(Size, Max);
}
int pickPivot(long long P) {
int pivot = -1, Max = -1;
memset(deg, 0, sizeof(deg));
for (int i = 0; i < n; i++) {
if (P & (1LL << i)) {
if (pivot == -1) {
pivot = i;
Max = deg[i];
}
for (int j = 0; j < i; j++) {
if ((P & (1LL << j)) && (v[i] & (1LL << j))) {
deg[i]++;
if (deg[i] > Max) {
Max = deg[i];
pivot = i;
}
deg[j]++;
if (deg[j] > Max) {
Max = deg[j];
pivot = j;
}
}
}
}
}
return pivot;
}
void BronKerbosch(long long R, long long P, long long X) {
if (!P) {
if (!X) {
update_maximum(R);
}
return;
}
int u = pickPivot(P | X);
for (int i = 0; i <= n - 1; i++) {
if (P & (~v[u]) & (1LL << i)) {
BronKerbosch(R | (1LL << i), P & v[i], X & v[i]);
P &= (~(1LL << i));
X |= (1LL << i);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> Q >> n;
for (int i = 0; i <= n - 1; i++) v[i] = ((1LL << n) - 1) & ~(1LL << i);
int cmd;
string str;
for (int q = 1; q <= Q; q++) {
cin >> cmd;
if (cmd == 1) {
for (int i = 0; i <= C - 1; i++)
for (int j = i + 1; j <= C - 1; j++) {
if (vis[i] && vis[j]) {
v[i] &= ~(1LL << j);
v[j] &= ~(1LL << i);
}
}
memset(vis, 0, sizeof(vis));
} else {
cin >> str;
if (msi.find(str) == msi.end()) {
msi[str] = C++;
}
int i = msi[str];
vis[i] = true;
}
}
for (int i = 0; i <= C - 1; i++)
for (int j = i + 1; j <= C - 1; j++) {
if (vis[i] && vis[j]) {
v[i] &= ~(1LL << j);
v[j] &= ~(1LL << i);
}
}
BronKerbosch(0, (1LL << C) - 1, 0);
cout << Max << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
template <class T>
T power(T a, T b) {
T result = 1;
while (b > 0) {
if (b & 1) result = result * a;
a = a * a;
b >>= 1;
}
return result;
}
template <class T>
T powerMod(T a, T b, T c) {
T result = 1 % c;
while (b > 0) {
if (b & 1) result = (result * a) % c;
a = (a * a) % c;
b >>= 1;
}
return result;
}
int A[200100], B[200100];
void eval() {
int n, i, j, a, pos = 0;
cin >> n;
for (i = 0, j = 0; i < n; i++) {
cin >> a;
if (a == 0) {
} else {
A[j] = a;
j++;
}
}
for (i = 0, j = 0; i < n; i++) {
cin >> a;
if (a == 0) {
} else {
B[j] = a;
j++;
}
}
for (i = 0; i < n - 1; i++) {
if (A[i] == B[0]) {
pos = i;
}
}
for (i = pos, j = 0; j < n - 1; j++) {
if (A[i] != B[j]) {
cout << "NO\n";
return;
}
i = (i + 1) % (n - 1);
}
cout << "YES\n";
}
int main() {
cin.sync_with_stdio(0);
cout.sync_with_stdio(0);
eval();
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int a, b, x1, y1, x2, y2;
scanf("%d%d%d%d%d%d", &a, &b, &x1, &y1, &x2, &y2);
a *= 2;
b *= 2;
int i, j, s1, s2, r1, r2;
s1 = x1 + y1;
s2 = x2 + y2;
r1 = 0;
r2 = 0;
if (s1 < 0) r1 = 1;
if (s2 < 0) r2 = 1;
i = fabs(s1 / a - r1 - s2 / a + r2);
s1 = x1 - y1;
s2 = x2 - y2;
r1 = 0;
r2 = 0;
if (s1 < 0) r1 = 1;
if (s2 < 0) r2 = 1;
j = fabs(s1 / b - r1 - s2 / b + r2);
if (i > j)
printf("%d", i);
else
printf("%d", j);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, t, r = 0;
cin >> t;
while (t--) {
cin >> a >> b;
r = pow(min(max((a + a), b), max((b + b), a)), 2);
cout << r << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const double pi = 4.0 * atan(1.0);
const double e = exp(1.0);
const int maxn = 3e5 + 8;
const long long mod = 1024 * 1024 * 1024;
const unsigned long long base = 1e7 + 7;
using namespace std;
vector<int> g[maxn];
int a[maxn], r[maxn], b[maxn];
int ans = 0;
int h = 0, l = 0;
void dfs(int u, int fa) {
if (a[u] == 1) r[u]++;
if (a[u] == 2) b[u]++;
for (int i = 0; i < g[u].size(); i++) {
if (g[u][i] != fa) {
dfs(g[u][i], u);
if (r[g[u][i]] == l && b[g[u][i]] == 0 ||
r[g[u][i]] == 0 && b[g[u][i]] == h) {
ans++;
}
r[u] += r[g[u][i]];
b[u] += b[g[u][i]];
}
}
}
int main() {
long long n, k;
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] == 1) {
l++;
} else if (a[i] == 2) {
h++;
}
}
int x, y;
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, 0);
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int main() {
int N, cnt=0;
cin >> N;
vector<int> A(N);
rep(i, N) cin >> A.at(i);
rep(i, N) if(A.at(A.at(i)-1)==i+1) cnt++;
cout << cnt/2 << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
typedef pair<int,int> P;
struct data{
int y,x;
int bit;
int s;
data(){
}
data(int yy,int xx,int bb,int ss){
x=xx;
y=yy;
bit=bb;
s=ss;
}
};
int h,w,L;
bool wall[32][25][25];
bool trap[25][25];
int swi[25][25];
P st,g;
int dp[25][25][32][3];
bool pus[6];
queue<data> que;
bool isok(int y,int x,int bit,int s){
if(y<0 || y>=h || x<0 || x>=w)return false;
if(s==0){
if(trap[y][x])return false;
if(wall[bit][y][x])return false;
}
if(s==1){
for(int i=0;i<L;i++){
if(x+i>=w)return false;
if(wall[bit][y][x+i])return false;
}
}
if(s==2){
for(int i=0;i<L;i++){
if(y+i>=h)return false;
if(wall[bit][y+i][x])return false;
}
}
return true;
}
int upd(int y,int x,int bit,int s){
memset(pus,false,sizeof(pus));
if(s==0){
pus[swi[y][x]]=true;
}
for(int i=0;i<5;i++){
if(pus[i+1]){
bit^=(1<<i);
}
}
return bit;
}
int check(int y,int x,int bit,int s){
if(!isok(y,x,bit,s))return -1;
int nbit=upd(y,x,bit,s);
if(!isok(y,x,nbit,s))return -1;
return nbit;
}
void trys(int y,int x,int bit,int s,int val){
int nbit=check(y,x,bit,s);
if(nbit>=0 && dp[y][x][nbit][s]==-1){
dp[y][x][nbit][s]=val+1;
que.push(data(y,x,nbit,s));
}
}
int bfs(){
memset(dp,-1,sizeof(dp));
que.push(data(st.first,st.second,31,0));
dp[st.first][st.second][31][0]=0;
while(que.size()){
data d=que.front();
que.pop();
if(d.x==g.second && d.y==g.first && d.s==0)return dp[d.y][d.x][d.bit][d.s];
int val=dp[d.y][d.x][d.bit][d.s];
if(d.s==0){
trys(d.y,d.x-L,d.bit,1,val);
trys(d.y,d.x+1,d.bit,1,val);
trys(d.y-L,d.x,d.bit,2,val);
trys(d.y+1,d.x,d.bit,2,val);
}
if(d.s==1){
trys(d.y,d.x-1,d.bit,0,val);
trys(d.y,d.x+L,d.bit,0,val);
trys(d.y-1,d.x,d.bit,1,val);
trys(d.y+1,d.x,d.bit,1,val);
}
if(d.s==2){
trys(d.y-1,d.x,d.bit,0,val);
trys(d.y+L,d.x,d.bit,0,val);
trys(d.y,d.x-1,d.bit,2,val);
trys(d.y,d.x+1,d.bit,2,val);
}
}
return -1;
}
int main(){
scanf("%d%d%d",&h,&w,&L);
for(int i=0;i<h;i++){
string str;
cin >> str;
for(int j=0;j<w;j++){
if(str[j]=='S'){
st=P(i,j);
}
if(str[j]=='G'){
g=P(i,j);
}
if(str[j]>='a' && str[j]<='e'){
int v=(str[j]-'a');
for(int k=0;k<32;k++){
if(k>>v & 1){
wall[k][i][j]=true;
}
}
}
if(str[j]>='A' && str[j]<='E'){
swi[i][j]=(str[j]-'A')+1;
}
if(str[j]=='^'){
trap[i][j]=true;
}
if(str[j]=='#'){
for(int k=0;k<32;k++){
wall[k][i][j]=true;
}
}
}
}
printf("%d\n",bfs());
return 0;
}
| 0 |
#include <iostream>
#include <string>
#include <sstream>
#include <algorithm>
#include <vector>
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<bool> vb;
typedef vector<vb> vvb;
#define vv(type,w,h,init) vector<vector<type>>(h,vector<type>(w,init))
typedef vector<string> vs;
typedef long long ll;
typedef unsigned uint;
typedef unsigned long ul;
typedef unsigned long long ull;
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define loop(i,a,b) for(int i=(a); i<(int)(b); i++)
#define rep(i,b) loop(i,0,b)
#define pb push_back
#define mp make_pair
void disp(vi const& v){
rep(i,v.size()){
cout << v[i] << " ";
}
cout << endl;
}
int main(){
vvi G;
string s;
while(cin>>s){
replace(all(s), ',', ' ');
vi v;
stringstream ss(s);
int i=0;
while(ss>>i) v.push_back(i);
G.push_back(v);
// disp(v);
}
rep(i,G.size()-1){
vi & next=G[i+1];
vi & cur=G[i];
if(next.size() > cur.size()){
rep(j,next.size()){
if(j==0) next[j] += cur[j];
else if(j==next.size()-1) next[j] += cur[j-1];
else next[j] += max(cur[j], cur[j-1]);
}
} else {
rep(j,next.size()){
next[j] += max(cur[j], cur[j+1]);
}
}
// <disp(next);
}
cout << G.back().back() << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long mx[2][2];
mx a, b, c;
long long d, l, r, k;
void mul(mx x, mx y) {
memset(c, 0, sizeof(c));
for (int i = 0; i < (2); ++i)
for (int j = 0; j < (2); ++j)
for (int k = 0; k < (2); ++k) (c[i][j] += x[i][k] * y[k][j] % d) %= d;
memcpy(x, c, sizeof(mx));
}
void pmx(long long x) {
memset(a, 0, sizeof(a)), memset(b, 0, sizeof(b));
a[0][1] = a[1][0] = a[1][1] = 1;
b[0][0] = b[1][1] = 1;
while (x) {
if (x & 1) mul(b, a);
mul(a, a);
x >>= 1;
}
}
int main() {
cin >> d >> l >> r >> k;
--l;
long long x = 1;
for (long long i = 1; i * i <= r; ++i) {
long long j = r / i;
if (r / (i)-l / (i) >= k) x = max(x, i);
if (r / (j)-l / (j) >= k) x = max(x, j);
}
pmx(x);
cout << b[0][1] % d << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int k;
cin >> k;
if (k <= 30)
cout << "NO" << endl;
else {
cout << "YES" << endl;
if (k - 30 == 6)
cout << 6 << ' ' << 10 << ' ' << 15 << ' ' << 5 << endl;
else if (k - 30 == 10)
cout << 6 << ' ' << 10 << ' ' << 15 << ' ' << 9 << endl;
else if (k - 30 == 14)
cout << 6 << ' ' << 10 << ' ' << 15 << ' ' << 13 << endl;
else
cout << 6 << ' ' << 10 << ' ' << 14 << ' ' << k - 30 << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int Min(int a, int b) { return a < b ? a : b; }
int main() {
int n, x1, x2, t1, t2, p, d;
int t3, t4, ans;
while (scanf("%d %d %d", &n, &x1, &x2) == 3) {
scanf("%d %d %d %d", &t1, &t2, &p, &d);
if (x2 > x1) {
t3 = (x2 - x1) * t2;
if (d == 1) {
if (p > x1)
t4 = (n - p + n + x2) * t1;
else
t4 = (x2 - p) * t1;
} else
t4 = (x2 + p) * t1;
} else {
t3 = (x1 - x2) * t2;
if (d == 1)
t4 = (n - p + n - x2) * t1;
else {
if (p < x1)
t4 = (p + n + n - x2) * t1;
else
t4 = (p - x2) * t1;
}
}
ans = Min(t3, t4);
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
#define mk make_pair
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
string s[500];
int h,w,sum=0;
vector<int>x,y;
void del(int t1,int t2){
vector<pair<char,pair<int,int> > >p;
for(int i=t1;i<h;i++)if(s[i][t2]!='.'){
p.push_back(mk(s[i][t2],mk(i,t2)));
break;
}
for(int i=t1;i>=0;i--)if(s[i][t2]!='.'){
p.push_back(mk(s[i][t2],mk(i,t2)));
break;
}
for(int i=t2;i<w;i++)if(s[t1][i]!='.'){
p.push_back(mk(s[t1][i],mk(t1,i)));
break;
}
for(int i=t2;i>=0;i--)if(s[t1][i]!='.'){
p.push_back(mk(s[t1][i],mk(t1,i)));
break;
}
sort(p.begin(),p.end());
if(p.size()>=2){
r(i,p.size()-1){
if(p[i].first==p[i+1].first){
sum++;
s[p[i].second.first][p[i].second.second]='.';
s[p[i+1].second.first][p[i+1].second.second]='.';
}
}
}
}
int main(){
cin>>h>>w;
r(i,h)cin>>s[i];
r(i,h)r(j,w)if(s[i][j]!='.'){
y.push_back(i),x.push_back(j);
if(i+1<h)y.push_back(i+1);
if(j+1<w)x.push_back(j+1);
}
r(k,10)r(i,y.size())r(j,x.size())
if(s[y[i]][x[j]]=='.')del(y[i],x[j]);
cout<<sum*2<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int MOD = 1e9 + 7;
int k;
long long now[2][2], tod[2][2], tmp[2][2], res[2][2];
void init() {
tod[0][0] = 2;
tod[0][1] = 2;
tod[1][0] = 0;
tod[1][1] = -1;
}
int flag = 0;
void mult(long long x) {
if (flag == 1) {
x--;
res[0][0] = 1;
res[0][1] = 1;
res[1][0] = 0;
res[1][1] = -1;
flag = 0;
} else {
res[0][0] = 1;
res[0][1] = 0;
res[1][0] = 0;
res[1][1] = 1;
}
while (x) {
if (x & 1) {
tmp[0][0] = tod[0][0] * res[0][0] + res[0][1] * tod[1][0];
tmp[1][0] = tod[0][0] * res[1][0] + res[1][1] * tod[1][0];
tmp[0][1] = tod[0][1] * res[0][0] + tod[1][1] * res[0][1];
tmp[1][1] = tod[0][1] * res[1][0] + tod[1][1] * res[1][1];
res[0][0] = tmp[0][0] % MOD;
res[0][1] = tmp[0][1] % MOD;
res[1][0] = tmp[1][0] % MOD;
res[1][1] = tmp[1][1] % MOD;
}
tmp[0][0] = tod[0][0] * tod[0][0] + tod[0][1] * tod[1][0];
tmp[1][0] = tod[0][0] * tod[1][0] + tod[1][1] * tod[1][0];
tmp[0][1] = tod[0][1] * tod[0][0] + tod[1][1] * tod[0][1];
tmp[1][1] = tod[0][1] * tod[1][0] + tod[1][1] * tod[1][1];
tod[0][0] = tmp[0][0] % MOD;
tod[0][1] = tmp[0][1] % MOD;
tod[1][0] = tmp[1][0] % MOD;
tod[1][1] = tmp[1][1] % MOD;
x = x >> 1;
}
tod[0][0] = res[0][0];
tod[0][1] = res[0][1];
tod[1][0] = res[1][0];
tod[1][1] = res[1][1];
}
long long gcd(long long x, long long y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int main(int argc, char const *argv[]) {
now[0][0] = 1;
now[0][1] = 0;
now[1][0] = 0;
now[1][1] = 1;
scanf("%d", &k);
init();
for (int i = 0; i < k; i++) {
long long x;
scanf("%I64d", &x);
mult(x);
}
long long a = tod[0][0], b = tod[0][1];
b = (a - b + MOD) % MOD;
if (a % 2 == 0)
a /= 2;
else
a = (a + MOD) / 2;
if (b % 2 == 0)
b /= 2;
else
b = (b + MOD) / 2;
printf("%I64d/%I64d\n", b, a);
return 0;
}
| 5 |
#include<iostream>
using namespace std;
int main(int argc, char const *argv[])
{
int a;
cin>>a;
cout<<1110-a;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 500;
const long long mod = 1e9 + 7;
const long long cmod = 998244353;
const long long inf = 1LL << 61;
const int M = 1e6 + 500;
const long long int ths = 1LL << 40;
const int NN = 5e3 + 6;
void solve() {
long long int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long int ans = 0;
for (int i = 0; i < 25; i++) {
vector<long long int> temp;
for (int j = 0; j < n; j++) {
temp.push_back(a[j] % (1 << (i + 1)));
}
sort(temp.begin(), temp.end());
long long int t = 0;
for (int j = 0; j < n; j++) {
long long int s1 =
lower_bound(temp.begin() + j + 1, temp.end(), (1 << i) - temp[j]) -
temp.begin();
long long int s2 = lower_bound(temp.begin() + j + 1, temp.end(),
(1 << (i + 1)) - temp[j]) -
temp.begin();
long long int s3 = lower_bound(temp.begin() + j + 1, temp.end(),
(1 << (i + 1)) + (1 << i) - temp[j]) -
temp.begin();
long long int s4 = lower_bound(temp.begin() + j + 1, temp.end(),
(1 << (i + 2)) - temp[j]) -
temp.begin();
t += (s2 - s1) + (s4 - s3);
}
if (t & 1) ans |= (1 << i);
}
cout << ans;
cout << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int64_t a, b, c;
cin >> a >> b >> c;
int64_t ans = abs(a - b) + abs(b - c) + abs(c - a);
for (int da = -1; da <= 1; da++) {
for (int db = -1; db <= 1; db++) {
for (int dc = -1; dc <= 1; dc++) {
int64_t val = abs(a + da - (b + db)) + abs(b + db - (c + dc)) +
abs(a + da - (c + dc));
ans = min(ans, val);
}
}
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int t = 1;
cin >> t;
for (; t; t--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void test();
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
test();
cout << endl;
}
return 0;
}
void test() {
map<string, int> mp, mp1;
int ans = INT_MIN;
string name;
int n;
cin >> n;
string s[n];
int m[n];
for (int i = 0; i < n; i++) {
cin >> s[i] >> m[i];
mp[s[i]] += m[i];
}
for (auto itr = mp.begin(); itr != mp.end(); itr++) {
ans = max(ans, itr->second);
}
for (int i = 0; i < n; i++) {
mp1[s[i]] += m[i];
if (mp1[s[i]] >= ans && mp[s[i]] == ans) {
name = s[i];
break;
}
}
cout << name;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int mp[2000003 * 6], tot, nxt[2000003], point[2000003], v[2000003], c[2000003],
val[2000003], siz[2000003], son[2000003];
int deep[2000003], ans[2000003], mx, mark[2000003], n;
void add(int x, int y, int z) {
tot++;
nxt[tot] = point[x];
point[x] = tot;
v[tot] = y;
c[tot] = z;
tot++;
nxt[tot] = point[y];
point[y] = tot;
v[tot] = x;
c[tot] = z;
}
void dfs1(int x, int fa) {
siz[x] = 1;
deep[x] = deep[fa] + 1;
for (int i = point[x]; i; i = nxt[i]) {
if (v[i] == fa) continue;
val[v[i]] = val[x] ^ c[i];
dfs1(v[i], x);
siz[x] += siz[v[i]];
if (siz[son[x]] < siz[v[i]]) son[x] = v[i];
}
}
int flag;
void get_ans(int dep, int x, int fa) {
mx = max(mx, mp[val[x]] + deep[x] - 2 * dep);
for (int i = 0; i <= 21; i++)
mx = max(mx, mp[val[x] ^ (1 << i)] + deep[x] - 2 * dep);
for (int i = point[x]; i; i = nxt[i])
if (v[i] != fa && flag != v[i]) get_ans(dep, v[i], x);
}
void change(int x, int fa) {
mp[val[x]] = max(mp[val[x]], deep[x]);
for (int i = point[x]; i; i = nxt[i])
if (v[i] != fa && flag != v[i]) change(v[i], x);
}
void init(int x, int fa) {
mp[val[x]] = -1000000000;
for (int i = point[x]; i; i = nxt[i])
if (v[i] != fa && flag != v[i]) init(v[i], x);
}
void dfs(int x, int fa, bool k) {
for (int i = point[x]; i; i = nxt[i])
if (v[i] != fa && v[i] != son[x])
dfs(v[i], x, 0), ans[x] = max(ans[x], ans[v[i]]);
if (son[x])
dfs(son[x], x, 1), ans[x] = max(ans[x], ans[son[x]]), mark[son[x]] = 1,
flag = son[x];
for (int i = point[x]; i; i = nxt[i])
if (v[i] != son[x] && v[i] != fa)
get_ans(deep[x], v[i], x), change(v[i], x);
mx = max(mx, mp[val[x]] - deep[x]);
for (int i = 0; i <= 21; i++) mx = max(mx, mp[val[x] ^ (1 << i)] - deep[x]);
mp[val[x]] = max(mp[val[x]], deep[x]);
ans[x] = max(ans[x], mx);
if (son[x]) mark[son[x]] = 0;
flag = 0;
if (!k) init(x, fa), mx = -1000000000;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
int x;
char c[3];
scanf("%d%s", &x, c);
add(x, i, 1 << (c[0] - 'a'));
}
for (int i = 0; i <= (1 << 22); i++) mp[i] = -1000000000;
dfs1(1, 0);
dfs(1, 0, 0);
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
}
| 4 |
#include <bits/stdc++.h>
typedef long long ll;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,a) FOR(i,0,a)
using namespace std;
const int ALP='z'-'a'+1,MAX_N=2e5,INF=1e8;
string S;
int N,opt[MAX_N+1],dp[1<<ALP],cnt[ALP];
int main(){
cin>>S;
N=(int)S.size();
opt[0]=0;
fill(dp,dp+(1<<ALP),INF);
dp[0]=0;
int b=0;
REP(i,N){
b^=1<<(S[i]-'a');
opt[i+1]=dp[b]+1;
REP(j,ALP){
opt[i+1]=min(dp[b^(1<<j)]+1,opt[i+1]);
}
dp[b]=min(dp[b],opt[i+1]);
}
cout<<opt[N]<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[52];
int b[52];
const int k5 = 5000;
int n;
long long dp[52][52][k5 + 5];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
vector<pair<int, int> > tasks;
tasks.push_back(pair<int, int>(1234567890, -1));
tasks.push_back(pair<int, int>(-1234567890, -1));
int st = 1;
for (int i = 0; i < n; i++) {
tasks.push_back(pair<int, int>(a[i], b[i]));
}
sort(tasks.begin(), tasks.end());
reverse(tasks.begin(), tasks.end());
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
fill(dp[i][j], dp[i][j] + k5 + 5, 123456783456789);
}
}
dp[0][0][0] = 0;
for (int i = 1; i <= n; i++) {
if (tasks[i].first != tasks[i + 1].first) {
long long power = tasks[i].first;
vector<int> proc;
for (int j = st; j <= i; j++) {
proc.push_back(tasks[j].second);
}
sort(proc.begin(), proc.end());
reverse(proc.begin(), proc.end());
int tot = i - st + 1;
long long psum = 0LL;
int procsum = 0;
for (int taker1 = 0; taker1 <= tot; taker1++) {
int r2 = tot - taker1;
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= k5; k++) {
if (k - procsum < 0) continue;
if (j + r2 - taker1 < 0 || j + r2 - taker1 > n) continue;
if (j + r2 - taker1 - r2 < 0) continue;
dp[i][j][k] = min(dp[i][j][k],
dp[st - 1][j + r2 - taker1][k - procsum] + psum);
}
}
if (taker1 < tot) {
procsum += proc[taker1];
}
psum += power;
}
st = i + 1;
} else
continue;
}
long long ans = 1234567890123457LL;
int bo = -1;
for (int i = 0; i <= n; i++) {
for (int j = 1; j <= k5; j++) {
if ((dp[n][i][j] * 1000LL + j - 1) / j < ans) {
bo = i;
}
ans = min(ans, (dp[n][i][j] * 1000LL + j - 1) / j);
}
}
cout << ans << endl;
cin >> ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,x,y) for(int i=(x);i<(y);++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
const int inf=1e9;
const int64_t inf64=1e18;
const double eps=1e-9;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec){
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
void solve(){
int n;
cin >> n;
int64_t s=0;
rep(i,0,n){
int64_t a;
cin >> a;
--a;
s=s*10+a;
}
int64_t sorted=0;
rep(i,0,n) sorted=sorted*10+i;
int64_t exp[10];
exp[0]=1;
rep(i,1,10) exp[i]=exp[i-1]*10;
auto reverse=[&](int64_t x,int l,int r){
rep(i,0,(r-l+1)/2){
int64_t p=x/exp[l+i]%10,q=x/exp[r-i]%10;
x-=p*exp[l+i]+q*exp[r-i];
x+=q*exp[l+i]+p*exp[r-i];
}
return x;
};
unordered_map<int64_t,int> num1;
{
queue<int64_t> queues[5];
num1[s]=0;
queues[0].push(s);
rep(k,0,5){
auto &que=queues[k];
while(!que.empty()){
auto x=que.front();
que.pop();
if(x==sorted){
cout << k << endl;
return;
}
int l,r;
rep(i,0,n){
if(x/exp[i]%10!=n-i-1){
l=i;
break;
}
}
for(int i=n-1; i>=0; --i){
if(x/exp[i]%10!=n-i-1){
r=i;
break;
}
}
rep(i,l,r){
rep(j,i+1,r+1){
int64_t y=reverse(x,i,j);
if(num1.find(y)!=num1.end()) continue;
if(y==sorted){
cout << k+1 << endl;
return;
}
num1[y]=k+1;
if(k+1<5) queues[k+1].push(y);
}
}
}
}
}
unordered_map<int64_t,int> num2;
{
queue<int64_t> queues[6];
num2[sorted]=0;
queues[0].push(sorted);
rep(k,0,6){
auto &que=queues[k];
while(!que.empty()){
auto x=que.front();
que.pop();
rep(i,0,n){
rep(j,i+1,n){
int64_t y=reverse(x,i,j);
if(num2.find(y)!=num2.end()) continue;
if(num1.find(y)!=num1.end()){
cout << num1[y]+k+1 << endl;
return;
}
num2[y]=k+1;
if(k+1<6) queues[k+1].push(y);
}
}
}
}
}
}
int main(){
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(10);
solve();
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
const int N=205;
int n,i,j,k,s[N][N],f[N][N],col[N],ans;
char c[N];
bool dfs(int u){
for(int i=1;i<=n;++i)if(s[u][i]){if(col[i]==-1 && s[u][i]){
col[i]=col[u]^1;
if(!dfs(i))return 0;
}else if(col[i]==col[u])return 0;}
return 1;
}
int main(){
scanf("%d",&n);
memset(col+1,-1,n<<2);
for(i=1;i<=n;++i){
for(j=1;j<=n;++j)f[i][j]=i==j?0:1<<25;
scanf("%s",c+1);
for(j=1;j<=n;++j)if(c[j]=='1')f[i][j]=s[i][j]=1;
}
col[1]=0;
if(!dfs(1)){puts("-1");return 0;}
for(i=1;i<=n;++i)for(j=1;j<=n;++j)for(k=1;k<=n;++k)
f[j][k]=std::min(f[j][k],f[j][i]+f[i][k]);
for(i=1;i<=n;++i)for(j=1;j<=n;++j)ans=max(ans,f[i][j]);
printf("%d\n",ans+1);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1e4 + 14;
const int MOD = 1e9 + 7;
const long long INF = 1e9 * 1ll * 1e9;
int n, l, r;
bool can[MaxN][MaxN];
bool used[MaxN];
pair<int, int> a[MaxN];
bool cmp(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second) return a.second > b.second;
if (a.second == 0) return false;
return a.first < b.first;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> l >> r;
int sum = 0;
for (int i = 1; i <= n; ++i) {
cin >> a[i].first;
sum += a[i].first;
}
for (int i = 1; i <= n; ++i) cin >> a[i].second;
sort(a + 1, a + n + 1, cmp);
can[n + 1][0] = true;
for (int i = n; i; --i)
for (int j = sum; j >= 0; --j)
if (can[i + 1][j] || (j >= a[i].first && can[i + 1][j - a[i].first])) {
can[i][j] = true;
}
int ans = 0;
for (int i = l; i <= r && i <= sum; ++i)
if (can[1][i]) {
int j = n;
int h = i;
for (int j = 1; j <= n; ++j) used[j] = false;
while (!can[j][h]) --j;
for (; j <= n && h; ++j)
if (!can[j + 1][h]) {
used[j] = true;
h -= a[j].first;
}
int curAns = 0;
h = i;
for (int i = 1; i <= n && a[i].second == 1 && h <= r; ++i)
if (!used[i]) {
++curAns;
h += a[i].first;
}
ans = max(curAns, ans);
}
cout << ans << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int j = 0; j < n - 1; j++) {
string t;
cin >> t;
for (int i = 0; i < t.length(); i++)
if (t[i] != '?' && t[i] != s[i])
if (s[i] == '?')
s[i] = t[i];
else
s[i] = '!';
}
for (int i = 0; i < s.length(); i++) {
if (s[i] == '?') s[i] = 'a';
if (s[i] == '!') s[i] = '?';
}
cout << s;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n;
long long primes[] = {2, 3, 5, 7, 11};
int cnts[] = {0, 0, 0, 0, 0};
int limit = 2;
vector<long long> ans;
void dfs(long long cur, int id) {
if (id == limit) {
ans.push_back(cur);
} else {
while (cur < n * n * 2) {
dfs(cur, id + 1);
cur *= primes[id];
}
}
}
bool check(int the_limit) {
limit = the_limit;
ans.clear();
dfs(1, 0);
sort(ans.begin(), ans.end());
reverse(ans.begin(), ans.end());
if (ans.size() < n) return false;
memset(cnts, 0, sizeof(cnts));
for (int i = 0; i < n; i++) {
for (int j = 0; j < limit; j++)
if (ans[i] % primes[j] == 0) cnts[j]++;
}
for (int j = 0; j < limit; j++)
if (cnts[j] * 2 < n) return false;
return true;
}
int MAIN() {
cin >> n;
while (check(limit) == false) limit++;
for (int i = 0; i < n; i++) cout << ans[i] << (i == n - 1 ? "\n" : " ");
return 0;
}
int main() {
ios ::sync_with_stdio(false);
cout << fixed << setprecision(16);
return MAIN();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 23;
int n, a[maxN], cnt[maxN], dp[maxN], bis[maxN], f[maxN];
bool bad[maxN];
int bs(int l, int r, int x) {
while (l < r) {
int mid = (r + l) / 2;
if (bis[mid] >= x)
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
int L = 1;
bis[0] = a[0];
dp[0] = L;
for (int i = 1; i < n; i++) {
int ind = bs(0, L, a[i]);
if (a[i] > bis[L - 1]) {
L++;
bis[L - 1] = a[i];
dp[i] = L;
} else {
bis[ind] = a[i];
dp[i] = ind + 1;
}
}
for (int i = n - 1; i >= 0; i--) {
int x = dp[i];
if (x != L && a[i] >= f[x + 1])
bad[i] = true;
else {
f[x] = a[i];
cnt[x]++;
}
}
for (int i = 0; i < n; i++) {
if (bad[i])
cout << 1;
else if (cnt[dp[i]] > 1)
cout << 2;
else
cout << 3;
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
bool debug = false;
int W;
struct company {
long long w, a, c;
bool operator<(const company b) const { return c * b.w < b.c * w; }
} coms[500005];
int main() {
scanf("%d%d%d", &n, &m, &W);
for (int i = 0; i < m; i++) scanf("%I64d", &coms[i].w);
for (int i = 0; i < m; i++) scanf("%I64d", &coms[i].c);
for (int i = 0; i < m; i++) scanf("%I64d", &coms[i].a);
long long zs = 0;
double xs = 0;
for (int i = 0; i < n; i++) {
if (i > 0) {
for (int j = 0; j < m; j++) {
coms[j].c -= coms[j].a;
}
}
long long tw = W;
int l = 0, r = m - 1;
while (l + 1 <= r) {
int mid = (l + r) / 2;
nth_element(coms + l, coms + mid, coms + r + 1);
long long tmpw = 0, tmpans = 0;
for (int j = l; j <= mid; j++) {
tmpw += coms[j].w;
tmpans += coms[j].c;
}
if (tw >= tmpw) {
tw -= tmpw;
zs += tmpans;
l = mid + 1;
} else {
r = mid;
}
}
long long last = coms[l].c * tw;
zs += last / coms[l].w;
xs += (last % coms[l].w) * 1.0 / coms[l].w;
zs += (long long)xs;
xs -= (long long)xs;
}
char buff[20];
sprintf(buff, "%.15f", xs);
printf("%I64d%s", zs, buff + 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, i = 0, j;
cin >> n;
j = n - 1;
int arr[n], dup[n];
for (int i = 0; i < n; i++) {
cin >> arr[i];
dup[i] = arr[i];
}
sort(dup, dup + n);
if (n == 1)
cout << dup[0];
else {
if (n % 2 == 0) {
while (i < j) {
cout << dup[i] << " " << dup[j] << " ";
i++;
j--;
}
} else {
while (i <= j) {
if (i == j) {
cout << dup[i];
i++;
j--;
} else {
cout << dup[i] << " " << dup[j] << " ";
i++;
j--;
}
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int pre = 0;
for (int i = 0; i < k; i++) {
pre += a[i];
}
int minval = pre;
int index = 0;
for (int i = 1; i < n - k + 1; i++) {
pre = pre - a[i - 1] + a[i + k - 1];
if (minval > pre) {
index = i;
minval = pre;
}
}
cout << index + 1 << endl;
return 0;
}
| 2 |
#include <iostream>
#include <fstream>
#include <set>
#include <map>
#include <string>
#include <vector>
#include <bitset>
#include <algorithm>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <queue>
#define mp make_pair
#define pb push_back
typedef long long ll;
typedef long double ld;
using namespace std;
struct st {
ll l, r;
ll x, d;
};
bool operator<(const st& a, const st& b) {
return a.l < b.l;
}
int n;
ll k;
ll a[120000];
int b[120000];
set<st> ss;
int main() {
scanf("%d%lld", &n, &k);
ll ans = 0;
for (int i = 0; i < n; ++i) {
scanf("%lld%d", a + i, b + i);
a[i] *= 2;
ans += a[i];
if (a[i] > k && b[i] == 1) {
cout << -1 << "\n";
return 0;
}
if (b[i] == 2)
a[i] %= k;
}
ss.insert({0, k, 0, 0});
ll cur = 0;
for (int i = 0; i < n; ++i) {
ll d = a[i];
ll nx = cur + d;
if (nx > k)
nx -= k;
if (b[i] == 1) {
if (cur < nx) {
auto it = ss.lower_bound({cur, 0, 0, 0});
while (it->r < nx)
ss.erase(it++);
st x1 = *it;
st x2 = *it;
ss.erase(it);
x1.l = cur;
x1.r = nx;
x2.l = nx;
x1.d = 1;
x1.x = x2.x + x2.d * (x2.r - nx);
ss.insert(x1);
if (x2.l != x2.r)
ss.insert(x2);
}
else {
auto it = ss.lower_bound({cur, 0, 0, 0});
while (it != ss.end())
ss.erase(it++);
it = ss.begin();
while (it->r < nx)
ss.erase(it++);
st x1 = *it;
st x2 = *it;
ss.erase(it);
x1.l = 0;
x1.r = nx;
x2.l = nx;
x1.d = 1;
x1.x = x2.x + x2.d * (x2.r - nx);
ss.insert(x1);
if (x2.l != x2.r)
ss.insert(x2);
x2.l = cur;
x2.r = k;
x2.d = 1;
x2.x = x1.x + x1.d * x1.r;
ss.insert(x2);
}
cur = (cur + a[i]) % k;
}
else {
cur += a[i];
cur %= k;
auto it = ss.lower_bound({cur, 0, 0, 0});
if (it == ss.begin())
continue;
--it;
if (it->r <= cur)
continue;
st x1 = *it;
st x2 = *it;
ss.erase(it);
x2.l = cur;
x1.x = x2.x + x2.d * (x2.r - cur);
x1.r = cur;
ss.insert(x1);
ss.insert(x2);
}
}
ll mn = ss.begin()->x;
for (auto x: ss)
mn = min(mn, x.x);
cout << ans + mn << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, m, k, u, v, c[200005] = {}, d[200005] = {}, z = 0;
vector<int> g[200005] = {};
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) cin >> c[i];
for (int i = 0; i < m; i++)
cin >> u >> v, g[u].push_back(v), g[v].push_back(u);
for (int i = 1; i <= n; i++) {
if (d[i]) continue;
d[i] = 1;
queue<int> q;
vector<int> w = {i};
q.push(i);
while (!q.empty()) {
int x = q.front();
q.pop();
for (int j = 0; j < g[x].size(); j++) {
if (!d[g[x][j]]) d[g[x][j]] = 1, q.push(g[x][j]), w.push_back(g[x][j]);
}
}
unordered_map<int, int> p;
int o = 0;
for (int j = 0; j < w.size(); j++) p[c[w[j]]]++, o = max(o, p[c[w[j]]]);
z += w.size() - o;
}
cout << z;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
const int INF = 1e8;
int main(){
int n,m;
while(cin >> n >> m, n){
vector<int> c(m);
for(int i=0;i<m;i++)cin >> c[i];
vector<int> x(n);
for(int i=0;i<n;i++)cin >> x[i];
vector<int> cur(256,INF), nxt(256);
cur[128] = 0;
for(int i=0;i<n;i++){
for(int j=0;j<256;j++)nxt[j] = INF;
for(int j=0;j<256;j++){
for(int k=0;k<m;k++){
int nj = min(255, max(0,j + c[k]) );
int dif = nj-x[i];
nxt[nj] = min(nxt[nj], cur[j] + dif*dif);
}
}
swap(cur, nxt);
}
cout << *min_element(cur.begin(),cur.end()) << endl;
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
#define MN 1000000
#define mod 1000000007
inline int read()
{
int x=0,f=1;char c=getchar();
while(c<'0'||c>'9'){if(c=='-') f=-1;c=getchar();}
while(c>='0'&&c<='9'){x=x*10+c-'0';c=getchar();}
return x*f;
}
int f[MN+5],p[MN+5],inv[MN+5],Inv[MN+5],n,ans;
inline int C(int n,int m){return 1LL*p[n]*Inv[m]%mod*Inv[n-m]%mod;}
int main()
{
n=read();p[0]=inv[0]=f[0]=Inv[0]=p[1]=inv[1]=1;
for(int i=2;i<=n;++i) p[i]=1LL*p[i-1]*i%mod,inv[i]=1LL*(mod-mod/i)*inv[mod%i]%mod;
for(int i=1;i<=n;++i) Inv[i]=1LL*inv[i]*Inv[i-1]%mod;
for(int i=1,j=2;i<=n;++i,j=j*2%mod) f[i]=(j+mod-f[i-1])%mod;
int pp=1LL*(mod+1)/3*inv[n]%mod;
for(int i=2;i<=n+1;++i) // G(n+1-i,i) -> C(n+1-i+i,i-1)
ans=(ans+1LL*f[i-2]*C(n,i-1)%mod*pp%mod*inv[i-1])%mod;
for(int i=1;i<n;++i) ans=1LL*ans*(mod+1)/3%mod;
cout<<ans;
return 0;
}
//tot -> k part
//E(min) = sum s=0-tot/k (tot-ks)^(k-1) / tot^(k-1)
// sum -> -1/k^2 (tot-ks)^k
//E(min) = 0 - (-1/k^2 * tot^k / tot^(k-1))
// = tot / k^2 | 0 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(239);
vector<vector<long long>> g;
vector<long long> color;
const long long MOD = 998244353;
long long n;
long long m;
bool ok = true;
long long l = 0;
long long r = 0;
void dfs(long long v, long long c) {
color[v] = c;
if (c == 0)
l++;
else
r++;
for (auto u : g[v]) {
if (color[u] == c) ok = false;
if (color[u] == -1) dfs(u, (c + 1) % 2);
}
}
long long step(long long x, long long y) {
if (y == 0) return 1;
long long z = step(x, y / 2);
if (y & 1)
return (long long)z * z % MOD * x % MOD;
else
return (long long)z * z % MOD;
}
long long solve() {
long long ans = 1;
color.resize(n + 1);
fill(color.begin(), color.end(), -1);
ok = true;
for (long long i = 1; i <= n; i++) {
if (color[i] == -1) {
l = r = 0;
dfs(i, 0);
if (!ok) ans = 0;
ans = ((long long)step(2, l) + step(2, r)) % MOD * ans % MOD;
}
}
return ans;
}
void read() {
cin >> n >> m;
g.clear();
g.resize(n + 1);
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
g[b].push_back(a);
g[a].push_back(b);
}
}
const long long MAXN = 5;
void gen() {
n = rnd() % MAXN + 1;
m = rnd() % MAXN + 1;
cout << n << " " << m << endl;
g.clear();
g.resize(n + 1);
for (long long i = 0; i < m; i++) {
long long a, b;
a = rnd() % n + 1;
b = rnd() % n + 1;
while (a == b || find(g[a].begin(), g[a].end(), b) != g[a].end()) {
a = rnd() % n + 1;
b = rnd() % n + 1;
}
cout << a << " " << b << endl;
g[b].push_back(a);
g[a].push_back(b);
}
}
signed main() {
long long t;
cin >> t;
for (; t; t--) {
read();
cout << solve() << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int arr[100005];
int pf[32][100005];
int st[4 * 100005];
void init() {
memset(arr, 0, sizeof(arr));
memset(pf, 0, sizeof(pf));
return;
}
void build(int l = 0, int r = n - 1, int idx = 0) {
if (l == r) {
st[idx] = arr[l];
return;
}
int mid = l + (r - l) / 2;
build(l, mid, 2 * idx + 1);
build(mid + 1, r, 2 * idx + 2);
st[idx] = st[2 * idx + 1] & st[2 * idx + 2];
return;
}
int query(int x, int y, int l = 0, int r = n - 1, int idx = 0) {
if (y < l || r < x) {
return (1 << 31) - 1;
}
if (x <= l && r <= y) {
return st[idx];
}
int mid = l + (r - l) / 2;
return query(x, y, l, mid, 2 * idx + 1) &
query(x, y, mid + 1, r, 2 * idx + 2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
init();
cin >> n >> m;
int l[m], r[m], q[m];
for (int i = 0; i < m; i++) {
cin >> l[i] >> r[i] >> q[i];
l[i]--;
r[i]--;
for (int j = 0; j < 32; j++) {
if ((q[i] >> j) & 1) {
pf[j][l[i]] += 1;
if (r[i] < n - 1) pf[j][r[i] + 1] -= 1;
}
}
}
for (int i = 0; i < 32; i++) {
for (int j = 1; j < n; j++) {
pf[i][j] += pf[i][j - 1];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 32; j++) {
if (pf[j][i] > 0) arr[i] += (1 << j);
}
}
build();
for (int i = 0; i < m; i++) {
if (query(l[i], r[i]) != q[i]) {
cout << "NO" << endl;
exit(0);
}
}
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
struct IO {
template <typename T>
inline friend IO operator>>(IO in, T &x) {
x = 0;
int 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 ^ 48);
ch = getchar();
}
x *= f;
return in;
}
template <typename T>
inline friend IO operator<<(IO in, T x) {
if (x < 0) x = -x, putchar('-');
static T sta[35];
T top = 0;
do {
sta[top++] = x % 10, x /= 10;
} while (x);
while (top) putchar(sta[--top] + '0');
return in;
}
} cin, cout;
int s[100] = {15, 14, 12, 13, 8, 9, 10, 11, 0, 1, 2, 3, 4, 5, 6, 7};
int main() {
int n;
cin >> n;
cout << s[n];
return 0;
}
| 3 |
#include<iostream>
using namespace std;
int main(){
char s;
cin >> s;
if(s=='A')cout << "T";
if(s=='T')cout << "A";
if(s=='G')cout << "C";
if(s=='C')cout << "G";
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define pb push_back
#define fi first
#define sc second
typedef pair<int,int> P;
int N,K;
int C[5003],R[5003];
int A,B;
vector<int>G[5003];int s1[5003];
vector<P>G2[5003];
int main()
{
scanf("%d%d",&N,&K);
for(int i=0;i<N;i++){
scanf("%d%d",&C[i],&R[i]);
}
for(int i=0;i<K;i++){
scanf("%d%d",&A,&B);A--;B--;
G[A].pb(B);
G[B].pb(A);
}
for(int i=0;i<N;i++){
for(int j=0;j<N;j++){
s1[j]=N+1;
}
priority_queue<P,vector<P>,greater<P> >que;que.push(P(0,i));
while(!que.empty()){
P p=que.top();que.pop();
if(s1[p.sc]<=p.fi)continue;
s1[p.sc]=p.fi;
for(int j=0;j<(int)G[p.sc].size();j++){
if(s1[G[p.sc][j]]>p.fi+1){
que.push(P(p.fi+1,G[p.sc][j]));
}
}
}
for(int j=0;j<N;j++){
if(i==j)continue;
if(s1[j]<=R[i]){
G2[i].pb(P(j,C[i]));
//printf("%d %d\n",i,j);
}
}
}
for(int j=0;j<N;j++){
s1[j]=10000*N+1;
}
priority_queue<P,vector<P>,greater<P> >que;que.push(P(0,0));
while(!que.empty()){
P p=que.top();que.pop();
if(s1[p.sc]<=p.fi)continue;
s1[p.sc]=p.fi;
for(int i=0;i<(int)G2[p.sc].size();i++){
if(s1[G2[p.sc][i].fi]>p.fi+G2[p.sc][i].sc){
que.push(P(p.fi+G2[p.sc][i].sc,G2[p.sc][i].fi));
}
}
}
printf("%d\n",s1[N-1]);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long long MOD = 1e9 + 7;
const double pi = acos(-1);
long long power(long long a, long long b, long long m = MOD) {
long long ans = 1;
while (b > 0) {
if (b & 1) ans = ((ans % m) * (a % m)) % m;
a = ((a % m) * (a % m)) % m;
b >>= 1;
}
return ans;
}
long long dir[] = {-1, 0, 1, 0, -1};
long long dx[8] = {0, 0, 1, -1, 1, -1, 1, -1};
long long dy[8] = {1, -1, 0, 0, 1, 1, -1, -1};
void solve() {
long long n, m;
cin >> n >> m;
;
vector<long long> g[n];
vector<long long> deg(n, 0);
for (long long j = 0; j < m; j++) {
long long u, v;
cin >> u >> v;
;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
deg[u]++;
deg[v]++;
}
long long ans = 0;
while (true) {
vector<long long> remove;
for (long long i = 0; i < n; i++) {
if (deg[i] == 1) remove.push_back(i);
}
if (!(long long)(remove).size()) break;
for (auto u : remove) {
deg[u]--;
for (auto v : g[u]) deg[v]--;
}
ans++;
}
cout << ans << " ";
;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
}
| 2 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
const int kMaxn = 5555;
int n, a[kMaxn], ok[kMaxn], cnt[55];
char str[kMaxn << 1], s[kMaxn][kMaxn];
bool cmp(int x, int y) { return strcmp(s[x], s[y]) < 0; }
int main() {
static int i, j, k, last;
static int ans, now, best;
memset(str, 0, sizeof(str));
memset(s, 0, sizeof(s));
scanf(" %s", str);
n = strlen(str);
for (i = 0; i < n; ++i) str[i + n] = str[i];
str[n << 1] = 0;
for (i = 0; i < n; ++i) strncpy(s[i], str + i, n);
for (i = 0; i < n; ++i) a[i] = i, ok[i] = 1;
std::sort(a, a + n, cmp);
for (i = 1; i < n; ++i)
if (strcmp(s[a[i - 1]], s[a[i]]) == 0) ok[i - 1] = ok[i] = 0;
ans = 0;
last = 0;
for (i = 1; i < n; ++i) {
if (s[a[i]][0] != s[a[last]][0]) {
best = 0;
for (k = 1; k < n; ++k) {
memset(cnt, 0, sizeof(cnt));
for (j = last; j < i; ++j) cnt[s[a[j]][k] - 'a']++;
now = 0;
for (j = 0; j < 26; ++j)
if (cnt[j] == 1) now++;
best = std::max(best, now);
}
ans += best;
last = i;
}
}
best = 0;
for (k = 1; k < n; ++k) {
memset(cnt, 0, sizeof(cnt));
for (j = last; j < n; ++j) cnt[s[a[j]][k] - 'a']++;
now = 0;
for (j = 0; j < 26; ++j)
if (cnt[j] == 1) now++;
best = std::max(best, now);
}
ans += best;
printf("%.15f\n", (double)ans / n);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
cin >> n >> a;
if (a % 2 == 0) a = n - a + 1;
cout << (a - 1) / 2 + 1;
}
| 1 |
#include <bits/stdc++.h>
template <typename T>
inline void read(T &t) {
int f = 0, c = getchar();
t = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) t = t * 10 + c - 48, c = getchar();
if (f) t = -t;
}
template <typename T>
void write(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + 48);
}
template <typename T>
inline void writeln(T x) {
write(x);
puts("");
}
template <typename T>
inline bool chkmin(T &x, const T &y) {
return y < x ? (x = y, 1) : 0;
}
template <typename T>
inline bool chkmax(T &x, const T &y) {
return x < y ? (x = y, 1) : 0;
}
const int maxn = 2e5 + 207;
const long long mod = 1e9 + 7;
struct Tree {
int v[maxn << 1], w[maxn << 1], head[maxn], next[maxn << 1], tot;
void ae(int x, int y, int z = 0) {
v[++tot] = y;
w[tot] = z;
next[tot] = head[x];
head[x] = tot;
v[++tot] = x;
w[tot] = z;
next[tot] = head[y];
head[y] = tot;
}
};
Tree T, V;
int dep[maxn], top[maxn], son[maxn], fa[maxn], size[maxn];
int dfn[maxn], xys;
int p[maxn];
void dfs1(int x) {
dep[x] = dep[fa[x]] + 1;
size[x] = 1;
dfn[x] = ++xys;
for (int i = T.head[x]; i; i = T.next[i])
if (T.v[i] != fa[x]) {
fa[T.v[i]] = x;
dfs1(T.v[i]);
size[x] += size[T.v[i]];
if (size[T.v[i]] > size[son[x]]) son[x] = T.v[i];
}
}
void dfs1(int x, int t) {
top[x] = t;
if (son[x]) dfs1(son[x], t);
for (int i = T.head[x]; i; i = T.next[i])
if (T.v[i] != fa[x] && T.v[i] != son[x]) dfs1(T.v[i], T.v[i]);
}
inline int getlca(int x, int y) {
while (top[x] != top[y])
if (dep[top[x]] < dep[top[y]])
y = fa[top[y]];
else
x = fa[top[x]];
return dep[x] < dep[y] ? x : y;
}
inline int getdist(int x, int y) {
return dep[x] + dep[y] - (dep[getlca(x, y)] << 1);
}
long long tmp[maxn], invphi[maxn];
int phi[maxn];
int mu[maxn], pri[maxn];
bool ff[maxn];
inline long long qpow(long long x, long long k) {
long long s = 1;
for (; k; x = x * x % mod, k >>= 1)
if (k & 1) s = s * x % mod;
return s;
}
inline void sieve(int n) {
mu[1] = phi[1] = 1;
for (int i = 2; i <= n; ++i) {
if (!ff[i]) {
phi[i] = i - 1;
mu[i] = -1;
pri[++pri[0]] = i;
}
for (int j = 1; j <= pri[0]; ++j) {
int x = i * pri[j];
if (x > n) break;
ff[x] = 1;
if (i % pri[j]) {
mu[x] = -mu[i];
phi[x] = phi[i] * phi[pri[j]];
} else {
mu[x] = 0;
phi[x] = phi[i] * pri[j];
break;
}
}
}
}
inline bool cmp(int a, int b) { return dfn[a] < dfn[b]; }
int stk[maxn], tp;
int vs[maxn], vk;
inline void insert(int x) {
if (!tp) {
stk[++tp] = x;
return;
}
int l = getlca(x, stk[tp]);
while (tp > 1 && dep[stk[tp - 1]] > dep[l]) {
int u = stk[tp - 1], v = stk[tp];
V.ae(u, v, getdist(u, v));
--tp;
}
if (dep[l] < dep[stk[tp]]) {
V.ae(l, stk[tp], getdist(l, stk[tp]));
--tp;
}
if (!tp || dep[stk[tp]] < dep[l]) stk[++tp] = l;
stk[++tp] = x;
}
inline void build() {
std::sort(vs + 1, vs + vk + 1, cmp);
tp = 0;
if (vs[1] != 1) stk[tp = 1] = 1;
V.tot = 0;
for (int i = 1; i <= vk; ++i) insert(vs[i]);
while (tp > 1) {
int u = stk[tp], v = stk[tp - 1];
V.ae(u, v, getdist(u, v));
--tp;
}
}
long long f[maxn], g[maxn], s[maxn];
int b[maxn], a[maxn];
void dfs2(int x, int ffa) {
f[x] = g[x] = 0;
s[x] = b[x];
for (int i = V.head[x]; i; i = V.next[i]) {
int v = V.v[i], w = V.w[i];
if (v != ffa) {
dfs2(v, x);
g[x] = (g[x] + g[v] + s[v] * (f[x] + s[x] * w % mod) % mod +
f[v] * s[x] % mod) %
mod;
s[x] = (s[x] + s[v]) % mod;
f[x] = (f[x] + f[v] + s[v] * w % mod) % mod;
}
}
V.head[x] = 0;
b[x] = 0;
}
int n;
int main() {
read(n);
for (int i = 1; i <= n; ++i) read(a[i]), p[a[i]] = i, T.head[i] = 0;
T.tot = 0;
for (int i = 1; i != n; ++i) {
int x, y;
read(x);
read(y);
T.ae(x, y);
}
dfs1(1);
dfs1(1, 1);
sieve(n);
for (int i = 1; i <= n; ++i) invphi[i] = qpow(phi[i], mod - 2);
for (int d = 1; d <= n; ++d)
for (int i = d; i <= n; i += d) {
tmp[i] = (tmp[i] + 1ll * d * mu[i / d] % mod * invphi[d] % mod) % mod;
if (tmp[i] < 0) tmp[i] += mod;
}
long long ans = 0;
for (int i = 1; i <= n; ++i) {
vk = 0;
for (int j = i; j <= n; j += i) {
vs[++vk] = p[j];
b[p[j]] = phi[j];
}
build();
dfs2(1, 0);
ans = (ans + tmp[i] * 2ll * g[1] % mod) % mod;
}
ans = ans * qpow(n, mod - 2) % mod * qpow(n - 1, mod - 2) % mod;
writeln(ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
set<int> edges[1000000];
set<int> rem;
int component[1000000];
set<int> comp_id;
void go(int id) {
queue<int> bfs;
bfs.push(id);
component[id] = id;
while (!bfs.empty()) {
int u = bfs.front();
bfs.pop();
stack<int> st;
for (auto v : rem) {
if (edges[u].find(v) != edges[u].end()) continue;
component[v] = id;
bfs.push(v);
st.push(v);
}
while (!st.empty()) {
rem.erase(rem.find(st.top()));
st.pop();
}
}
}
int main() {
int n, m, k;
scanf("%d", &n);
scanf("%d", &m);
scanf("%d", &k);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
edges[u].insert(v);
edges[v].insert(u);
}
for (int i = 1; i <= n; i++) {
if ((int)edges[i].size() == n - 1) {
printf("impossible");
return 0;
}
}
for (int i = 2; i <= n; i++) rem.insert(i);
int comp = 0;
while (rem.begin() != rem.end()) {
int node = *rem.begin();
rem.erase(*rem.begin());
go(node);
comp++;
}
for (int i = 2; i <= n; i++)
if (edges[1].find(i) == edges[1].end()) comp_id.insert(component[i]);
if (comp > k) {
printf("impossible");
return 0;
} else if (k > (n - 1 - (int)edges[1].size())) {
printf("impossible");
return 0;
} else if ((int)comp_id.size() != comp) {
printf("impossible");
return 0;
}
printf("possible");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 1e9;
char match(char c) { return c == ']' ? '[' : '('; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string line;
while (cin >> line) {
int n = line.size();
vector<int> closing(n, -1);
stack<int> st;
pair<int, string> ans = pair<int, string>(0, "");
for (int i = (0); i < ((int)line.size()); ++i) {
char c = line[i];
if (c == '(' || c == '[') {
st.push(i);
} else {
if (!st.empty() && line[st.top()] == match(c)) {
closing[st.top()] = i;
st.pop();
} else {
while (!st.empty()) st.pop();
}
}
}
int l = 0, r = 0;
while (l < n) {
while (r < n && closing[r] == -1) r++;
l = r;
while (r < n && closing[r] != -1) r = closing[r] + 1;
string s = line.substr(l, r - l);
int cnt = count(s.begin(), s.end(), '[');
if (cnt > ans.first) {
ans.first = cnt;
ans.second = s;
}
l = r;
}
cout << ans.first << '\n';
cout << ans.second << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const char letters[] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
const int dx[] = {0, -1, 0, 1, -1, -1, 1, 1};
const int dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
long long inline max3(long long a, long long b, long long c) {
return max(a, max(b, c));
}
long long inline min3(long long a, long long b, long long c) {
return min(a, min(b, c));
}
long long power(long long x, long long p) {
if (p == 0)
return 1;
else if (p % 2 == 0)
return power(1LL * x * x, p / 2);
else
return 1LL * x * power(1LL * x * x, (p - 1) / 2);
}
long long GCD(long long a, long long b) {
if (b == 0) return a;
return GCD(b, a % b);
}
const int N = 1e5 + 10;
int arr[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &arr[i]);
long long ans = arr[0] + 1;
int h = arr[0];
for (int i = 1; i < n; ++i) {
ans += max(arr[i] - min(arr[i], h), 0) + 2;
ans += (arr[i] >= h) ? 0 : h - arr[i];
h = arr[i];
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
bool row(vector<vector<int> > &table) {
for (int i = 0; i < n; ++i) {
bool flag = true;
for (int j = 0; j < n; ++j) {
if (!table[i][j]) flag = false;
}
if (flag) return true;
}
return false;
}
bool col(vector<vector<int> > &table) {
for (int j = 0; j < n; ++j) {
bool flag = true;
for (int i = 0; i < n; ++i) {
if (!table[i][j]) flag = false;
}
if (flag) return true;
}
return false;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
vector<vector<int> > table(n, vector<int>(n));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
char c;
cin >> c;
if (c == 'E') table[i][j] = 1;
}
}
vector<pair<int, int> > ans;
if (row(table) && col(table)) {
cout << "-1\n";
return 0;
} else if (row(table)) {
for (int j = 0; j < n; ++j) {
for (int i = 0; i < n; ++i) {
if (!table[i][j]) {
ans.push_back(pair<int, int>(i + 1, j + 1));
break;
}
}
}
} else {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (!table[i][j]) {
ans.push_back(pair<int, int>(i + 1, j + 1));
break;
}
}
}
}
for (int i = 0; i < n; ++i) {
cout << ans[i].first << " " << ans[i].second << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 30000;
const int INF = 1000000000;
map<string, int> lzs;
char str[50];
string s, sub[N];
int num[N], score[N];
int getsum(string sb) {
int r = 0, i;
for (i = sb.size() - 1; i >= 0; i--) r += (sb[i] - 'a' + 1);
return r;
}
int _max(string sb) {
int r = 0, i;
for (i = sb.size() - 1; i >= 0; i--)
if (r < sb[i] - 'a' + 1) r = sb[i] - 'a' + 1;
return r;
}
int u[N], dp1[N], dp2[N];
void win(int x) {
if (u[x] != -1) return;
int r = 0, i, id;
char c;
string sb;
for (i = 0; i < 26; i++) {
c = 'a' + i;
sb = sub[x] + c;
if (lzs.find(sb) != lzs.end()) {
id = lzs[sb];
win(id);
if (!u[id]) r = 1;
}
sb = c + sub[x];
if (lzs.find(sb) != lzs.end()) {
id = lzs[sb];
win(id);
if (!u[id]) r = 1;
}
}
u[x] = r;
}
void work(int x) {
if (dp1[x] != -1) return;
int r1 = -INF, r2 = INF, i, k, p, id;
char c;
string sb;
p = -1;
for (i = 0; i < 26; i++) {
c = 'a' + i;
sb = sub[x] + c;
if (lzs.find(sb) != lzs.end()) {
id = lzs[sb];
if (u[x] == 1 && u[id] == 0 || u[x] == 0) {
work(id);
if (r1 < score[id] + dp2[id]) {
r1 = score[id] + dp2[id];
p = 0;
k = id;
} else if (r1 == score[id] + dp2[id]) {
p = 1;
}
}
}
sb = c + sub[x];
if (lzs.find(sb) != lzs.end()) {
id = lzs[sb];
if (u[x] == 1 && u[id] == 0 || u[x] == 0) {
work(id);
if (r1 < score[id] + dp2[id]) {
r1 = score[id] + dp2[id];
p = 0;
k = id;
} else if (r1 == score[id] + dp2[id]) {
p = 1;
}
}
}
}
if (p == -1) {
dp2[x] = 0;
dp1[x] = 0;
} else {
if (p == 0) {
dp1[x] = r1;
dp2[x] = dp1[k];
} else {
for (i = 0; i < 26; i++) {
c = 'a' + i;
sb = sub[x] + c;
if (lzs.find(sb) != lzs.end()) {
id = lzs[sb];
if (u[x] == 1 && u[id] == 0 || u[x] == 0) {
if (r1 == score[id] + dp2[id]) {
if (r2 > dp1[id]) r2 = dp1[id];
}
}
}
sb = c + sub[x];
if (lzs.find(sb) != lzs.end()) {
id = lzs[sb];
if (u[x] == 1 && u[id] == 0 || u[x] == 0) {
if (r1 == score[id] + dp2[id]) {
if (r2 > dp1[id]) r2 = dp1[id];
}
}
}
}
dp1[x] = r1;
dp2[x] = r2;
}
}
}
int main() {
int n, i, j, h, len, id, k;
while (~scanf("%d", &n)) {
lzs.clear();
k = 0;
memset(num, 0, sizeof(num));
for (i = 0; i < n; i++) {
memset(u, 0, sizeof(u));
scanf("%s", str);
len = strlen(str);
for (h = 0; h < len; h++) {
for (s = "", j = h; j < len; j++) {
s += str[j];
id = lzs[s];
if (!id) {
id = ++k;
lzs[s] = k;
sub[k] = s;
}
if (!u[id]) num[id]++;
u[id] = 1;
}
}
}
for (i = 1; i <= k; i++) {
score[i] = getsum(sub[i]) * _max(sub[i]) + num[i];
}
score[0] = 0;
sub[0] = "";
memset(dp1, -1, sizeof(dp1));
memset(u, -1, sizeof(u));
win(0);
if (u[0])
puts("First");
else
puts("Second");
work(0);
printf("%d %d\n", dp1[0], dp2[0]);
getchar();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long w, h, n, a, i, z = 0;
cin >> w >> h >> n;
set<long long> sh, sv;
map<long long, long long, greater<long long> > m1, m2;
map<long long, long long, greater<long long> >::iterator itx, ity;
sh.insert(z);
sh.insert(h);
sv.insert(z);
sv.insert(w);
m1[h]++;
m2[w]++;
set<long long>::iterator it1, it2;
char ch;
for (i = 0; i < n; ++i) {
cin >> ch >> a;
if (ch == 'H') {
sh.insert(a);
it1 = sh.lower_bound(a);
--it1;
it2 = sh.upper_bound(a);
if (m1.find(*it2 - *it1) != m1.end()) m1[*it2 - *it1]--;
if (m1[*it2 - *it1] == 0) m1.erase(*it2 - *it1);
m1[abs(a - *it1)]++;
m1[abs(*it2 - a)]++;
} else {
sv.insert(a);
it1 = sv.lower_bound(a);
--it1;
it2 = sv.upper_bound(a);
if (m2.find(*it2 - *it1) != m2.end()) m2[*it2 - *it1]--;
if (m2[*it2 - *it1] == 0) m2.erase(*it2 - *it1);
m2[abs(a - *it1)]++;
m2[abs(*it2 - a)]++;
}
itx = m1.begin();
ity = m2.begin();
cout << itx->first * ity->first << endl;
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
t = 1;
while (t--) {
solve();
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a, t;
cin >> n >> a;
t = 0;
for (int i = 1; i <= n; i++) {
if (a % i != 0) {
continue;
}
if (i > a) {
break;
}
for (int j = 1; j <= n; j++) {
if (j > a) {
break;
}
if (i * j == a) {
t++;
}
}
}
cout << t << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char s[10];
int n;
int notzero[12], cnt[12], ten[10], ans;
int main() {
ten[0] = 1;
for (int i = 1; i < 8; ++i) ten[i] = 10 * ten[i - 1];
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%s", s);
int len = strlen(s);
notzero[s[0] - 'a'] = 1;
for (int j = 0; j < len; ++j) cnt[s[j] - 'a'] += ten[len - j - 1];
}
int zero = -1;
for (int i = 0; i < 10; ++i) {
if (notzero[i] == 0) {
if (zero == -1 || cnt[i] > cnt[zero]) zero = i;
}
}
vector<int> v;
for (int i = 0; i < 10; ++i) {
if (zero != i) v.push_back(cnt[i]);
}
sort(v.begin(), v.end());
for (int i = 0; i < 9; ++i) {
ans += (9 - i) * v[i];
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include"bits/stdc++.h"
#define int long long
#define REP(i,n) for(int i=0,i##_len=(n);i<i##_len;++i)
using namespace std;
const int MAX_N=2999;
int N;
vector<double> p;
double dp[MAX_N+1][MAX_N+1];
signed main(){
cin>>N;
p.resize(N);
REP(i,N) cin>>p[i];
REP(i,(N+1)/2) dp[N-i][i]=1;
for(int i=N-1;i>=0;--i){
for(int j=N-1;j>=0;--j){
if(i+j<N) dp[i][j]=dp[i+1][j]*p[i+j]+dp[i][j+1]*(1-p[i+j]);
}
}
printf("%.16f\n",dp[0][0]);
} | 0 |
#include <iostream>
using namespace std;
int main() {
int a,b; cin>>a>>b; int an=-1;
for(int i=0;i<=10000&&an==-1;i++) {
if (i*8/100==a && i/10==b) an=i;
}
cout<<an<<endl;
} | 0 |
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
int main(void){
int cards[5];
char dummy;
while (cin>>cards[0]>>dummy>>cards[1]>>dummy>>cards[2]>>dummy>>cards[3]>>dummy>>cards[4])
{
int count=0,ans=0;
sort(cards,cards+5);
for (int i=0; i<4; i++)
{
if ( cards[i] == cards[i+1] )
{
count++;
ans+=count;
}
else count=0;
}
if (ans==0)
{
int sum=0;
for (int i=0; i<5; i++) sum+=cards[i];
if(sum-cards[0]*5==10) puts("straight");
else if(cards[0]==1 && cards[1]==10 && cards[2]==11 && cards[3]==12 && cards[4]==13) puts("straight");
else puts("null");
}
else if (ans==1) puts("one pair");
else if (ans==2) puts("two pair");
else if (ans==3) puts("three card");
else if (ans==4) puts("full house");
else if (ans==6) puts("four card");
}
return 0;
} | 0 |
#include<stdio.h>
#include<string.h>
typedef long long ll;
int pre[10005];
void init(){
int s=1;
for(int i=1;i<=10000;i++){
pre[i]=pre[i-1]+s;
s++;
}
}
int main(){
int t;
scanf("%d",&t);
init();
while(t--){
int x;
scanf("%d",&x);
int ans,a;
for(int i=1;i<=x;i++){
if(pre[i]>=x){
a=pre[i];
ans=i;
break;
}
}
if(a==x+1){
ans++;
}
printf("%d\n",ans);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
vector<int> G[N];
int n, m;
void Direct() {
vector<int> dis(n + 1, 1e9), par(n + 1, -1);
queue<int> que;
que.push(1);
dis[1] = 0;
int mx = 0;
while (que.size() > 0) {
int u = que.front();
que.pop();
for (int v : G[u]) {
if (dis[v] > dis[u] + 1) {
dis[v] = dis[u] + 1;
que.push(v);
par[v] = u;
mx = max(mx, dis[v]);
}
}
}
if (dis[n] <= 3) {
vector<int> path;
int v = n;
while (v != -1) {
path.push_back(v);
v = par[v];
}
reverse(path.begin(), path.end());
cout << path.size() - 1 << endl;
for (int x : path) cout << x << " ";
cout << endl;
exit(0);
}
if (mx == 0) {
cout << "-1" << endl;
exit(0);
}
if (mx >= 2) {
for (int i = 1; i <= n; i++) {
if (dis[i] == 2) {
vector<int> path;
int v = i;
while (v != -1) {
path.push_back(v);
v = par[v];
}
reverse(path.begin(), path.end());
path.push_back(1);
path.push_back(n);
cout << path.size() - 1 << endl;
for (int x : path) cout << x << " ";
exit(0);
}
}
}
vector<int> dis2(n + 1, 1e9), par2(n + 1, -1);
for (int i = 2; i <= n; i++) {
if (dis[i] == 1e9) continue;
if (dis2[i] != 1e9) continue;
vector<int> nodes;
queue<int> que;
que.push(i);
dis2[i] = 0;
while (que.size() > 0) {
int u = que.front();
nodes.push_back(u);
que.pop();
for (int v : G[u]) {
if (v == 1) continue;
if (dis2[v] > dis2[u] + 1) {
dis2[v] = dis2[u] + 1;
que.push(v);
}
}
}
int rt = -1;
int sz = nodes.size();
for (int x : nodes) {
if ((int)G[x].size() != sz) {
rt = x;
break;
}
}
if (rt == -1) continue;
for (int x = 1; x <= n; x++) {
dis2[x] = 1e9;
}
que.push(rt);
dis2[rt] = 0;
int ttt = -1;
while (que.size() > 0) {
int u = que.front();
nodes.push_back(u);
que.pop();
for (int v : G[u]) {
if (v == 1) continue;
if (dis2[v] > dis2[u] + 1) {
dis2[v] = dis2[u] + 1;
par2[v] = u;
if (dis2[v] == 2) ttt = v;
que.push(v);
}
}
}
vector<int> path;
while (ttt != -1) {
path.push_back(ttt);
ttt = par2[ttt];
}
reverse(path.begin(), path.end());
path.push_back(path[0]);
path.insert(path.begin(), 1);
path.push_back(n);
cout << path.size() - 1 << endl;
for (int x : path) {
cout << x << " ";
}
cout << endl;
exit(0);
}
cout << "-1" << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
G[v].push_back(u);
}
Direct();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void print(vector<int> v) {
for (long long int i = 0; i < v.size(); i++) {
cout << v[i];
}
}
int main() {
long long int n, k;
cin >> n >> k;
string s;
cin >> s;
vector<int> v;
for (long long int i = 0; i < s.length(); i++) {
if (s[i] == '1') {
v.push_back(1);
}
if (s[i] == '2') {
v.push_back(2);
}
if (s[i] == '3') {
v.push_back(3);
}
if (s[i] == '4') {
v.push_back(4);
}
if (s[i] == '5') {
v.push_back(5);
}
if (s[i] == '6') {
v.push_back(6);
}
if (s[i] == '7') {
v.push_back(7);
}
if (s[i] == '8') {
v.push_back(8);
}
if (s[i] == '9') {
v.push_back(9);
}
if (s[i] == '0') {
v.push_back(0);
}
}
if (v.size() == 1 && k > 0) {
cout << 0;
return 0;
}
int start = 0, pos = 0;
while (start != k && pos < v.size()) {
if (pos == 0 && v[pos] != 1) {
v[pos] = 1;
start++;
} else if (pos != 0 && v[pos] != 0) {
v[pos] = 0;
start++;
}
pos++;
}
print(v);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[26];
int A[26], m;
void solve() {
string s;
cin >> s;
for (int i = 0; i < s.length(); i++) v[s[i] - 'a'].push_back(i);
for (int i = 0; i < 26; i++) {
if (s.find(i + 'a') != string::npos) {
m = v[i][0] + 1;
for (int j = 1; j < (int)v[i].size(); j++)
m = max(m, v[i][j] - v[i][j - 1]);
m = max(m, (int)s.length() - v[i][(int)v[i].size() - 1]);
A[i] = m;
}
}
m = INT_MAX;
for (int i = 0; i < 26; i++) {
if (A[i] != 0) m = min(m, A[i]);
}
cout << m << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <iostream>
#include <set>
using namespace std;
long long n, a, s, l, r, b[200005];
set<int> st;
int main() {
int i;
scanf("%d", &n);
for(i=1; i<=n; i++) scanf("%d", &a), b[a] = i;;
st.insert(0);
st.insert(n+1);
for(i=1; i<=n; i++) {
l = *(--st.lower_bound(b[i]));
r = *st.lower_bound(b[i]);
s += i * (b[i]-l) * (r-b[i]);
st.insert(b[i]);
}
printf("%lld", s);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int n, a[MAXN], b[MAXN], x, y, sec[MAXN];
long long pt[2][MAXN];
bool cmp(int u, int v) { return a[u] - b[u] > a[v] - b[v]; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> x >> y;
y = min(y, n);
for (int i = 0; i < n; i++) cin >> a[i] >> b[i];
iota(sec, sec + n, 0);
sort(sec, sec + n, cmp);
for (int i = 0; i < n; i++)
pt[0][i + 1] = pt[0][i] + max(a[sec[i]], b[sec[i]]);
for (int i = 0; i < n; i++) pt[1][i + 1] = pt[1][i] + b[sec[i]];
long long ans = pt[0][y] + (pt[1][n] - pt[1][y]);
if (y) {
y--;
for (int i = 0; i < n; i++) {
int id = sec[i];
long long ret = 1ll * a[id] * (1 << x);
if (i >= y)
ret += pt[0][y] + (pt[1][i] - pt[1][y]) + (pt[1][n] - pt[1][i + 1]);
else
ret += pt[0][i] + (pt[0][min(n, y + 1)] - pt[0][i + 1]) +
(pt[1][n] - pt[1][min(n, y + 1)]);
ans = max(ans, ret);
}
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
set<long long> G[2000];
vector<long long> path;
long long cnt;
long long mat[2001][2001];
long long low[2009], pre[2009];
struct Edge {
long long F, S, cost;
};
vector<Edge> edges;
vector<long long> mb;
long long N, M, s, t;
long long vs[2009];
bool DFS(long long u, long long p) {
long long ret = 0;
vs[u] = 1;
for (auto v : G[u]) {
Edge e = edges[v];
long long nx = (e.F ^ e.S ^ u);
if (!vs[nx]) {
bool pp = DFS(nx, u);
if (pp) {
path.push_back(v);
ret = 1;
}
}
}
if (u == t) return 1;
return ret;
}
bool DFS2(long long u, long long p) {
pre[u] = ++cnt;
low[u] = pre[u];
bool ret = 0;
long long nc = 0;
for (auto v : G[u]) {
Edge e = edges[v];
long long nx = (e.F ^ e.S ^ u);
if (nx == p) {
nc++;
if (nc >= 2) {
low[u] = min(low[u], pre[nx]);
}
} else if (pre[nx] == 0) {
bool tp = DFS2(nx, u);
if (tp == 1 && low[nx] > pre[u]) {
mb.push_back(v);
}
low[u] = min(low[nx], low[u]);
ret |= tp;
} else if (pre[nx] < pre[u]) {
low[u] = min(low[u], pre[nx]);
}
}
if (u == t) return 1;
return ret;
}
long long ans;
vector<long long> now;
int main() {
long long i, j, k, a, b, c;
cin >> N >> M;
cin >> s >> t;
for (i = 0; i <= N; i++)
for (j = 0; j <= N; j++) mat[i][j] = -1;
for (i = 0; i < M; i++) {
cin >> a >> b >> c;
if (a > b) swap(a, b);
edges.push_back({a, b, c});
k = edges.size();
G[a].insert(k - 1);
G[b].insert(k - 1);
}
if (!DFS(s, 0)) {
cout << 0 << endl;
cout << 0 << endl;
return 0;
}
ans = 1000000000000;
for (auto v : path) {
G[edges[v].F].erase(v);
G[edges[v].S].erase(v);
mb.clear();
for (i = 0; i <= N; i++) {
pre[i] = 0;
}
cnt = 0;
if (!DFS2(s, 0)) {
if (edges[v].cost < ans) {
ans = edges[v].cost;
now.clear();
now.push_back(v);
G[edges[v].F].insert(v);
G[edges[v].S].insert(v);
continue;
}
}
for (auto p : mb) {
if (edges[p].cost + edges[v].cost < ans) {
ans = edges[p].cost + edges[v].cost;
now.clear();
now.push_back(p);
now.push_back(v);
}
}
G[edges[v].F].insert(v);
G[edges[v].S].insert(v);
}
if (ans == 1000000000000) {
cout << -1 << endl;
} else {
cout << ans << endl;
cout << now.size() << endl;
if ((long long)now.size() == 2) {
cout << now[0] + 1 << " " << now[1] + 1 << endl;
} else {
cout << now[0] + 1 << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long double eps = 1e-9;
const long long maxn = 1e5 + 1;
const long long inf = 5e18;
const long long minf = -inf;
bool solve() {
long long n, ans_cnt = 0, ans_use = 0;
cin >> n;
vector<long long> cnt(n + 1, 0), use(n + 1, 0);
for (long long i = 0, t, f; i < n; ++i) {
cin >> t >> f;
cnt[t]++;
if (f) use[t]++;
}
priority_queue<pair<long long, long long>> have;
multiset<long long> high;
for (long long i = 1; i <= n; ++i) {
if (!cnt[i])
continue;
else {
have.push({cnt[i], use[i]});
}
}
for (long long i = n; i > 0; --i) {
while (!have.empty() && (have.top()).first >= i) {
high.insert((have.top()).second);
have.pop();
}
if (!high.empty()) {
auto x = high.end();
x = prev(x);
ans_cnt += i;
ans_use += min(i, *x);
high.erase(x);
}
}
cout << ans_cnt << " " << ans_use << "\n";
return true;
}
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
cin >> t;
while (t--) {
if (solve()) {
} else {
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t-- > 0) {
int n, k;
cin >> n >> k;
vector<int> a(n, 0);
vector<bool> is_peak(n, false);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int border = 1, max_size = 0;
for (int i = 1; i < k - 1; ++i) {
if (a[i] > a[i - 1] && a[i] > a[i + 1]) {
is_peak[i] = true;
max_size++;
}
}
int cur_size = max_size;
for (int i = k - 1; i < n - 1; ++i) {
if (is_peak[i - k + 2]) {
cur_size--;
}
if (a[i] > a[i - 1] && a[i] > a[i + 1]) {
is_peak[i] = true;
cur_size++;
}
if (cur_size > max_size) {
max_size = cur_size;
border = i - k + 3;
}
}
cout << max_size + 1 << ' ' << border << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, p;
cin >> n >> p;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
long long l = max(a[0], a[n - 1] - n + 1);
long long r = a[n - 1];
vector<long long> ans;
long long L, R;
{
long long lo = l;
long long hi = r;
while (lo < hi) {
long long mid = (lo + hi) / 2;
bool zero_found = false;
for (long long x = mid; x < mid + n; x++) {
long long in_lo = 0;
long long in_hi = n - 1;
while (in_lo < in_hi) {
long long in_mid = (in_lo + in_hi + 1) / 2;
if (a[in_mid] > x) {
in_hi = in_mid - 1;
} else {
in_lo = in_mid;
}
}
if (in_lo + 1 == x - mid) {
zero_found = true;
}
}
if (zero_found) {
lo = mid + 1;
} else {
hi = mid;
}
}
L = lo;
}
{
long long lo = l;
long long hi = r;
while (lo < hi) {
long long mid = (lo + hi + 1) / 2;
bool max_found = false;
for (long long x = mid; x < mid + n; x++) {
long long in_lo = 0;
long long in_hi = n - 1;
while (in_lo < in_hi) {
long long in_mid = (in_lo + in_hi + 1) / 2;
if (a[in_mid] > x) {
in_hi = in_mid - 1;
} else {
in_lo = in_mid;
}
}
if (in_lo + 1 - (x - mid) >= p) {
max_found = true;
}
}
if (max_found) {
hi = mid - 1;
} else {
lo = mid;
}
}
R = lo;
}
if (L == R) {
for (long long x = L; x < L + n; x++) {
long long in_lo = 0;
long long in_hi = n - 1;
while (in_lo < in_hi) {
long long in_mid = (in_lo + in_hi + 1) / 2;
if (a[in_mid] > x) {
in_hi = in_mid - 1;
} else {
in_lo = in_mid;
}
}
if (in_lo + 1 - (x - L) >= p || in_lo + 1 - (x - L) == 0) {
cout << "0\n\n";
return 0;
}
}
}
if (R >= L) {
cout << R - L + 1 << "\n";
for (long long i = L; i <= R; i++) cout << i << " ";
cout << "\n";
} else {
cout << "0\n\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
void print_case() {
static int cnt = 0;
printf("Case #%d: ", ++cnt);
}
int l, r;
void solve() {
scanf("%d%d", &l, &r);
if (r < 2 * l) {
printf("YES\n");
} else {
printf("NO\n");
}
}
int main() {
int casen = 1;
scanf("%d", &casen);
while (casen--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, ans = 0, it = 0;
cin >> n;
vector<int> v1(n), v2(n);
for (int i = 0; i < n; i++) {
cin >> v1[i];
v2[i] = v1[i];
}
sort(v2.begin(), v2.end());
while (v1 != v2) {
it++;
for (int i = 0; i < n - 1; i++) {
if ((it % 2) == (i + 1) % 2) {
if (v1[i] > v1[i + 1]) swap(v1[i], v1[i + 1]);
}
}
ans++;
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char mapp[12][12];
bool vis[12][12][4];
int dis[4][2] = {0, 1, 1, 1, 1, 0, 1, -1};
bool dfs(int i, int j, int k) {
int cnt = 4;
while (cnt--) {
vis[i][j][k] = 1;
i += dis[k][0];
j += dis[k][1];
if (i < 1 || j < 1 || i > 10 || j > 10 || mapp[i][j] != 'X') return 0;
}
return 1;
}
bool judge() {
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= 10; i++) {
for (int j = 1; j <= 10; j++) {
if (mapp[i][j] == 'X') {
for (int k = 0; k < 4; k++) {
if (!vis[i][j][k]) {
bool flag = dfs(i, j, k);
if (flag) return 1;
}
}
}
}
}
return 0;
}
int main() {
int sum = 0;
for (int i = 1; i <= 10; i++) {
for (int j = 1; j <= 10; j++) {
cin >> mapp[i][j];
if (mapp[i][j] == 'X') sum++;
}
getchar();
}
if (sum < 4) {
cout << "NO" << endl;
return 0;
}
bool flag = 0;
for (int i = 1; i <= 10; i++) {
for (int j = 1; j <= 10; j++) {
if (mapp[i][j] == '.') {
mapp[i][j] = 'X';
if (judge()) {
cout << "YES" << endl;
return 0;
} else
mapp[i][j] = '.';
}
}
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
template <class T1, class T2>
inline bool cmin(T1 &a, const T2 &b) {
return b < a ? (a = b, true) : false;
}
template <class T1, class T2>
inline bool cmax(T1 &a, const T2 &b) {
return a < b ? (a = b, true) : false;
}
const int N = 1e5 + 5;
int n, last[26], l[N], r[N], pre[N][27], nex[N][27], f[N][27], g[N][27],
curl[N], curr[N], flift[17][N], glift[17][N];
char s[N];
long long fsum[17][N], gsum[17][N];
int main() {
assert(scanf("%s", s) == 1);
n = strlen(s);
for (int i = 0; i < n; ++i) s[i] -= 'a';
for (int i = 0; i < n; ++i) {
l[i] = last[s[i]];
last[s[i]] = i;
memcpy(pre[i], last, sizeof(last));
std::sort(pre[i], pre[i] + 26, std::greater<int>());
pre[i][26] = -1;
}
for (int i = 0; i < 26; ++i) last[i] = n - 1;
for (int i = n; i--;) {
r[i] = last[s[i]];
last[s[i]] = i;
memcpy(nex[i], last, sizeof(last));
std::sort(nex[i], nex[i] + 26);
nex[i][26] = n;
}
for (int i = 0; i < n; ++i) {
curl[i] = curr[i] = i;
f[i][0] = g[i][0] = i;
for (int j = 0; j < 26; ++j) {
f[i][j + 1] = std::min(f[i][j], l[nex[i][j]]);
g[i][j + 1] = std::max(g[i][j], r[pre[i][j]]);
}
}
long long ans = 0;
for (int t = 1; t <= 26; ++t) {
for (int i = 0; i < n; ++i) {
flift[0][i] = f[i][t];
glift[0][i] = g[i][t];
fsum[0][i] = gsum[0][i] = i;
}
for (int i = 1; (1 << i) <= n; ++i)
for (int j = 0; j < n; ++j) {
flift[i][j] = flift[i - 1][flift[i - 1][j]];
glift[i][j] = glift[i - 1][glift[i - 1][j]];
fsum[i][j] = fsum[i - 1][j] + fsum[i - 1][flift[i - 1][j]];
gsum[i][j] = gsum[i - 1][j] + gsum[i - 1][glift[i - 1][j]];
}
for (int i = 0; i < n; ++i) {
for (int j = 31 - __builtin_clz(n); j >= 0; --j) {
int nexl = flift[j][curl[i]], nexr = glift[j][curr[i]];
if (nexr < nex[nexl][t]) {
ans += ((n - 1ll) << j) + fsum[j][curl[i]] - gsum[j][curr[i]];
curl[i] = nexl, curr[i] = nexr;
}
}
if (curr[i] < nex[curl[i]][t]) {
ans += n - 1 + curl[i] - curr[i];
curl[i] = f[curl[i]][t];
curr[i] = g[curr[i]][t];
}
}
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define finish(x) return cout << x << endl, 0
#define ll long long
int n;
vector <int> a;
ll solve(int l, ll cl, int r, ll cr){
if(l + 1 == r) return 0;
ll ret = 1e18;
for(int k = l + 1 ; k < r ; k++){
ret = min(ret, solve(l, cl, k, cl + cr) + solve(k, cl + cr, r, cr) + (cl + cr) * a[k]);
}
return ret;
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
a.resize(n);
for(auto &i : a) cin >> i;
cout << solve(0, 1, n - 1, 1) + a[0] + a[n - 1] << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(void){
int n;
cin>>n;
vector<int> a(n),b(n);
for(int i=0;i<n;i++){
cin>>a[i];
b[i]=a[i];
}
sort(b.begin(),b.end());
for(int i=0;i<n;i++){
if(a[i]!=b[n-1]){
cout<<b[n-1]<<endl;
}else{
cout<<b[n-2]<<endl;
}
}
return 0;
} | 0 |
#include<bits/stdc++.h>
#define ll long long
#define fi first
#define se second
using namespace std;
const ll MOD=10000;
string a,b;
int m;
ll dp[502][2][500][11][3][2];
inline ll solve(string s){
int n=(int)s.length();
for(int i=0;i<n+1;i++)
for(int j=0;j<2;j++)
for(int k=0;k<m;k++)
for(int l=0;l<11;l++)
for(int mm=0;mm<3;mm++)
for(int o=0;o<2;o++)
dp[i][j][k][l][mm][o]=0;
dp[0][0][0][0][0][0]=1;
for(int i=0;i<n;i++){
for(int j=0;j<2;j++){
for(int k=0;k<m;k++){
for(int l=0;l<11;l++){
for(int mm=0;mm<3;mm++){
for(int o=0;o<2;o++){
int lim=j?9:s[i]-'0';
int pre=l-1;
for(int d=0;d<lim+1;d++){
if(d==0 && o==0){
(dp[i+1][j || d<lim][(10*k+d)%m][0][0][0]+=dp[i][j][k][l][mm][o])%=MOD;
continue;
}
if(pre==-1){
(dp[i+1][j || d<lim][(10*k+d)%m][d+1][0][1]+=dp[i][j][k][l][mm][o])%=MOD;
continue;
}
if(pre<d && mm!=1){
(dp[i+1][j || d<lim][(10*k+d)%m][d+1][1][1]+=dp[i][j][k][l][mm][o])%=MOD;
}
if(pre>d && mm!=2){
(dp[i+1][j || d<lim][(10*k+d)%m][d+1][2][1]+=dp[i][j][k][l][mm][o])%=MOD;
}
}
}
}
}
}
}
}
ll ans=0;
for(int i=0;i<2;i++)for(int j=1;j<11;j++)for(int k=0;k<3;k++){
(ans+=dp[n][i][0][j][k][1])%=MOD;
}
return ans;
}
inline string min1(string s){
int n=(int)s.length();
for(int i=n-1;i>=0;i--){
int now=s[i]-'0';
if(now-1<0){
s[i]='9';
}else{
s[i]='0'+now-1;
break;
}
}
for(int i=0;i<n;i++){
if(s=="0")break;
if(s[i]=='0')s=s.substr(1,s.length()-1);
else break;
}
return s;
}
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout<<fixed;
#ifdef LOCAL_DEFINE
freopen("in", "r", stdin);
freopen("out","w",stdout);
#endif
ll ansa,ansb;
cin>>a>>b>>m;
a=min1(a);
ansb=solve(b);
ansa=solve(a);
cout<<(ansb+MOD-ansa)%MOD<<"\n";
#ifdef LOCAL_DEFINE
cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << " s.\n";
#endif
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
const int lazy = int('a' - 'A');
const long long N = 1e7 + 1;
string alphabet = "abcdefghijklmnopqrstuvwxyz";
long long sum = 0, final = 0, result = 0;
unsigned long long MOD = 1000000007;
long long fastPower(long long b, long long p) {
if (p == 0) return 1;
long long ans = fastPower(b, p / 2);
ans = (ans * ans);
if (p % 2 != 0) ans = (ans * b);
return ans;
}
bool isPalindrome(string s) {
string lol = s;
reverse(lol.begin(), lol.end());
if (s == lol) {
return true;
} else {
return false;
}
}
void it_is_me_dio_hahahahahaha() {
long long n;
cin >> n;
long long cnt = 0;
while (n >= 100) {
n -= 100;
cnt++;
}
while (n >= 20) {
n -= 20;
cnt++;
}
while (n >= 10) {
n -= 10;
cnt++;
}
while (n >= 5) {
n -= 5;
cnt++;
}
while (n > 0) {
n -= 1;
cnt++;
}
cout << cnt << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
t = 1;
while (t--) {
it_is_me_dio_hahahahahaha();
}
}
| 1 |
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
typedef struct{
double x;
double y;
}point;
void Printp(point a){
printf("%lf %lf\n", a.x, a.y);
}
void koch(int d, point p, point q){
if(d==0) return;
point s, u, t;
//calculation
s.x=(2*p.x+q.x)/3.0;
s.y=(2*p.y+q.y)/3.0;
t.x=(p.x+2*q.x)/3.0;
t.y=(p.y+2*q.y)/3.0;
double ang=M_PI*60/180.0;
u.x=(t.x-s.x)*cos(ang) - (t.y-s.y)*sin(ang) +s.x;
u.y=(t.x-s.x)*sin(ang) + (t.y-s.y)*cos(ang) +s.y;
koch(d-1, p, s);
Printp(s);
koch(d-1, s, u);
Printp(u);
koch(d-1, u, t);
Printp(t);
koch(d-1, t, q);
}
int main(){
int n;
scanf(" %d", &n);
point s1,s2;
s1.x=0; s1.y=0;
s2.x=100; s2.y=0;
Printp(s1);
koch(n, s1, s2);
Printp(s2);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.