solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include<iostream>
using namespace std;
int main(){
int n=0;
int a=0;
int b=0;
int k=0;
int c[101];
int i=0;
int j=0;
int t=0;
int w=0;
int wa=0;
int s=0;
cin>>n;
cin>>a;
cin>>b;
cin>>k;
for(i=0;i<101;i++){
c[i]=0;
}
for(i=0;i<n;i++){
cin>>c[i];
}
wa=k;
t=k/a;
for(i=0;i<n;i++){
for(j=0;j<n;j++){
if(c[s]<c[j]){
s=j;
}
}
if(t*b<c[s]){
wa=wa+c[s];
w++;
}else{
break;
}
for(j=s;j<100;j++){
c[j]=c[j+1];
}
t=wa/(a+w*b);
s=0;
}
cout<<t<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, b, g, x[11111], y[11111];
int main() {
cin >> n >> m >> b;
for (int i = 0; i < b; i++) {
int A;
cin >> A;
x[A] = 1;
}
cin >> g;
for (int i = 0; i < g; i++) {
int A;
cin >> A;
y[A] = 1;
}
int j = 0, i = 0;
for (int k = 0; k < int(1e5); k++) {
if (x[i % n] || y[j % m]) {
x[i % n] = 1;
y[j % m] = 1;
}
i++;
j++;
j %= m;
i %= n;
}
for (int i = 0; i < n; i++)
if (!x[i]) {
cout << "No";
return 0;
}
for (int i = 0; i < m; i++) {
if (!y[i]) {
cout << "No";
return 0;
}
}
cout << "Yes";
}
| 5 |
#include<iostream>
#include<cstdio>
using namespace std;
short dp[5001][5001];
int n,m;
short max2(short a,short b){
if(a>b)return a;
return b;
}
int main(void){
scanf("%d%d",&n,&m);
for(int i=0;i<m;i++){
int a,b,x;
scanf("%d%d%d",&b,&a,&x);
a--,b--;
dp[a][b]=max2(dp[a][b],x+1);
}
int cnt=0;
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
if(dp[j][i]>0)cnt++;
dp[j][i+1]=max2(dp[j][i+1],dp[j][i]-1);
dp[j+1][i+1]=max2(dp[j+1][i+1],dp[j][i]-1);
}
}
printf("%d\n",cnt);
return 0;
} | 0 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>
#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define between(a,x,b) ((a)<=(x)&&(x)<=(b))
using namespace std;
string convert(string str){
string res = "";
map<char, string>s;
s[' '] = "101";
s['\''] = "000000";
s[','] = "000011";
s['-'] = "10010001";
s['.'] = "010001";
s['?'] = "000001";
s['A'] = "100101";
s['B'] = "10011010";
s['C'] = "0101";
s['D'] = "0001";
s['E'] = "110";
s['F'] = "01001";
s['G'] = "10011011";
s['H'] = "010000";
s['I'] = "0111";
s['J'] = "10011000";
s['K'] = "0110";
s['L'] = "00100";
s['M'] = "10011001";
s['N'] = "10011110";
s['O'] = "00101";
s['P'] = "111";
s['Q'] = "10011111";
s['R'] = "1000";
s['S'] = "00110";
s['T'] = "00111";
s['U'] = "10011100";
s['V'] = "10011101";
s['W'] = "000010";
s['X'] = "10010010";
s['Y'] = "10010011";
s['Z'] = "10010000";
rep(i, str.length()){
res += s[str[i]];
}
while(res.size() % 5) res += "0";
return res;
}
string reconvert(string str){
string res = "";
map<string, char>s;
s["00000"] = 'A';
s["00001"] = 'B';
s["00010"] = 'C';
s["00011"] = 'D';
s["00100"] = 'E';
s["00101"] = 'F';
s["00110"] = 'G';
s["00111"] = 'H';
s["01000"] = 'I';
s["01001"] = 'J';
s["01010"] = 'K';
s["01011"] = 'L';
s["01100"] = 'M';
s["01101"] = 'N';
s["01110"] = 'O';
s["01111"] = 'P';
s["10000"] = 'Q';
s["10001"] = 'R';
s["10010"] = 'S';
s["10011"] = 'T';
s["10100"] = 'U';
s["10101"] = 'V';
s["10110"] = 'W';
s["10111"] = 'X';
s["11000"] = 'Y';
s["11001"] = 'Z';
s["11010"] = ' ';
s["11011"] = '.';
s["11100"] = ',';
s["11101"] = '-';
s["11110"] = '\'';
s["11111"] = '?';
for(int i = 0; i < str.length(); i += 5){
string f; // = string(str[i] + str[i+1] + str[i+2] + str[i+3] + str[i+4]);
f = str[i]; f += str[i+1]; f+= str[i+2]; f += str[i+3]; f += str[i+4];
res += s[f];
}
return res;
}
int main(){
string str;
while(getline(cin, str)){
str = convert(str);
str = reconvert(str);
cout << str << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
int main() {
char genome[256];
int i, n, base, count[5];
scanf("%d", &n);
scanf("%s", genome);
if (n % 4 == 0) {
base = n / 4;
count[0] = count[1] = count[2] = count[3] = count[4] = 0;
for (i = 0; i < n; i++) {
switch (genome[i]) {
case 'A':
count[0]++;
break;
case 'C':
count[1]++;
break;
case 'G':
count[2]++;
break;
case 'T':
count[3]++;
break;
case '?':
count[4]++;
break;
}
}
if (count[0] > base || count[1] > base || count[2] > base ||
count[3] > base) {
printf("===\n");
} else if (count[4] == 0) {
printf("%s\n", genome);
} else {
for (i = 0; i < n; i++) {
if (genome[i] == '?') {
if (count[0] < base) {
printf("A");
count[0]++;
} else if (count[1] < base) {
printf("C");
count[1]++;
} else if (count[2] < base) {
printf("G");
count[2]++;
} else {
printf("T");
}
} else {
printf("%c", genome[i]);
}
}
printf("\n");
}
} else {
printf("===\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
const int mod = 998244353;
int u[maxn], s[maxn];
int a[maxn], b[maxn], c[maxn];
int val[maxn];
int find(int x){
if(x == u[x]) return x;
return u[x] = find(u[x]);
}
void join(int x, int y){
x = find(x);
y = find(y);
if(x^y){
s[x] += s[y];
s[y] = 0;
u[y] = x;
}
}
vector<pair<int,int> > e[maxn];
int main(){
int n, m; scanf("%d %d", &n, &m);
for(int i = 0; i < m; i++) scanf("%d %d %d", a + i, b + i, c + i);
map<int,map<int,int>> rest;
for(int i = 0; i < m; i++) rest[a[i]][b[i]] = c[i];
auto get = [&](int i, int j){
auto it = rest.find(i);
if(it == rest.end()) return -1;
auto it2 = it->second.find(j);
if(it2 == it->second.end()) return -1;
return it2->second;
};
long long pairs = 0;
int ans = 1;
for(int i = 1; i <= n; i++) pairs += n - i;
set<pair<int,int>> seen;
for(int i = 0; i < m; i++){
int x = min(a[i], b[i]), y = max(a[i], b[i]);
if(x == y) continue;
int vxy = get(x, y), vyx = get(y, x);
int nv = -1;
if(vxy != -1 && vyx != -1) nv = (vxy + vyx)%2;
else if(vxy == -1 && vyx == -1) assert(0);
if(y - x >= 3 && (nv != -1 && nv != 0)) return !printf("0\n");
rest[x][y] = nv;
rest[y][x] = 0;
seen.insert({x, y});
}
pairs -= seen.size();
memset(val, -1, sizeof(val));
for(int i = 1; i <= n; i++){
int vii = get(i, i);
if(vii != -1) {
if(val[i] != -1 && val[i] != vii) return !printf("0\n");
val[i] = vii;
}
if(i + 2 > n) continue;
int vij = get(i, i + 2);
if(vij != -1) {
if(val[i + 1] != -1 && val[i + 1] != vij) return !printf("0\n");
val[i + 1] = vij;
}
}
for(int i = 1; i <= n; i++) u[i] = i, s[i] = val[i] != -1;
for(int i = 1; i < n; i++){
int vij = get(i, i + 1);
int vji = get(i + 1, i);
if(vij != -1 && vji != -1){
int exp = (vij + vji) % 2;
if(val[i] != -1 && val[i+1] != -1){
int is = (val[i] + val[i + 1]) % 2;
if(exp != is) return !printf("0\n");
}
e[i].push_back({i + 1, exp});
e[i + 1].push_back({i, exp});
}
}
queue<int> q;
for(int i = 1; i <= n; i++) if(val[i] != -1) q.push(i);
while(!q.empty()){
int cur = q.front(); q.pop();
for(auto ee : e[cur]){
int nval = val[cur] ^ ee.second;
if(val[ee.first] == -1){
val[ee.first] = nval;
q.push(ee.first);
} else if(val[ee.first] != nval) return !printf("0\n");
}
}
int pk = 0;
for(int i = 1; i <= n; i++) if(val[i] == -1){
ans = (ans + ans) % mod;
pk += e[i].size();
}
pairs -= pk / 2;
int p2 = 1, b2 = 2;
for(; pairs; b2 = 1ll * b2 * b2 % mod, pairs >>= 1) if(pairs&1) p2 = 1ll * p2 * b2 % mod;
ans = 1ll * ans * p2 % mod;
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int n;
cin >> n;
int arr[n];
int i;
for (i = 0; i < n; i++) scanf("%d", &arr[i]);
int round = (n - arr[0]) % n;
for (i = 0; i < n; i++) {
if (i & 1) {
arr[i] = (arr[i] - round) % n;
if (arr[i] < 0) arr[i] += n;
} else
arr[i] = (arr[i] + round) % n;
}
bool isFake = false;
for (i = 0; i < n; i++)
if (arr[i] != i) {
isFake = true;
break;
}
if (isFake)
cout << "No";
else
cout << "Yes";
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
int h,w;
h=w=100;
cout<<h<<" "<<w<<endl;
char ma[100][100];
for(int i=0;i<100;i++)
for(int j=0;j<100;j++)
if(i<50)ma[i][j]='.';
else ma[i][j]='#';
for(int i=0;i/2<b-1;i+=2)ma[2*(i/100)][i%100]='#';
for(int i=0;i/2<a-1;i+=2)ma[2*(i/100)+50][i%100]='.';
for(int i=0;i<50;i++){
for(int j=0;j<100;j++){
cout<<ma[i][j];
}
cout<<endl;
}
for(int i=99;i>=50;i--){
for(int j=0;j<100;j++){
cout<<ma[i][j];
}
cout<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int logn = 30;
class Trie {
public:
Trie() { nodes.push_back(Node()); }
void Add(int x) {
int cur = 0;
for (int i = logn - 1; i >= 0; --i) {
int b = (x >> i) % 2;
nodes[cur].size++;
if (nodes[cur].ne[b] == -1) {
nodes.push_back(Node());
nodes[cur].ne[b] = (int)((nodes).size()) - 1;
}
cur = nodes[cur].ne[b];
}
nodes[cur].size++;
}
int Find(int x) {
int cur = 0;
bool switched = false;
int res = 0;
for (int i = logn - 1; i >= 0; --i) {
int b = (x >> i) % 2;
int ne = nodes[cur].ne[b];
if (ne == -1) {
b = 1 - b;
switched = true;
ne = nodes[cur].ne[b];
}
assert(ne != -1);
if (nodes[ne].size == 1 && !switched) {
b = !b;
switched = true;
}
res = res * 2 + b;
cur = nodes[cur].ne[b];
assert(cur != -1);
}
return res;
}
int Solve(int cur = 0) {
if (cur == -1) return 0;
for (int b = 0; b < 2; ++b) {
if (nodes[cur].ne[b] == -1) {
return Solve(nodes[cur].ne[!b]);
}
}
int le = nodes[cur].ne[0];
int ri = nodes[cur].ne[1];
int ans_le = Solve(le);
int ans_ri = Solve(ri);
int ans = ans_le + nodes[ri].size - 1;
ans = min(ans, ans_ri + nodes[le].size - 1);
return ans;
}
private:
struct Node {
int ne[2] = {-1, -1};
int size = 0;
};
vector<Node> nodes;
};
int n;
int main() {
scanf("%d", &n);
Trie trie;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
int x;
scanf("%d", &x);
trie.Add(x);
a[i] = x;
}
cout << trie.Solve() << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using li = long long;
using ld = long double;
void solve(bool);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(20);
solve(true);
return 0;
}
const int inf = 1e9;
const int maxn = 6e5 + 55;
int tsz, n, m, q;
vector<pair<li, int> > vals;
li t[4 * maxn], tp[4 * maxn], a[maxn], b[maxn], qx[maxn];
int qi[maxn], qid[maxn], qtype[maxn], aid[maxn], pos[maxn];
void push(int v) {
tp[2 * v] += tp[v];
tp[2 * v + 1] += tp[v];
t[v] += tp[v];
tp[v] = 0;
}
void upd_seg(int v, int l, int r, int tl, int tr, int val) {
if (l > r || tl > tr) return;
if (l == tl && r == tr) {
tp[v] += val;
return;
}
push(v);
int m = (l + r) / 2;
upd_seg(2 * v, l, m, tl, min(tr, m), val);
upd_seg(2 * v + 1, m + 1, r, max(tl, m + 1), tr, val);
t[v] = min(t[2 * v] + tp[2 * v], t[2 * v + 1] + tp[2 * v + 1]);
}
int getans(int v, int l, int r) {
if (l > r || t[v] + tp[v] >= 0) return -1;
if (l == r) return vals[l].first;
push(v);
int m = (l + r) / 2;
if (t[2 * v] + tp[2 * v] < 0)
return getans(2 * v, l, m);
else
return getans(2 * v + 1, m + 1, r);
}
void upd(int v, int l, int r, int pos, int val) {
upd_seg(v, l, r, pos, pos, val);
}
void add(int id) {
int p = pos[id];
upd(1, 0, tsz, p, -inf);
upd_seg(1, 0, tsz, p, tsz, -1);
}
void del(int id) {
int p = pos[id];
upd(1, 0, tsz, p, inf);
upd_seg(1, 0, tsz, p, tsz, 1);
}
void add_p(li val) {
int r = lower_bound((vals).begin(), (vals).end(), make_pair(val, inf),
greater<pair<li, int> >()) -
vals.begin();
upd_seg(1, 0, tsz, r, tsz, 1);
}
void del_p(li val) {
int r = lower_bound((vals).begin(), (vals).end(), make_pair(val, inf),
greater<pair<li, int> >()) -
vals.begin();
upd_seg(1, 0, tsz, r, tsz, -1);
}
void solve(bool __attribute__((unused)) read) {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
aid[i] = i;
vals.push_back({a[i], i});
}
for (int i = 0; i < m; ++i) {
cin >> b[i];
}
cin >> q;
for (int i = 0; i < q; ++i) {
cin >> qtype[i] >> qi[i] >> qx[i];
--qi[i];
if (qtype[i] == 1) {
qid[i] = vals.size();
vals.push_back({qx[i], qid[i]});
}
}
sort((vals).begin(), (vals).end());
reverse((vals).begin(), (vals).end());
for (int i = 0; i < (int)vals.size(); ++i) {
pos[vals[i].second] = i;
}
tsz = (int)vals.size() - 1;
memset(t, 0, sizeof t);
memset(tp, 0, sizeof tp);
int cnt0 = 0;
for (int i = 0; i < (int)vals.size(); ++i) {
if (vals[i].second < n) {
++cnt0;
upd(1, 0, tsz, i, -cnt0);
} else {
upd(1, 0, tsz, i, -cnt0 + inf);
}
}
for (int i = 0; i < m; ++i) {
add_p(b[i]);
}
for (int i = 0; i < q; ++i) {
if (qtype[i] == 1) {
int j = qi[i];
del(aid[j]);
aid[j] = qid[i];
add(aid[j]);
} else {
int j = qi[i];
del_p(b[j]);
b[j] = qx[i];
add_p(b[j]);
}
int ans = getans(1, 0, tsz);
cout << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int mod = 998244353;
long long dp[300005][3];
vector<int> v[300005];
long long f_pow(long long a, long long b) {
long long res = 1, temp = a;
while (b) {
if (b & 1) res = res * temp % mod;
temp = temp * temp % mod;
b >>= 1;
}
return res;
}
void dfs(int first, int f) {
long long sum1 = 1, sum2 = 1, sum3 = 1;
int zero, cnt = 0;
for (auto it : v[first]) {
if (it != f) {
dfs(it, first);
if ((dp[it][0] * 2 + dp[it][1]) % mod == 0) {
cnt++;
zero = it;
} else {
sum1 *= (dp[it][0] * 2 + dp[it][1]) % mod;
sum1 %= mod;
}
sum2 *= (dp[it][0] + dp[it][1]) % mod;
sum2 %= mod;
sum3 *= (dp[it][0] * 2 + dp[it][1]) % mod;
sum3 %= mod;
}
}
dp[first][0] = 0;
dp[first][1] = sum2;
dp[first][2] = sum3;
if (cnt == 2) return;
for (auto it : v[first]) {
if (it != f) {
if (cnt == 1 && zero != it) continue;
if (!cnt)
dp[first][0] += dp[it][2] * sum1 % mod *
f_pow(dp[it][1] + dp[it][0] * 2, mod - 2) % mod;
else
dp[first][0] += dp[it][2] * sum1 % mod;
dp[first][0] %= mod;
}
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int first, second;
scanf("%d %d", &first, &second);
v[first].push_back(second);
v[second].push_back(first);
}
dfs(1, 0);
printf("%lld\n", (dp[1][0] + dp[1][1]) % mod);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int B(int n, vector<int> &a) {
int mid, diff;
set<int> num(a.begin(), a.end());
sort(a.begin(), a.end());
if (num.size() == 1)
return 0;
else if ((num.size() == 2) && ((a[0] + a[n - 1]) & 1))
return a[n - 1] - a[0];
mid = (a[0] + a[n - 1]) / 2;
diff = mid - a[0];
for (int i = 0; i < n; i++)
if ((a[i] < mid && a[i] + diff != mid) ||
(a[i] > mid && a[i] - diff != mid))
return -1;
return diff;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
cout << B(n, a);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
template <class T1, class T2, class T3>
inline void gn(T1 &x1, T2 &x2, T3 &x3) {
gn(x1, x2), gn(x3);
}
template <class T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <class T>
inline void println(T first) {
print(first);
putchar('\n');
}
template <class T>
inline void printsp(T first) {
print(first);
putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
printsp(x1), printsp(x2), println(x3);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = (long long)a * a % m)
if (b & 1) ans = (long long)ans * a % m;
return ans;
}
int size(int n) {
int ans = 0;
while (n) {
n /= 7;
ans++;
}
smax(ans, 1);
return ans;
}
int f[11], p[11];
int calc(int st, int ed) {
int ans = 0;
int nn = 0;
for (int i = ed; i >= st; i--) {
ans += p[i] * f[nn];
nn++;
}
return ans;
}
int main() {
int n, m;
gn(n, m);
int N = size(n - 1), M = size(m - 1);
if (N + M > 7) return puts("0");
f[0] = 1;
for (int i = 1; i < 11; i++) f[i] = f[i - 1] * 7;
for (int i = 0; i < 7; i++) p[i] = i;
int ans = 0;
do {
int a = calc(0, N - 1), b = calc(N, N + M - 1);
if (a < n && b < m) ans++;
} while (next_permutation(p, p + 7));
int num = 1;
for (int i = 2; i <= 7 - N - M; i++) num *= i;
println(ans / num);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
double c[55][55];
double p[55][55][55];
double dp[55][55][55];
int n, m, a[55];
void make_c() {
for (int i = 0; i <= 50; i++) {
for (int j = 0; j <= 50; j++) c[i][j] = 0;
c[i][0] = 1;
for (int j = 1; j <= i; j++) c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
}
}
void init() {
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= i; j++) {
for (int k = 0; k <= m; k++) {
p[i][j][k] = 1;
for (int l = 1; l <= j; l++) p[i][j][k] /= k;
for (int l = 1; l <= i - j; l++) p[i][j][k] *= (k - 1) / (double)k;
p[i][j][k] *= c[i][j];
}
}
}
}
void solve() {
init();
memset(dp, 0, sizeof(dp));
dp[0][n][0] = 1;
for (int i = 0; i < m; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= n; k++) {
for (int l = 0; l <= j; l++) {
int next = (l + a[i] - 1) / a[i];
next = max(k, next);
dp[i + 1][j - l][next] += dp[i][j][k] * p[j][l][m - i];
}
}
}
}
double ans = 0;
for (int i = 0; i <= n; i++) ans += dp[m][0][i] * i;
printf("%.15f\n", ans);
}
int main() {
make_c();
while (scanf("%d%d", &n, &m) == 2) {
for (int i = 0; i < m; i++) scanf("%d", a + i);
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, c = 0, d = 0, e = 0, f = 0;
cin >> n;
string a, b;
cin >> a >> b;
for (int i = 0; i < n; i++) {
if (a[i] == '1') c++;
if ((a[i] == '0') && (b[i] == '0')) d++;
if (a[i] == '0' and (b[i] == '1')) e++;
if ((a[i] == '1') and (b[i] == '0')) f++;
}
cout << (c * d) + (e * f);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010, Mod = 1e9 + 7;
long long n, a[N], x, f, ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
cin >> x >> f;
for (int i = 0; i < n; i++) ans += (a[i] + f - 1) / (x + f) * f;
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long factorial[10002];
long long power(long long a, long long b) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2) {
x = (x * y) % mod;
}
y = (y * y) % mod;
b /= 2;
}
return x % mod;
}
long long inverse[4010];
long long nCr(long long n, long long k) {
long long flag = ((factorial[n]) * (inverse[k])) % mod;
return (flag * inverse[n - k]) % mod;
}
long long bell[4010];
int main() {
factorial[0] = 1;
for (int i = 1; i < 10002; ++i) {
factorial[i] = ((long long)i * factorial[i - 1]) % mod;
}
for (int i = 0; i < 4010; ++i) {
inverse[i] = power(factorial[i], mod - 2);
}
int n;
cin >> n;
bell[0] = 1;
for (int i = 1; i < 4010; ++i) {
long long sum = 0;
for (int j = 0; j < i; ++j) {
sum = (sum + nCr(i - 1, j) * bell[j]) % mod;
}
bell[i] = sum;
}
long long ans = 0;
for (int i = 1; i < n + 1; ++i) {
ans = (ans + nCr(n, i) * bell[n - i]) % mod;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T& x) {
x = 0;
int fl = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') fl = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
x *= fl;
}
template <typename T, typename... Args>
inline void read(T& t, Args&... args) {
read(t);
read(args...);
}
const int N = 500005;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int T, n, m;
long long c[N];
vector<int> edge[N];
int main() {
read(T);
while (T--) {
read(n, m);
for (int i = 1; i <= n; i++) edge[i].clear();
for (int i = 1; i <= n; i++) read(c[i]);
for (int i = 1; i <= m; i++) {
int u, v;
read(u, v);
edge[v].emplace_back(u);
}
map<vector<int>, long long> a;
for (int i = 1; i <= n; i++) {
if (edge[i].empty()) continue;
sort(edge[i].begin(), edge[i].end());
a[edge[i]] += c[i];
}
long long ans = 0;
for (auto x : a) ans = gcd(x.second, ans);
printf("%lld\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int mod = 1e9 + 7;
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 << 1) + (x << 3) + c - '0', c = getchar();
return x * f;
}
long long a[N];
long long sum[N];
int main() {
int n = read();
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + a[i];
long long cnt = 0;
for (int i = 1; i <= n; i++) {
int o = 0;
while ((1ll << o) <= a[i]) o++;
for (int j = i - 1; j >= 1 && sum[i - 1] - sum[j] < 2 * a[i]; j--) {
if ((a[j] ^ a[i]) == (sum[i - 1] - sum[j]) && a[i] > a[j]) {
cnt++;
}
}
}
for (int i = 1; i <= n; i++) {
int o = 0;
while ((1ll << o) <= a[i]) o++;
for (int j = i + 1; j <= n && (sum[j - 1] - sum[i]) < 2 * a[i]; j++) {
if ((a[j] ^ a[i]) == (sum[j - 1] - sum[i]) && a[i] > a[j]) {
cnt++;
}
}
}
cout << cnt << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimizer("O3")
int main() {
int t;
cin >> t;
while (t--) {
int x, y, a, b;
cin >> x >> y >> a >> b;
int del = (y - x) / (a + b);
if (del * (a + b) == y - x) {
cout << del << "\n";
} else {
cout << -1 << "\n";
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int N;
int main(){
scanf("%lld", &N);
puts(N / 10 % 111 && N % 1000 % 111 ? "No" : "Yes");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct IO {
IO() {}
inline bool is(char c) { return c >= '0' && c <= '9'; }
inline int read() {
char c;
while (!is(c = getchar()))
;
int num = c - '0';
while (is(c = getchar())) num = num * 10 + c - '0';
return num;
}
inline void out(int x) {
if (x == 0) {
printf("0 ");
return;
}
char tmp[20];
int cnt = 0;
while (x) {
tmp[cnt++] = x % 10 + '0';
x /= 10;
}
for (int i = cnt - 1; i >= 0; i--) printf("%c", tmp[i]);
printf(" ");
}
} FAST;
const int N = 200005;
int n;
int off = 1, lo, hi;
vector<int> EDGE;
int LIJEVA, DESNA;
struct stabalce {
vector<pair<int, int> > graf[200005];
bool bio[200005];
vector<pair<int, int> > T[(1 << 19) + 10];
vector<pair<int, int> > V[(1 << 19) + 10];
int disc[200005];
int fin[200005];
int depth[200005];
int which_node[200005];
int timer;
pair<int, int> VEZE[200005];
stabalce() { timer = -1; }
void dfs(int node = 0, int par = -1, int dub = 0) {
disc[node] = ++timer;
which_node[timer] = node;
depth[node] = dub;
for (int i = 0; i < graf[node].size(); i++) {
int sus = graf[node][i].first;
if (sus != par) dfs(sus, node, dub + 1);
}
fin[node] = timer;
}
inline void merge(int node) {
int cnt1 = 0, cnt2 = 0;
int vel1 = (int)T[node * 2].size();
int vel2 = (int)T[node * 2 + 1].size();
for (;;) {
if (cnt1 < vel1 && cnt2 < vel2) {
if (T[node * 2][cnt1].first < T[node * 2 + 1][cnt2].first) {
T[node].push_back(T[node * 2][cnt1]);
cnt1++;
} else {
T[node].push_back(T[node * 2 + 1][cnt2]);
cnt2++;
}
} else if (cnt1 < vel1)
T[node].push_back(T[node * 2][cnt1]), cnt1++;
else if (cnt2 < vel2)
T[node].push_back(T[node * 2 + 1][cnt2]), cnt2++;
else
break;
}
}
inline void ajmo(int node) {
int cnt1 = 0, cnt2 = 0;
int vel1 = (int)V[node * 2].size();
int vel2 = (int)V[node * 2 + 1].size();
for (;;) {
if (cnt1 < vel1 && cnt2 < vel2) {
if (V[node * 2][cnt1].first > V[node * 2 + 1][cnt2].first) {
V[node].push_back(V[node * 2][cnt1]);
cnt1++;
} else {
V[node].push_back(V[node * 2 + 1][cnt2]);
cnt2++;
}
} else if (cnt1 < vel1)
V[node].push_back(V[node * 2][cnt1]), cnt1++;
else if (cnt2 < vel2)
V[node].push_back(V[node * 2 + 1][cnt2]), cnt2++;
else {
break;
}
}
}
inline void init() {
for (int i = off; i < off + off; i++) {
sort(T[i].begin(), T[i].end());
sort(V[i].begin(), V[i].end());
reverse(V[i].begin(), V[i].end());
}
for (int i = off - 1; i >= 1; i--) merge(i), ajmo(i);
}
void query(int a, int b, int node) {
if (a > hi || b < lo) return;
if (a >= lo && b <= hi) {
while (!V[node].empty()) {
int na_kojeg = V[node].back().first;
int idx = V[node].back().second;
if (bio[idx]) {
V[node].pop_back();
continue;
}
if (na_kojeg >= LIJEVA) break;
bio[idx] = 1;
V[node].pop_back();
EDGE.push_back(idx);
}
while (!T[node].empty()) {
int na_kojeg = T[node].back().first;
int idx = T[node].back().second;
if (bio[idx]) {
T[node].pop_back();
continue;
}
if (na_kojeg <= DESNA) break;
bio[idx] = 1;
T[node].pop_back();
EDGE.push_back(idx);
}
return;
}
query(a, (a + b) / 2, node * 2);
query((a + b) / 2 + 1, b, node * 2 + 1);
}
};
stabalce BLUE, RED;
inline void load() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
int x;
x = FAST.read();
--x;
BLUE.VEZE[i - 1].first = x;
BLUE.VEZE[i - 1].second = i;
BLUE.graf[x].push_back(make_pair(i, i - 1));
BLUE.graf[i].push_back(make_pair(x, i - 1));
}
for (int i = 1; i <= n - 1; i++) {
int x;
x = FAST.read();
--x;
RED.graf[x].push_back(make_pair(i, i - 1));
RED.graf[i].push_back(make_pair(x, i - 1));
RED.VEZE[i - 1].first = x;
RED.VEZE[i - 1].second = i;
}
}
inline void solve() {
while (off < n) off <<= 1;
BLUE.dfs();
RED.dfs();
for (int i = 0; i < n; i++) {
int koji_cvor = BLUE.which_node[i];
if (RED.graf[koji_cvor].empty()) continue;
for (int j = 0; j < RED.graf[koji_cvor].size(); j++) {
int susjed = RED.graf[koji_cvor][j].first;
int index = RED.graf[koji_cvor][j].second;
int ovaj_izvana = BLUE.disc[susjed];
BLUE.T[i + off].push_back(make_pair(ovaj_izvana, index));
BLUE.V[i + off].push_back(make_pair(ovaj_izvana, index));
}
}
for (int i = 0; i < n; i++) {
int koji_cvor = RED.which_node[i];
if (BLUE.graf[koji_cvor].empty()) continue;
for (int j = 0; j < BLUE.graf[koji_cvor].size(); j++) {
int susjed = BLUE.graf[koji_cvor][j].first;
int index = BLUE.graf[koji_cvor][j].second;
int ovaj_izvana = RED.disc[susjed];
RED.T[i + off].push_back(make_pair(ovaj_izvana, index));
RED.V[i + off].push_back(make_pair(ovaj_izvana, index));
}
}
BLUE.init();
RED.init();
int za_heroje;
scanf("%d", &za_heroje);
za_heroje--;
EDGE.push_back(za_heroje);
RED.bio[za_heroje] = 1;
for (int i = 0;; i++) {
if (EDGE.empty()) break;
vector<int> tmp;
if (i % 2 == 0)
printf("Blue\n");
else
printf("Red\n");
sort(EDGE.begin(), EDGE.end());
for (int j = 0; j < EDGE.size(); j++) FAST.out(EDGE[j] + 1);
printf("\n");
tmp = EDGE;
EDGE.clear();
for (int j = 0; j < tmp.size(); j++) {
if (i % 2 == 0) {
int node1 = BLUE.VEZE[tmp[j]].first;
int node2 = BLUE.VEZE[tmp[j]].second;
int dub1 = BLUE.depth[node1];
int dub2 = BLUE.depth[node2];
if (dub1 > dub2) swap(node1, node2);
lo = BLUE.disc[node2];
hi = BLUE.fin[node2];
LIJEVA = lo;
DESNA = hi;
BLUE.query(0, off - 1, 1);
} else {
int node1 = RED.VEZE[tmp[j]].first;
int node2 = RED.VEZE[tmp[j]].second;
int dub1 = RED.depth[node1];
int dub2 = RED.depth[node2];
if (dub1 > dub2) swap(node1, node2);
lo = RED.disc[node2];
hi = RED.fin[node2];
LIJEVA = lo;
DESNA = hi;
RED.query(0, off - 1, 1);
}
}
}
}
int main(void) {
load();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
long long a[N], p[N], s[N];
long long ans = 0;
int n, k, x;
signed main() {
cin >> n >> k >> x;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) {
p[i] = (i ? p[i - 1] | a[i] : a[i]);
}
for (int i = n - 1; i >= 0; --i) {
s[i] = ((i == n - 1) ? a[i] : s[i + 1] | a[i]);
}
long long mx = 1;
while (k--) mx *= 1LL * x;
for (int i = 0; i < n; ++i) {
long long tmp = a[i] * mx;
ans = max(ans, (i ? p[i - 1] : 0) | tmp | (i == n - 1 ? 0 : s[i + 1]));
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const double pi = acos(-1.0);
const int inf = 0x3f3f3f3f;
inline long long read() {
long long f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c ^ 48);
c = getchar();
}
return f * x;
}
const int N = 2e5 + 10;
int a[40][40];
int num0[100], num1[100];
int main() {
int t = read();
while (t--) {
memset(num1, 0, sizeof num1);
memset(num0, 0, sizeof num0);
int n = read(), m = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
a[i][j] = read();
if (a[i][j] == 1)
num1[i + j]++;
else
num0[i + j]++;
}
if (n == 2 && m == 2) {
puts("0");
continue;
}
int ans = 0;
int l = 2, r = n + m;
while (l < r) {
if ((num1[l] && num0[l]) || (num1[r] && num0[r]) ||
(num1[l] && num0[r]) || (num0[l] && num1[r]))
ans += min(num0[l] + num0[r], num1[l] + num1[r]);
l++, r--;
}
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool digits[10][7] = {{1, 1, 1, 0, 1, 1, 1}, {0, 0, 1, 0, 0, 1, 0},
{1, 0, 1, 1, 1, 0, 1}, {1, 0, 1, 1, 0, 1, 1},
{0, 1, 1, 1, 0, 1, 0}, {1, 1, 0, 1, 0, 1, 1},
{1, 1, 0, 1, 1, 1, 1}, {1, 0, 1, 0, 0, 1, 0},
{1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 0, 1, 1}};
bool valid(int d1, int d2) {
for (int i = 0; i < 7; ++i) {
if (digits[d1][i] && !digits[d2][i]) {
return false;
}
}
return true;
}
int count(int dig) {
int cnt = 1;
for (int i = 0; i < 10; ++i) {
if (i != dig) {
if (valid(dig, i)) ++cnt;
}
}
return cnt;
}
int main() {
ios_base::sync_with_stdio(0);
char c1, c2;
cin >> c1 >> c2;
cout << count(c1 - '0') * count(c2 - '0') << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int containsDigit(long long int number, long long int digit) {
while (number != 0) {
int curr_digit = number % 10;
if (curr_digit == digit) return 1;
number /= 10;
}
return 0;
}
long long int soltn(long long int x, long long int n) {
if (x >= 0)
return x % n;
else
return n + x % n;
}
long long int bin_srch(long long int L[], long long int N, long long int item) {
long long int flag = -2;
int l = 0, u = N - 1, m;
while (l <= u) {
m = (l + u) / 2;
if (item == L[m]) {
flag = m - 1;
break;
} else if (item > L[m])
l = m - 1;
else
u = m + 1;
}
return flag;
}
long long int modExp(long long int b, long long int p) {
long long int res = 1;
while (p > 0) {
if (p & 1) {
res = (res * b) % 1000000007;
}
b = (b * b) % 1000000007;
p >>= 1;
}
return res;
}
long long int properdiv(long long int x, long long int y) {
if (x % y == 0)
return x / y;
else
return x / y + 1;
}
long long int coda(long long int n, long long int d) {
long long int count = 0;
while (n != 0) {
if (n % 10 == d) count++;
n /= 10;
}
return count;
}
long long int mdls(long long int x) { return max(x, -x); }
int main() {
long long int i, j, k, N;
cin >> N;
string s;
cin >> s;
long long int z = 0, e = 0, n = 0, r = 0, o = 0;
for (long long int i = 0; i < N; i++) {
if (s[i] == 'z')
z++;
else if (s[i] == 'e')
e++;
else if (s[i] == 'r')
r++;
else if (s[i] == 'o')
o++;
else if (s[i] == 'n')
n++;
}
long long int one = min(min(o, n), e);
e = e - min(min(o, n), e);
o = o - min(min(o, n), e);
n = n - min(min(o, n), e);
long long int zero = min(min(z, e), min(r, o));
for (long long int i = 0; i < one; i++) cout << 1 << " ";
for (long long int i = 0; i < zero; i++) cout << 0 << " ";
cout << endl;
return 0;
}
| 1 |
#define _CRT_SECURE_NO_WARNINGS
#include"bits/stdc++.h"
#ifdef _DEBUG
#define DBG(n) n
#else
#define DBG(n)
#endif
#define INF 1e9
#define INFLL 1e18
#define EPS 1e-9
#define REP(i,n) for(ll i=0,i##_len=(n);i<i##_len;++i)
#define REP1(i,n) for(ll i=1,i##_len=(n);i<=i##_len;++i)
#define REPR(i,n) for(ll i=(n)-1;i>=0;--i)
#define REPR1(i,n) for(ll i=(n);i>0;--i)
#define REPC(i,obj) for(auto i:obj)
#define ALL(obj) (obj).begin(),(obj).end()
#define SETP(n) cout<<fixed<<setprecision(n)
#define VEC2(T,h,w) move(vector<vector<T>>(h,vector<T>(w)))
#define VEC2I(T,h,w,i) move(vector<vector<T>>(h,vector<T>(w,i)))
using namespace std;
using ll = long long;
template<typename T, ll h, ll w>using vec2 = vector<vector<T>>;
template<typename T = ll>inline T in() { T ret; cin >> ret; return ret; }
signed main()
{
ll m = in(), n = in();
vector<vector<ll>>dist(m);
vector<ll> indeg(m, 0);
REP(i, n) {
ll x = in() - 1, y = in() - 1;
dist[x].push_back(y);
++indeg[y];
}
ll cnt = 0;
while (true) {
REP(i, m) {
if (indeg[i] == 0) {
cout << i + 1 << endl;
--indeg[i];
if (++cnt == m) return 0;
REPC(j, dist[i]) --indeg[j];
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
string s, t;
cin >> s >> t;
vector<int> moves;
for (int i = 0; i < (int)(n); ++i) {
char c = t[n - 1 - i];
int x = -1;
for (int j = i; j < n; j++) {
if (s[j] == c) {
x = j;
break;
}
}
if (x == -1) {
cout << -1 << endl;
return 0;
}
moves.push_back(n);
moves.push_back(x);
moves.push_back(1);
s.erase(x, 1);
s.insert(s.begin(), c);
reverse(s.begin() + x + 1, s.end());
}
cout << moves.size() << "\n";
for (int i = 0; i < (int)(moves.size()); ++i)
cout << moves[i] << " \n"[i + 1 == moves.size()];
return 0;
}
| 3 |
#include <bits/stdc++.h>
const int maxn = 2e5 + 10;
const int inf = 0x3f3f3f3f;
const double eps = 1e-7;
const int mod = 1e9 + 7;
const double pi = acos(-1.0);
using namespace std;
vector<int> p[27];
int vis[maxn];
int main() {
int n;
cin >> n;
string a, t;
cin >> t;
for (int i = 1; i <= n; i++) a += t;
for (int i = 0; i < a.size(); i++) {
p[a[i] - 'a' + 1].push_back(i);
}
int m;
cin >> m;
int x;
char c;
while (m--) {
cin >> x >> c;
vis[p[c - 'a' + 1][x - 1]] = 1;
p[c - 'a' + 1].erase(p[c - 'a' + 1].begin() + x - 1);
}
for (int i = 0; i < a.size(); i++) {
if (!vis[i]) printf("%c", a[i]);
}
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
#define rep(i, n) for(int i=0; i<(int)(n); ++i)
const int M = 1e9 + 7;
ll mod_pow(ll a, ll b) {
ll ans = 1;
while (b){
if (b&1) ans = ans * a % M;
a = a * a % M;
b >>= 1;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
ll n, k;
cin >> n >> k;
vector<ll> c(k+1);
for (ll i = k; i >= 1; --i) {
c[i] = mod_pow(k / i, n);
int j = 2;
while (i * j <= k) {
c[i] = (c[i] + M - c[i*j])%M;
++j;
}
}
ll ans = 0;
rep(i, k+1) {
ans += (c[i] * i % M);
ans %= M;
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return __builtin_popcountll(s);
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
long long n, L, d;
int RR[2025];
long long f[2025][2025];
map<pair<int, long long>, long long> M;
long long cal(int id, long long x) {
if (M[make_pair(id, x)]) return M[make_pair(id, x)] - 1;
fflush(stdout);
cout << "? " << id << " " << x << endl;
long long res;
cin >> res;
M[make_pair(id, x)] = res + 1;
return res;
}
long long find(int id, int vt) {
long long &res = f[id][vt];
if (res != -1) return res;
long long x = vt * d;
long long l = 0, r = (long long)(1e18);
while (l < r) {
long long mid = (l + r) / 2;
if (cal(id, mid) < x)
l = mid + 1;
else
r = mid;
}
res = l;
return res;
}
pair<vector<int>, vector<int> > divide(vector<int> V, int u, int v, int k) {
int len = (v - u + 1);
int id = V[rand() % len];
long long vt = find(id, k);
vector<int> behon, lonhon, bang;
for (int i = 0; i < (((int)(V).size())); ++i) {
int x = V[i];
long long y = cal(x, vt);
if (y > k * d)
behon.push_back(x);
else if (y == k * d)
bang.push_back(x);
else
lonhon.push_back(x);
}
pair<vector<int>, vector<int> > res;
if (((int)(behon).size()) > k - u) {
pair<vector<int>, vector<int> > temp =
divide(behon, u, u + ((int)(behon).size()) - 1, k);
res = temp;
for (int i = 0; i < (((int)(bang).size())); ++i)
res.second.push_back(bang[i]);
for (int i = 0; i < (((int)(lonhon).size())); ++i)
res.second.push_back(lonhon[i]);
temp.first.clear();
temp.second.clear();
} else if (((int)(lonhon).size()) > v - k) {
pair<vector<int>, vector<int> > temp =
divide(lonhon, v - ((int)(lonhon).size()) + 1, v, k);
res = temp;
for (int i = 0; i < (((int)(behon).size())); ++i)
res.first.push_back(behon[i]);
for (int i = 0; i < (((int)(bang).size())); ++i)
res.first.push_back(bang[i]);
temp.first.clear();
temp.second.clear();
} else {
for (int i = 0; i < (((int)(behon).size())); ++i)
res.first.push_back(behon[i]);
for (int i = 0; i < (((int)(bang).size())); ++i) {
if (((int)(res.first).size()) < k - u + 1)
res.first.push_back(bang[i]);
else
res.second.push_back(bang[i]);
}
for (int i = 0; i < (((int)(lonhon).size())); ++i)
res.second.push_back(lonhon[i]);
}
V.clear();
behon.clear();
bang.clear();
lonhon.clear();
return res;
}
void go(vector<int> V, int u, int v) {
int mid = (u + v) / 2;
int len = (v - u + 1);
if (u == v) {
RR[V[0]] = u;
return;
}
pair<vector<int>, vector<int> > VV = divide(V, u, v, mid);
go(VV.first, u, mid);
go(VV.second, mid + 1, v);
}
void sol() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
srand(time(NULL));
memset(f, -1, sizeof(f));
cin >> n >> L;
d = L / n;
vector<int> V;
for (int i = (1); i <= (n); ++i) V.push_back(i);
go(V, 1, n);
vector<long long> vv;
vv.push_back(0);
for (int i = (1); i <= (n); ++i) vv.push_back(find(i, RR[i]));
sort((vv).begin(), (vv).end());
cout << "!" << endl;
for (int i = (1); i <= (n); ++i)
cout << vv[RR[i] - 1] << " " << vv[RR[i]] << endl;
}
int main() {
sol();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long linf = 1e18 + 9;
const int inf = 1e9 + 9;
const int N = 3e3 + 9;
int dp[N][N];
int hash[N][N], h[N];
int d[N][N], d2[N][N];
string str, ans, ans2;
void print() {
int bas = 0, son = str.size() - 1;
while (bas <= son) {
if (bas == son) {
ans += str[bas];
break;
} else if (d[bas][son] == 1) {
ans += str[bas];
ans2 += str[son];
bas++, son--;
} else if (d[bas][son] == 2)
son--;
else
bas++;
if (ans.size() + ans2.size() == 100) break;
}
reverse(ans2.begin(), ans2.end());
cout << ans << ans2 << endl;
}
int f(int bas, int son) {
int &r = dp[bas][son];
if (r != -1) return r;
if (bas > son or son < bas or bas >= str.size() or son < 0) return r = 0;
if (bas == son) {
return r = 1;
}
if (str[bas] == str[son]) {
r = 1;
r += f(bas + 1, son - 1);
r++;
d[bas][son] = 1;
} else {
int mx1 = f(bas, son - 1);
int mx2 = f(bas + 1, son);
if (mx1 > mx2)
d[bas][son] = 2;
else
d[bas][son] = 3;
r = max(mx1, mx2);
}
return r;
}
int main() {
cin >> str;
for (int i = 0; i < str.size(); i++) h[str[i]]++;
for (int i = 0; i < 26; i++) {
if (h[i + 'a'] >= 100) {
for (int j = 1; j <= min(100, h[i + 'a']); j++) {
cout << (char)(i + 'a');
}
return 0;
}
}
memset(dp, -1, sizeof dp);
f(0, str.size() - 1);
print();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct T {
int x;
T() { x = -1; }
T(int _x) { x = _x; }
};
T operator+(const T &L, const T &R) {
if (L.x == -1) return R;
if (R.x == -1) return L;
return T(L.x | R.x);
}
T operator-(const T &L, const T &R) {
if (L.x == -1) return R;
if (R.x == -1) return L;
return T(L.x & R.x);
}
struct LazyPropagation {
vector<T> v;
int N;
void sz(int x) {
N = 1;
while (N < x) N <<= 1;
v.resize(N << 1, T());
}
void add(int pos, T x) { v[N + pos] = x; }
T query(int pos) {
T ans = T((1 << 30) - 1);
for (pos += N; pos > 0; pos >>= 1) ans = ans - v[pos];
return ans;
}
void update(int l, int r, T &x) {
for (l += N, r += N; l < r; l >>= 1, r >>= 1) {
if (l & 1) v[l] = v[l++] + x;
if (r & 1) v[--r] = v[r] + x;
}
}
void Flush() {
for (int i = 1; i < N; i++) {
v[i << 1] = v[i << 1] + v[i];
v[i << 1 | 1] = v[i << 1 | 1] + v[i];
v[i] = -1;
}
}
};
struct SegmentTree {
vector<T> v;
int N;
void sz(int x) {
N = 1;
while (N < x) N <<= 1;
v.assign(N << 1, T());
}
void add(int pos, T x) { v[N + pos] = x; }
void build() {
for (int i = N - 1; i > 0; i--) v[i] = v[i << 1] - v[i << 1 | 1];
}
T query(int l, int r) {
T ans1 = T(), ans2 = T();
for (l += N, r += N; l < r; l >>= 1, r >>= 1) {
if (l & 1) ans1 = ans1 - v[l++];
if (r & 1) ans2 = v[--r] - ans2;
}
return ans1 - ans2;
}
void update(int pos, T x) {
for (v[pos + N] = x, pos = (pos + N) >> 1; pos > 0; pos >>= 1)
v[pos] = v[pos << 1] + v[pos << 1 | 1];
}
};
vector<pair<int, pair<int, int> > > res;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
LazyPropagation H;
H.sz(n);
for (int i = 0; i < m; i++) {
int l, r, q;
cin >> l >> r >> q;
res.push_back({l, {r, q}});
T xx = T(q);
H.update(l - 1, r, xx);
}
H.Flush();
SegmentTree P;
P.sz(n);
for (int i = 0; i < n; i++) P.add(i, H.v[H.N + i].x);
P.build();
for (auto a : res) {
if (P.query(a.first - 1, a.second.first).x == a.second.second) {
continue;
} else {
cout << "NO" << '\n';
return 0;
}
}
cout << "YES" << '\n';
for (int i = 0; i < n; i++) {
if (H.v[H.N + i].x == -1)
cout << ((1 << 30) - 1) << " ";
else
cout << H.v[H.N + i].x << " ";
}
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[15] = {0}, b[15] = {0}, x, ans[105] = {0};
vector<int> v;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
a[x]++;
}
for (int i = 0; i < n; i++) {
cin >> x;
b[x]++;
}
int cnt = 0, flag = 0;
for (int i = 1; i <= 5; i++) {
if ((a[i] + b[i]) % 2 == 1) {
flag = 1;
}
int y = abs(a[i] - b[i]);
cnt = cnt + y;
if (y > 0) v.push_back(y);
}
if (v.size() > 1 && cnt % 4 == 0 && flag == 0) {
cout << cnt / 4;
} else if (cnt == 0) {
cout << 0 << endl;
} else {
cout << "-1" << endl;
}
}
| 1 |
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <complex>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <cassert>
typedef long long ll;
using namespace std;
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
#define mod 1000000007 //1e9+7(prime number)
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define SIZE 100010
/* Aho Corasick */
struct ACNode{
int val;
ACNode *next[26], *failure;
ACNode():val(0) { memset(next,0,sizeof(next)); }
void insert(char *s){
if(!*s){ val++; return; }
int al = *s-'a';
if(next[al]==NULL) next[al] = new ACNode;
next[al]->insert(s+1);
}
ACNode *nextNode(char c){
int al = c - 'a';
if (next[al]) return next[al];
return failure == this ? this : failure->nextNode(c);
}
};
struct AhoCorasick{
ACNode *node;
AhoCorasick(){node = new ACNode;}
void insert(char *s) {
node->insert(s);
}
void build() {
queue<ACNode*> que;
que.push(node);
node->failure = node;
while(que.size()){
ACNode *p = que.front();
que.pop();
for(int i=0;i<26;i++){
if(p->next[i]){
ACNode *failure = p->failure;
while(!failure->next[i] && failure != node){
failure = failure->failure;
}
if (failure->next[i] && failure != p){
p->next[i]->failure = failure->next[i];
p->next[i]->val += failure->next[i]->val;
}else{
p->next[i]->failure = node;
}
que.push(p->next[i]);
}
}
}
}
};
int main(){
int n;
char S[SIZE], p[SIZE];
AhoCorasick ac;
scanf("%s%d", S, &n);
for(int i=0;i<n;i++){
scanf("%s", p);
ac.insert(p);
}
ac.build();
int ans = 0;
ACNode *cur = ac.node;
for(int i=0;S[i];i++){
cur = cur->nextNode(S[i]);
if(cur->val){
ans++;
cur = ac.node;
}
}
printf("%d\n", ans);
return 0;
}
| 0 |
/**
* author: milos
* created: 11.04.2021 16:53:22
**/
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T inverse(T a, T m) {
T u = 0, v = 1;
while (a != 0) {
T t = m / a;
m -= t * a; swap(a, m);
u -= t * v; swap(u, v);
}
assert(m == 1);
return u;
}
template <typename T>
class Modular {
public:
using Type = typename decay<decltype(T::value)>::type;
constexpr Modular() : value() {}
template <typename U>
Modular(const U& x) {
value = normalize(x);
}
template <typename U>
static Type normalize(const U& x) {
Type v;
if (-mod() <= x && x < mod()) v = static_cast<Type>(x);
else v = static_cast<Type>(x % mod());
if (v < 0) v += mod();
return v;
}
const Type& operator()() const { return value; }
template <typename U>
explicit operator U() const { return static_cast<U>(value); }
constexpr static Type mod() { return T::value; }
Modular& operator+=(const Modular& other) { if ((value += other.value) >= mod()) value -= mod(); return *this; }
Modular& operator-=(const Modular& other) { if ((value -= other.value) < 0) value += mod(); return *this; }
template <typename U> Modular& operator+=(const U& other) { return *this += Modular(other); }
template <typename U> Modular& operator-=(const U& other) { return *this -= Modular(other); }
Modular& operator++() { return *this += 1; }
Modular& operator--() { return *this -= 1; }
Modular operator++(int) { Modular result(*this); *this += 1; return result; }
Modular operator--(int) { Modular result(*this); *this -= 1; return result; }
Modular operator-() const { return Modular(-value); }
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int>::value, Modular>::type& operator*=(const Modular& rhs) {
#ifdef _WIN32
uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x), d, m;
asm(
"divl %4; \n\t"
: "=a" (d), "=d" (m)
: "d" (xh), "a" (xl), "r" (mod())
);
value = m;
#else
value = normalize(static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value));
#endif
return *this;
}
template <typename U = T>
typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value, Modular>::type& operator*=(const Modular& rhs) {
int64_t q = static_cast<int64_t>(static_cast<long double>(value) * rhs.value / mod());
value = normalize(value * rhs.value - q * mod());
return *this;
}
template <typename U = T>
typename enable_if<!is_integral<typename Modular<U>::Type>::value, Modular>::type& operator*=(const Modular& rhs) {
value = normalize(value * rhs.value);
return *this;
}
Modular& operator/=(const Modular& other) { return *this *= Modular(inverse(other.value, mod())); }
template <typename U>
friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
template <typename U>
friend std::istream& operator>>(std::istream& stream, Modular<U>& number);
private:
Type value;
};
template <typename T> bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value == rhs.value; }
template <typename T, typename U> bool operator==(const Modular<T>& lhs, U rhs) { return lhs == Modular<T>(rhs); }
template <typename T, typename U> bool operator==(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) == rhs; }
template <typename T> bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(const Modular<T>& lhs, U rhs) { return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(U lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
template <typename T> bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value < rhs.value; }
template <typename T> Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
template <typename T> Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
template <typename T> Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
template <typename T> Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }
template<typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b) {
assert(b >= 0);
Modular<T> x = a, res = 1;
U p = b;
while (p > 0) {
if (p & 1) res *= x;
x *= x;
p >>= 1;
}
return res;
}
template <typename T>
string to_string(const Modular<T>& number) {
return to_string(number());
}
template <typename T>
std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) {
return stream << number();
}
template <typename T>
std::istream& operator>>(std::istream& stream, Modular<T>& number) {
typename common_type<typename Modular<T>::Type, int64_t>::type x;
stream >> x;
number.value = Modular<T>::normalize(x);
return stream;
}
/*
using ModType = int;
struct VarMod { static ModType value; };
ModType VarMod::value;
ModType& md = VarMod::value;
using Mint = Modular<VarMod>;
*/
constexpr int md = 1e9 + 7;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
vector<Mint> fact(1, 1);
vector<Mint> inv_fact(1, 1);
Mint C(int n, int k) {
if (k < 0 || k > n) {
return 0;
}
while ((int) fact.size() < n + 1) {
fact.push_back(fact.back() * (int) fact.size());
inv_fact.push_back(1 / fact.back());
}
return fact[n] * inv_fact[k] * inv_fact[n - k];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt--) {
int n;
cin >> n;
vector<int> a(n);
int res = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i == 0) {
res = a[0];
} else {
res &= a[i];
}
}
sort(a.begin(), a.end());
if (a[0] != res) {
cout << 0 << '\n';
continue;
}
Mint cnt = 0;
for (int i = 0; i < n; i++) {
if (a[i] == a[0]) {
cnt++;
}
}
if (cnt == 1) {
cout << 0 << '\n';
continue;
}
Mint ans = cnt * (cnt - 1);
for (int i = 1; i <= n - 2; i++) ans *= i;
cout << ans << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double pi = acos(-1.0);
const int K = 1e5 + 7;
const int mod = 1e9 + 7;
int n, m, q, f[K], rl[K];
map<string, int> hs;
string sa, sb;
int fd(int x) {
if (f[x] == x) return x;
int fa = f[x];
f[x] = fd(f[x]);
rl[x] = (rl[x] + rl[fa]) % 2;
return f[x];
}
int main(void) {
cin >> n >> m >> q;
for (int i = 1; i <= n; i++) cin >> sa, hs[sa] = i, f[i] = i;
for (int i = 1, op; i <= m; i++) {
cin >> op >> sa >> sb;
int x = hs[sa], y = hs[sb];
int fx = fd(x), fy = fd(y);
op--;
if (fx != fy) {
puts("YES");
f[fy] = fx;
rl[fy] = (op + rl[x] + rl[y]) % 2;
} else {
if ((rl[x] + rl[y]) % 2 == op)
puts("YES");
else
puts("NO");
}
}
for (int i = 1, ans; i <= q; i++) {
cin >> sa >> sb;
int x = hs[sa], y = hs[sb];
int fx = fd(x), fy = fd(y);
if (fx != fy)
ans = 3;
else if ((rl[x] + rl[y]) % 2 == 0)
ans = 1;
else
ans = 2;
printf("%d\n", ans);
}
return 0;
}
| 4 |
#include<iostream>
using namespace std;
int main(){
long long n,nmon;
long long sum=0,avr;
cin>>n;
for(int i=0;i<n;i++){
cin>>nmon;
sum+=nmon;
}
avr=sum/n;
cout<<avr<<endl;
return 0;
} | 0 |
#include<iostream>
using namespace std;
int l;
string a;
int main()
{
cin>>a;
l=a.size();
cout<<a[0]<<l-2<<a[l-1];
} | 0 |
#include <bits/stdc++.h>
const int N = 1000010;
using ll = long long;
using pii = std::pair <ll, ll>;
template <typename T>
void read(T &n){
char ch;
while (!isdigit(ch = getchar()))
;
n = ch - '0';
while (isdigit(ch = getchar())){
n = n * 10 + ch - '0';
}
}
struct Treap{
#define ls(u) (ch[(u)][0])
#define rs(u) (ch[(u)][1])
int root;
ll val[N], key[N], sum[N], sum1[N], key1[N];
int sz[N], lazy[N], cnt[N];
int ch[N][2];
void pull(int u){
sz[u] = sz[ls(u)] + sz[rs(u)] + cnt[u];
sum[u] = sum[ls(u)] + sum[rs(u)] + key[u];
sum1[u] = sum1[ls(u)] + sum1[rs(u)] + key1[u];
}
void push(int u){
if (!lazy[u]){
return;
}
update(ls(u), lazy[u]);
update(rs(u), lazy[u]);
lazy[u] = 0;
}
void update(int u, int value){
sum1[u] += value * sum[u];
key1[u] += value * key[u];
lazy[u] += value;
}
int build(int sit, ll *c, int l, int r){
if (l > r){
return 0;
}
int mid = (l + r + 1) / 2;
val[sit] = c[mid];
ls(sit) = build(sit << 1, c, l, mid - 1);
rs(sit) = build(sit << 1 | 1, c, mid + 1, r);
return sit;
}
void build(ll *c, int cnt){
root = build(1, c, 0, cnt - 1);
}
pii split(int p, ll u){
if (!p) return {0, 0};
push(p);
if (val[p] <= u){
pii ret = split(rs(p), u);
rs(p) = ret.first;
pull(p);
return {p, ret.second};
}
pii ret = split(ls(p), u);
ls(p) = ret.second;
pull(p);
return {ret.first, p};
}
int merge(int u, int v){
if (!u || !v) return u ^ v;
if (u < v){
push(u);
rs(u) = merge(rs(u), v);
pull(u);
return u;
}
push(v);
ls(v) = merge(u, ls(v));
pull(v);
return v;
}
void insert(ll x){
pii pair = split(root, x);
pii pair1 = split(pair.first, x - 1);
int node = pair1.second;
key[node] = x;
key1[node] = (sz[pair1.first] + 1) * x;
cnt[node] = 1;
pull(node);
update(pair.second, 1);
root = merge(pair1.first, node);
root = merge(root, pair.second);
}
void erase(ll x){
pii pair = split(root, x);
update(pair.second, -1);
pii pair1 = split(pair.first, x - 1);
int node = pair1.second;
key[node] = 0;
key1[node] = 0;
cnt[node] = 0;
pull(node);
root = merge(pair1.first, node);
root = merge(root, pair.second);
}
pii pre(int u, int count){
if (!u || count <= 0){
return {0, 0};
}
if (count >= sz[u]){
return {sum[u], sum1[u]};
}
push(u);
if (count <= sz[ls(u)]){
return pre(ls(u), count);
}
pii ret = pre(rs(u), count - sz[ls(u)] - cnt[u]);
ll x = ret.first + sum[ls(u)] + key[u];
ll y = ret.second + sum1[ls(u)] + key1[u];
return {x, y};
}
pii suf(int u, int count){
if (!u || count <= 0){
return {0, 0};
}
if (count >= sz[u]){
return {sum[u], sum1[u]};
}
push(u);
if (count <= sz[rs(u)]){
return suf(rs(u), count);
}
pii ret = suf(ls(u), count - sz[rs(u)] - cnt[u]);
ll x = ret.first + sum[rs(u)] + key[u];
ll y = ret.second + sum1[rs(u)] + key1[u];
return {x, y};
}
};
Treap treap;
ll a[N], b[N], c[N];
int type[N];
ll calc(){
int sz = treap.sz[treap.root];
if (sz <= 1){
return 0;
}
pii tot = treap.pre(treap.root, sz);
pii left = treap.pre(treap.root, (sz + 1) / 2);
pii right = treap.suf(treap.root, (sz - 1) / 2);
if (right.first <= left.first){
right = treap.suf(treap.root, sz - 1);
ll add = tot.first * (sz + 1) - tot.second;
ll sub = right.second - right.first;
ll valid = add - sub;
return tot.first - valid;
}
int l = 1, r = (sz + 1) / 2;
while (l < r){
int mid = (l + r + 1) / 2;
if (treap.pre(treap.root, mid).first <= treap.suf(treap.root, mid - 1).first){
r = mid - 1;
}
else{
l = mid;
}
}
left = treap.pre(treap.root, l);
right = treap.suf(treap.root, l - 1);
ll add = left.first * (l + 1) - left.second;
ll sub = right.second - right.first * (sz - l + 1);
ll valid = (add - sub) * 2;
return tot.first - valid;
}
int main(){
int n, q;
read(n), read(q);
int cnt = 0;
for (int i = 0; i < n; ++ i){
read(a[i]);
c[cnt ++] = a[i];
}
for (int i = 0; i < q; ++ i){
scanf("%d%lld", &type[i], &b[i]);
c[cnt ++] = b[i];
}
std::sort(c, c + cnt);
cnt = std::unique(c, c + cnt) - c;
treap.build(c, cnt);
for (int i = 0; i < n; ++ i){
treap.insert(a[i]);
}
printf("%lld\n", calc());
for (int i = 0; i < q; ++ i){
int op = type[i];
ll x = b[i];
if (op == 1){
treap.insert(x);
}
else{
treap.erase(x);
}
printf("%lld\n", calc());
}
return 0;
} | 5 |
#include<iostream>
#include<cstdio>
using namespace std;
int main() {
int n, b, sum2;
float y, r, t, joe;
float sum = 0, math, s, d;
while (1) {
scanf("%d", &n);
if (n == 0)return 0;
cin >> y;
for (int i = 0; i < n; i++) {
cin >> b >> r >> t;
if (t == 1) {
math = 10000 * (1 + y*(r / 100));
s = math;
}
else if (t == 2) {
math = 1 + (r / 100);
joe = math;
//cout<<math;
for (int i = 0; i < y - 1; i++) {
joe = joe*math;
}
//cout << math;
math = 10000 * joe;
d = math;
}
if (i == 0) {
sum = math;
sum2 = b;
continue;
}
if (sum < math) {
sum = math;
sum2 = b;
}
}
printf("%d\n", sum2);
sum = sum2 = 0;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, sum1[100050], sum2[100050];
char a[100050];
int main() {
scanf("%s", a + 1), n = strlen(a + 1);
for (int i = 1; i <= n; i++)
sum1[i] = sum1[i - 1] + bool(a[i] >= 'a' && a[i] <= 'z');
for (int i = n; i >= 1; i--)
sum2[i] = sum2[i + 1] + bool(a[i] >= 'A' && a[i] <= 'Z');
int ans = 0x3f3f3f3f;
for (int i = 0; i <= n; i++) ans = min(ans, sum1[i] + sum2[i + 1]);
printf("%d\n", ans);
return 0;
}
| 3 |
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <vector>
#include <queue>
using namespace std;
typedef pair<int,int> pii;
struct Situation{
public:
pii cost;
int node;
int rev;
Situation(pii cost_,int node_,int rev_){
cost=cost_;
node=node_;
rev=rev_;
}
Situation();
bool operator<(const Situation &s)const{
return s.cost<this->cost;
}
};
const int INF=1000000000;
const int MAX_V=1001;
vector<int> G[MAX_V];
vector<int> revG[MAX_V];
pii d[MAX_V][2];
int EdgeNum[MAX_V][MAX_V];
pii prevv[MAX_V][2];
void dijkstra(int s){
priority_queue<Situation> que;
for(int i=0;i<MAX_V;i++){
for(int j=0;j<2;j++){
d[i][j].first=INF;d[i][j].second=0;
prevv[i][j].first=prevv[i][j].second=-1;
}
}
d[s][0].first=0;
que.push(Situation(pii(0,0),s,0));
while(que.size()){
Situation p=que.top();que.pop();
int node=p.node;
pii cost=p.cost;
int rev=p.rev;
if(d[node][rev]<cost)continue;
for(int i=0;i<G[node].size();i++){
int to=G[node][i];
if(d[to][rev].first>d[node][rev].first+1){
d[to][rev].first=d[node][rev].first+1;
d[to][rev].second=d[node][rev].second;
que.push(Situation(d[to][rev],to,rev));
prevv[to][rev]=pii(node,rev);
}
// 一致する場合
else if(d[to][rev].first
==d[node][rev].first+1){
if(d[to][rev].second>d[node][rev].second){
d[to][rev].second=d[node][rev].second;
que.push(Situation(d[to][rev],to,rev));
prevv[to][rev]=pii(node,rev);
}
}
}
if(!rev){
for(int i=0;i<revG[node].size();i++){
int to=revG[node][i];
if(d[to][rev^1].first>d[node][rev].first+1){
d[to][rev^1].first=d[node][rev].first+1;
d[to][rev^1].second=EdgeNum[to][node];
que.push(Situation(d[to][rev^1],to,rev^1));
prevv[to][rev^1]=pii(node,rev);
}
else if(d[to][rev^1].first
==d[node][rev].first+1){
if(d[to][rev^1].second>EdgeNum[to][node]){
d[to][rev^1].second=EdgeNum[to][node];
que.push(Situation(d[to][rev^1],to,rev));
prevv[to][rev^1]=pii(node,rev);
}
}
}
}
}
}
int N,M;
int S,T;
int main(){
while(cin>>N&&N){
for(int i=0;i<N;i++){
G[i].clear();
revG[i].clear();
}
cin>>S>>T;
S--;T--;
cin>>M;
for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
EdgeNum[i][j]=INF;
for(int i=0;i<M;i++){
int a,b;
cin>>a>>b;
a--;b--;
G[a].push_back(b);
revG[b].push_back(a);
EdgeNum[a][b]=min(EdgeNum[a][b],i+1);
EdgeNum[b][a]=min(EdgeNum[b][a],i+1);
}
dijkstra(S);
pii res=min(d[T][0],d[T][1]);
cout<<res.first<<" "<<res.second<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
string s;
cin >> s;
sort(s.begin(), s.end());
if (s[0] == s[s.length() - 1])
cout << -1 << endl;
else
cout << s << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, x;
int cnt[N];
int main() {
scanf("%d", &n);
int res = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
if (x > n) res++;
else cnt[x]++;
}
for (int i = 1; i <= n; i++) {
res += cnt[i];
if (cnt[i] >= i) res -= i;
}
cout << res;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dois, cinco, sete, zero1, zero2, dist, tam, inf = 1000 * 1000 * 1000;
int mind = inf;
string num;
int main() {
cin >> num;
tam = num.size();
for (int k = 0; k < tam; k++) {
char c = num[k];
if (c == '2')
dois = k + 1;
else if (c == '5')
cinco = k + 1;
else if (c == '7')
sete = k + 1;
else if (c == '0')
zero2 = k + 1;
}
for (int k = 0; k < tam; k++) {
if (num[k] == '0' && k + 1 != zero2) zero1 = k + 1;
}
if (dois && cinco) {
dist = 0;
if ((dois == 1 && num[1] == '0') || (cinco == 1 && num[1] == '0')) {
for (int k = 1; k < tam && num[k] == '0'; k++, dist++)
;
}
if (cinco < dois) dist++;
dist += tam - cinco + tam - 1 - dois;
mind = min(dist, mind);
}
if (sete && cinco) {
dist = 0;
if ((sete == 1 && num[1] == '0') || (cinco == 1 && num[1] == '0')) {
for (int k = 1; k < tam && num[k] == '0'; k++, dist++)
;
}
if (cinco < sete) dist++;
dist += tam - cinco + tam - 1 - sete;
mind = min(dist, mind);
}
if (cinco && zero2) {
dist = 0;
if (zero2 < cinco) dist++;
dist += tam - zero2 + tam - 1 - cinco;
mind = min(dist, mind);
}
if (zero1 && zero2) {
dist = 0;
dist += tam - zero2 + tam - 1 - zero1;
mind = min(dist, mind);
}
cout << (mind < inf ? mind : -1) << endl;
return 0;
}
| 5 |
#include<iostream>
#include<cstring>
#include<cassert>
#include<cmath>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<vector>
#include<cstdio>
#include<time.h>
#include<algorithm>
using namespace std;
#define REP(i,x,y) for(ll i=x;i<=y;i++)
#define rep(i,n) REP(i,1,n)
#define rep0(i,n) REP(i,0,n-1)
#define repG(i,x) for(ll i=pos[x];~i;i=e[i].next)
#define ll long long
#define db double
const ll N=1e5+7;
const ll INF=1e9+7;
ll n,m,q;
ll a[N],b[N],c[N],f[N],sz[N];
ll ff(ll x){return (f[x]==x)?x:f[x]=ff(f[x]);}
int main(){
scanf("%lld%lld%lld",&n,&m,&q);
rep(i,q)scanf("%lld%lld%lld",&a[i],&b[i],&c[i]);
rep(i,q)a[i]++,b[i]++;
if(m==n-1)rep(i,q)if(c[i]){puts("No"); return 0;}
rep(i,n)f[i]=i,sz[i]=1;
rep(i,q){
if(!c[i]){
ll u=ff(a[i]),v=ff(b[i]);
if(u!=v){
sz[v]+=sz[u];
f[u]=v;
}
}
}
rep(i,q)if(c[i])if(ff(a[i])==ff(b[i])){puts("No"); return 0;}
ll hh=0;
rep(i,n)if(ff(i)==i)hh++;
if(m>n+hh*(hh-3)/2){puts("No"); return 0;}
puts("Yes");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int mn, mx, i, j, k, ii, sum, step, a[10], n, m, kol;
int main() {
cin >> n >> m;
for (i = 1; i <= n; i++) a[i] = i;
step = 1;
for (i = 2; i <= n; i++) step *= i;
mx = 0;
for (i = 1; i <= step; i++) {
sum = 0;
for (j = 1; j <= n; j++)
for (k = j; k <= n; k++) {
mn = (int)2e9;
for (ii = j; ii <= k; ii++) mn = min(mn, a[ii]);
sum += mn;
}
mx = max(mx, sum);
next_permutation(a + 1, a + 1 + n);
}
for (i = 1; i <= n; i++) a[i] = i;
kol = 0;
for (i = 1; i <= step; i++) {
sum = 0;
for (j = 1; j <= n; j++)
for (k = j; k <= n; k++) {
mn = (int)2e9;
for (ii = j; ii <= k; ii++) mn = min(mn, a[ii]);
sum += mn;
if (sum == mx) kol++;
if (kol == m) {
for (ii = 1; ii <= n; ii++) cout << a[ii] << ' ';
cout << endl;
return 0;
}
}
next_permutation(a + 1, a + 1 + n);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b,c;
cin>>a>>b>>c;
for(int i=1;i<=b;i++){
if(a*i%b==c){
cout<<"YES"<<endl;
return 0;
}
}
cout<<"NO"<<endl;
}
| 0 |
#include<cstdio>
int main() {
int N, K, X, Y;
scanf("%d%d%d%d", &N, &K, &X, &Y);
printf("%d\n", K > N ? X * N : X * K + (N - K) * Y);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int maxm = 1e5 + 7;
const int maxn = 1e5 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const double pi = 3.1415926535898;
inline long long read() {
long long a = 0;
int f = 0;
char p = getchar();
while (!((p) >= '0' && (p) <= '9')) {
f |= p == '-';
p = getchar();
}
while (((p) >= '0' && (p) <= '9')) {
a = (a << 3) + (a << 1) + (p ^ 48);
p = getchar();
}
return f ? -a : a;
}
inline void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
long long y;
char str[5];
int n, q, x;
long long a[maxn], k[maxn], sum[maxn], num[maxn], lazy[maxn << 2],
sm[maxn << 2];
void build(int rt, int l, int r) {
lazy[rt] = INF;
if (l == r)
sm[rt] = num[l];
else
build(rt << 1, l, ((l + r) >> 1)),
build(rt << 1 | 1, ((l + r) >> 1) + 1, r),
sm[rt] = sm[(rt << 1)] + sm[(rt << 1 | 1)];
}
void pushdown(int rt, int l, int r) {
sm[(rt << 1)] = lazy[rt] * (((l + r) >> 1) - l + 1);
sm[(rt << 1 | 1)] = lazy[rt] * (r - ((l + r) >> 1));
lazy[(rt << 1)] = lazy[(rt << 1 | 1)] = lazy[rt];
lazy[rt] = INF;
}
void update(int rt, int l, int r, int L, int R, long long v) {
if (l == L && r == R) {
lazy[rt] = v;
sm[rt] = v * (r - l + 1);
} else {
if (lazy[rt] != INF) pushdown(rt, l, r);
if (R <= ((l + r) >> 1))
update(rt << 1, l, ((l + r) >> 1), L, R, v);
else if (L > ((l + r) >> 1))
update(rt << 1 | 1, ((l + r) >> 1) + 1, r, L, R, v);
else
update(rt << 1, l, ((l + r) >> 1), L, ((l + r) >> 1), v),
update(rt << 1 | 1, ((l + r) >> 1) + 1, r, ((l + r) >> 1) + 1, R, v);
sm[rt] = sm[(rt << 1)] + sm[(rt << 1 | 1)];
}
}
long long query(int rt, int l, int r, int L, int R) {
if (L == l && r == R) return sm[rt];
if (lazy[rt] != INF) pushdown(rt, l, r);
if (R <= ((l + r) >> 1))
return query(rt << 1, l, ((l + r) >> 1), L, R);
else if (L > ((l + r) >> 1))
return query(rt << 1 | 1, ((l + r) >> 1) + 1, r, L, R);
else
return query(rt << 1, l, ((l + r) >> 1), L, ((l + r) >> 1)) +
query(rt << 1 | 1, ((l + r) >> 1) + 1, r, ((l + r) >> 1) + 1, R);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i)
cin >> k[i], k[i] += k[i - 1], sum[i] = sum[i - 1] + k[i],
num[i] = a[i] - k[i - 1];
num[n] = a[n] - k[n - 1];
build(1, 1, n);
for (cin >> q; q--;) {
cin >> str >> x >> y;
if (str[0] == 's')
cout << query(1, 1, n, x, y) + sum[y - 1] - (x >= 2 ? sum[x - 2] : 0)
<< endl;
else {
int l = x, r = n, ans = x;
long long temp = query(1, 1, n, x, x) + y;
while (l <= r) {
if (query(1, 1, n, ((l + r) >> 1), ((l + r) >> 1)) >= temp)
r = ((l + r) >> 1) - 1;
else
ans = ((l + r) >> 1), l = ((l + r) >> 1) + 1;
}
update(1, 1, n, x, ans, temp);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5e6 + 5;
const int MOD = 1e9 + 7;
int chkp[MAX];
int val[MAX];
long long dp[MAX];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = 2; i < MAX; i++) {
if (chkp[i]) continue;
val[i] = i;
for (int j = i + i; j < MAX; j += i) {
chkp[j] = 1;
if (!val[j]) val[j] = i;
}
}
long long t, l, r;
cin >> t >> l >> r;
for (int i = l; i <= r; i++) {
long long t = i;
while (t != 1) {
long long v = val[t];
dp[i] += (t / v) * v * (v - 1) / 2;
dp[i] %= MOD;
t /= v;
}
}
long long ans = 0, v = 1;
for (int i = l; i <= r; i++) {
ans = (ans + v * dp[i]) % MOD;
v = v * t % MOD;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const int maxn = 6e5 + 5;
const long long mod = 1e9 + 7;
struct Tree {
int mi, lz, pos, cnt;
} T[maxn << 2];
inline void build(int u, int l, int r) {
T[u].lz = T[u].mi = 0;
T[u].pos = r;
T[u].cnt = r - l + 1;
if (l == r) return;
build((u << 1), l, ((l + r) >> 1)),
build((u << 1 | 1), ((l + r) >> 1) + 1, r);
}
inline void pushup(int u) {
if (T[(u << 1)].mi == T[(u << 1 | 1)].mi) {
T[u].mi = T[(u << 1)].mi;
T[u].cnt = T[(u << 1)].cnt + T[(u << 1 | 1)].cnt;
T[u].pos = T[(u << 1 | 1)].pos;
} else {
int lz = T[u].lz;
T[u] =
(T[(u << 1)].mi > T[(u << 1 | 1)].mi) ? T[(u << 1 | 1)] : T[(u << 1)];
T[u].lz = lz;
}
}
inline void pushdown(int u) {
if (T[u].lz) {
T[(u << 1)].lz += T[u].lz, T[(u << 1)].mi += T[u].lz;
T[(u << 1 | 1)].lz += T[u].lz, T[(u << 1 | 1)].mi += T[u].lz;
T[u].lz = 0;
}
}
inline void change(int u, int l, int r, int L, int R, int v) {
if (L <= l && r <= R) {
T[u].lz += v;
T[u].mi += v;
return;
}
pushdown(u);
if (L <= ((l + r) >> 1)) change((u << 1), l, ((l + r) >> 1), L, R, v);
if (R > ((l + r) >> 1)) change((u << 1 | 1), ((l + r) >> 1) + 1, r, L, R, v);
pushup(u);
}
Tree nod;
inline void query(int u, int l, int r, int L, int R) {
if (L <= l && r <= R) {
if (T[u].mi < nod.mi) {
nod = T[u];
} else if (T[u].mi == nod.mi) {
nod.pos = max(nod.pos, T[u].pos);
nod.cnt += T[u].cnt;
}
return;
}
pushdown(u);
if (L <= ((l + r) >> 1)) query((u << 1), l, ((l + r) >> 1), L, R);
if (R > ((l + r) >> 1)) query((u << 1 | 1), ((l + r) >> 1) + 1, r, L, R);
pushup(u);
}
int n, m, N;
char s[maxn];
int S[maxn];
inline Tree query(int L, int R) {
nod.mi = INF;
query(1, 1, N, L, R);
return nod;
}
void dbg() {
for (int i = 1; i <= N; i++) printf("%d ", query(i, i).mi);
puts("");
}
int main() {
scanf("%d%d", &n, &m);
scanf("%s", s + 1);
N = 2 * n;
build(1, 1, N);
for (int i = 1; i <= n; i++) {
S[i] = S[i + n] = (s[i] == '(' ? 1 : -1);
change(1, 1, N, i, N, S[i]);
change(1, 1, N, i + n, N, S[i + n]);
}
if (query(n, n).mi != 0) {
puts("0\n1 1");
return 0;
}
int ans = 0;
int rl = 1, rr = 1;
for (int i = 1; i <= n; i++) {
Tree tmp = query(i, i + n - 1);
if (S[i] == 1) {
if (tmp.mi == 0) {
if (tmp.cnt > ans) {
ans = tmp.cnt;
rl = rr = 1;
}
}
} else {
if (tmp.mi == -1) {
change(1, 1, N, i, tmp.pos, 2);
Tree tmp2 = query(i, i + n - 1);
assert(tmp2.mi == 0);
if (tmp2.cnt > ans) {
ans = tmp2.cnt;
rl = i, rr = tmp.pos + 1;
}
change(1, 1, N, i, tmp.pos, -2);
} else if (tmp.mi == -2) {
change(1, 1, N, i, tmp.pos, 1);
Tree tmp2 = query(i, i + n - 1);
assert(tmp2.mi == -1);
change(1, 1, N, i, tmp2.pos, 1);
if (tmp.pos < tmp2.pos) change(1, 1, N, tmp.pos + 1, tmp2.pos, 1);
Tree tmp3 = query(i, i + n - 1);
assert(tmp3.mi == 0);
if (tmp3.cnt > ans) {
ans = tmp3.cnt;
rl = i, rr = tmp2.pos + 1;
}
change(1, 1, N, i, tmp2.pos, -2);
}
}
change(1, 1, N, i, N, -S[i]);
}
if (rl > n) rl -= n;
if (rr > n) rr -= n;
printf("%d\n%d %d\n", ans, rl, rr);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
int i;
int storeIt[n];
for (i = 0; i < n; i++) {
cin >> a[i];
storeIt[a[i] - 1] = i;
}
string printIt = "";
int l = n;
int r = 0;
for (i = 0; i < n; i++) {
l = min(l, storeIt[i]);
r = max(r, storeIt[i]);
if (r - l == i) {
printIt += '1';
} else {
printIt += '0';
}
}
cout << printIt << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
long long int dp[2][320][320];
int main() {
int n, m, x;
scanf("%d%d%d", &n, &m, &x);
if (n > m)
puts("0");
else {
dp[0][0][0] = 1;
for (int i = 1; i <= m; i++)
for (int l = 0; l <= n; l++)
for (int r = 0; r <= l; r++) {
dp[i & 1][l][r] = 0;
if (i == x) {
if (l) dp[i & 1][l][r] += dp[~i & 1][l - 1][r];
if (l && r) dp[i & 1][l][r] += dp[~i & 1][l - 1][r - 1];
} else {
dp[i & 1][l][r] += dp[~i & 1][l][r];
if (l - 1 >= r) dp[i & 1][l][r] += dp[~i & 1][l - 1][r];
if (r) dp[i & 1][l][r] += dp[~i & 1][l][r - 1];
if (l && r) dp[i & 1][l][r] += dp[~i & 1][l - 1][r - 1];
}
dp[i & 1][l][r] %= mod;
}
long long int ans = dp[m & 1][n][n];
for (int i = 1; i <= n; i++) ans = (ans * i) % mod;
printf("%I64d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
vector<int> ans;
int sum(int curr) {
int sum = 0;
while (curr > 0) {
sum += curr % 10;
curr = curr / 10;
}
return sum;
}
long long go(long long x, int n) {
long long ans = 1;
for (int i = 0; i < n; i++) {
ans = ans * x;
}
return ans;
}
int main() {
scanf("%d %d %d", &a, &b, &c);
for (int i = 0; i <= 81; i++) {
long long curr = go(i, a) * b + c;
if (curr > 1000000000LL || curr <= 0) continue;
if (sum(curr) == i) ans.push_back(curr);
}
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) {
printf("%d ", ans[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int hashu[505][505];
int ar[501][501];
int xline[250001], yline[250001], fline[250001];
int main() {
int n, m, a, b;
cin >> n >> m;
memset(ar, 0, sizeof(ar));
memset(hashu, -1, sizeof(hashu));
for (int i = 0; i < m; ++i) {
cin >> a >> b;
ar[a][++ar[a][0]] = b;
ar[b][++ar[b][0]] = a;
}
int fin = 0, l = 1, r = 1;
xline[l] = 1, yline[l] = n;
hashu[1][n] = 0;
while (l <= r) {
int nowx = xline[l];
int nowy = yline[l];
for (int x = 1; x <= ar[nowx][0]; ++x) {
for (int y = 1; y <= ar[nowy][0]; ++y) {
int nex = ar[nowx][x], ney = ar[nowy][y];
if (hashu[nex][ney] == -1 && nex != ney) {
++r;
hashu[nex][ney] = hashu[nowx][nowy] + 1;
xline[r] = nex;
yline[r] = ney;
fline[r] = l;
if (xline[r] == n && yline[r] == 1) fin = r;
}
}
}
if (fin) break;
++l;
}
cout << hashu[n][1] << endl;
if (hashu[n][1] == 0) {
cout << l << " " << r << endl;
}
if (hashu[n][1] == -1) return 0;
int now = fin;
while (true) {
cout << yline[now] << " ";
if (now == 1) break;
now = fline[now];
}
now = fin;
cout << endl;
while (true) {
cout << xline[now] << " ";
if (now == 1) break;
now = fline[now];
}
cout << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 17;
long long fen[MAXN][2], a[MAXN];
long double ans, res, inv, n;
long long get(bool flag, int x) {
long long res = 0;
for (; x; x -= x & (-x)) res += fen[x][flag];
return res;
}
void add(int x, long long y) {
for (; x <= n; x += x & (-x)) fen[x][0]++, fen[x][1] += y;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (long long i = n; i > 0; i--) {
inv += get(0, a[i]);
res += i * get(1, a[i]);
add(a[i], n - i + 1);
}
res = -res;
for (long long i = 2; i <= n; i++) res += (n - i + 1) * i * (i - 1) / 4;
ans = inv;
ans += res / (n * (n + 1) / 2);
cout << fixed << setprecision(11) << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int a, long long int n, long long int m);
long long int power(long long int a, long long int n, long long int m) {
if (n == 0) return 1;
long long int x = power(a, n / 2, m);
if (n % 2 != 0)
return (((a * x) % m) * (x) % m) % m;
else
return (x * x) % m;
}
vector<long long int> order[2001];
long long int sz[2005] = {0};
void dfs(long long int i, long long int arr[], vector<long long int> v[]) {
sz[i] = 1;
for (auto j : v[i]) {
dfs(j, arr, v);
sz[i] += sz[j];
for (auto k : order[j]) {
order[i].push_back(k);
}
}
if (sz[i] - 1 < arr[i]) {
cout << "NO\n";
exit(0);
}
order[i].insert(order[i].begin() + arr[i], i);
}
int32_t main() {
long long int i, n, j, x, y, m, k, t, sum, count, cnt, b, c, d, j1, z, a,
temp;
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
long long int root;
long long int arr[n + 1];
vector<long long int> v[n + 1];
for (i = 1; i <= n; i++) {
cin >> x >> arr[i];
if (x == 0) {
root = i;
continue;
}
v[x].push_back(i);
}
dfs(root, arr, v);
cout << "YES\n";
long long int ans[n + 1];
for (i = 0; i < n; i++) {
ans[order[root][i]] = i + 1;
}
for (i = 1; i <= n; i++) cout << ans[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int tab[103][103];
int main() {
long long w, n;
cin >> w >> n;
bool ans = true;
while (ans && n) {
int r = n % w;
if (r == 0 || r == 1)
n /= w;
else if (r == w - 1) {
n /= w;
n++;
} else
ans = false;
}
cout << (ans ? "YES\n" : "NO\n");
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int l;
cin>>l;
printf("%f",(float)l/3*l/3*l/3);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int temp[10] = {0};
int a;
for (int i = 0; i < 6; i++) {
scanf("%d", &a);
temp[a]++;
}
int ans1 = false, ans2 = false, ans3 = true;
int b = 0;
for (int i = 1; i <= 9; i++) {
if (temp[i] >= 4) {
ans1 = true;
temp[i] -= 4;
break;
}
}
for (int i = 1; i <= 9; i++) {
if (temp[i] == 2) {
ans2 = true;
temp[i] -= 2;
break;
}
}
if (ans2) ans3 = false;
if (ans1 && ans2)
puts("Elephant");
else if (ans1 && ans3)
puts("Bear");
else
puts("Alien");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 20;
const int Maxl = 16;
const string let = "0123456789abcdef";
long long C[Maxn][Maxn];
long long k;
int t;
int ans[Maxn];
long long Solve(int n, const vector<int> &av, bool fl = false) {
if (fl && av[0] <= 0) return 0;
for (int i = 0; i < av.size(); i++)
if (av[i] < 0) return 0;
vector<long long> dp(n + 1, 0);
dp[n - fl] = 1;
for (int i = 0; i < av.size(); i++)
for (int j = 0; j <= n - fl; j++)
for (int k = 1; k <= j && k <= av[i] - (fl && i == 0); k++)
dp[j - k] += dp[j] * C[j][k];
return dp[0];
}
int main() {
for (int i = 0; i < Maxn; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
cin >> k >> t;
int len = 1;
vector<int> cur(Maxl, t);
long long got, tmp, last;
while ((got = Solve(len, cur) - Solve(len, cur, true)) < k) {
k -= got;
len++;
}
for (int i = 0; i < len; i++) {
ans[i] = (i ? 0 : 1);
cur[ans[i]]--;
while ((got = Solve(len - 1 - i, cur)) < k) {
k -= got;
cur[ans[i]]++;
ans[i]++;
cur[ans[i]]--;
}
printf("%c", let[ans[i]]);
}
printf("\n");
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma warning(disable : 4786)
using namespace std;
int son[300010], par[300010];
int find(int x) {
if (son[x] != x) son[x] = find(son[x]);
return son[x];
}
int main(void) {
int m, n;
cin >> n >> m;
for (int i = 1; i <= n + 1; i++) son[i] = i;
for (int i = 1; i <= m; i++) {
int l, h, x;
cin >> l >> h >> x;
int cur = find(l);
while (1) {
if (cur == x) break;
par[cur] = x;
son[cur] = cur + 1;
cur = find(cur);
}
cur = find(x + 1);
while (1) {
if (cur > h) break;
par[cur] = x;
son[cur] = cur + 1;
cur = find(cur);
}
}
for (int i = 1; i <= n; i++) cout << par[i] << " ";
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int step(char c) {
if (c == 'a') return 0;
return 'z' - c + 1;
}
int main(void) {
string s;
int k;
cin >> s >> k;
for (int i = 0; i < s.size(); i++) {
int n = step(s[i]);
if (n <= k) {
s[i] = 'a';
k -= n;
}
}
for (int i = 0; i < k % 26; i++) {
s[s.size()-1]++;
}
cout << s << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return x * f;
}
long long qp(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a;
b >>= 1;
a = a * a;
}
return res;
}
const double eps = 1e-8;
const int N = 1e4 + 10, mod = 1e9 + 7;
int ask1(int i, int j) {
cout << "or" << ' ' << i << ' ' << j << endl;
int x;
cin >> x;
return x;
}
int ask2(int i, int j) {
cout << "and" << ' ' << i << ' ' << j << endl;
int x;
cin >> x;
return x;
}
int a[N];
void solve() {
int n, k;
cin >> n >> k;
int x, y, z;
int z1 = ask1(1, 2), z2 = ask2(1, 2);
x = z1 + z2;
z1 = ask1(2, 3), z2 = ask2(2, 3);
y = z1 + z2;
z1 = ask1(1, 3), z2 = ask2(1, 3);
z = z1 + z2;
a[3] = (y + z - x) / 2;
a[1] = z - a[3];
a[2] = x - a[1];
for (int i = 3; i <= n - 1; i++) {
z1 = ask1(i, i + 1), z2 = ask2(i, i + 1);
a[i + 1] = z1 + z2 - a[i];
}
sort(a + 1, a + 1 + n);
printf("finish %d\n", a[k]);
}
int main() {
int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Node {
Node(int x = 0, int y = 0) : x(x), y(y) {}
int x, y;
} a[100010], q[100010];
struct P {
P(int w = 0, int x = 0, int y = 0) : w(w), x(x), y(y) {}
int w, x, y;
} t;
int x, y, i, j, k, n, m, f[100010], ch[100010][2], s[100010], l[100010], Q,
p[100010];
bool b[100010], r[100010], v[100010];
inline bool Get(int x) { return ch[f[x]][1] == x; }
inline void Up(int x) { s[x] = s[ch[x][0]] + s[ch[x][1]] + 1; }
inline void Update_rev(int x) {
r[x] ^= 1;
swap(ch[x][0], ch[x][1]);
}
inline void Down(int x) {
if (r[x]) {
Update_rev(ch[x][0]);
Update_rev(ch[x][1]);
r[x] = 0;
}
}
inline void Rotate(int x) {
bool d = Get(x);
int y = f[x];
if (b[y])
b[x] = 1, b[y] = 0;
else
ch[f[y]][Get(y)] = x;
ch[y][d] = ch[x][d ^ 1];
f[ch[y][d]] = y;
ch[x][d ^ 1] = y;
f[x] = f[y];
f[y] = x;
Up(y);
}
inline void Push(int x) {
if (!b[x]) Push(f[x]);
Down(x);
}
inline void Splay(int x) {
for (Push(x); !b[x]; Rotate(x))
if (!b[f[x]]) Rotate(Get(x) == Get(f[x]) ? f[x] : x);
Up(x);
}
inline void Access(int x) {
int y = 0;
while (x) {
Splay(x);
b[ch[x][1]] = 1;
ch[x][1] = y;
b[y] = 0;
Up(x);
y = x;
x = f[x];
}
}
inline void mr(int x) {
Access(x);
Splay(x);
Update_rev(x);
}
inline void Link(int x, int y) {
mr(x);
f[x] = y;
}
inline void Del(int x, int y) {
mr(x);
Access(y);
Splay(y);
ch[y][0] = f[x] = 0;
b[x] = 1;
Up(y);
}
inline int Find(int x) {
if (f[x]) return Find(f[x]);
return x;
}
inline int Query(int x, int y) {
mr(x);
Access(y);
Splay(y);
return s[y];
}
map<int, int> M[100010];
vector<P> g;
inline void Solve(int l, int r, vector<P>& g) {
vector<P> L, R;
vector<int> c;
int Mid = l + r >> 1;
for (int i = 0; i < g.size(); i++) {
if (g[i].x == l && g[i].y == r) {
if (Find(a[g[i].w].x) != Find(a[g[i].w].y))
Link(a[g[i].w].x, a[g[i].w].y), c.push_back(i);
else if (Query(a[g[i].w].x, a[g[i].w].y) & 1) {
for (int j = l; j <= r; j++) puts("NO");
for (int j = 0; j < c.size(); j++) Del(a[g[c[j]].w].x, a[g[c[j]].w].y);
return;
}
} else if (g[i].y <= Mid)
L.push_back(g[i]);
else if (g[i].x > Mid)
R.push_back(g[i]);
else
L.push_back(P(g[i].w, g[i].x, Mid)),
R.push_back(P(g[i].w, Mid + 1, g[i].y));
}
if (l == r) {
puts("YES");
for (int j = 0; j < c.size(); j++) Del(a[g[c[j]].w].x, a[g[c[j]].w].y);
return;
}
Solve(l, Mid, L);
Solve(Mid + 1, r, R);
for (int j = 0; j < c.size(); j++) Del(a[g[c[j]].w].x, a[g[c[j]].w].y);
}
int main() {
scanf("%d%d", &n, &Q);
for (i = 1; i <= n; i++) b[i] = s[i] = 1;
for (i = 1; i <= Q; i++) {
scanf("%d%d", &q[i].x, &q[i].y);
if (q[i].x > q[i].y) swap(q[i].x, q[i].y);
if (!M[q[i].x][q[i].y])
M[q[i].x][q[i].y] = ++m, a[m] = Node(q[i].x, q[i].y);
}
for (i = 1; i <= Q; i++) {
x = M[q[i].x][q[i].y];
if (p[x])
g.push_back(P(x, p[x], i - 1)), p[x] = 0;
else
p[x] = i;
}
for (i = 1; i <= m; i++)
if (p[i]) g.push_back(P(i, p[i], Q));
Solve(1, Q, g);
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<bool> u(n + 1, 0);
int k, kl, kr;
k = kl = kr = 0;
for (int i = 0; i < n; ++i) {
char a;
cin >> a;
if (a == '>')
kr++;
else if (a == '<')
kl++;
else {
if (!u[i]) k++;
if (!u[((i + 1) % n)]) k++;
u[i] = u[((i + 1) % n)] = 1;
}
}
if (k == 0) {
if (!kl || !kr)
cout << n << endl;
else
cout << "0\n";
continue;
}
cout << min(k + ((!kl || !kr) ? kl + kr : 0), n) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, k;
vector<pair<long long, pair<long long, long long>>> v;
vector<long long> ans;
priority_queue<long long, vector<long long>, greater<long long>> q;
long long qs = 0;
int32_t main() {
cin >> n >> k;
v.resize(n);
ans.resize(n);
for (long long i = 0; i < n; i++) cin >> v[i].first;
for (long long i = 0; i < n; i++)
cin >> v[i].second.first, v[i].second.second = i;
sort(v.begin(), v.end());
for (long long i = 0; i < n; i++) {
if (k == 0) {
ans[v[i].second.second] = v[i].second.first;
} else {
ans[v[i].second.second] = qs + v[i].second.first;
if (q.size() < k) {
q.push(v[i].second.first);
qs += v[i].second.first;
} else if (q.top() < v[i].second.first) {
long long val = q.top();
qs -= val;
q.pop();
q.push(v[i].second.first);
qs += v[i].second.first;
}
}
}
for (long long i = 0; i < n; i++) {
cout << ans[i] << " ";
}
cout << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 1;
long long n, m;
long long mult(long long a, long long b) {
a %= 1000000007;
b %= 1000000007;
if (a < 0) a += 1000000007;
if (b < 0) b += 1000000007;
return (a * b) % 1000000007;
}
long long ad(long long a, long long b) {
a %= 1000000007;
b %= 1000000007;
return (a + b + 1000000007 + 1000000007) % 1000000007;
}
int main() {
cin >> n >> m;
long long ans = mult(n, m);
long long last = 0;
for (long long i = 1; i * i <= n && i <= m; ++i) {
ans = ad(ans, -mult(i, n / i));
last = i;
}
for (long long i = 1; i * i < n; ++i) {
long long r = min(n / i, m);
long long l = max(n / (i + 1), last);
if (l > r) continue;
long long ch1, ch2;
if (r & 1)
ch1 = mult(r, (r + 1) / 2);
else
ch1 = mult(r / 2, r + 1);
if (l & 1)
ch2 = mult(l, (l + 1) / 2);
else
ch2 = mult(l / 2, l + 1);
ans = ad(ans, mult(i, -ad(ch1, -ch2)));
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
bool k = false;
cin >> s;
for (int i = 0; s[i] != 0; i++) {
if (s[i] == 'H' || s[i] == 'Q' || s[i] == '9') {
k = true;
break;
}
}
if (k)
cout << "YES";
else
cout << "NO";
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
cout<<setprecision(10)<<(double)(int(n+1)/2)/n<<endl;
} | 0 |
#include<iostream>
#include<functional>
#include<vector>
#include<queue>
#include<utility>
#include<cstring>
#define MP make_pair
#define PB push_back
using namespace std;
typedef pair<int, int> PII;
typedef vector<PII> VP;
typedef VP::iterator VPI;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int r;
int w[2], h[2], x[2], y[2];
int room[2][500][500];
VP level[2];
bool though[2][500][500];
int main()
{
while(cin >> r && r){
memset(though, false, sizeof though);
level[0].clear();
level[1].clear();
//part1
for(int i = 0; i < 2; i++){
cin >> w[i] >> h[i] >> x[i] >> y[i];
for(int j = 0; j < h[i]; j++){
for(int k = 0; k < w[i]; k++){
cin >> room[i][j][k];
}
}
}
//part2
for(int i = 0; i < 2; i++){
priority_queue<PII, vector<PII>, greater<PII> > search;
search.push(MP(1, (y[i] - 1) * 10000 + (x[i] - 1)));
though[i][y[i] - 1][x[i] - 1] = true;
int counter = 0, lv = 0;
while(!search.empty()){
PII now = search.top();
search.pop();
if(now.first > lv){
level[i].PB(MP(counter, lv));
lv = now.first;
}
counter++;
for(int j = 0; j < 4; j++){
int nexty = now.second / 10000 + dy[j];
int nextx = now.second % 10000 + dx[j];
if(0 <= nexty && nexty < h[i] && 0 <= nextx && nextx < w[i] && !though[i][nexty][nextx]){
though[i][nexty][nextx] = true;
search.push(MP(room[i][nexty][nextx], nexty * 10000 + nextx));
}
}
}
level[i].PB(MP(counter, lv));
}
//part3
int ans = 2e9;
for(int i = 0; i < level[0].size(); i++){
VPI pr = lower_bound(level[1].begin(), level[1].end(), MP(r - level[0][i].first, 0));
if(pr != level[1].end())
ans = min(ans, level[0][i].second + pr->second);
}
cout << ans << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
char ss[101000];
char s[101000];
char ans[101000];
int main() {
while (gets(s)) {
int len = strlen(s);
int cnt = 0;
for (int i = 0; i < len; i++) {
if (s[i] == ',') {
ans[cnt++] = s[i];
if (i != len - 1) ans[cnt++] = ' ';
} else if (s[i] == '.') {
if (cnt != 0 && ans[cnt - 1] != ' ') ans[cnt++] = ' ';
ans[cnt++] = '.';
ans[cnt++] = '.';
ans[cnt++] = '.';
i = i + 2;
} else if (s[i] != ' ') {
if (i != 0 && s[i - 1] == ' ') {
if (cnt != 0 && (ans[cnt - 1] >= '0' && ans[cnt - 1] <= '9'))
ans[cnt++] = ' ';
}
while (s[i] >= '0' && s[i] <= '9') {
ans[cnt++] = s[i];
i++;
}
i--;
}
}
ans[cnt] = 0;
printf("%s\n", ans);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<n;i++)
#define repn(i,n) for(int i=1;i<=n;i++)
#define LL long long
#define pii pair <int,int>
#define fi first
#define se second
#define pb push_back
#define mpr make_pair
using namespace std;
const LL MOD=1e9+7;
int n,n2=1,tmp[30],son[2000000][30],num[2000000][30],sv,ans=0;
string s[200010];
bool cmp(string a,string b)
{
return a.size()>b.size();
}
void add(int k)
{
rep(i,26) if(tmp[i]>0) num[k][i]++;
}
int main()
{
cin>>n;
rep(i,n) cin>>s[i];
sort(s,s+n,cmp);
rep(i,n)
{
int cur=1,ok=1;
for(int j=s[i].size()-1;j>0;j--)
{
if(son[cur][s[i][j]-'a']==0)
{
ok=0;
break;
}
cur=son[cur][s[i][j]-'a'];
//if(i==1) cout<<cur<<" hhh\n";
}
if(ok) ans+=num[cur][s[i][0]-'a'];//,cout<<s[i]<<" stane\n";
rep(j,28) tmp[j]=0;
rep(j,s[i].size()) tmp[s[i][j]-'a']++;
cur=1;
add(cur);
for(int j=s[i].size()-1;j>=0;j--)
{
sv=cur;
if(son[cur][s[i][j]-'a']==0) son[sv][s[i][j]-'a']=cur=++n2;
else cur=son[sv][s[i][j]-'a'];
tmp[s[i][j]-'a']--;
//if(i==0) cout<<cur<<" kkk\n";
add(cur);
}
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<int> q;
int main() {
int n, t;
long long ans = 0;
cin >> n >> t;
q.push(t);
for (int i = 1; i < n; i++) {
cin >> t;
t -= i;
if (q.top() > t) {
ans += q.top() - t;
q.pop();
q.push(t);
}
q.push(t);
}
cout << ans << endl;
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,i,s=0;
cin>>n;
vector<int> l(n);
for(i=0;i<n;i++) cin>>l.at(i);
sort(l.begin(),l.end());
for(i=0;i<n-1;i++) s+=l.at(i);
if(l.at(n-1)<s) cout<<"Yes"<<endl;
else cout<<"No"<<endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int n,d[100005];
int main(){
cin>>n;
for(int i=0;i<n;i++)cin>>d[i];
sort(d,d+n);
cout<<d[n/2]-d[n/2-1]<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a[10005];
long long int c = 0, d = 0;
cin >> n;
long long int i;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 1; i < n - 1; i++) {
if (a[i] < a[i - 1] && a[i] < a[i + 1]) c++;
if (a[i] > a[i - 1] && a[i] > a[i + 1]) d++;
}
cout << c + d << endl;
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int n;
int main()
{
cin>>n;
for(int i=0;i<1<<n;i++)
{
cout<<i<<":";
for(int j=0;j<n;j++)if(i>>j&1)cout<<" "<<j;
cout<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void file() {}
signed main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
long long t;
cin >> t;
while (t--) {
long long n, l, r;
cin >> n >> l >> r;
vector<long long> a;
long long cnt = 0, flag = 0;
for (long long i = 1; i <= n && cnt < r; i++) {
if (cnt < l && l <= cnt + (n - i) * 2) {
flag = 1;
}
if (flag) {
for (long long j = i + 1; j <= n; j++) {
a.push_back(i);
cnt++;
if (cnt == r) break;
a.push_back(j);
cnt++;
if (cnt == r) break;
}
} else
cnt += (n - i) * 2;
}
if (r == n * (n - 1) + 1) a.push_back(1);
long long len = a.size();
for (long long i = len - (r - l + 1); i < len; i++) cout << a[i] << " ";
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long int n, a, b, ans = 1;
cin >> n >> a >> b;
if (a > b) swap(a, b);
if (a <= n / 2 && b > n / 2) {
cout << "Final!\n";
return 0;
}
while (!(a % 2 == 1 && a == b - 1)) {
a = (a + 1) / 2;
b = (b + 1) / 2;
ans++;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int k;
cin >> k;
if (k == 0)
cout << "ab" << endl;
else {
int sum = 0;
for (char i = 'a'; i <= 'z'; i++) {
if (sum == k) break;
for (int j = 0; j + sum <= k; j++) sum += j, cout << i;
}
cout << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void scan(long long &n) { scanf("%lld", &n); }
void scan(long long &n, long long &m) { scanf("%lld%lld", &n, &m); }
void scan(vector<long long> &v) {
long long n = v.size();
for (long long i = 0; i < n; i++) scanf("%lld", &v[i]);
}
void solve() {
long long n, k, i;
cin >> n >> k;
vector<long long> v(n);
for (i = 0; i < n; i++) cin >> v[i];
vector<long long> tmp(n), a, b;
long long mm = 2;
while (mm--) {
long long mx = LLONG_MIN;
for (i = 0; i < n; i++) mx = max(mx, v[i]);
for (i = 0; i < n; i++) {
tmp[i] = mx - v[i];
v[i] = tmp[i];
}
if (mm == 1)
a = tmp;
else
b = tmp;
}
if (k % 2)
for (auto it : a) cout << it << ' ';
else
for (auto it : b) cout << it << ' ';
cout << endl;
}
int main() {
long long t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int n,m;
int s[6],c[6];
bool v[6];
int t[10];
int main() {
memset(v,0,sizeof(v));
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++) {
scanf("%d%d",&s[i],&c[i]);
if(v[s[i]] && t[s[i]]!=c[i]) {
cout<<-1;
exit(0);
}
v[s[i]]=1;
t[s[i]]=c[i];
}
if(n==1 && t[1]==0) {
printf("0\n");
exit(0);
}
if(v[1]==0) {
t[1]=1;
}
bool first=1;
for(int i=1;i<=n;i++) {
if(first && t[first]==0) {
cout<<-1;
exit(0);
}
first=0;
printf("%d",t[i]);
}
return 0;
} | 0 |
#include<bits/stdc++.h>
#define lowbit( x ) (x&(-x))
#define mp( x , y ) make_pair(x,y)
using namespace std;
typedef long long ll;
typedef pair < int , int > P;
const int N = 2e5 + 10;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
int n, a[N], c[N], cnt[N], num[N], in[N], out[N], tot;
int b[N], m; // 离散化
vector<int> G[N];
void dfs(int u, int fa)
{
in[u] = ++ tot;
int pre_num = num[a[u]];
++ num[a[u]];
for(auto &v:G[u]) {
if(v == fa) continue;
int pre = num[a[u]];
dfs(v, u);
if(num[a[u]] != pre) {
++ c[1];
-- c[in[v]];
++ c[out[v] + 1];
}
}
out[u] = tot;
if(pre_num || num[a[u]] != cnt[a[u]]) {
++ c[in[u]];
-- c[out[u] + 1];
}
}
int main () {
scanf("%d", &n);
for(int i = 1; i <= n; ++ i) {
scanf("%d", &a[i]);
b[i] = a[i];
}
int u, v;
for(int i = 1; i < n; ++ i) {
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
sort(b + 1, b + n + 1);
m = unique(b + 1, b + n + 1) - b - 1;
for(int i = 1; i <= n; ++ i) {
a[i] = lower_bound(b + 1, b + m + 1, a[i]) - b;
++ cnt[a[i]];
}
dfs(1, - 1);
int ans = 0;
for(int i = 1; i <= n; ++ i) {
c[i] += c[i - 1];
if(!c[i]) {
++ ans;
}
}
printf("%d\n", ans);
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using pii = pair<int, int>;
using ld = long double;
const int N = 100001;
const int M = 1000001;
const int LG = 21;
struct DSU {
vi p, s;
DSU(int n) : p(n), s(n, 1) { iota((p).begin(), (p).end(), 0); }
int get(int v) { return p[v] == v ? v : p[v] = get(p[v]); }
void unite(int u, int v) {
if ((u = get(u)) != (v = get(v))) {
if (s[u] < s[v]) swap(u, v);
s[u] += s[v];
p[v] = u;
}
}
};
struct edge {
int u, v, w, id;
bool operator<(const edge& him) const { return w < him.w; }
};
int n, m;
edge a[M];
vector<pii> g[N];
vi ids[N];
int tin[N], tout[N], tik_tak;
int up[LG][N], cup[LG][N];
int ans[M];
void dfs(int v, int p, int w) {
tin[v] = tik_tak++;
up[0][v] = p;
cup[0][v] = w;
for (int i = 1; i < LG; i++) {
up[i][v] = up[i - 1][up[i - 1][v]];
cup[i][v] = max(cup[i - 1][v], cup[i - 1][up[i - 1][v]]);
}
for (pii e : g[v]) {
int to = e.first;
if (to != p) dfs(to, v, e.second);
}
tout[v] = tik_tak++;
}
bool upper(int u, int v) { return tin[u] <= tin[v] && tout[v] <= tout[u]; }
int get(int u, int v) {
if (tin[u] > tin[v]) swap(u, v);
int ans = 0;
if (upper(u, v)) {
for (int i = LG - 1; i >= 0; i--) {
if (!upper(up[i][v], u)) {
ans = max(ans, cup[i][v]);
v = up[i][v];
}
}
return max(ans, cup[0][v]);
} else {
for (int i = LG - 1; i >= 0; i--) {
if (!upper(up[i][v], u)) {
ans = max(ans, cup[i][v]);
v = up[i][v];
}
}
for (int i = LG - 1; i >= 0; i--) {
if (!upper(up[i][u], v)) {
ans = max(ans, cup[i][u]);
u = up[i][u];
}
}
return max({ans, cup[0][v], cup[0][u]});
}
}
int lca(int u, int v) {
if (tin[u] > tin[v]) swap(u, v);
if (upper(u, v)) return u;
for (int i = LG - 1; i >= 0; i--) {
if (!upper(up[i][v], u)) {
v = up[i][v];
}
}
return up[0][v];
}
vi in[N], out[N];
multiset<int> kek[N];
multiset<int>* lol[N];
void dfs1(int v, int p, int id) {
bool ok = false;
for (int i = 0; i < (int)((g[v]).size()); i++) {
int to = g[v][i].first;
if (to != p) {
dfs1(to, v, ids[v][i]);
if (!ok || (int)((*lol[to]).size()) > (int)((*lol[v]).size()))
lol[v] = lol[to], ok = true;
}
}
if (!ok) {
lol[v] = &kek[v];
}
for (pii e : g[v]) {
int to = e.first;
if (to != p && lol[v] != lol[to]) {
for (int x : *lol[to]) lol[v]->insert(x);
multiset<int>().swap(*lol[to]);
}
}
for (int x : in[v]) lol[v]->insert(x);
for (int x : out[v]) lol[v]->erase(lol[v]->find(x));
if (id != -1) {
if (lol[v]->empty())
ans[id] = 1000000000;
else
ans[id] = *(*lol[v]).begin();
}
}
int32_t main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
--u;
--v;
a[i] = {u, v, w, i};
}
sort(a, a + m);
DSU dsu(n);
for (int i = 0; i < m; i++) {
edge& e = a[i];
if (dsu.get(e.u) != dsu.get(e.v)) {
g[e.u].push_back({e.v, e.w});
g[e.v].push_back({e.u, e.w});
ids[e.u].push_back(e.id);
ids[e.v].push_back(e.id);
dsu.unite(e.u, e.v);
e.id = -1;
}
}
dfs(0, 0, 0);
memset(ans, -1, sizeof(ans));
for (int i = 0; i < m; i++)
if (a[i].id != -1) ans[a[i].id] = get(a[i].u, a[i].v);
for (int i = 0; i < m; i++)
if (a[i].id != -1) {
int u = a[i].u, v = a[i].v, w = a[i].w;
if (tin[u] > tin[v]) swap(u, v);
if (upper(u, v)) {
in[v].push_back(w);
out[u].push_back(w);
} else {
int o = lca(u, v);
in[u].push_back(w);
in[v].push_back(w);
out[o].push_back(w);
out[o].push_back(w);
}
}
dfs1(0, -1, -1);
for (int i = 0; i < m; i++) cout << ans[i] << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1000 * 100 + 10;
int n, alone;
vector<vector<int> > v[maxN];
bool mark[maxN];
int circle[maxN], p[maxN];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i];
if (p[i] == i) alone = i;
}
if (alone != 0) {
cout << "YES" << endl;
for (int i = 1; i <= n; i++)
if (i != alone) cout << i << " " << alone << endl;
} else {
int x[2];
bool found = 0;
for (int i = 1; i <= n; i++) {
if (p[p[i]] == i) {
mark[i] = mark[p[i]] = 1;
x[0] = i;
x[1] = p[i];
found = 1;
break;
}
}
if (!found) {
cout << "NO" << endl;
return 0;
}
for (int i = 1; i <= n; i++) {
if (!mark[i]) {
vector<int> c;
c.push_back(i);
mark[i] = 1;
int cnt = 1, now = i;
while (p[now] != i) {
cnt++;
now = p[now];
mark[now] = 1;
c.push_back(now);
}
if (cnt % 2 == 1) {
cout << "NO" << endl;
return 0;
}
v[cnt].push_back(c);
}
}
cout << "YES" << endl;
cout << x[0] << " " << x[1] << endl;
int par = 0;
for (int i = 2; i <= n; i += 2) {
for (int j = 0; j < v[i].size(); j++)
for (int k = 0; k < v[i][j].size(); k++)
cout << x[k % 2] << " " << v[i][j][k] << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class t, class u>
void chmax(t& first, u second) {
if (first < second) first = second;
}
template <class t, class u>
void chmin(t& first, u second) {
if (second < first) first = second;
}
template <class t>
using vc = vector<t>;
template <class t>
using vvc = vc<vc<t>>;
using pi = pair<int, int>;
using vi = vc<int>;
template <class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t>
ostream& operator<<(ostream& os, const vc<t>& v) {
os << "{";
for (auto e : v) os << e << ",";
return os << "}";
}
using uint = unsigned;
using ull = unsigned long long;
template <class t, size_t n>
ostream& operator<<(ostream& os, const array<t, n>& first) {
return os << vc<t>(first.begin(), first.end());
}
template <int i, class T>
void print_tuple(ostream&, const T&) {}
template <int i, class T, class H, class... Args>
void print_tuple(ostream& os, const T& t) {
if (i) os << ",";
os << get<i>(t);
print_tuple<i + 1, T, Args...>(os, t);
}
template <class... Args>
ostream& operator<<(ostream& os, const tuple<Args...>& t) {
os << "{";
print_tuple<0, tuple<Args...>, Args...>(os, t);
return os << "}";
}
template <class t>
void print(t x, int suc = 1) {
cout << x;
if (suc == 1) cout << "\n";
if (suc == 2) cout << " ";
}
ll read() {
ll i;
cin >> i;
return i;
}
vi readvi(int n, int off = 0) {
vi v(n);
for (int i = int(0); i < int(n); i++) v[i] = read() + off;
return v;
}
template <class T>
void print(const vector<T>& v, int suc = 1) {
for (int i = int(0); i < int(v.size()); i++)
print(v[i], i == int(v.size()) - 1 ? suc : 2);
}
string readString() {
string s;
cin >> s;
return s;
}
template <class T>
T sq(const T& t) {
return t * t;
}
void yes(bool ex = true) {
cout << "Yes"
<< "\n";
if (ex) exit(0);
}
void no(bool ex = true) {
cout << "No"
<< "\n";
if (ex) exit(0);
}
void possible(bool ex = true) {
cout << "Possible"
<< "\n";
if (ex) exit(0);
}
void impossible(bool ex = true) {
cout << "Impossible"
<< "\n";
if (ex) exit(0);
}
constexpr ll ten(int n) { return n == 0 ? 1 : ten(n - 1) * 10; }
const ll infLL = LLONG_MAX / 3;
const int inf = INT_MAX / 2 - 100;
int topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
int topbit(ll t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
int botbit(signed first) { return first == 0 ? 32 : __builtin_ctz(first); }
int botbit(ll first) { return first == 0 ? 64 : __builtin_ctzll(first); }
int popcount(signed t) { return __builtin_popcount(t); }
int popcount(ll t) { return __builtin_popcountll(t); }
bool ispow2(int i) { return i && (i & -i) == i; }
ll mask(int i) { return (ll(1) << i) - 1; }
bool inc(int first, int second, int c) {
return first <= second && second <= c;
}
template <class t>
void mkuni(vc<t>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
ll rand_int(ll l, ll r) {
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<ll>(l, r)(gen);
}
template <class t>
void myshuffle(vc<t>& first) {
for (int i = int(0); i < int(int(first.size())); i++)
swap(first[i], first[rand_int(0, i)]);
}
template <class t>
int lwb(const vc<t>& v, const t& first) {
return lower_bound(v.begin(), v.end(), first) - v.begin();
}
int popcnt(uint x) { return __builtin_popcount(x); }
int popcnt(ull x) { return __builtin_popcountll(x); }
int bsr(uint x) { return 31 - __builtin_clz(x); }
int bsr(ull x) { return 63 - __builtin_clzll(x); }
int bsf(uint x) { return __builtin_ctz(x); }
int bsf(ull x) { return __builtin_ctzll(x); }
struct FastSet {
static constexpr uint B = 64;
int n, lg;
vvc<ull> seg;
FastSet(int _n, ull val = 0) : n(_n) {
do {
seg.push_back(vc<ull>((_n + B - 1) / B, val));
_n = (_n + B - 1) / B;
} while (_n > 1);
lg = seg.size();
}
bool operator[](int i) const { return (seg[0][i / B] >> (i % B) & 1) != 0; }
void set(int i) {
for (int h = 0; h < lg; h++) {
seg[h][i / B] |= 1ULL << (i % B);
i /= B;
}
}
void reset(int i) {
for (int h = 0; h < lg; h++) {
seg[h][i / B] &= ~(1ULL << (i % B));
if (seg[h][i / B]) break;
i /= B;
}
}
int next(int i) {
for (int h = 0; h < lg; h++) {
if (i / B == seg[h].size()) break;
ull d = seg[h][i / B] >> (i % B);
if (!d) {
i = i / B + 1;
continue;
}
i += bsf(d);
for (int g = h - 1; g >= 0; g--) {
i *= B;
i += bsf(seg[g][i / B]);
}
return i;
}
return n;
}
int prev(int i) {
i--;
for (int h = 0; h < lg; h++) {
if (i == -1) break;
ull d = seg[h][i / B] << (63 - i % 64);
if (!d) {
i = i / B - 1;
continue;
}
i += bsr(d) - (B - 1);
for (int g = h - 1; g >= 0; g--) {
i *= B;
i += bsr(seg[g][i / B]);
}
return i;
}
return -1;
}
};
int B = 200;
struct Query {
int l, r, i;
bool operator<(const Query& rhs) const { return r < rhs.r; }
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
cout << fixed << setprecision(20);
int n;
cin >> n;
bool dbg = n < 0;
vi first;
if (dbg) {
n = 100000;
for (int i = int(0); i < int(n); i++) first.push_back(rand_int(0, ten(9)));
} else {
first = readvi(n);
}
vi vals = first;
mkuni(vals);
vi id(n);
for (int i = int(0); i < int(n); i++) id[i] = lwb(vals, first[i]);
vvc<Query> qs((n + B - 1) / B);
int q;
if (dbg)
q = 300000;
else
cin >> q;
for (int i = int(0); i < int(q); i++) {
int l, r;
if (dbg) {
l = rand_int(1, n);
r = rand_int(1, n);
if (l > r) swap(l, r);
} else {
cin >> l >> r;
}
l--;
qs[l / B].push_back({l, r, i});
}
vi ans(q);
for (int i = int(0); i < int(int(qs.size())); i++) {
vi cnt(int(vals.size()));
FastSet fs(int(vals.size()));
int cur = inf;
auto add = [&](int x) {
if (cnt[x]) {
cur = 0;
} else {
{
int z = fs.next(x);
if (z < int(vals.size())) chmin(cur, vals[z] - vals[x]);
}
{
int z = fs.prev(x);
if (z >= 0) chmin(cur, vals[x] - vals[z]);
}
fs.set(x);
}
cnt[x]++;
};
auto del = [&](int x) {
if (--cnt[x] == 0) {
fs.reset(x);
}
};
sort(qs[i].begin(), qs[i].end());
int lim = (i + 1) * B;
for (auto w : qs[i]) {
assert(inc(i * B, w.l, (i + 1) * B));
while (lim < w.r) {
add(id[lim++]);
}
int tmp = cur;
for (int j = int(w.l); j < int(min((i + 1) * B, w.r)); j++) add(id[j]);
ans[w.i] = cur;
for (int j = int(w.l); j < int(min((i + 1) * B, w.r)); j++) del(id[j]);
cur = tmp;
}
}
for (auto v : ans) print(v);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout.tie(nullptr);
;
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long ans = 0;
long long cur;
while (n >= 10) {
cur = n - n % 10;
ans += cur;
n = (n % 10) + cur / 10;
}
cout << ans + n << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937 gene(233);
inline char GET_CHAR() {
const int maxn = 131072;
static char buf[maxn], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, maxn, stdin), p1 == p2)
? EOF
: *p1++;
}
inline int getInt() {
int res(0);
char c = getchar();
while (c < '0') c = getchar();
while (c >= '0') {
res = res * 10 + (c - '0');
c = getchar();
}
return res;
}
inline int fastpo(int x, int n, int mod) {
int res(1);
while (n) {
if (n & 1) {
res = res * (long long)x % mod;
}
x = x * (long long)x % mod;
n /= 2;
}
return res;
}
inline string itoa(int x, int width = 0) {
string res;
if (x == 0) res.push_back('0');
while (x) {
res.push_back('0' + x % 10);
x /= 10;
}
while ((int)res.size() < width) res.push_back('0');
reverse(res.begin(), res.end());
return res;
}
const int N = 300033;
const int LOG = 20;
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
int n, m;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
struct P {
long long x, y;
P operator-(const P& b) const { return P{x - b.x, y - b.y}; }
long long operator*(const P& b) const { return x * b.y - y * b.x; }
};
int main() {
scanf("%d", &n);
long long cur = 0;
vector<P> a, c;
for (int i(1); i <= n; i++) {
int x;
scanf("%d", &x);
cur += x;
a.push_back(P{i, cur});
}
c.push_back(P{0, 0});
for (P p : a) {
while (c.size() >= 2u &&
(p - c.back()) * (c.back() - c[(int)c.size() - 2]) >= 0) {
c.pop_back();
}
c.push_back(p);
}
P prv{0, 0};
int _ = 0;
for (P p : c) {
if (p.x == 0 && p.y == 0) continue;
for (int i = prv.x; i < p.x; i++) {
_++;
printf("%.12f\n", (double)(p.y - prv.y) / (p.x - prv.x));
}
prv = p;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int sum = 0;
k = 240 - k;
int i = 0;
if (k < 5) cout << 0;
for (i = 1; i <= n; i++) {
sum = sum + i * 5;
if (k - sum < (i + 1) * 5 && k - sum >= 0) {
cout << i;
break;
}
}
if (sum < k && i > n) cout << n;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n, q, x, y, cnt = 0;
cin >> n >> q;
vector<vector<long long int>> dp(3, vector<long long int>(n + 2, 0));
while (q--) {
cin >> x >> y;
if (dp[x][y] == 0) {
cnt += (dp[3 - x][y] == 1);
cnt += (dp[3 - x][y - 1] == 1);
cnt += (dp[3 - x][y + 1] == 1);
dp[x][y] = 1;
} else {
cnt -= (dp[3 - x][y] == 1);
cnt -= (dp[3 - x][y - 1] == 1);
cnt -= (dp[3 - x][y + 1] == 1);
dp[x][y] = 0;
}
if (cnt == 0)
cout << "Yes" << '\n';
else
cout << "No" << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, p;
cin >> s;
int n = s.length(), i, j;
for (i = 0, j = n - 1; i < j; i++, j--) {
if (n % 2) {
p = s[j] + (s[i] + p);
} else {
p = s[i] + (s[j] + p);
}
}
if (n % 2) p = s[i] + p;
cout << p << endl;
}
| 1 |
#include <stdio.h>
#include <string.h>
#define R register
#define MN 205
#define P 998244353
int n,x[MN],y[MN],p[MN],ans;
inline int read(){
R int x; R bool f; R char c;
for (f=0; (c=getchar())<'0'||c>'9'; f=c=='-');
for (x=c^'0'; (c=getchar())>='0'&&c<='9'; x=(x<<1)+(x<<3)+(c^'0'));
return f?-x:x;
}
inline void del(int &x,int y){x-=y; if (x<0) x+=P;}
int main(){
n=read();for (R int i=1; i<=n; ++i) x[i]=read(),y[i]=read();
p[0]=1;for (R int i=1; i<=n; ++i) p[i]=p[i-1]<<1,p[i]>=P?p[i]-=P:0;
ans=p[n];del(ans,n+1);
for (R int i=2; i<=n; ++i)
for (R int j=1,cnt; j<i; ++j){
cnt=0;
for (R int k=1; k<j; ++k)
if ((x[k]-x[i])*(y[j]-y[i])==(y[k]-y[i])*(x[j]-x[i])) ++cnt;
del(ans,p[cnt]);
}printf("%d\n",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[20011], i, j, n;
int main() {
cin >> n;
for (i = 0; i < n; i++) {
int h, m;
cin >> h >> m;
dp[h * 60 + m]++;
}
int res = 0;
for (i = 0; i < 20011; i++)
if (dp[i] > res) res = dp[i];
cout << res << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e6 + 7, M = 1000000007, inf = INT_MAX;
const long long INF = LLONG_MAX;
void solve() {
long long w, m;
cin >> w >> m;
vector<long long> vec;
while (m) {
long long r = m % w;
vec.push_back(r);
m /= w;
}
vec.push_back(0);
long long sz = vec.size();
bool f = 1;
long long carry = 0;
for (long long i = 0; i < (long long)sz; i++) {
vec[i] += carry;
carry = vec[i] / w;
vec[i] %= w;
if (vec[i] <= 1) continue;
if (vec[i] < w - 1)
f = 0;
else
carry++;
}
if (f)
cout << "YES" << '\n';
else
cout << "NO" << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long test = 1;
while (test--) solve();
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
string s;
int l,flag;
int main(){
getline(cin,s);
l=s.size();
for(int i=0;i<l;i++)
if(s[i]=='F'&&flag){
puts("Yes");
return 0;
}
else if(s[i]=='C')flag++;
puts("No");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[100010];
int n;
void work(int l, int r) {
if (l > r) return;
if (l == r) {
a[l] = l;
return;
}
a[l] = l + 1;
a[l + 1] = r;
a[r - 1] = l;
a[r] = r - 1;
work(l + 2, r - 2);
}
int main() {
cin >> n;
if (n == 1) {
puts("1");
} else if (n % 4 > 1) {
puts("-1");
} else {
work(1, n);
for (int i = 1; i <= n; i++) {
printf("%d", a[i]);
if (i < n) printf(" ");
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool done[1000] = {0};
const int INF = 1e9;
int n, k, A[4][1000];
vector<tuple<int, int, int>> M;
void show() {
cout << M.size() << '\n';
for (auto V : M) {
int a, b, c;
tie(a, b, c) = V;
cout << c << ' ' << a << ' ' << b << '\n';
}
}
int main() {
vector<pair<int, int>> cyc;
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k;
for (int i = 0; i < n; ++i) cyc.push_back({1, i});
for (int i = 0; i < n; ++i) cyc.push_back({2, n - i - 1});
for (int i = 0; i < 4; ++i)
for (int j = 0; j < n; ++j) cin >> A[i][j];
if (n == 1) {
if (k == 2) {
if (A[1][0] != A[0][0] or A[2][0] != A[3][0])
return cout << "-1\n", 0;
else
return 0 * printf("2\n1 1 %d\n%d 4 1\n", A[1][0], A[2][0]);
} else {
int reach = A[0][0] ? 0 : 3;
int cur = A[1][0] ? 1 : 2;
int num = A[cur][0];
while (cur != reach) {
cur += reach > cur ? 1 : -1;
M.emplace_back(cur + 1, 1, num);
}
show();
return 0;
}
}
auto park = [&] {
for (int i = 0; i < n; ++i)
if (A[1][i] and A[0][i] == A[1][i])
M.emplace_back(1, i + 1, A[0][i]), A[1][i] = 0, --k;
for (int i = 0; i < n; ++i)
if (A[2][i] and A[2][i] == A[3][i])
M.emplace_back(4, i + 1, A[2][i]), A[2][i] = 0, --k;
};
park();
if (count(A[1], A[1] + n, 0) + count(A[2], A[2] + n, 0) == 0)
return 0 * puts("-1");
int idx = find_if(cyc.begin(), cyc.end(),
[&](pair<int, int> I) {
int i, j;
tie(i, j) = I;
return A[i][j] == 0;
}) -
cyc.begin();
while (k) {
park();
for (int d = idx; (d + 1) % (2 * n) != idx;) {
int ne = (d + 1) % cyc.size();
int x, y, nx, ny;
tie(x, y) = cyc[d], tie(nx, ny) = cyc[ne];
assert(A[x][y] == 0);
if (A[nx][ny])
A[x][y] = A[nx][ny], A[nx][ny] = 0,
M.emplace_back(x + 1, y + 1, A[x][y]);
d = ne;
}
idx = (idx - 1 + cyc.size()) % cyc.size();
}
show();
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.