solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int v[200];
int main() {
int n, p = 0, p2 = 0;
cin >> n;
for (int i = 1; i <= n / 2; i++) cin >> v[i];
sort(v + 1, v + n / 2 + 1);
for (int i = 1; i <= n / 2; i++) {
p += abs(i * 2 - v[i]), p2 += abs((i * 2 - 1) - v[i]);
}
cout << min(p, p2);
cin >> p;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long Set(long long N, long long pos) { return N = N | (1 << pos); }
long long reset(long long N, long long pos) { return N = N & ~(1 << pos); }
bool check(long long N, long long pos) { return (bool)(N & (1 << pos)); }
void CI(long long &_x) { scanf("%I64d", &_x); }
void CO(long long &_x) { cout << _x; }
template <typename T>
void getarray(T a[], long long n) {
for (long long i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void prLLIarray(T a[], long long n) {
for (long long i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
const double EPS = 1e-9;
const long long INF = 0x7f7f7f7f;
long long dr8[8] = {1, -1, 0, 0, 1, -1, -1, 1};
long long dc8[8] = {0, 0, -1, 1, 1, 1, -1, -1};
long long dr4[4] = {0, 0, 1, -1};
long long dc4[4] = {-1, 1, 0, 0};
long long kn8r[8] = {1, 2, 2, 1, -1, -2, -2, -1};
long long kn8c[8] = {2, 1, -1, -2, -2, -1, 1, 2};
long long pile[100005];
long long n;
long long mem[100005];
int main() {
memset(mem, -1, sizeof mem);
CI(n);
for (long long i = 0; i < n; i++) {
CI(pile[i]);
}
sort(pile, pile + n);
reverse(pile, pile + n);
for (long long i = 1; i < n; i++) {
pile[i] += pile[i - 1];
}
long long query;
CI(query);
while (query--) {
long long k, ans = 0;
CI(k);
if (mem[k] != -1) {
cout << mem[k] << "\n";
continue;
}
long long sz = 1;
for (long long i = 1, t = 1; i < n; i += sz, t++) {
sz *= k;
ans += (pile[min(n - 1, i + sz - 1)] - pile[i - 1]) * t;
}
mem[k] = ans;
cout << ans << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long lcm(long long a, long long b) { return (a * (b / gcd(a, b))); }
class UnionFind {
private:
vector<int> p, rank, setSize;
int numSets;
public:
UnionFind(int N) {
setSize.assign(N, 1);
numSets = N;
rank.assign(N, 0);
p.assign(N, 0);
for (int i = 0; i < N; i++) p[i] = i;
}
int findSet(int i) { return (p[i] == i) ? i : (p[i] = findSet(p[i])); }
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
void unionSet(int i, int j) {
if (!isSameSet(i, j)) {
numSets--;
int x = findSet(i), y = findSet(j);
if (rank[x] > rank[y]) {
p[y] = x;
setSize[x] += setSize[y];
} else {
p[x] = y;
setSize[y] += setSize[x];
if (rank[x] == rank[y]) rank[y]++;
}
}
}
int numDisjointSets() { return numSets; }
int sizeOfSet(int i) { return setSize[findSet(i)]; }
};
pair<int, int> p[102];
int main() {
int n;
cin >> n;
UnionFind uf(n);
for (int i = 0; i < int(n); ++i) scanf("%d%d", &p[i].first, &p[i].second);
for (int i = 0; i < int(n); ++i) {
for (int j = 0; j < int(n); ++j) {
if (i == j) continue;
if (p[i].first == p[j].first || p[i].second == p[j].second)
uf.unionSet(i, j);
}
}
cout << uf.numDisjointSets() - 1 << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)4e5 + 7;
int curnode = 2;
int par[22][N];
long long parsum[22][N];
long long last = 0;
long long weight[N];
void add(int node, long long w) {
weight[curnode] = w;
if (weight[curnode] <= weight[node]) {
par[0][curnode] = node;
} else {
int from = node;
for (int i = 20; i >= 0; i--) {
if (weight[curnode] > weight[par[i][from]]) {
from = par[i][from];
}
}
par[0][curnode] = par[0][from];
}
parsum[0][curnode] =
((par[0][curnode] == 0) ? 1e15 : weight[par[0][curnode]]);
for (int i = 1; i <= 20; i++) {
par[i][curnode] = par[i - 1][par[i - 1][curnode]];
parsum[i][curnode] =
(par[i][curnode] == 0)
? 1e15
: parsum[i - 1][curnode] + parsum[i - 1][par[i - 1][curnode]];
}
curnode++;
}
int getans(int node, long long x) {
int ans = 1;
if (weight[node] > x) {
ans = 0;
} else {
x -= weight[node];
for (int i = 20; i >= 0; i--) {
if (parsum[i][node] <= x) {
ans += (1 << i);
x -= parsum[i][node];
node = par[i][node];
}
}
}
return ans;
}
int main() {
int q;
scanf("%d", &q);
weight[0] = 1e18;
for (int i = 0; i <= 20; i++) {
parsum[i][1] = 1e15;
}
while (q--) {
int tp;
scanf("%d", &tp);
long long p, q;
scanf("%I64d %I64d", &p, &q);
if (tp == 1) {
p ^= last;
q ^= last;
add(p, q);
} else {
p ^= last;
q ^= last;
last = getans(p, q);
printf("%I64d\n", last);
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long a, idx, d;
};
long long n, m, k;
vector<vector<long long> > v;
vector<long long> vis;
vector<long long> par;
long long flag;
void dfs(long long u) {
vis[u] = 1;
for (auto x : v[u]) {
if (x == par[u]) continue;
if (vis[x] == 2)
continue;
else if (vis[x] == 1) {
flag = 1;
} else {
par[x] = u;
dfs(x);
}
}
vis[u] = 2;
}
void solve() {
long long i, j, x, y, z;
cin >> n >> m;
v.resize(n + 1);
for (i = 0; i < m; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
vis.resize(n + 1, 0);
par.resize(n + 1, 0);
long long ans = 0;
for (i = 1; i < n + 1; i++) {
if (vis[i] == 0) {
flag = 0;
dfs(i);
if (flag == 0) ans++;
}
}
cout << ans << endl;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
#define rep(i, n) for (rint i = 1; i <= (n); i ++)
#define re0(i, n) for (rint i = 0; i < (int) n; i ++)
#define travel(i, u) for (rint i = head[u]; i; i = e[i].nxt)
#define rint register int
using namespace std;
typedef long long lo;
template<typename tp> inline void read(tp &x) {
x = 0; char c = getchar(); int f = 0;
for (; c < '0' || c > '9'; f |= c == '-', c = getchar());
for (; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + c - '0', c = getchar());
if (f) x = -x;
}
#define pb push_back
#define p pair <int, int>
const int N = 6666;
int n, ans = 1e9;
vector <p> a, b;
char s[N], t[N];
inline void doit() {
for (int add0 = 0; add0 <= 2 * n + 1; add0++) {
if ((add0 + (a.front() == b.front())) % 2 == 0)
continue;
vector <p> na(add0, p('0', 1));
for (p v : a) na.pb(v);
int i = 0, j = 0;
bool valid = true;
int now = 0;
while (!(i == na.size() && j == b.size())) {
if (i == na.size()) now += n + 1 - b[j++].second;
else if (j == b.size()) now += n + 1 - na[i++].second;
else {
valid &= na[i].first == b[j].first;
now += abs(na[i++].second - b[j++].second);
}
}
ans = min(ans, now);
}
}
int main(void) {
read(n);
scanf("%s%s", s + 1, t + 1);
re0 (i, n) {
if (s[i + 1] != s[i]) a.pb(p(s[i + 1], i + 1));
if (t[i + 1] != t[i]) b.pb(p(t[i + 1], i + 1));
}
// for (p v : a) cout << v.first << " "; cout << "\n";
// for (p v : b) cout << v.first << " "; cout << "\n";
doit();
swap(a, b);
doit();
cout << ans << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double one = 1.0;
const double PI = 3.14159265;
const long long maxn = 1e5 + 10;
char s[maxn];
void solve() {
scanf("%s", s);
long long len = strlen(s);
vector<long long> a[2];
long long cur = 0;
long long pos = 0;
while (pos < len) {
if (s[pos] == ':' && s[pos + 1] == ':') cur++;
while (s[pos] == ':') pos++;
if (pos >= len) break;
long long t;
sscanf(s + pos, "%x", &t);
a[cur].push_back(t);
while (pos < len && s[pos] != ':') ++pos;
}
long long cnt = 8 - a[0].size() - a[1].size();
for (long long i = 0; i < cnt; i++) a[0].push_back(0);
for (long long i = 0; i < a[1].size(); i++) a[0].push_back(a[1][i]);
printf("%04x", a[0][0]);
for (long long i = 1; i < 8; i++) printf(":%04x", a[0][i]);
puts("");
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
scanf("%lld", &t);
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1e8;
const int MAX = 200003;
int str[MAX], pat[MAX];
int fail[MAX];
int getlen(int l, int c) {
while (l && pat[l] != c) l = fail[l - 1];
if (pat[l] == c) l++;
return l;
}
int n, m;
int res = 0;
void build() {
fail[0] = 0;
int l = 0;
for (int i = 1; i < m - 1; i++) {
l = getlen(l, pat[i]);
fail[i] = l;
}
}
void match() {
build();
int l = 0;
for (int i = 0; i < n - 1; i++) {
l = getlen(l, str[i]);
if (l == m - 1) {
res++;
l = fail[l - 1];
}
}
}
int main() {
scanf("%d%d", &n, &m);
if (m == 1) {
cout << n << endl;
return 0;
}
int prev, cur;
scanf("%d", &prev);
for (int i = 0; i < n - 1; i++) {
scanf("%d", &cur);
str[i] = cur - prev;
prev = cur;
}
scanf("%d", &prev);
for (int i = 0; i < m - 1; i++) {
scanf("%d", &cur);
pat[i] = cur - prev;
prev = cur;
}
match();
cout << res << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static const long long L = 233333;
static char sxd[L], *sss = sxd, *ttt = sxd;
if (sss == ttt) {
ttt = (sss = sxd) + fread(sxd, 1, L, stdin);
if (sss == ttt) {
return EOF;
}
}
return *sss++;
}
inline char readalpha() {
char c = gc();
for (; !isalpha(c); c = gc())
;
return c;
}
inline char readchar() {
char c = gc();
for (; c == ' '; c = gc())
;
return c;
}
template <class T>
inline bool read(T& x) {
bool flg = false;
char c = gc();
x = 0;
for (; !isdigit(c); c = gc()) {
if (c == '-') {
flg = true;
} else if (c == EOF) {
return false;
}
}
for (; isdigit(c); c = gc()) {
x = (x << 1) + (x << 3) + (c ^ 48);
}
if (flg) {
x = -x;
}
return true;
}
template <class T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x < 10) {
putchar(x | 48);
return;
}
write(x / 10);
putchar((x % 10) | 48);
}
template <class T>
inline void writesp(T x) {
write(x);
putchar(' ');
}
template <class T>
inline void writeln(T x) {
write(x);
puts("");
}
const int maxn = 105;
const int inf = 0x3f3f3f3f;
int n, m, F, T, K;
int mp[maxn][maxn];
int f[maxn][maxn];
int g[maxn][maxn];
int t[maxn][maxn];
int cnt[maxn][maxn];
bitset<maxn> cut[maxn][maxn];
struct Bus {
int f, t;
} bus[maxn];
inline bool instp(int u, int v, int x) { return f[u][x] + f[x][v] == f[u][v]; }
inline bool instp(int u, int v, int x, int y) {
return f[u][x] + 1 + f[y][v] == f[u][v];
}
struct ZT {
int zh, to, bu;
ZT(int z, int t, int b) { zh = z, to = t, bu = b; }
};
int main() {
memset(f, 0x3f, sizeof(f));
memset(g, 0x3f, sizeof(g));
read(n), read(m), read(F), read(T);
for (int i = 1; i <= m; ++i) {
int u, v;
read(u), read(v);
f[u][v] = mp[u][v] = 1;
}
for (int i = 1; i <= n; ++i) {
f[i][i] = 0;
}
for (int k = 1; k <= n; ++k) {
for (int i = 1; i <= n; ++i) {
if (i != k) {
for (int j = 1; j <= n; ++j) {
if (j != k) {
if (f[i][j] > f[i][k] + f[k][j]) {
f[i][j] = f[i][k] + f[k][j];
cut[i][j] = cut[i][k] | cut[k][j];
cut[i][j][k] = 1;
} else if (f[i][j] == f[i][k] + f[k][j]) {
cut[i][j] &= cut[i][k] | cut[k][j];
}
}
}
}
}
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
cut[i][j][i] = cut[i][j][j] = 1;
}
}
read(K);
deque<ZT> q;
q.clear();
for (int i = 1; i <= K; ++i) {
read(bus[i].f), read(bus[i].t);
if (instp(bus[i].f, bus[i].t, T)) {
g[T][i] = 1;
q.emplace_back(1, T, i);
}
for (int j = 1; j <= n; ++j) {
for (int k = 1; k <= n; ++k) {
if (mp[j][k] && instp(bus[i].f, bus[i].t, j, k)) {
cnt[j][i]++;
}
}
}
}
while (!q.empty()) {
ZT nowzt = q.front();
q.pop_front();
if (nowzt.zh > g[nowzt.to][nowzt.bu]) {
continue;
}
int now = nowzt.to;
int bs = nowzt.bu;
if (cut[bus[bs].f][bus[bs].t][now]) {
for (int i = 1; i <= K; ++i) {
if (i != bs && instp(bus[i].f, bus[i].t, now) &&
g[now][i] > g[now][bs] + 1) {
g[now][i] = g[now][bs] + 1;
q.emplace_back(g[now][i], now, i);
}
}
}
for (int i = 1; i <= n; ++i) {
if (mp[i][now] && instp(bus[bs].f, bus[bs].t, i, now)) {
t[i][bs] = max(g[now][bs], t[i][bs]);
cnt[i][bs]--;
if (!cnt[i][bs] && t[i][bs] < g[i][bs]) {
g[i][bs] = t[i][bs];
q.emplace_front(g[i][bs], i, bs);
}
}
}
}
int ans = inf;
for (int i = 1; i <= K; ++i) {
if (cut[bus[i].f][bus[i].t][F]) {
ans = min(ans, g[F][i]);
}
}
if (ans < inf) {
writeln(ans);
} else {
puts("-1");
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
using ll = long long;
using Edge = pair<int,int>;
using P = pair<ll,ll>;
const ll inf = numeric_limits<ll>::max()/3;
int visit[110];
ll deg[110];
vector< vector<int> > T;
vector< Edge > E;
ll dfs(int n,int d){
visit[n] = 1;
ll res = 0;
ll cnt = 0;
for(int i : T[n]){
if(!visit[i]){
++cnt;
res = max(res,dfs(i,d+1));
}
}
deg[d] = max(deg[d],cnt);
return res + 1;
}
P calc(int n){
fill(visit,visit+110,0);
fill(deg,deg+110,0);
visit[n] = 1;
ll d = dfs(n,0);
ll l = 1;
for(int i = 0;i < d-1;++i){
l *= deg[i];
}
return P(d,l);
}
P calc2(Edge e){
fill(visit,visit+110,0);
fill(deg,deg+110,0);
visit[e.first] = 1;
visit[e.second] = 1;
ll d = max(dfs(e.first,0),dfs(e.second,0));
ll l = 1;
for(int i = 0;i < d-1;++i){
l *= deg[i];
}
l *= 2;
return P(d,l);
}
int main(void){
ll n;
cin >> n;
T.clear();E.clear();
T.resize(n);
for(int i = 0;i < n-1;++i){
int a,b;
cin >> a >> b;
--a;--b;
T[a].push_back(b);
T[b].push_back(a);
E.push_back(Edge(a,b));
}
ll color = inf;
ll leaf = inf;
for(int i = 0;i < n;++i){
ll newc,newl;
tie(newc,newl) = calc(i);
if(newc < color){
color = newc;
leaf = newl;
}else if(newc == color){
leaf = min(leaf,newl);
}
}
for(Edge e : E){
ll newc,newl;
tie(newc,newl) = calc2(e);
if(newc < color){
color = newc;
leaf = newl;
}else if(newc == color){
leaf = min(leaf,newl);
}
}
cout << color << " " << leaf << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int memo[110][110][10];
int n;
int c[110];
void dp(int l, int r){
if(memo[l][r][0] != -1){
return;
}
if(l == r){
for(int i = 0;i <= 9;i++){
memo[l][r][i] = 0;
}
memo[l][r][c[l]] = 1;
return;
}
for(int i = l;i < r;i++){
dp(l,i);
dp(i+1,r);
}
for(int x = 1;x <= 9;x++){
memo[l][r][x] = 0;
for(int i = l;i < r;i++){
if(memo[l][i][x] == 1 && (memo[i+1][r][x] == 1 || memo[i+1][r][0] == 1)){
memo[l][r][x] = 1;
}else if((memo[l][i][x] == 1 || memo[l][i][0] == 1) && memo[i+1][r][x] == 1){
memo[l][r][x] = 1;
}
}
}
memo[l][r][0] = 0;
for(int i = l;i < r;i++){
for(int x = 0;x <= 9;x++){
if(memo[l][i][x] == 1 && memo[i+1][r][x] == 1){
memo[l][r][0] = 1;
}
}
}
return;
}
int main(){
cin >> n;
for(int i = 0;i < n;i++) cin >> c[i];
memset(memo, -1, sizeof(memo));
dp(0, n-1);
if(memo[0][n-1][0] == 1){
cout << "yes" << endl;
}else{
cout << "no" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 100010;
const long long P = 1500000;
struct node {
long long x, y, id;
} a[MAXN];
int ans[MAXN];
int main() {
int n, i;
long long x, y, p;
scanf("%d", &n);
p = P * P;
for (i = 1; i <= n; ++i) {
scanf("%lld%lld", &a[i].x, &a[i].y);
a[i].id = i;
}
while (true) {
random_shuffle(a + 1, a + n + 1);
x = y = 0;
for (i = 1; i <= n; ++i) {
if ((x + a[i].x) * (x + a[i].x) + (y + a[i].y) * (y + a[i].y) >
(x - a[i].x) * (x - a[i].x) + (y - a[i].y) * (y - a[i].y)) {
x -= a[i].x;
y -= a[i].y;
ans[a[i].id] = -1;
} else {
x += a[i].x;
y += a[i].y;
ans[a[i].id] = 1;
}
}
if (x * x + y * y <= p) {
for (i = 1; i <= n; ++i) printf("%d ", ans[i]);
return 0;
}
}
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main() {
int n,q;
string s;
cin >> n >> s >> q;
set<int> alpha[26];
for(int i=0;i<n;i++)alpha[(int)(s[i]-'a')].insert(i);
for(int i=0;i<q;i++){
int t;
cin >> t;
if(t==1){
int I;
char c;
cin >> I >> c;
I--;
if(s[I]!=c){
alpha[(int)(s[I]-'a')].erase(I);
alpha[(int)(c-'a')].insert(I);
s[I]=c;
}
}
else{
int l,r;
cin >> l >> r;
l--; r--;
int ans=0;
for(int j=0;j<26;j++){
auto u = alpha[j].lower_bound(l);
if(u!=alpha[j].end() && *u<=r)ans++;
}
cout << ans << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int x[1024], b[1024], pre[1024], ans[1024], cnt;
double dp[1024];
int main() {
int n, ll;
scanf("%d%d", &n, &ll);
for (int i = 0; i < n; i++) {
scanf("%d %d", x + i, b + i);
}
double l = 0, r = 1e6;
while (fabs(l - r) > 1e-8) {
double t = (l + r) / 2.;
for (int i = 0; i < n; i++) {
dp[i] = sqrt(fabs(x[i] - ll)) - t * b[i];
for (int j = 0; j < i; j++) {
double tmp = dp[j] + sqrt(fabs(x[i] - x[j] - ll)) - t * b[i];
if (tmp < dp[i]) {
dp[i] = tmp;
}
}
}
if (dp[n - 1] > 1e-3) {
l = t;
} else {
r = t;
}
}
double t = (l + r) / 2;
for (int i = 0; i < n; i++) {
dp[i] = sqrt(fabs(x[i] - ll)) - t * b[i];
pre[i] = -1;
for (int j = 0; j < i; j++) {
double tmp = dp[j] + sqrt(fabs(x[i] - x[j] - ll)) - t * b[i];
if (tmp < dp[i]) {
dp[i] = tmp;
pre[i] = j;
}
}
}
cnt = 0;
int x = n - 1;
while (x >= 0) {
ans[cnt++] = x;
x = pre[x];
}
for (int i = cnt - 1; i >= 0; i--) {
printf("%d ", ans[i] + 1);
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef long long lglg;
const int INF = 1 << 28;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n; cin >> n;
int adj[n][n];
vector<pair<int,int>> edges;
for (int i=0; i<n; ++i) {
string x; cin >> x;
for (int j=0; j<n; ++j) {
if (i == j) adj[i][j] = 0;
else if (x[j] == '1') {
adj[i][j] = 1;
if (i < j) edges.push_back({i, j});
}
else adj[i][j] = INF;
}
}
for (int k=0; k<n; ++k)
for (int i=0; i<n; ++i)
for (int j=0; j<n; ++j)
adj[i][j] = min(adj[i][j], adj[i][k] + adj[k][j]);
bool failed = false;
for (pair<int,int> pr : edges) {
int x, y; tie(x, y) = pr;
if (adj[0][x] == adj[0][y]) {
failed = true;
break;
}
}
if (failed) cout << -1;
else {
int best = -1;
for (int i=0; i<n; ++i) for (int j=0; j<n; ++j) best = max(best, adj[i][j]);
cout << best+1;
}
}
| 0 |
#include <iostream>
#include <string>
using namespace std;
void solve()
{
string s;
while(getline(cin, s))
{
for(int i = 0; i < 26; ++i)
{
for(int j = 0; j < s.size(); ++j)
{
if('a' <= s[j] && s[j] <= 'z')
{
if(s[j] == 'z')
{
s[j] = 'a';
}
else
{
++s[j];
}
}
}
if(s.find("this") != string::npos || s.find("that") != string::npos || s.find("the") != string::npos)
{
cout << s << endl;
break;
}
}
}
}
int main()
{
solve();
return(0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<int> arr[101];
int vis[101];
void dfs(int node) {
vis[node] = 1;
for (auto child : arr[node]) {
if (vis[child] == 0) dfs(child);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, cnt = 0;
cin >> n >> m;
set<int> s;
for (int i = 0; i < n; i++) {
int x, a, b;
cin >> x;
if (x == 0) {
cnt++;
continue;
}
cin >> a;
x--;
s.insert(a);
while (x--) {
cin >> b;
s.insert(b);
arr[a].push_back(b), arr[b].push_back(a);
a = b;
}
}
int cc = 0;
for (auto it = s.begin(); it != s.end(); it++) {
int x = *it;
if (vis[x] == 0) {
dfs(x);
cc++;
}
}
if (cc > 1) cnt += cc - 1;
cout << cnt << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int main() {
cin >> m >> n;
int c = min(n, m);
cout << c + 1 << '\n';
for (int i = 0; i <= c; i++) cout << i << ' ' << n - i << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char inp[260][260];
bool cov[260][260];
int mx, my, Mx, My;
vector<int> outai;
vector<int> outaj;
void dfs(int i, int j) {
cov[i][j] = true;
mx = min(mx, j);
my = min(i, my);
Mx = max(Mx, j);
My = max(My, i);
outai.push_back(i);
outaj.push_back(j);
for (int dx = -1; dx <= 1; dx++) {
for (int dy = -1; dy <= 1; dy++) {
int y = i + dy;
int x = j + dx;
if (y < 0 || y >= n || x < 0 || x >= m || inp[y][x] == '0' || cov[y][x])
continue;
dfs(y, x);
}
}
}
int ar[4];
bool firstType() {
memset(ar, 0, sizeof(ar));
for (int t = 0; t < outai.size(); t++) {
bool ch = false;
if (outai[t] == my && outaj[t] >= mx && outaj[t] <= Mx) ar[0]++, ch = true;
if (outai[t] >= my && outai[t] <= My && outaj[t] == mx) ar[1]++, ch = true;
if (outai[t] == My && outaj[t] >= mx && outaj[t] <= Mx) ar[2]++, ch = true;
if (outai[t] >= my && outai[t] <= My && outaj[t] == Mx) ar[3]++, ch = true;
if (!ch) return false;
}
if (ar[0] == ar[1] && ar[1] == ar[2] && ar[2] == ar[3]) {
if (ar[0] > 1 && ar[0] == (Mx - mx + 1) && ar[0] == (My - my + 1))
return true;
}
return false;
}
int getcord(int i, int j) { return i + j; }
bool secondType() {
memset(ar, 0, sizeof(ar));
mx = my = 1000;
Mx = My = -1;
for (int t = 0; t < outai.size(); t++) {
int ty = outai[t];
int tx = outaj[t];
outai[t] = getcord(ty, tx);
outaj[t] = getcord(ty, m - 1 - tx);
mx = min(outaj[t], mx);
Mx = max(outaj[t], Mx);
My = max(outai[t], My);
my = min(outai[t], my);
}
for (int t = 0; t < outai.size(); t++) {
if ((outai[t] - my) % 2 != 0 || (outaj[t] - mx) % 2 != 0) return false;
}
for (int t = 0; t < outai.size(); t++) {
bool ch = false;
if (outai[t] == my && outaj[t] >= mx && outaj[t] <= Mx) ar[0]++, ch = true;
if (outai[t] >= my && outai[t] <= My && outaj[t] == mx) ar[1]++, ch = true;
if (outai[t] == My && outaj[t] >= mx && outaj[t] <= Mx) ar[2]++, ch = true;
if (outai[t] >= my && outai[t] <= My && outaj[t] == Mx) ar[3]++, ch = true;
if (!ch) return false;
}
if (ar[0] == ar[1] && ar[1] == ar[2] && ar[2] == ar[3]) {
if (ar[0] > 1 && ar[0] == (1 + (Mx - mx + 1)) / 2 &&
ar[0] == (1 + (My - my + 1)) / 2)
return true;
}
return false;
}
int main() {
int tc;
scanf("%d", &tc);
while (tc--) {
memset(inp, 0, sizeof(inp));
scanf("%d%d", &n, &m);
int ret = 0;
for (int i = 0; i < n; i++) scanf("%s", inp[i]);
memset(cov, 0, sizeof(cov));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (inp[i][j] == '0') continue;
if (cov[i][j]) continue;
mx = my = 260;
Mx = My = -1;
outai.clear();
outaj.clear();
dfs(i, j);
if (firstType()) ret++;
if (secondType()) ret++;
}
}
printf("%d\n", ret);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int NMAX = 100000;
struct edge {
edge(int dest, int cost) : dest(dest), cost(cost) {}
int dest, cost;
};
vector<edge> old_T[NMAX], T[NMAX];
int size[NMAX], len[NMAX];
long long K[NMAX], cdyn[NMAX];
int DFS_ch(int u, int prev) {
for (int i = 0, _n = (old_T[u].size()); i < _n; ++i) {
const int v = old_T[u][i].dest;
if (v != prev) {
T[u].push_back(edge(v, old_T[u][i].cost));
size[u] += DFS_ch(v, u);
len[u] += 2 * old_T[u][i].cost + len[v];
}
}
++size[u];
return size[u];
}
struct vertex_cmp {
bool operator()(const edge& e1, const edge& e2) const {
const int u = e1.dest, v = e2.dest;
return K[u] * size[v] < K[v] * size[u];
}
};
long long dyn(int u) {
for (int i = 0, _n = (T[u].size()); i < _n; ++i) {
const int v = T[u][i].dest, t = T[u][i].cost;
cdyn[v] = dyn(v);
K[v] = len[v] + 2 * t;
}
sort((T[u]).begin(), (T[u]).end(), vertex_cmp());
long long res = 0, Ksum = 0;
for (int i = 0, _n = (T[u].size()); i < _n; ++i) {
const int v = T[u][i].dest, t = T[u][i].cost;
res += cdyn[v] + size[v] * (t + Ksum);
Ksum += K[v];
}
return res;
}
int main() {
int N;
scanf("%d", &N);
for (int i = 0, _n = (N - 1); i < _n; ++i) {
int a, b, t;
scanf("%d%d%d", &a, &b, &t);
old_T[a - 1].push_back(edge(b - 1, t));
old_T[b - 1].push_back(edge(a - 1, t));
}
DFS_ch(0, -1);
printf("%.7lf\n", 1.0 * dyn(0) / (N - 1));
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
vector<int> v1(n), v2(n);
int pos1;
for (int i = 0; i < n; i++) {
cin >> v1[i];
if (v1[i] == 1) pos1 = i;
}
int pos2;
for (int i = 0; i < n; i++) {
cin >> v2[i];
if (v2[i] == 1) pos2 = i;
}
for (int i = 0; i < n; i++, pos1 = (pos1 + 1) % n, pos2 = (pos2 + 1) % n) {
if (v1[pos1] == 0) pos1 = (pos1 + 1) % n;
if (v2[pos2] == 0) pos2 = (pos2 + 1) % n;
if (v1[pos1] != v2[pos2]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, d, nn = 0, a[500069], dsu[1000069], cc[1000069];
pair<long long, long long> hs[1000069];
bitset<500069> spc;
vector<pair<long long, long long>> al[500069];
long long fd(long long x) {
if (dsu[x] != x) {
return fd(dsu[x]);
}
return x;
}
void jo(long long x, long long y) {
x = fd(x);
y = fd(y);
if (cc[x] < cc[y]) {
swap(x, y);
}
if (x != y) {
dsu[y] = x;
cc[x] += cc[y];
}
nn++;
hs[nn] = {x, y};
}
void un() {
long long k, l;
k = hs[nn].first;
l = hs[nn].second;
nn--;
if (k != l) {
dsu[l] = l;
cc[k] -= cc[l];
}
}
bool cmp(pair<long long, long long> x, pair<long long, long long> y) {
return a[x.second] < a[y.second];
}
int main() {
long long i, j, r, ii, k, l, sz, sm = 0, c, z = 0;
bool bad;
scanf("%lld%lld%lld", &n, &m, &d);
for (i = 1; i <= n; i++) {
scanf("%lld", a + i);
}
for (i = 1; i <= n * 2; i++) {
dsu[i] = i;
cc[i] = 1;
}
for (i = 0; i < m; i++) {
scanf("%lld%lld", &k, &l);
if (a[k] == a[l]) {
spc[a[k]] = spc[a[k]] | fd(k) == fd(l);
jo(k, n + l);
jo(n + k, l);
} else {
if (a[k] < a[l]) {
swap(k, l);
}
al[a[k]].push_back({k, l});
}
}
for (i = 1; i <= d; i++) {
if (!spc[i]) {
c = 0;
bad = 0;
sort(al[i].begin(), al[i].end(), cmp);
sz = al[i].size();
for (r = 0, j = 0; j < sz; j++) {
k = al[i][j].first;
l = al[i][j].second;
bad |= fd(k) == fd(l);
jo(k, n + l);
jo(n + k, l);
if (j == sz - 1 || a[l] != a[al[i][j + 1].second]) {
c += bad && !spc[a[l]];
bad = 0;
for (; r <= j; r++) {
for (ii = 0; ii < 2; ii++) {
un();
}
}
}
}
z += sm - c;
sm++;
}
}
printf("%lld\n", z);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 44721 + 5;
bool notPri[N];
int pri[N];
void Init() {
for (int i = 2; i < N; i++) {
if (!notPri[i]) pri[++pri[0]] = i;
for (int j = 1; j <= pri[0] && i * pri[j] < N; j++) {
notPri[i * pri[j]] = 1;
if (i % pri[j] == 0) break;
}
}
}
void ExGCD(long long a, long long b, long long &x, long long &y) {
if (!b)
x = 1, y = 0;
else
ExGCD(b, a % b, y, x), y -= x * (a / b);
}
int main() {
Init();
int n;
cin >> n;
vector<int> fac;
int x = n;
for (int i = 1; i <= pri[0] && pri[i] * pri[i] <= x; i++) {
if (x % pri[i] == 0) {
fac.push_back(pri[i]);
while (x % pri[i] == 0) x /= pri[i];
}
}
if (x > 1) fac.push_back(x);
if (fac.size() < 2)
cout << "NO";
else {
cout << "YES\n2\n";
long long a = fac[0], b = fac[1], x, y;
ExGCD(a, b, x, y);
x *= n - 1, y *= n - 1;
if (y <= 0) {
long long t = -y / a;
x -= t * b;
y += a * t;
while (y <= 0) x -= b, y += a;
}
if (x <= 0) {
long long t = -x / b;
x += t * b;
y -= a * t;
while (x <= 0) x += b, y -= a;
}
cout << x << ' ' << n / a << endl;
cout << y << ' ' << n / b << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000500000;
struct node {
int l, r, x;
bool operator<(const node &p) const { return l > p.l; }
} a[300100];
int n, m, k;
struct NODE {
int val;
NODE() { val = inf; }
int ls, rs;
} tr[10000000];
int tot = 0, rt[300100];
inline void pushup(int p) {
tr[p].val = max(tr[tr[p].ls].val, tr[tr[p].rs].val);
}
inline void insert(int &p, int la, int l, int r, int kkk, int v) {
if (p == 0) p = ++tot;
if (l == r) {
tr[p].val = min(tr[la].val, v);
return;
}
int mid = (l + r) >> 1;
if (kkk <= mid)
insert(tr[p].ls, tr[la].ls, l, mid, kkk, v), tr[p].rs = tr[la].rs;
else
insert(tr[p].rs, tr[la].rs, mid + 1, r, kkk, v), tr[p].ls = tr[la].ls;
pushup(p);
}
inline int query(int p, int l, int r, int ql, int qr) {
if (p == 0) return inf;
if (ql <= l && qr >= r) return tr[p].val;
int mid = (l + r) >> 1, ans = 0;
if (ql <= mid) ans = max(ans, query(tr[p].ls, l, mid, ql, qr));
if (qr > mid) ans = max(ans, query(tr[p].rs, mid + 1, r, ql, qr));
return ans;
}
inline void init() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= k; i++) scanf("%d%d%d", &a[i].l, &a[i].r, &a[i].x);
sort(a + 1, a + k + 1);
for (int i = 1; i <= k; i++) insert(rt[i], rt[i - 1], 1, n, a[i].x, a[i].r);
}
inline bool getquery(int aa, int bb, int x, int y) {
int l = 1, r = k, ans = 0;
while (l <= r) {
int mid = (l + r) >> 1;
if (a[mid].l >= x)
ans = max(ans, mid), l = mid + 1;
else
r = mid - 1;
}
if (ans == 0) return 0;
return query(rt[ans], 1, n, aa, bb) <= y;
}
int main() {
init();
while (m--) {
int a, b, x, y;
scanf("%d%d%d%d", &a, &b, &x, &y);
puts(getquery(a, b, x, y) ? "yes" : "no");
fflush(stdout);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using vint = vector<int>;
using pint = pair<int, int>;
using vpint = vector<pint>;
template <typename A, typename B>
inline void chmin(A &a, B b) {
if (a > b) a = b;
}
template <typename A, typename B>
inline void chmax(A &a, B b) {
if (a < b) a = b;
}
template <class A, class B>
ostream &operator<<(ostream &ost, const pair<A, B> &p) {
ost << "{" << p.first << "," << p.second << "}";
return ost;
}
template <class T>
ostream &operator<<(ostream &ost, const vector<T> &v) {
ost << "{";
for (int i = 0; i < v.size(); i++) {
if (i) ost << ",";
ost << v[i];
}
ost << "}";
return ost;
}
struct Node {
int mi, ma, dep;
int lopt, ropt;
int opt;
Node(char c) {
if (c == '(') {
mi = 0;
ma = 1;
dep = 1;
lopt = 0;
ropt = 1;
opt = 1;
} else {
mi = -1;
ma = 0;
dep = -1;
lopt = 2;
ropt = 0;
opt = 1;
}
}
Node() { mi = ma = dep = lopt = ropt = opt = 0; }
};
auto ff = [](Node a, Node b) -> Node {
b.mi += a.dep;
b.ma += a.dep;
b.dep += a.dep;
b.lopt -= a.dep;
b.ropt -= a.dep;
Node c;
c.mi = min(a.mi, b.mi);
c.ma = max(a.ma, b.ma);
c.dep = b.dep;
c.lopt = max(a.lopt, max(b.lopt, a.ma - 2 * b.mi));
c.ropt = max(a.ropt, max(b.ropt, b.ma - 2 * a.mi));
c.opt = max(a.opt, max(b.opt, max(a.lopt + b.ma, b.ropt + a.ma)));
return c;
};
template <class T, class F>
struct SegmentTree {
const F f;
const T ti;
vector<T> dat;
int32_t sz;
SegmentTree(const T &ti, const F &f) : ti(ti), f(f) {}
void build(const vector<T> &v) {
assert(v.size());
sz = 1;
while (sz < v.size()) sz <<= 1;
dat.resize(sz << 1, ti);
for (int32_t i = 0; i < v.size(); i++) dat[sz - 1 + i] = v[i];
for (int32_t i = sz - 2; i >= 0; i--)
dat[i] = f(dat[i * 2 + 1], dat[i * 2 + 2]);
}
inline void update(int32_t k, const T &x) {
k += sz - 1;
dat[k] = x;
while (k) {
k = (k - 1) >> 1;
dat[k] = f(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
inline void add(int32_t k, const T &x) {
k += sz - 1;
dat[k] = f(dat[k], x);
while (k) {
k = (k - 1) >> 1;
dat[k] = f(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
inline T query(int32_t a, int32_t b) { return query(a, b, 0, 0, sz); }
T query(int32_t a, int32_t b, int32_t k, int32_t l, int32_t r) {
if (r <= a || b <= l) return ti;
if (a <= l && r <= b) return dat[k];
return f(query(a, b, k * 2 + 1, l, (l + r) >> 1),
query(a, b, k * 2 + 2, (l + r) >> 1, r));
}
};
SegmentTree<Node, decltype(ff)> seg(Node(), ff);
char buf[222222];
signed main() {
int N, Q;
scanf("%d%d", &N, &Q);
string S;
scanf("%s", buf);
S = buf;
vector<Node> ini;
for (auto c : S) ini.emplace_back(c);
seg.build(ini);
printf("%d\n", seg.query(0, S.size()).opt);
while (Q--) {
int a, b;
scanf("%d%d", &a, &b);
a--;
b--;
swap(S[a], S[b]);
seg.update(a, Node(S[a]));
seg.update(b, Node(S[b]));
printf("%d\n", seg.query(0, S.size()).opt);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long x;
long long ans[10000][2], tot;
int main() {
cin >> x;
for (int i = 1; i <= x; i++) {
long long t = x + (long long)(i - 1) * i / 2 * i -
(long long)(i - 1) * (i) * (2 * i - 1) / 6;
long long tt = (long long)i * i - (long long)(i - 1) * i / 2;
long long fuck = t / tt;
if (fuck < i) break;
if (fuck * tt == t) {
tot++;
ans[tot][0] = i;
ans[tot][1] = fuck;
}
}
int anss = tot * 2;
if (ans[tot][0] == ans[tot][1]) anss--;
cout << anss << endl;
for (int i = 1; i <= tot; i++) printf("%I64d %I64d\n", ans[i][0], ans[i][1]);
if (ans[tot][0] == ans[tot][1]) tot--;
for (int i = tot; i >= 1; i--) printf("%I64d %I64d\n", ans[i][1], ans[i][0]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char c = getchar();
bool f = 0;
for (; c > '9' || c < '0'; f = c == '-', c = getchar())
;
for (; c >= '0' && c <= '9'; x = (x << 1) + (x << 3) + c - '0', c = getchar())
;
return f ? -x : x;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + 48);
}
template <class T>
bool Enlarge(T &a, T const &b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
bool Reduce(T &a, T const &b) {
return a > b ? a = b, 1 : 0;
}
long long n, l, r, k, m;
void work1() {
long long x = n - m;
for (long long i = 2 * n; i >= n; --i) {
long long t = (k - 1) % i + 1;
if (m <= t && t <= m * 2)
if ((t - x <= i && i <= 2 * x + t) ||
((t + 1 - x <= i && i <= 2 * x + t + 1))) {
write(i - n);
puts("");
return;
}
}
puts("-1");
}
void work2() {
long long res = -n, x = n - m;
if (m <= k && k <= 2 * m) {
write(min(k - m + 1 + x, n));
puts("");
return;
}
for (long long i = 1, lim = k / n; i <= lim; ++i) {
long long L = (k - 2 * m + i - 1) / i, R = (k - m) / i;
Enlarge(L, n);
Reduce(R, 2 * n);
Enlarge(L, (k - x + i) / (i + 1));
Reduce(R, (2 * x + k + 1) / (i + 1));
if (L <= R) Enlarge(res, R);
}
write(res < 0 ? -1 : res - n), puts("");
}
int main() {
n = read(), l = read(), r = read(), k = read();
m = r - l + 1;
if (m <= 0) m += n;
if (n <= k / n)
work1();
else
work2();
}
| 4 |
#include <bits/stdc++.h>
char a[300010];
std::vector<int> num;
int main() {
int s;
scanf("%d", &s);
scanf("%s", a);
a[s] = 'z';
int cnt = 0;
for (int k = 0; k < s; k++) {
cnt++;
if (a[k] != a[k + 1]) {
num.push_back(cnt);
cnt = 0;
}
}
long long ans = 0;
ans = (long long)s * (long long)(s - 1) / 2;
int sz = num.size();
for (int k = 0; k < sz - 1; k++) {
ans -= (num[k] + num[k + 1] - 1);
}
printf("%lld\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> g;
vector<long long> s;
vector<long long> p;
vector<long long> a;
bool govno = false;
void dfs(long long v) {
if (s[v] == -1) {
long long my_min = 1e9 + 10;
for (long long it : g[v]) my_min = min(my_min, s[it] - s[p[v]]);
if (my_min == 1e9 + 10)
a[v] = 0;
else
a[v] = my_min;
s[v] = a[v] + s[p[v]];
} else {
if (v != 0 && s[v] < s[p[p[v]]]) govno = true;
if (v != 0)
a[v] = s[v] - s[p[v]];
else
a[v] = s[v];
}
for (long long it : g[v]) dfs(it);
}
int main() {
long long n;
cin >> n;
g.assign(n, vector<long long>(0));
p.resize(n);
a.resize(n);
s.resize(n);
for (long long i = 1; i < n; ++i) {
int x;
cin >> x;
x--;
g[x].push_back(i);
p[i] = x;
}
for (long long i = 0; i < n; ++i) cin >> s[i];
dfs(0);
long long ans = 0;
for (int i = 0; i < n; ++i) ans += a[i];
if (govno)
cout << -1 << '\n';
else
cout << ans << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
long long n, a[400000], dbd;
cin >> n;
map<int, int> maps;
set<int> aibe;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i == 1) {
dbd = gcd(a[i], a[i - 1]);
} else if (i > 1) {
dbd = gcd(dbd, a[i]);
}
}
if (n == 1) dbd = a[0];
long long dal[1000], ind = 0, kiek = 0;
long long kur = dbd;
if (dbd % 2 == 0) {
kiek++;
dbd /= 2;
while (dbd % 2 == 0) {
dbd /= 2;
kiek++;
}
dal[ind++] = kiek;
}
kur = dbd;
long long da = 3;
while (dbd != 1 && da < sqrt(dbd)) {
kiek = 0;
if (dbd % da == 0) {
kiek++;
dbd /= da;
while (dbd % da == 0) {
dbd /= da;
kiek++;
}
dal[ind++] = kiek;
}
da += 2;
}
if (dbd != 1) {
if (da * da == dbd)
dal[ind++] = 2;
else
dal[ind++] = 1;
dbd = 1;
}
long long san = 1;
for (int i = 0; i < ind; i++) {
san *= dal[i] + 1;
}
cout << san;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int MAX(int a, int b) { return (a > b) ? a : b; }
int GCD(int a, int b) { return b ? GCD(b, a % b) : a; }
void swop(int &a, int &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
int main() {
int n, i;
unsigned long long int rez = 1;
scanf("%d", &n);
for (i = 1; i < n; i++) {
rez = (rez * 3) % 1000003;
}
cout << rez;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[300005];
long long mod = 998244353;
long long qpow(long long a1, long long b) {
if (b == 0) return 1;
long long c = qpow(a1, b / 2);
if (b % 2 == 0)
return c * c % mod;
else
return c * c % mod * a1 % mod;
}
int main(void) {
scanf("%lld", &n);
for (long long i = 1; i <= n * 2; i++) scanf("%lld", &a[i]);
sort(a + 1, a + n * 2 + 1);
long long sum = 0;
for (long long i = 1; i <= n; i++) {
sum = sum + a[i + n] - a[i];
}
sum %= mod;
long long n1 = 1, n2 = 1;
for (long long i = 1; i <= n; i++) {
n1 = n1 * i % mod;
n2 = n2 * i % mod * (i + n) % mod;
}
n1 = n1 * n1 % mod;
long long ccc = n2 * qpow(n1, mod - 2) % mod;
long long ans = ccc * sum % mod;
printf("%lld\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int oo = 0x3f3f3f3f;
const long long ooo = 9223372036854775807ll;
const int _cnt = 1000 * 1000 + 7;
const int _p = 1000 * 1000 * 1000 + 7;
const int N = 100005;
const double PI = acos(-1.0);
const double eps = 1e-9;
int o(int x) { return x % _p; }
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
void file_put() {
freopen("filename.in", "r", stdin);
freopen("filename.out", "w", stdout);
}
int n, m;
string s, t;
char p[15], q[105];
map<string, string> M;
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); ++i) {
scanf("%s%s", p, q);
s = p, t = q, M[t] = s;
}
for (int i = (1); i <= (m); ++i) {
scanf("%s%s", p, q);
t = q, t.erase(--t.end());
printf("%s %s #%s\n", p, q, M[t].c_str());
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char* x) { cerr << '\"' << x << '\"'; }
void __print(const string& x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V>& x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T& x) {
int f = 0;
cerr << '{';
for (auto& i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
template <typename T>
istream& operator>>(istream& stream, vector<T>& v) {
for (T& x : v) stream >> x;
return stream;
}
const long long inf = 1e18;
void solve() {
long long q;
cin >> q;
const long long mxn = 5e5 + 1;
vector<list<long long>> pos(mxn + 1);
long long s = 0;
for (long long i = 0; i < q; i++) {
long long t;
cin >> t;
if (t == 1) {
s++;
long long x;
cin >> x;
pos[x].push_back(s);
} else {
long long x, y;
cin >> x >> y;
pos[y].splice(pos[y].end(), pos[x]);
}
}
vector<long long> a(s + 1);
for (long long i = 1; i < mxn; i++)
for (long long j : pos[i]) a[j] = i;
for (long long i = 1; i <= s; i++) cout << a[i] << " ";
cout << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5007;
const long long inf = 1e18;
int n, s, e;
int x[MAX], a[MAX], b[MAX], c[MAX], d[MAX];
long long dp[MAX][MAX];
int main() {
ios ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < MAX; ++i)
for (int j = 0; j < MAX; ++j) dp[i][j] = inf;
cin >> n >> s >> e;
for (int i = 1; i <= n; ++i) cin >> x[i];
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) cin >> b[i];
for (int i = 1; i <= n; ++i) cin >> c[i];
for (int i = 1; i <= n; ++i) cin >> d[i];
if (s == 1)
dp[1][1] = d[1] - x[1];
else if (e == 1)
dp[1][1] = b[1] - x[1];
else
dp[1][1] = b[1] + d[1] - 2 * x[1];
for (int i = 2; i <= n; ++i) {
for (int j = 1; j <= n; ++j) {
if (dp[i - 1][j] == inf) continue;
if (i == s) {
dp[i][j + 1] = min(dp[i][j + 1], dp[i - 1][j] + d[i] - x[i]);
if (i >= e && j == 1 && i != n)
;
else
dp[i][j] = min(dp[i][j], dp[i - 1][j] + c[i] + x[i]);
} else if (i == e) {
dp[i][j + 1] = min(dp[i][j + 1], dp[i - 1][j] + b[i] - x[i]);
if (i >= s && j == 1 && i != n)
;
else
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[i] + x[i]);
} else {
dp[i][j + 1] = min(dp[i][j + 1], dp[i - 1][j] + b[i] + d[i] - 2 * x[i]);
if (i >= s && j == 1 && i != n)
;
else
dp[i][j] = min(dp[i][j], dp[i - 1][j] + b[i] + c[i]);
if (i >= e && j == 1 && i != n)
;
else
dp[i][j] = min(dp[i][j], dp[i - 1][j] + a[i] + d[i]);
if (i >= s && i >= e && j == 2 && i != n)
;
else if (j >= 2)
dp[i][j - 1] =
min(dp[i][j - 1], dp[i - 1][j] + a[i] + c[i] + 2 * x[i]);
}
}
}
cout << dp[n][1] << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 2e5 + 5;
int dp[mx][26], id[mx][26];
int main() {
string s;
cin >> s;
int n = s.size();
for (int i = 0; i <= n; i++)
for (int j = 0; j < 26; j++) dp[i][j] = 2 * n + 1;
for (int i = 0; i < 26; i++) dp[0][i] = 0;
for (int i = 1; i <= n; i++) {
int cur = s[i - 1] - 'a';
for (int last = 0; last < 26; last++) {
for (int newCur = 0; newCur < 26; newCur++) {
if (newCur == last) continue;
if (dp[i - 1][last] + (newCur != cur) < dp[i][newCur]) {
dp[i][newCur] = dp[i - 1][last] + (newCur != cur);
id[i][newCur] = last;
}
}
}
}
int ind = int(min_element(dp[n], dp[n] + 26) - dp[n]);
char ans[n + 1];
for (int i = n; i > 0; ind = id[i][ind], i--) {
ans[i - 1] = char('a' + ind);
}
ans[n] = '\0';
puts(ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
const int INF = 1000000000;
int N, M, num;
struct Edge {
int u, v, type, next, f, id;
} edge[maxn * 2];
int dis[maxn], head[maxn];
int pre[maxn], cnt[maxn];
int vis[maxn], id[maxn];
void init() {
num = 0;
memset(head, -1, sizeof(head));
memset(cnt, 0, sizeof(cnt));
memset(pre, -1, sizeof(pre));
}
void add_edge(int u, int v, int type, int id) {
edge[num].v = v;
edge[num].u = u;
edge[num].next = head[u];
edge[num].type = type;
edge[num].f = 1;
edge[num].id = id;
head[u] = num++;
}
void SPFA(int s, int t) {
for (int i = 0; i <= N; i++) {
dis[i] = INF;
vis[i] = 0;
}
queue<int> q;
q.push(s);
vis[s] = 1;
dis[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
vis[u] = 0;
for (int i = head[u]; i != -1; i = edge[i].next) {
int v = edge[i].v, w = edge[i].f;
if ((dis[v] > dis[u] + w) ||
(dis[v] == dis[u] + 1 && cnt[v] < cnt[u] + (edge[i].type))) {
dis[v] = dis[u] + w;
pre[v] = u;
id[v] = edge[i].id;
cnt[v] = cnt[u];
cnt[v] += edge[i].type;
if (!vis[v]) {
q.push(v);
vis[v] = 1;
}
}
}
}
}
int vis_edge[maxn * 2];
int main() {
while (scanf("%d%d", &N, &M) != EOF) {
init();
int u, v, type;
for (int i = 1; i <= M; i++) {
scanf("%d%d%d", &u, &v, &type);
add_edge(u, v, type, i);
add_edge(v, u, type, i);
}
memset(id, 0, sizeof(id));
SPFA(1, N);
memset(vis, 0, sizeof(vis));
memset(vis_edge, 0, sizeof(vis_edge));
u = N;
while (pre[u] != -1) {
vis_edge[id[u]] = 1;
u = pre[u];
}
int ans = 0;
for (int u = 1; u <= N; ++u) {
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (!vis_edge[edge[i].id] && edge[i].type && !vis[edge[i].id]) {
++ans;
vis[edge[i].id] = 1;
} else if (vis_edge[edge[i].id] && !edge[i].type && !vis[edge[i].id]) {
++ans;
vis[edge[i].id] = 1;
}
}
}
memset(vis, 0, sizeof(vis));
printf("%d\n", ans);
for (int u = 1; u <= N; ++u) {
for (int i = head[u]; ~i; i = edge[i].next) {
int v = edge[i].v;
if (vis[edge[i].id]) {
continue;
}
if (!vis_edge[edge[i].id] && edge[i].type) {
printf("%d %d 0\n", u, v);
vis[edge[i].id] = 1;
} else if (vis_edge[edge[i].id] && !edge[i].type) {
printf("%d %d 1\n", u, v);
vis[edge[i].id] = 1;
}
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXCELLS = 300000;
const char CHARS[4] = {'A', 'C', 'G', 'T'};
int h, w;
char s[MAXCELLS + 1];
char ans[MAXCELLS + 1];
char t[MAXCELLS + 1];
void solve() {
int best = INT_MAX;
for (int i = (0); i < (h * w); ++i) ans[i] = '?';
t[h * w] = ans[h * w] = '\0';
for (int a = (0); a < (4); ++a)
for (int b = (a + 1); b < (4); ++b)
for (int c = (0); c < (4); ++c)
for (int d = (c + 1); d < (4); ++d) {
if (c == a || c == b || d == a || d == b) continue;
for (int x = (0); x < (h); ++x) {
int u = x % 2 == 0 ? a : c, v = x % 2 == 0 ? b : d;
int match[2];
match[0] = match[1] = 0;
for (int y = (0); y < (w); ++y)
if (s[x * w + y] == CHARS[u])
++match[y % 2];
else if (s[x * w + y] == CHARS[v])
++match[1 - y % 2];
if (match[1] > match[0]) swap(u, v);
for (int y = (0); y < (w); ++y)
t[x * w + y] = y % 2 == 0 ? CHARS[u] : CHARS[v];
}
{
int cur = 0;
for (int i = (0); i < (h * w); ++i)
if (s[i] != t[i]) ++cur;
if (cur < best) {
best = cur;
for (int i = (0); i < (h * w); ++i) ans[i] = t[i];
}
}
for (int y = (0); y < (w); ++y) {
int u = y % 2 == 0 ? a : c, v = y % 2 == 0 ? b : d;
int match[2];
match[0] = match[1] = 0;
for (int x = (0); x < (h); ++x)
if (s[x * w + y] == CHARS[u])
++match[x % 2];
else if (s[x * w + y] == CHARS[v])
++match[1 - x % 2];
if (match[1] > match[0]) swap(u, v);
for (int x = (0); x < (h); ++x)
t[x * w + y] = x % 2 == 0 ? CHARS[u] : CHARS[v];
}
{
int cur = 0;
for (int i = (0); i < (h * w); ++i)
if (s[i] != t[i]) ++cur;
if (cur < best) {
best = cur;
for (int i = (0); i < (h * w); ++i) ans[i] = t[i];
}
}
}
}
void run() {
scanf("%d%d", &h, &w);
for (int x = (0); x < (h); ++x) scanf("%s", s + x * w);
solve();
for (int x = (0); x < (h); ++x) printf("%.*s\n", w, ans + x * w);
}
int main() {
run();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
long long F[202020];
long long D[202020];
int N;
vector<int> adj[202020];
long long ans;
void dfs(int now, int par) {
if (adj[now].size() == 1 && now != 1) {
D[now] = 1;
return;
}
for (int i : adj[now]) {
if (i == par) continue;
dfs(i, now);
}
if (now == 1) {
ans = F[(int)adj[now].size()] * N % MOD;
for (int i : adj[now]) ans = ans * D[i] % MOD;
} else {
D[now] = 1;
D[now] = D[now] * F[(int)adj[now].size() - 1] % MOD;
D[now] = D[now] * (int)adj[now].size() % MOD;
for (int i : adj[now])
if (i != par) D[now] = D[now] * D[i] % MOD;
}
}
int main() {
F[0] = 1;
for (int i = 1; i <= 200000; i++) F[i] = F[i - 1] * i % MOD;
scanf("%d", &N);
for (int i = 1; i < N; i++) {
int a, b;
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
dfs(1, 0);
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int mark[100000];
long long prime[10000], k, mn, mx, N;
vector<pair<long long, long long> > a;
void sieve() {
for (long long i = 2; i < 1000; i++)
if (!mark[i])
for (long long j = i * i; j < 100000; j += i) mark[j] = 1;
prime[k++] = 2;
for (long long i = 3; i < 100000; i += 2)
if (!mark[i]) prime[k++] = i;
}
long long power(long long a, long long b) {
long long ret = 1;
while (b--) ret *= a;
return ret;
}
void f(int pos, long long A, long long B, long long C) {
if (pos == a.size()) {
mn = min(mn, (A + 1) * (B + 2) * (C + 2));
mx = max(mx, (A + 1) * (B + 2) * (C + 2));
return;
}
for (int i = 0; i <= a[pos].second; i++)
for (int j = 0; i + j <= a[pos].second; j++)
f(pos + 1, A * power(a[pos].first, i), B * power(a[pos].first, j),
C * power(a[pos].first, a[pos].second - i - j));
}
int main() {
sieve();
long long n;
cin >> n;
N = n;
for (long long i = 0; i < k && prime[i] * prime[i] <= n; i++) {
long long cc = 0, p = 1;
while (n % prime[i] == 0) {
p = prime[i], cc++;
n /= p;
}
if (cc) a.push_back(pair<long long, long long>(p, cc));
}
if (n > 1) a.push_back(pair<long long, long long>(n, 1));
mx = 0;
mn = (1LL << 60);
f(0, 1, 1, 1);
cout << mn - N << " " << mx - N << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
struct Edge {
double x;
int i;
} p[maxn];
int n, k;
double tmp, sum, gl, gr;
bool cmp(const Edge &a, const Edge &b) { return a.x < b.x; }
void init() {
tmp = 0;
sum = 0;
gl = 0;
gr = 0;
sort(p, p + n, cmp);
for (int i = 1; i < k; i++) {
double len = p[i].x - p[i - 1].x;
sum += len;
tmp += len * i * (k - i);
gl += len * (k - i);
gr += len * i;
}
}
int gao() {
double ans = tmp;
int ansi = 0;
for (int i = 1; i + k <= n; i++) {
double lenl = p[i].x - p[i - 1].x;
double lenr = p[i + k - 1].x - p[i + k - 2].x;
sum -= lenl;
tmp -= gl;
gl -= lenl * (k - 1);
gl += sum + lenr;
gr -= sum + lenl;
gr += lenr * (k - 1);
tmp += gr;
sum += lenr;
if (tmp < ans) {
ans = tmp;
ansi = i;
}
}
return ansi;
}
int main() {
while (~scanf("%d", &n)) {
for (int i = 0; i < n; i++) {
scanf("%lf", &p[i].x);
p[i].i = i + 1;
}
scanf("%d", &k);
init();
int x = gao();
for (int i = x, j = 0; j < k; j++, i++) {
printf("%d", p[i].i);
putchar(j == k - 1 ? 10 : 32);
}
}
return 0;
}
| 5 |
#include<iostream>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
int N;
cin>>N;
int tmp_s,tmp_e;
bool flag=false;
for(int i=0;i<N;i++){
cin>>tmp_s>>tmp_e;
if(a<tmp_e&&b>tmp_s)flag=true;
else if(a==tmp_e&&b==tmp_s)flag=true;
}
cout<<flag<<endl;
}
| 0 |
#include<cstdio>
#include<algorithm>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
int main(){
int h, w; scanf("%d %d", &h, &w);
int c[10][10];
rep(i, 10) rep(j, 10) scanf("%d", &c[i][j]);
rep(k, 10) rep(i, 10) rep(j, 10) c[i][j] = min(c[i][j], c[i][k] + c[k][j]);
int res = 0;
rep(i, h) rep(j, w){
int a; scanf("%d", &a);
if(a == -1) continue;
res += c[a][1];
}
printf("%d\n", res);
return 0;
}
| 0 |
#include<iostream>
using namespace std;
//Strongly Connected Components
#include<vector>
struct SCC{
int n;
vector<int>comp,order;
vector<bool>used;
vector<vector<int> >G,RG;
SCC(int _n=0):n(_n),comp(_n,-1),used(_n,false),G(_n),RG(_n){}
void add_edge(int from,int to)
{
G[from].push_back(to);
RG[to].push_back(from);
}
void copy(const vector<vector<int> >&H)
{
for(int i=0;i<H.size();i++)
{
for(int j=0;j<H[i].size();j++)
{
G[i].push_back(H[i][j]);
RG[H[i][j]].push_back(i);
}
}
}
int operator[](int u)const{return comp[u];}
void dfs(int u)
{
used[u]=true;
for(int i=0;i<G[u].size();i++)if(!used[G[u][i]])dfs(G[u][i]);
order.push_back(u);
}
void rdfs(int u,int cnt)
{
comp[u]=cnt;
for(int i=0;i<RG[u].size();i++)if(comp[RG[u][i]]==-1)rdfs(RG[u][i],cnt);
}
int build()
{
for(int i=0;i<n;i++)if(!used[i])dfs(i);
int cnt=0;
for(int i=n-1;i>=0;i--)if(comp[order[i]]==-1)rdfs(order[i],cnt++);
return cnt;
}
int build(vector<vector<int> >&H)
{
int ret=build();
H.assign(ret,vector<int>());
for(int i=0;i<n;i++)
{
for(int j=0;j<G[i].size();j++)
{
if(comp[i]!=comp[G[i][j]])
H[comp[i]].push_back(comp[G[i][j]]);
}
}
return ret;
}
};
int N,M;
int main()
{
cin>>N>>M;
SCC P(N);
for(int i=0;i<M;i++)
{
int u,v;cin>>u>>v;
P.add_edge(u,v);
}
int K=P.build();
cout<<K<<endl;
vector<vector<int> >ans(K);
for(int i=0;i<N;i++)ans[P[i]].push_back(i);
for(int i=0;i<K;i++)
{
cout<<ans[i].size();
for(int v:ans[i])cout<<" "<<v;
cout<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1E5 + 10;
int s, a[maxn], n, d[maxn];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
s = a[n];
d[n] = 1;
for (int i = n - 1; i > 0; --i) {
if (s >= a[i])
s -= a[i];
else {
s = a[i] - s;
d[i] = 1;
}
}
if (s < 0) {
int x = 0;
for (int i = 1; i <= n; ++i) {
x = abs(d[i] - x);
if (x)
putchar('-');
else
putchar('+');
}
} else {
int x = 0;
for (int i = 1; i <= n; ++i) {
x = abs(d[i] - x);
if (x)
putchar('+');
else
putchar('-');
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 2 * acos(0.0);
const int maxn = 3e5 + 10;
const int inf = 2e9;
const int maxm = 1e4 + 10;
const int mod = 998244353;
const int base = 5e6 + 10;
int dp[maxn][21];
int n, m;
int pre[21];
int a[maxn];
void init() {
for (int i = 0; i < 20; i++) {
if ((a[1] >> i) & 1) {
dp[1][i] = 1;
pre[i] = 1;
}
}
for (int i = 2; i <= n; i++) {
for (int j = 0; j < 20; j++) {
if ((a[i] >> j) & 1) {
dp[i][j] = i;
for (int k = 0; k < 20; k++) {
dp[i][k] = max(dp[i][k], dp[pre[j]][k]);
}
pre[j] = i;
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
init();
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
int flag = 0;
for (int j = 0; j < 20; j++) {
if (((a[x] >> j) & 1) && dp[y][j] >= x) {
flag = 1;
break;
}
}
if (flag)
printf("Shi\n");
else
printf("Fou\n");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> in;
vector<int> vis;
map<int, vector<int>> hmap;
void bfs(int v) {
queue<int> q;
vis[v] = 1;
q.push(v);
while (!q.empty()) {
int p = q.front();
q.pop();
for (auto i : hmap[p]) {
if (vis[i] == -1) {
q.push(i);
vis[i] = 1;
cout << p + 1 << " " << i + 1 << endl;
}
}
}
}
void solve() {
int n, m;
scanf("%d", &n);
scanf("%d", &m);
vis = vector<int>(n, -1);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d", &a);
scanf("%d", &b);
a--, b--;
hmap[a].push_back(b);
hmap[b].push_back(a);
in[a]++;
in[b]++;
}
int mxin = -1, mxdg = -1;
for (int i = 0; i < n; i++) {
if (in[i] > mxdg) {
mxin = i;
mxdg = in[i];
}
}
bfs(mxin);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long a, b, c;
scanf("%lld %lld %lld", &a, &b, &c);
printf("%lld %lld\n",min(min(a, b), c), max(max(a, b), c));
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << 6 * n * (n - 1) + 1;
return 0;
}
| 2 |
#include<iostream>
using namespace std;
int main(){
int s[100]={0,1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1,51};
int a;
cin>>a;
cout<<s[a]<<endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n, a, b;
cin >> n >> a >> b;
int t;
int count = 0;
for(int i = 0; i < n; i++){
cin >> t;
if(t >= a && t < b){
continue;
}else{
count++;
}
}
cout << count << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> v[((int)(2e5 + 5))];
long long int a[((int)(2e5 + 5))], x[((int)(2e5 + 5))], b[((int)(2e5 + 5))],
bmx[((int)(2e5 + 5))];
int main() {
long long int n, t, i, j;
scanf("%lld %lld", &n, &t);
for (i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
}
for (i = 1; i <= n; i++) {
scanf("%lld", &x[i]);
v[x[i]].push_back(i);
}
for (i = 1; i <= n; i++) {
for (j = 0; j < v[i].size(); j++) b[i] = max(b[i], a[v[i][j]] + t);
}
long long int cnt = 0;
long long int mx = ((long long int)(2000000000000000001));
for (i = n; i > 0; i--) {
if (cnt < n - i) {
printf("No\n");
return 0;
}
if (mx != ((long long int)(2000000000000000001)) && mx + t <= b[i]) {
printf("No\n");
return 0;
}
if (v[i].size() == 0) {
bmx[i] = bmx[i + 1] - 1;
continue;
}
if (mx != ((long long int)(2000000000000000001)))
bmx[i] = mx + t - 1;
else
bmx[i] = 3000000000000000000;
cnt += (long long int)v[i].size();
for (j = 0; j < v[i].size(); j++) {
mx = min(mx, a[v[i][j]]);
}
}
if (bmx[1] < 1) {
printf("No\n");
return 0;
}
for (i = n; i > 0; i--) {
cnt = b[i];
b[i] = bmx[i];
if (i < n) b[i] = min(b[i], b[i + 1] - 1);
if (b[i] < cnt) {
printf("No\n");
return 0;
}
}
long long int r = n;
long long int l = (long long int)v[n].size() - 1;
for (i = n; i > 0; i--) {
if (v[i].size() > 0) sort(v[i].begin(), v[i].end());
}
for (i = n; i > 0; i--) {
if (a[v[r][l]] + t > b[i]) {
printf("No\n");
return 0;
}
if (v[r].size() - 1 > l && a[v[r][l + 1]] + t > b[i]) {
printf("No\n");
return 0;
}
l--;
if (l < 0) {
r--;
while (r >= 0 && (long long int)v[r].size() == 0) r--;
if (r >= 0) l = (long long int)v[r].size() - 1;
}
}
printf("Yes\n");
for (i = 1; i <= n; i++) printf("%lld ", b[i]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
string s;
cin >> n >> s;
int tx, ty;
cin >> tx >> ty;
vector<int> x(n + 1), y(n + 1);
for (int i = 0; i < n; i++) {
x[i + 1] = x[i];
y[i + 1] = y[i];
switch (s[i]) {
case 'U': {
y[i + 1]++;
break;
}
case 'D': {
y[i + 1]--;
break;
}
case 'L': {
x[i + 1]--;
break;
}
case 'R': {
x[i + 1]++;
break;
}
}
}
int lo = 0, hi = n + 1;
if (abs(tx) + abs(ty) > n || (abs(tx) + abs(ty)) % 2 != n % 2) {
cout << -1 << endl;
return 0;
}
auto can = [&](int len) {
for (int i = len; i <= n; i++) {
int dx = tx - (x[n] - (x[i] - x[i - len]));
int dy = ty - (y[n] - (y[i] - y[i - len]));
if (abs(dx) + abs(dy) <= len) {
return true;
}
}
return false;
};
while (lo < hi) {
int mid = lo + (hi - lo) / 2;
if (can(mid)) {
hi = mid;
} else {
lo = mid + 1;
}
}
cout << hi << endl;
}
| 3 |
#include<cstdio>
#include<vector>
#define rep(i,l,r) for (int i=(l); i<=(r); i++)
using namespace std;
int main(){
int n,m; scanf("%d%d",&n,&m);
vector<vector<int> > e(n);
for(int t=0;t<m;t++){
int a,b; scanf("%d%d",&a,&b); a--,b--;
e[a].push_back(b);
e[b].push_back(a);
}
int r6=0; vector<int> r4;
rep(i,0,n-1){
if(e[i].size()%2!=0){ puts("No"); return 0; }
if(e[i].size()>=6) r6++;
else if(e[i].size()==4) r4.push_back(i);
}
if(r6>0 || r4.size()>=3) puts("Yes");
else if(r4.size()<2) puts("No");
else{
bool F=0;
rep(x,0,3){
int i=e[r4[0]][x],p=r4[0];
while(e[i].size()==2){ int temp=e[i][0]+e[i][1]-p; p=i; i=temp; }
if(i==r4[0]) F=1;
}
puts(F?"Yes":"No");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n;
cin >> n;
if (n % 2) {
cout << n / 2;
} else
cout << (n / 2) - 1;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n, m, i, j, aux;
long long soma;
scanf("%d%d", &n, &m);
int numeros[n][m];
soma = 0;
for (i = 0; i < n; i++) {
aux = 0;
for (j = 0; j < m; j++) {
scanf("%d", &numeros[i][j]);
if (numeros[i][j] == 1) {
aux++;
}
}
soma += (1ll << aux) - 1 + (1ll << (m - aux)) - 1;
}
for (j = 0; j < m; j++) {
aux = 0;
for (i = 0; i < n; i++) {
if (numeros[i][j] == 1) {
aux++;
}
}
soma += (1ll << aux) - 1 + (1ll << (n - aux)) - 1;
}
soma -= m * n;
printf("%lld", soma);
return 0;
}
| 2 |
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<vector>
#include<map>
using namespace std;
typedef long long LL;
const int N=1000005;
const int MOD=998244353;
const int inv=499122177;
int add (int x,int y) {x=x+y;return x>=MOD?x-MOD:x;}
int mul (int x,int y) {return (LL)x*y%MOD;}
int dec (int x,int y) {x=x-y;return x<0?x+MOD:x;}
int Pow (int x,LL y)
{
if (y==0) return 1;
if (y==1) return x;
int lalal=Pow(x,y>>1);
lalal=mul(lalal,lalal);
if (y&1) lalal=mul(lalal,x);
return lalal;
}
int n,m;
LL cnt,cnt1;
LL calc (LL x) {return (1+x)*x/2;}
map<int,int> mp[N];
int f[N][2];
int main()
{
scanf("%d%d",&n,&m);
cnt=calc(n-3);int tot=0,sum=0;
for (int u=1;u<=m;u++)
{
int x,y,c;
scanf("%d%d%d",&x,&y,&c);
c++;sum=sum+c;
if (mp[x][y]!=0)
{
if (mp[x][y]!=c) {printf("0\n");return 0;}
continue;
}
mp[x][y]=c;
int id=max(x,y);//对应的格子
int dis=(id-x)+(id-y);
if (dis==0) tot++;
if (dis<=1) continue;
if (dis>2) {cnt--;mp[y][x]=c;}
}
if (n==2)
{
if (m==4)
{
if (sum&1) printf("0\n");
else printf("1\n");
}
else printf("%d",Pow(2,3-m));
return 0;
}
//printf("YES:%lld\n",cnt);
LL cnt1=0;
for (int u=2;u<n;u++)
{
int x=-1,y=-1;
if (mp[u-1][u+1]!=0) x=mp[u-1][u+1]-1;
if (mp[u+1][u-1]!=0) y=mp[u+1][u-1]-1;
if (x==-1&&y==-1) cnt1++;
else if (x!=-1&&y!=-1)
{
if (mp[u][u]==0)mp[u][u]=(x^y)+1;
else if (mp[u][u]!=(x^y)+1) {printf("0\n");return 0;}
}
}
//printf("%lld %lld\n",cnt1,cnt);
f[n][1]=1;f[n][0]=1;
if (mp[n][n]!=0) f[n][2-mp[n][n]]=0;
//printf("YES:%d %d\n",f[n][0],f[n][1]);
for (int u=n-1;u>=1;u--)
{
int x=-1,y=-1;
if (mp[u][u+1]!=0) x=mp[u][u+1]-1;
if (mp[u+1][u]!=0) y=mp[u+1][u]-1;
if (x!=-1&&y!=-1)
{
f[u][x^y]=f[u+1][0];
f[u][x^y^1]=f[u+1][1];
}
else if (x==-1&&y==-1)
{
f[u][0]=mul(add(f[u+1][0],f[u+1][1]),2);
f[u][1]=mul(add(f[u+1][0],f[u+1][1]),2);
}
else
{
f[u][0]=add(f[u+1][0],f[u+1][1]);
f[u][1]=add(f[u+1][0],f[u+1][1]);
}
if (mp[u][u]!=0) f[u][2-mp[u][u]]=0;
//printf("%d %d %d\n",u,f[u][0],f[u][1]);
}
int ans=mul(Pow(2,cnt1+cnt),add(f[1][1],f[1][0]));
printf("%d\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long l, r;
int main() {
scanf("%I64d%I64d", &l, &r);
puts("YES");
for (long long i = l; i <= r; i += 2) printf("%I64d %I64d\n", i, i + 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, x, y, z, l = 0, o = 0, r = 0;
cin >> a >> b >> c >> x >> y >> z;
l = (x > a) ? l + (x - a) : l;
l = (y > b) ? l + (y - b) : l;
l = (z > c) ? l + (z - c) : l;
if (a > x) {
o += (a - x) / 2;
}
if (b > y) {
o += (b - y) / 2;
}
if (c > z) {
o += (c - z) / 2;
}
if (o >= l)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[100];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (a[0] > 15)
cout << 15 << endl;
else
for (int i = 0; i < n; i++) {
if (a[i] - a[i - 1] > 15) {
cout << a[i - 1] + 15 << endl;
break;
} else if (i == n - 1 && a[n - 1] <= 75)
cout << a[i] + 15 << endl;
else if (i == n - 1 && a[n - 1] > 75)
cout << 90 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define mset(a,b) memset(a,b,sizeof a)
#define mcpy(a,b) memcpy(a,b,sizeof b)
#define swap(a,b) a^=b^=a^=b
#define lb(x) ((x)&(-(x)))
#define inf 0x3f3f3f3f
#define N 300010
using namespace std;
typedef long long ll;
int n,head[N],nxt[N],to[N],val[N],cnt;
ll d[N];
inline void add(int a,int b,int c){to[++cnt]=b,val[cnt]=c,nxt[cnt]=head[a],head[a]=cnt;}
inline void dfs(int x,int p){for(int i=head[x];i;i=nxt[i])if(to[i]^p)d[to[i]]=d[x]+val[i],dfs(to[i],x);}
int main(){
cin>>n;
for(int i=1;i<n;i++){
int a,b,c;scanf("%d%d%d",&a,&b,&c);
add(a,b,c),add(b,a,c);
}
int q,k;
cin>>q>>k;
dfs(k,0);
while(q--){
int x,y;scanf("%d%d",&x,&y);
printf("%lld\n",d[x]+d[y]);
}
return 0;
}
| 0 |
#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;
struct Node {
Node *parent, *left, *right;
int key;
};
Node *root, *nil;
void insert(int& a) {
Node *b = (Node*)malloc(sizeof(Node)), *c = root, *d = nil;
b->left = nil;
b->right = nil;
b->key = a;
while (c != nil) {
d = c;
if (b->key < c->key) c = c->left;
else c = c->right;
}
b->parent = d;
if (b->parent == nil) root = b;
else if (b->key < b->parent->key) b->parent->left = b;
else b->parent->right = b;
}
Node* find(int& a) {
Node* b = root;
while (b != nil && a != b->key) {
if (a < b->key) b = b->left;
else b = b->right;
}
return b;
}
Node* getMinimum(Node* a) {
while (a->left != nil) a = a->left;
return a;
}
Node* getSuccessor(Node* a) {
if (a->right != nil) return getMinimum(a->right);
Node* b = a->parent;
while (b != nil && a == b->right) {
a = b;
b = b->parent;
}
return b;
}
void erase(int& a) {
Node *b = find(a), *c, *d;
if (b->left == nil || b->right == nil) c = b;
else c = getSuccessor(b);
b->key = c->key;
if (c->left != nil) d = c->left;
else d = c->right;
if (d != nil) d->parent = c->parent;
if (c->parent == nil) root = d;
else if (c == c->parent->left) c->parent->left = d;
else c->parent->right = d;
free(c);
}
void inorderTreeWalk(Node* a = root) {
if (a != nil) {
inorderTreeWalk(a->left);
cout << ' ' << a->key;
inorderTreeWalk(a->right);
}
}
void preorderTreeWalk(Node* a = root) {
if (a != nil) {
cout << ' ' << a->key;
preorderTreeWalk(a->left);
preorderTreeWalk(a->right);
}
}
int main() {
int m, k;
cin >> m;
for (int i = 0; i < m; i++) {
string a;
cin >> a;
if (a == "insert") {
cin >> k;
insert(k);
}
else if (a == "find") {
cin >> k;
if (find(k) == nil) cout << "no";
else cout << "yes";
cout << endl;
}
else if (a == "delete") {
cin >> k;
erase(k);
}
else {
inorderTreeWalk();
cout << endl;
preorderTreeWalk();
cout << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1012345678;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
--a[i];
}
int ans = 0;
for (int i = 0; i < 8; ++i) {
if (find(a.begin(), a.end(), i) != a.end()) {
++ans;
}
}
for (int i = 1; i <= n / 8; ++i) {
vector<int> p1(n, n + 1), p2(n, n + 1);
for (int j = 0; j < n; ++j) {
int ptr = j, cnt = 0;
while (ptr != n && cnt < i) {
cnt += (a[ptr] == a[j]);
++ptr;
}
if (cnt == i) p1[j] = ptr;
while (ptr != n && cnt < i + 1) {
cnt += (a[ptr] == a[j]);
++ptr;
}
if (cnt == i + 1) p2[j] = ptr;
}
vector<vector<int> > dp(n + 1, vector<int>(1 << 8, -inf));
dp[0][0] = 0;
for (int j = 0; j < n; ++j) {
for (int k = 0; k < 1 << 8; ++k) {
dp[j + 1][k] = max(dp[j + 1][k], dp[j][k]);
if (((k >> a[j]) & 1) || p1[j] == n + 1) continue;
dp[p1[j]][k + (1 << a[j])] =
max(dp[p1[j]][k + (1 << a[j])], dp[j][k] + i);
if (p2[j] != n + 1) {
dp[p2[j]][k + (1 << a[j])] =
max(dp[p2[j]][k + (1 << a[j])], dp[j][k] + i + 1);
}
}
}
ans = max(ans, dp[n][(1 << 8) - 1]);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dpmin[2][100001][102], dpmax[2][100001][102];
int N, arr[101];
int ans = 0;
map<int, int> cnt;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N;
for (int i = 0; i < N; i++) {
cin >> arr[i];
cnt[arr[i]]++;
}
if (cnt.size() <= 2) {
cout << N << '\n';
return 0;
}
for (int i = 0; i <= N * 100; i++)
for (int j = 0; j <= N; j++) {
dpmin[0][i][j] = 2001001001;
dpmax[0][i][j] = -2001001001;
dpmin[1][i][j] = 2001001001;
dpmax[1][i][j] = -2001001001;
}
dpmin[0][0][0]--;
dpmax[0][0][0]++;
for (int i = 0; i < N; i++) {
for (int j = 0; j <= N * 100; j++)
for (int k = 0; k <= N; k++) {
if (dpmin[0][j][k] == 2001001001) continue;
dpmax[1][j + arr[i]][k + 1] =
max(dpmax[1][j + arr[i]][k + 1], max(dpmax[0][j][k], arr[i]));
dpmax[1][j][k] = max(dpmax[1][j][k], dpmax[0][j][k]);
dpmin[1][j + arr[i]][k + 1] =
min(dpmin[1][j + arr[i]][k + 1], min(dpmin[0][j][k], arr[i]));
dpmin[1][j][k] = min(dpmin[1][j][k], dpmin[0][j][k]);
}
for (int j = 0; j <= N * 100; j++)
for (int k = 0; k <= N; k++) {
dpmax[0][j][k] = dpmax[1][j][k];
dpmax[1][j][k] = -2001001001;
dpmin[0][j][k] = dpmin[1][j][k];
dpmin[1][j][k] = 2001001001;
}
}
for (int i = 1; i <= N * 100; i++)
for (int j = 0; j <= N; j++)
if (dpmin[0][i][j] == dpmax[0][i][j] && dpmax[0][i][j] != -2001001001) {
ans = max(ans, j);
}
cout << ans << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n];
map<long long, long long> m;
for (int i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
}
sort(a, a + n);
long long p = a[0], q = a[1], r = a[2];
if (p == q and q == r) {
long long x = m[p];
cout << ((x * (x - 1) * (x - 2)) / 6);
} else if (q == r) {
long long x = m[q];
long long y = m[p];
cout << (((x * (x - 1)) / 2) * (y));
} else if (p == q) {
long long x = m[p];
long long y = m[r];
cout << (((x * (x - 1)) / 2) * (y));
} else {
cout << (m[p] * m[q] * m[r]);
}
cout << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(2e5) + 10;
const int MOD = int(1e9) + 7;
const int INF = int(1e9) + 5;
long long prefix[N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
long long x;
cin >> x;
prefix[i] = prefix[i - 1] + x;
}
int l = 0, r = 0;
long long ans = 0;
set<long long> s;
while (l <= n) {
while (r <= n && s.count(prefix[r]) == 0) {
s.insert(prefix[r]);
r++;
}
ans += (r - l - 1);
s.erase(prefix[l]);
l++;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 30;
int chd[N], n, need[N];
inline bool cmp(int a, int b) { return a > b; }
void sea(int p) {
if (p == n) {
printf("YES\n");
exit(0);
}
need[p] = chd[p] - 1;
for (int i = 0; chd[i] > chd[p] + 1; i++) {
if (need[i] >= chd[p]) {
need[i] -= chd[p];
sea(p + 1);
need[i] += chd[p];
}
}
if (chd[p] == 1) {
printf("NO\n");
exit(0);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", chd + i);
}
sort(chd, chd + n, cmp);
need[0] = n - 1;
if (chd[0] == n) sea(1);
printf("NO\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m;
vector<long double> a;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long double j;
cin >> j;
a.push_back(j);
}
sort(a.begin(), a.end());
long double s = 1001;
for (long long i = 0; i < m - n + 1; i++) {
long double b = abs(a[i] - a[i + n - 1]);
if (b < s) {
s = b;
}
}
cout << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long K,A,B;cin>>K>>A>>B;
K += 1;
if(B - A > 2 && K >= A){
long long rem = K - A;
cout<<A + (B-A)*(rem/2) + (rem%2)<<endl;
}else{
cout<<K<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n >= 0)
cout << n;
else {
int a = n % 10, b = n % 100;
b = b / 10;
if (abs(a) > abs(b)) {
cout << n / 10;
} else
cout << (n / 100) * 10 + a;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int po[1005][10];
vector<int> primes;
using ll = long long int;
using dl = double;
int main() {
ios_base::sync_with_stdio(false);
string ptr, str, uni;
ll n, i, j, p = 2, m, after, a, mark, ans = 0, array[10000], guest;
vector<ll> cv;
set<ll> sc;
cin >> n >> m;
for (i = 0; i < n; i++) {
cin >> array[i];
}
for (i = 1; i < n; i++) {
if (array[i] < array[i - 1]) {
ll dif = array[i - 1] - array[i];
mark = dif / m;
if (dif % m != 0) mark++;
ans += mark;
array[i] = array[i] + mark * m;
}
if (array[i] == array[i - 1]) {
array[i] = array[i] + m;
ans++;
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
struct Comp {
int operator()(const std::pair<char, long long>& a,
const std::pair<char, long long>& b) {
return b.second < a.second;
}
};
int main() {
std::unordered_map<char, long long> m;
std::vector<char> first;
int n;
std::cin >> n;
for (int i = 0; i < n; ++i) {
std::string str;
std::cin >> str;
for (int j = str.size() - 1; j >= 0; --j) {
char c = str[j];
auto got = m.find(c);
int add = 1;
for (int k = 0; k < str.size() - 1 - j; ++k) {
add *= 10;
}
if (got == m.end()) {
m[c] = add;
} else {
m[c] += add;
}
if (j == 0) {
first.push_back(c);
}
}
}
std::unique(first.begin(), first.end());
std::sort(first.begin(), first.end());
std::vector<std::pair<char, long long>> v(m.begin(), m.end());
std::sort(v.begin(), v.end(), Comp{});
int zero_pos = -1;
for (int i = 0; i < v.size(); ++i) {
int pos = -1;
for (int j = 0; j < first.size(); ++j) {
if (first[j] == v[i].first) {
pos = j;
break;
}
}
if (pos == -1) {
zero_pos = i;
break;
}
}
long long sum = 0;
long long current = 1;
for (int i = 0; i < v.size(); ++i) {
if (i != zero_pos) {
sum += current * v[i].second;
;
++current;
}
}
std::cout << sum << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int MAX = 1000000;
int MIN = -1000000;
int INF = 1000000000;
int x4[4] = {0, 1, 0, -1};
int y4[4] = {1, 0, -1, 0};
int x8[8] = {0, 1, 1, 1, 0, -1, -1, -1};
int y8[8] = {1, 1, 0, -1, -1, -1, 0, 1};
int i, j, k;
int n, m, h, t, x[100010], y[100010], have[100010], sial[100010], aduh[100010];
vector<int> v[100010], A, B, C;
map<pair<int, int>, bool> M;
int main() {
int mi, ma;
cin >> n >> m >> h >> t;
mi = min(h, t) + 1;
ma = max(h, t) + 1;
for (i = (0); i < (m); i++) {
scanf("%d %d", &x[i], &y[i]);
v[x[i]].push_back(y[i]);
v[y[i]].push_back(x[i]);
sial[x[i]]++;
sial[y[i]]++;
}
for (int i = 0; i < m; i++) {
if (min(sial[x[i]], sial[y[i]]) < mi || max(sial[x[i]], sial[y[i]]) < ma)
continue;
int a = x[i];
int b = y[i];
int a1 = v[a].size();
int b1 = v[b].size();
A.clear();
B.clear();
C.clear();
A.reserve(sial[a]);
B.reserve(sial[b]);
C.reserve(sial[a]);
for (int j = 0; j < a1; j++) aduh[v[a][j]] = 0;
for (int j = 0; j < b1; j++) aduh[v[b][j]] = 0;
for (int j = 0; j < a1; j++) aduh[v[a][j]]++;
for (int j = 0; j < b1; j++) aduh[v[b][j]]++;
for (int j = 0; j < a1; j++) {
int z = v[a][j];
if (aduh[z] == 1 && z != b) {
A.push_back(z);
} else if (z != b)
C.push_back(z);
}
for (int j = 0; j < b1; j++) {
int z = v[b][j];
if (aduh[z] == 1 && z != a) {
B.push_back(z);
}
}
int Asize = A.size();
int Bsize = B.size();
int Csize = C.size();
if (Asize >= h && Bsize >= t) {
cout << "YES" << endl;
cout << a << " " << b << endl;
cout << A[0];
for (int j = 1; j < h; j++) cout << " " << A[j];
cout << endl;
cout << B[0];
for (int j = 1; j < t; j++) cout << " " << B[j];
cout << endl;
return 0;
} else if (Asize >= t && Bsize >= h) {
cout << "YES" << endl;
cout << b << " " << a << endl;
cout << B[0];
for (int j = 1; j < h; j++) cout << " " << B[j];
cout << endl;
cout << A[0];
for (int j = 1; j < t; j++) cout << " " << A[j];
cout << endl;
return 0;
} else if (max((h - Asize), 0) + max(0, (t - Bsize)) <= Csize) {
int indx = 0;
while (A.size() < h) {
A.push_back(C[indx]);
indx++;
}
while (B.size() < t) {
B.push_back(C[indx]);
indx++;
}
cout << "YES" << endl;
cout << a << " " << b << endl;
cout << A[0];
for (int j = 1; j < h; j++) cout << " " << A[j];
cout << endl;
cout << B[0];
for (int j = 1; j < t; j++) cout << " " << B[j];
cout << endl;
return 0;
} else if (max((t - Asize), 0) + max(0, (h - Bsize)) <= Csize) {
int indx = 0;
while (A.size() < t) {
A.push_back(C[indx]);
indx++;
}
while (B.size() < h) {
B.push_back(C[indx]);
indx++;
}
cout << "YES" << endl;
cout << b << " " << a << endl;
cout << B[0];
for (int j = 1; j < h; j++) cout << " " << B[j];
cout << endl;
cout << A[0];
for (int j = 1; j < t; j++) cout << " " << A[j];
cout << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
set<pair<long long, long long> > st;
vector<pair<pair<long long, long long>, int> > len;
long long l[N + 100], r[N + 100];
int ans[N + 100];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%lld%lld", l + i, r + i);
}
for (int i = 2; i <= n; i++) {
long long d1 = l[i] - r[i - 1];
long long d2 = r[i] - l[i - 1];
len.push_back(make_pair(make_pair(d2, d1), i - 1));
}
for (int i = 1; i <= m; i++) {
long long a;
scanf("%lld", &a);
st.insert(make_pair(a, i));
}
sort(len.begin(), len.end());
bool flag = true;
for (auto it : len) {
int idx1 = it.second;
long long r = it.first.first;
long long l = it.first.second;
auto nxt = st.lower_bound(make_pair(l, -1));
if (nxt == st.end() || nxt->first > r) {
flag = false;
break;
}
ans[idx1] = nxt->second;
st.erase(nxt);
}
if (flag) {
printf("Yes\n");
for (int i = 1; i < n; i++) {
printf("%d ", ans[i]);
}
} else {
printf("No\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, d, ans = 128, x[128], sum[128];
int main() {
cin >> n >> d;
for (int i = 0; i < n; ++i) cin >> x[i];
sort(x, x + n);
for (int l = 0; l < n; ++l)
for (int r = l; r < n; ++r)
if (x[r] - x[l] <= d) ans = min(ans, l + n - 1 - r);
cout << ans;
}
| 1 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <iomanip>
#include <complex>
#include <cmath>
#include <array>
using namespace std;
const double EPS = 1e-10;
const double INF = 1e12;
const double PI = acos(-1);
#define EQ(n,m) (abs((n)-(m)) < EPS)
#define X real()
#define Y imag()
typedef complex<double> P;
typedef vector<P> VP;
struct L : array<P, 2>{
L(const P& a, const P& b){ at(0)=a; at(1)=b; }
L(){}
};
double cross(P a, P b){
return (conj(a)*b).Y;
}
P rotate(const P &p, double rad){
return p *P(cos(rad), sin(rad));
}
P crosspointLL(const L &l, const L &m) {
double A = cross(l[1]-l[0], m[1]-m[0]);
double B = cross(l[1]-l[0], l[1]-m[0]);
return m[0] + B/A *(m[1]-m[0]);
}
double getarea(const VP &poly){
double ret = 0;
for (int i=0; i<(int)poly.size(); i++){
ret += cross(poly[i], poly[(i+1)%poly.size()]);
}
return ret*0.5;
}
int main(){
int n,k;
cin >> n >> k;
VP v(n);
for(int i=0; i<n; i++){
v[i] = rotate(P(0, 1), 2*PI *i/n);
}
VP star;
for(int i=0; i<n; i++){
star.push_back(v[i]);
if(k >= 2){
star.push_back(crosspointLL(L(v[i], v[(i+k)%n]), L(v[(i+1)%n], v[(i+1-k+n)%n])));
}
}
cout << fixed << setprecision(10);
cout << getarea(star) << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n;
string s;
cin >> t;
while (t--) {
cin >> n >> s;
int x = n;
while (x--) cout << s[n - 1];
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, i, l, r, m, j;
cin >> t;
while (t--) {
cin >> l >> r >> m;
for (i = l; i <= r; i++) {
if (m < i) {
if (i - m <= r - l) {
cout << i << " " << l << " " << l + i - m % i << "\n";
break;
}
} else if (i - m % i <= r - l) {
cout << i << " " << l << " " << l + i - m % i << "\n";
break;
} else if (m % i <= r - l) {
cout << i << " " << l + m % i << " " << l << "\n";
break;
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
int dp[N];
string s;
vector<string> o;
bool repeat(int a, int b, int c) {
if (b + c >= s.size()) return false;
for (int i = a; i <= b; ++i)
if (s[i] != s[i + c]) return false;
return true;
}
string gen(int a, int b) {
string temp = "";
for (int i = a; i <= b; ++i) temp.push_back(s[i]);
return temp;
}
int main() {
cin >> s;
if (s.size() <= 6) {
cout << "0" << endl;
return 0;
}
dp[s.size()] = 1;
o.push_back(gen(s.size() - 2, s.size() - 1));
dp[s.size() - 2] = 1;
if (s.size() >= 8) {
o.push_back(gen(s.size() - 3, s.size() - 1));
dp[s.size() - 3] = 1;
}
for (int i = s.size() - 4; i >= 5; --i) {
if (dp[i + 2] == 1) {
if (!repeat(i, i + 1, 2)) {
o.push_back(gen(i, i + 1));
dp[i] = 1;
} else if (dp[i + 2 + 3] == 1) {
o.push_back(gen(i, i + 1));
dp[i] = 1;
}
}
if (dp[i + 3] == 1) {
if (!repeat(i, i + 2, 3)) {
o.push_back(gen(i, i + 2));
dp[i] = 1;
} else if (dp[i + 3 + 2] == 1) {
o.push_back(gen(i, i + 2));
dp[i] = 1;
}
}
}
sort(o.begin(), o.end());
o.resize(unique(o.begin(), o.end()) - o.begin());
cout << o.size() << endl;
for (int i = 0; i < o.size(); ++i) cout << o[i] << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e) {
cout << e << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
template <class T>
T Abs(T x) {
return x > 0 ? x : -x;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
long long Pow(long long B, long long P) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) R = (R * B);
P /= 2;
B = (B * B);
}
return R;
}
long long BigMod(long long B, long long P, long long M) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return R;
}
long long n;
long long dist[100050];
set<long long> S[100050];
struct data {
long long to, w;
data(int a, int b) {
to = a;
w = b;
}
};
vector<data> v[100050];
struct vertice {
long long node, dist;
vertice(int a, int b) {
node = a;
dist = b;
}
bool operator<(const vertice& x) const { return dist > x.dist; }
};
long long dijkstra(int source) {
for (int i = 0; i <= n; i++) dist[i] = (1LL << 50);
dist[source] = 0;
priority_queue<vertice> Q;
Q.push(vertice(source, 0));
while (!Q.empty()) {
long long now = Q.top().node, cost = Q.top().dist;
Q.pop();
if (now == n) return cost;
while (S[now].find(cost) != S[now].end()) cost++;
for (int i = 0; i < (int)v[now].size(); i++) {
long long to = v[now][i].to;
long long w = v[now][i].w;
if (dist[to] > cost + w) {
dist[to] = cost + w;
Q.push(vertice(to, cost + w));
}
}
}
return -1;
}
int main() {
long long m, a, b, c;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
v[a].push_back(data(b, c));
v[b].push_back(data(a, c));
}
for (int i = 1; i <= n; i++) {
cin >> c;
while (c--) {
cin >> a;
S[i].insert(a);
}
}
long long ans = dijkstra(1);
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
class node {
public:
int memo;
node* child[26];
node() {
memo = -1;
for (int i = 0; i < 26; i++) child[i] = NULL;
}
};
node* root;
int n, k;
void insert(node* now, string a, int pos) {
if (pos == a.size()) return;
int c = a[pos] - 'a';
if (now->child[c] == NULL) {
now->child[c] = new node();
}
insert(now->child[c], a, pos + 1);
}
int dp(node* now) {
if (now->memo != -1) return now->memo;
int& res = now->memo;
bool leaf = 1;
for (int i = 0; i < 26; i++)
if (now->child[i] != NULL) leaf = 0;
if (leaf) return res = 0;
bool x[4];
memset(x, 0, sizeof(x));
for (int i = 0; i < 26; i++)
if (now->child[i] != NULL) x[dp(now->child[i])] = 1;
if ((x[0] && x[1]) || x[3]) return res = 2;
if (x[0]) return res = 1;
if (x[1]) return res = 0;
return res = 3;
}
int main() {
scanf("%d%d", &n, &k);
root = new node();
for (int i = 1; i <= n; i++) {
string a;
cin >> a;
insert(root, a, 0);
}
int res = dp(root);
if (res == 2 || (res == 1 && k & 1))
puts("First");
else
puts("Second");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N;
cin>>N;
while(N--){
double x1, x2, x3,y1, y2, y3;
cin>>x1>>y1>>x2>>y2>>x3>>y3;
double a, b, c, d, e, f;
double px,py,r;
a=2.0*(x2-x1);
b=2.0*(y2-y1);
c=x1*x1+y1*y1-x2*x2-y2*y2;
d=2.0*(x3-x1);
e=2.0*(y3-y1);
f=x1*x1+y1*y1-x3*x3-y3*y3;
px=(b*f-c*e)/(a*e-b*d);
py=(c*d-a*f)/(a*e-b*d);
r=sqrt((px-x1)*(px-x1)+(py-y1)*(py-y1));
printf("%.3f %.3f %.3f\n",px,py,r);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 << 18;
const int MAGIC = 100000;
int N;
char S[MAXN];
unsigned int T[MAXN];
int pleft[MAXN];
unsigned brute() {
pleft[N] = 0;
for (int i = (N)-1; i >= (0); --i) {
pleft[i] = pleft[i + 1];
if (S[i] == '?')
++pleft[i];
else
--pleft[i];
}
T[0] = 1;
int L = 0, R = 0;
for (int i = 0; i < (N); ++i) {
for (int j = (R + 2) - 1; j >= (L + 1); --j) T[j] = T[j - 1];
T[L] = 0;
++L, ++R;
if (S[i] == '?') {
L = max(0, L - 2);
for (int j = (L); j < (R + 1); ++j) T[j] += T[j + 2];
}
while (R > pleft[i + 1] + 1) {
T[R--] = 0;
}
}
unsigned int res = T[0];
for (int i = 0; i < (pleft[0] / 2); ++i) res *= 25;
return res;
}
int main() {
scanf("%d%s", &N, S);
if (N % 2) {
printf("0\n");
return 0;
}
unsigned int r = brute();
printf("%u\n", r);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
set<int> ss1;
set<int>::iterator pos;
vector<int> g[500010];
queue<int> q;
struct Edge {
int v, pre;
};
Edge e[2000010];
int use[500010];
int ecnt, hh[500010], p[500010];
void addEdge(int u, int v) {
e[ecnt].v = v;
e[ecnt].pre = hh[u];
hh[u] = ecnt++;
}
int main() {
int n, m;
while (scanf("%d%d", &n, &m) == 2) {
ss1.clear();
for (int i = 1; i <= n; i++) ss1.insert(i);
memset(hh, -1, sizeof(hh));
memset(use, 0, sizeof(use));
ecnt = 0;
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
addEdge(u, v);
addEdge(v, u);
}
int cnts = 0, anss = 0, now = 0;
while (cnts != n) {
int num = *ss1.begin(), cnt = 0;
while (!q.empty()) q.pop();
q.push(num);
ss1.erase(num);
g[anss].clear();
while (!q.empty()) {
now++;
int cnt = 0;
int num = q.front();
g[anss].push_back(num);
cnts++;
q.pop();
for (int i = hh[num]; i != -1; i = e[i].pre) {
int v = e[i].v;
use[v] = now;
}
pos = ss1.begin();
while (pos != ss1.end()) {
if (use[*pos] != now) {
q.push(*pos);
p[cnt++] = *pos;
}
pos++;
}
for (int i = 0; i < cnt; i++) ss1.erase(p[i]);
}
anss++;
}
printf("%d\n", anss);
for (int i = 0; i < anss; i++) {
int len = g[i].size();
printf("%d", len);
for (int j = 0; j < len; j++) printf(" %d", g[i][j]);
puts("");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MN = 201234, MOD = 998244353;
void solve() {
long long a, b, ans = 0, n;
cin >> a >> b >> n;
if (a < b) swap(a, b);
while (b <= n && a <= n) {
if (a < b) swap(a, b);
b += a;
ans++;
}
cout << ans << '\n';
}
int32_t main() {
long long q;
cin >> q;
while (q--) solve();
}
| 1 |
#include<deque>
#include<list>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<vector>
#include<algorithm>
#include<string>
#include<sstream>
#include<cmath>
#include<cstdio>
using namespace std;
int main(){
int i;
int h,w,n;
while(scanf("%d%d%d",&h,&w,&n),h||w||n){
int a[50000],b[50000],c[50000];
for(i=0;i<n;++i)
scanf("%d%d%d",a+i,b+i,c+i);
int d[50000]={},e[50000]={},f=0,g=0;
int ct=0;
for(i=n-1;i>=0;--i){
if(a[i]){
if(d[b[i]]==0){
if(c[i])
ct+=h-g;
d[b[i]]=-1;
++f;
}
}else{
if(e[b[i]]==0){
if(c[i])
ct+=w-f;
e[b[i]]=-1;
++g;
}
}
}
printf("%d\n",ct);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,i,j;
int w;
string str;
cin >> n;
for (i=0;i<n;i++){
cin >> str;
vector <int> s;
for(j=0;j<str.length();j++){
s.push_back(str[j]-'0');
}
w=0;
while(s.size()>1){
int b = (s[0]+s[1])/10;
s[1]=(s[0]+s[1])%10;
if(b==0)s.erase(s.begin());
else s[0]=1;
/*for(int k=0;k<s.size();k++)cout<<s[k]<<" ";
cout<<endl;*/
w++;
}
if(w%2==0) printf("Audrey wins.\n");
else printf("Fabre wins.\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
int i, n = s.size(), ans = 0, ctr1 = 0;
vector<int> hash(26, 0);
for (i = 0; i < n; i++) {
hash[s[i] - 'a']++;
}
for (i = 0; i < 26; i++) {
if (hash[i] > 1)
ans++;
else if (hash[i] == 1)
ctr1++;
}
ans += (ctr1 / 2);
cout << ans << endl;
}
return 0;
}
| 2 |
#include<iostream>
#include<cstring>
using namespace std;
int n,m,s;
int map[50][3001];
int main(void){
while(1){
cin >> n >> m >> s;
if(n==0 && m==0 && s==0)break;
memset(map,0,sizeof(map));
map[0][0]=1;
for(int i=1;i<=m;i++){
for(int j=n*n;j>=1;j--){
for(int k=i;k<=s;k++){
map[j][k]=(map[j][k]+map[j-1][k-i])%100000;
}
}
}
cout << map[n*n][s] << endl;
}
return 0;
}
| 0 |
#include<iostream>
#include<vector>
#include<string>
#include<cstdio>
#include<algorithm>
using namespace std;
#define rep(i,a) for(int i = 0 ; i < a ; i ++)
#define loop(i,a,b) for(int i = a ; i < b ; i ++)
int main(void){
int n,m;
while(cin>>n>>m,n+m){
int sun = 0, sum = 0;
vector<int> in(n);
vector<int> im(m);
rep(i,n)cin>>in[i],sun+=in[i];
rep(i,m)cin>>im[i],sum+=im[i];
bool find = false;
rep(i,n){
if(find)break;
rep(j,m){
//cout<<in[i]<<" "<<im[j]<<endl;
//cout<<sun+im[j]-in[i] <<" "<<sum+in[i]-im[j]<<endl;
if(sun + im[j] - in[i] == sum + in[i] - im[j]){
cout<<in[i]<<" "<<im[j]<<endl;
find = true;
break;
}
}
}
if(!find)cout<<-1<<endl;
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
const int maxn=3010,mod=998244353;
int a,b,c,d,dp[maxn][maxn];
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin>>a>>b>>c>>d;
dp[a][b]=1;
for(int i=a;i<=c;i++)
for(int j=b;j<=d;j++)
if(i!=a||j!=b)
{
if(i==1||j==1)
dp[i][j]=1;
else
dp[i][j]=(dp[i-1][j]*j%mod+dp[i][j-1]*i%mod-dp[i-1][j-1]*(i-1)%mod*(j-1)%mod+mod)%mod;
}
cout<<dp[c][d]<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000")
int main() {
int n, m;
cin >> n;
if (n % 2) {
m = n / 2 * (n / 2 + 1);
printf("%d\n", m);
for (int i = 1; i <= n / 2; i++)
for (int j = 1; j <= n / 2 + 1; j++) printf("%d %d\n", i, j + n / 2);
} else {
m = n * n / 4;
printf("%d\n", m);
for (int i = 1; i <= n / 2; i++)
for (int j = 1; j <= n / 2; j++) printf("%d %d\n", i, j + n / 2);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
int p[MAXN], q[MAXN], n, s[MAXN], temp[MAXN], k;
bool ck() {
for (int i = 1; i <= n; ++i) {
if (s[i] != p[i]) return false;
}
return true;
}
void go() {
for (int i = 1; i <= n; ++i) {
temp[i] = p[q[i]];
}
for (int i = 1; i <= n; ++i) {
p[i] = temp[i];
}
return;
}
void go2() {
for (int i = 1; i <= n; ++i) {
temp[q[i]] = p[i];
}
for (int i = 1; i <= n; ++i) {
p[i] = temp[i];
}
return;
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &q[i]);
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &s[i]);
}
for (int i = 1; i <= n; ++i) {
p[i] = i;
}
if (ck()) {
printf("NO\n");
return 0;
}
int ans1 = -1;
for (int i = 1; i <= k; ++i) {
go();
if (ck()) {
ans1 = i;
break;
}
}
for (int i = 1; i <= n; ++i) {
p[i] = i;
}
int ans2 = -1;
for (int i = 1; i <= k; ++i) {
go2();
if (ck()) {
ans2 = i;
break;
}
}
bool f = false;
if (ans1 == 1 && ans2 == 1) {
if (k == 1) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
}
if (ans1 != -1) {
if ((k - ans1) % 2 == 0) f = true;
}
if (ans2 != -1) {
if ((k - ans2) % 2 == 0) f = true;
}
if (f) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
}
| 2 |
#include<cstdio>
#include<algorithm>
#include<map>
#include<cstring>
#include<cmath>
#include<iostream>
using namespace std;
typedef long long LL;
map<pair <string,string>,LL> cnt;
const int maxn = 50;
char s[maxn];
int main(){
int n; scanf("%d",&n);
scanf("%s",s);
for(int i = 0;i < (1 << n);i++){
string s1 = "",s2 = "";
for(int j = 0;j < n;j++){
if(i & (1 << j)) s1 += s[j];
else s2 += s[j];
}
cnt[make_pair(s1,s2)]++;
}
LL sum = 0;
for(int i = 0;i < (1 << n);i++){
string s1 = "",s2 = "";
for(int j = n - 1;j >= 0;j--){
if(i & (1 << j)) s1 += s[j + n];
else s2 += s[j + n];
}
sum += cnt[make_pair(s1,s2)];
}
printf("%lld\n",sum);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<string, int> pi;
int main() {
int n;
cin >> n;
int m, m1, a, b, c, d, e;
string str, s;
int mx = -1000000;
while (n--) {
cin >> str >> m >> m1 >> a >> b >> c >> d >> e;
pi.first = str;
int plus1 = m * 100;
int minus1 = m1 * 50;
int sum = a + b + c + d + e + plus1 - minus1;
pi.second = sum;
if (sum > mx) {
mx = sum;
s = pi.first;
}
}
cout << s << endl;
}
| 1 |
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
int main() {
string s, t;
cin >> s >> t;
sort(s.begin(), s.end());
sort(t.rbegin(), t.rend());
cout << (s < t ? "Yes" : "No") << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int ans[N];
int deg[N];
bool trip[N];
set<int> g[N];
int cnt, k;
void remove(int u) {
if (!trip[u]) return;
queue<int> q;
q.push(u);
trip[u] = false;
while (!q.empty()) {
u = q.front();
q.pop();
cnt--;
for (int v : g[u]) {
deg[v]--;
g[v].erase(u);
if (trip[v] and deg[v] < k) {
trip[v] = false;
q.push(v);
}
}
g[u].clear();
}
}
int main() {
int n, m;
scanf("%d %d %d", &n, &m, &k);
vector<pair<int, int> > e;
cnt = n;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
deg[x]++;
deg[y]++;
e.emplace_back(x, y);
g[x].insert(y);
g[y].insert(x);
}
for (int i = 1; i <= n; i++) trip[i] = true;
for (int i = 1; i <= n; i++) {
if (trip[i] and deg[i] < k) remove(i);
}
ans[m - 1] = cnt;
for (int i = m - 2; i >= 0; i--) {
int a = e[i + 1].first, b = e[i + 1].second;
if (!trip[a] or !trip[b]) {
ans[i] = cnt;
continue;
}
deg[a]--;
deg[b]--;
g[a].erase(b);
g[b].erase(a);
if (deg[a] < k) remove(a);
if (deg[b] < k) remove(b);
ans[i] = cnt;
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
//mod逆元を使ったnCkの計算(速)
const int64_t MAX = 510000;
const int64_t MOD = 1000000007;
int64_t fac[MAX], finv[MAX], inv[MAX];
// テーブルを作る前処理
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// 二項係数計算
int64_t COM(int64_t n, int64_t k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
int main(){
int64_t N, M, K;
cin >> N >> M >> K;
int64_t ans = 0;
int64_t n = N*(N*N-1) / 6;
n %= MOD;
n *= M*M;
n %= MOD;
int64_t m = M*(M*M-1) / 6;
m %= MOD;
m *= N*N;
m %= MOD;
ans = n + m;
ans %= MOD;
COMinit();
int64_t all = COM(N*M-2,K-2);
ans *= all;
ans %= MOD;
cout << ans << endl;
}
| 0 |
#include <iostream>
#include <algorithm>
using namespace std;
int main()
{
int X,Y,cnt;
while(cin >> X >> Y, (X||Y))
{
cnt = 0;
if(X<Y) swap(X,Y);
while(Y!=0)
{
cnt++;
X%=Y;
swap(X,Y);
}
cout << X << " " << cnt << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#define REP(i, a, n) for(ll i = ((ll) a); i < ((ll) n); i++)
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
ll N, P;
vector<ll> W, B;
int main(void) {
cin >> N >> P;
W.resize(N), B.resize(N);
REP(i, 0, N) cin >> W[i] >> B[i];
vector<pll> vec;
REP(i, 0, N) vec.push_back(pll(-((100 - P) * W[i] + P * B[i]), i));
sort(vec.begin(), vec.end());
ll white = 0, all = 0;
REP(i, 0, N) all += B[i];
ll ans;
REP(i, 0, N) {
ll idx = vec[i].second;
white += W[idx];
all += W[idx] - B[idx];
if(white * 100 >= P * all) {
ans = i + 1;
break;
}
}
cout << ans << endl;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.