solution
stringlengths 53
181k
| difficulty
int64 0
13
|
---|---|
#include <bits/stdc++.h>
using namespace std;
const long long A = 100000000000000LL, N = 10000, M = 1000000007;
long long i, j, n, m, a, b = 1;
int main() {
cin >> n;
for (i = 0; i < n - 1; i++) {
long long pr[2] = {a, b};
a = pr[1] * 3;
a %= M;
b = pr[1] * 2 + pr[0];
b %= M;
}
cout << a;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void fn(long long int *arr, int n, long long int val) {
int st = 0, en = n - 1;
int ans;
while (st <= en) {
int mid = (st + en) >> 1;
if (arr[mid] == val) {
ans = mid + 1;
break;
} else if (arr[mid] > val) {
ans = mid + 1;
en = mid - 1;
} else
st = mid + 1;
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n;
cin >> n;
long long int arr[n];
cin >> arr[0];
for (int i = 1; i < n; i++) {
cin >> arr[i];
arr[i] += arr[i - 1];
}
int m;
cin >> m;
while (m--) {
long long int val;
cin >> val;
fn(arr, n, val);
}
return 0;
}
| 2 |
#include<iostream>
#include<cstdio>
using namespace std;
const int mod=998244353;
int fac[5000001],ifac[5000001];
int n=100005,m=100005;
inline int add(int x,int y){
return x+y<mod?x+y:x+y-mod;
}
inline int sub(int x,int y){
return x<y?x+mod-y:x-y;
}
inline int power(int a,int n){
int tp=1;
while(n){
if(n&1) tp=1ll*tp*a%mod;
a=1ll*a*a%mod,n>>=1;
}
return tp;
}
inline int q(int n,bool op){
if(n<0) return 0;
if(n==0) return op==0;
return power(2,n-1);
}
inline int c(int n,int m){
return n<m||m<0?0:1ll*fac[n]*ifac[m]%mod*ifac[n-m]%mod;
}
void init(){
fac[0]=1;
for(int i=1;i<=n;i++) fac[i]=1ll*fac[i-1]*i%mod;
ifac[n]=power(fac[n],mod-2);
for(int i=n-1;~i;i--) ifac[i]=1ll*ifac[i+1]*(i+1)%mod;
return;
}
int t,nn;
int a[1000005];
string s;
int main(){
init();
scanf ("%d",&t);
while(t--){
scanf ("%d",&nn);
cin>>s;
for (int i=1;i<=nn;i++)
a[i]=s[i-1]-'0';
int s1=0,s2=0;
for (int i=1;i<=nn;i++){
int js=0;
if (a[i]==1){
while(a[i++]==1){
js++;
}
if (js>1)
s2+=js/2,s1+=js%2;
else s1++;
i--;
}
}
long long ans=1ll*c(nn-s2-s1,s2)%mod;
printf ("%lld\n",ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n, anton = 0, danik = 0;
char t;
scanf("%d", &n);
for (int i = 0; i <= n; i++) {
scanf("%c", &t);
if (t == 'A') {
anton += 1;
} else if (t == 'D') {
danik += 1;
}
}
if (danik < anton) {
printf("Anton");
} else if (danik > anton) {
printf("Danik");
} else {
printf("Friendship");
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<string, string> arr[100007];
int idx[100007];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i].first >> arr[i].second;
for (int i = 0; i < n; i++) cin >> idx[i];
vector<string> sol;
for (int i = 0; i < n; i++) {
pair<string, string> tmp = arr[idx[i] - 1];
if (i == 0) {
if (tmp.first < tmp.second)
sol.push_back(tmp.first);
else
sol.push_back(tmp.second);
} else {
string cur = sol[i - 1];
if (tmp.first < tmp.second && tmp.first >= cur)
sol.push_back(tmp.first);
else if (tmp.second < cur)
sol.push_back(tmp.first);
else
sol.push_back(tmp.second);
}
}
for (int i = 1; i < n; i++) {
if (sol[i] < sol[i - 1]) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
char ch = getchar();
bool positive = 1;
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') positive = 0;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
long long N, M, a[1005];
char s[1005][1005], tmp[1005][1005];
inline long long work(int N, int M) {
long long ans = 0;
for (int i = 1; i <= N; ++i) {
a[i] = 0;
for (int j = 1; j <= M; ++j)
if (s[i][j] == 'X') {
a[i] = j;
break;
}
if (a[i]) ans += 4ll * (a[i] - 1) * (M - a[i]);
}
long long cnt1 = 0, sig = 0, cnt2 = 0, last = 0;
for (int i = 1; i <= N; ++i) {
if (a[i] > last) cnt2 = 0;
last = a[i];
ans += 4LL * cnt2 * max(a[i] - 1, 0ll);
cnt2 += M - a[i];
ans += (M - (a[i] > 0)) * sig;
cnt1 += M - (a[i] > 0);
sig += cnt1;
}
cnt1 = 0, sig = 0, cnt2 = 0, last = 0;
for (int i = N; i; --i) {
if (a[i] > last) cnt2 = 0;
last = a[i];
ans += 4LL * cnt2 * max(a[i] - 1, 0ll);
cnt2 += M - a[i];
ans += (M - (a[i] > 0)) * sig;
cnt1 += M - (a[i] > 0);
sig += cnt1;
}
return ans;
}
int main() {
N = read(), M = read();
for (int i = 1; i <= N; ++i) scanf("%s", s[i] + 1);
long long ans = work(N, M), tot = 0;
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j) {
tmp[i][j] = s[i][j];
tot += tmp[i][j] == '.';
}
for (int i = 1; i <= N; ++i)
for (int j = 1; j <= M; ++j) s[j][i] = tmp[i][j];
ans += work(M, N);
printf("%.10lf\n", ans * 1. / tot / tot);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n;
cin >> m >> n;
int count = 0;
int temp1 = min(m, n);
for (int i = 0; i <= temp1; i++) {
for (int j = 0; j <= temp1; j++) {
if (((i * i + j) == m) and ((i + j * j) == n)) {
count++;
}
}
}
cout << count << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int n, m, ans;
int a[34][34], t[34][34], bin[20];
int cal3(int x, int y, int bj) {
t[x][y] = bj, t[x + m][y] = t[x][y] ^ t[m][y];
t[x][y + m] = t[x][y] ^ t[x][m], t[x + m][y + m] = t[x][y + m] ^ t[m][y + m];
int re = (t[x][y] ? -a[x][y] : a[x][y]) +
(t[x + m][y] ? -a[x + m][y] : a[x + m][y]) +
(t[x][y + m] ? -a[x][y + m] : a[x][y + m]) +
(t[x + m][y + m] ? -a[x + m][y + m] : a[x + m][y + m]);
return re;
}
int cal2(int y, int bj) {
t[m][y] = bj, t[m][y + m] = t[m][y] ^ t[m][m];
int re = (t[m][y] ? -a[m][y] : a[m][y]) +
(t[m][y + m] ? -a[m][y + m] : a[m][y + m]);
for (register int i = 1; i < m; ++i) re += max(cal3(i, y, 0), cal3(i, y, 1));
return re;
}
int cal1() {
int re = 0;
for (register int i = 1; i <= n; ++i) re += (t[i][m] ? -a[i][m] : a[i][m]);
for (register int i = 1; i < m; ++i) re += max(cal2(i, 0), cal2(i, 1));
return re;
}
int main() {
scanf("%d", &n);
for (register int i = 1; i <= n; ++i)
for (register int j = 1; j <= n; ++j) scanf("%d", &a[i][j]);
m = (n + 1) >> 1, ans = -inf;
bin[1] = 1;
for (register int i = 2; i <= m + 1; ++i) bin[i] = bin[i - 1] << 1;
for (register int zt = 0; zt < bin[m + 1]; ++zt) {
for (register int i = 1; i <= m; ++i)
t[i][m] = ((zt & bin[i]) == 0 ? 0 : 1);
for (register int i = m + 1; i <= n; ++i) t[i][m] = t[i - m][m] ^ t[m][m];
ans = max(ans, cal1());
}
printf("%d\n", ans);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 10;
const int M = 100 * 100 + 10;
int n, a[N], b[N];
int dp[M], maxw[M];
int main() {
ios::sync_with_stdio(false);
cin >> n;
int sum = 0, total = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
}
for (int i = 0; i < n; ++i) {
cin >> b[i];
total += b[i];
}
memset(dp, -1, sizeof dp);
memset(maxw, 0, sizeof maxw);
dp[0] = maxw[0] = 0;
for (int i = 0; i < n; ++i) {
for (int k = total; k >= b[i]; --k) {
if (dp[k - b[i]] != -1) {
if (dp[k] == -1) {
dp[k] = dp[k - b[i]] + 1;
maxw[k] = maxw[k - b[i]] + a[i];
} else {
if (dp[k] > dp[k - b[i]] + 1) {
dp[k] = dp[k - b[i]] + 1;
maxw[k] = maxw[k - b[i]] + a[i];
} else if (dp[k] == dp[k - b[i]] + 1) {
maxw[k] = max(maxw[k], maxw[k - b[i]] + a[i]);
}
}
}
}
}
int num = 101, maxW = 0;
for (int k = sum; k <= total; ++k) {
if (dp[k] != -1) num = min(num, dp[k]);
}
for (int k = sum; k <= total; ++k) {
if (dp[k] == num) maxW = max(maxW, maxw[k]);
}
cout << num << " " << sum - maxW << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int x, y, z, a, b, c;
int a0() {
if (y < 0)
return 1;
else
return 0;
}
int a1() {
if (y > b)
return 1;
else
return 0;
}
int a2() {
if (z < 0)
return 1;
else
return 0;
}
int a3() {
if (z > c)
return 1;
else
return 0;
}
int a4() {
if (x < 0)
return 1;
else
return 0;
}
int a5() {
if (x > a)
return 1;
else
return 0;
}
int d[10];
int main() {
int i;
scanf("%d%d%d", &x, &y, &z);
scanf("%d%d%d", &a, &b, &c);
for (i = 0; i < 6; i++) scanf("%d", &d[i]);
int ans = 0;
if (a0()) ans += d[0];
if (a1()) ans += d[1];
if (a2()) ans += d[2];
if (a3()) ans += d[3];
if (a4()) ans += d[4];
if (a5()) ans += d[5];
printf("%d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
map<int, int> m_p;
int n, sum, a[N];
pair<int, int> p[N];
int main() {
ios ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++)
cin >> p[i].first >> p[i].second, sum += p[i].first, a[i] = p[i].second;
sort(a, a + n);
int ans = sum * a[n - 1];
for (int i = 0; i < n; i++)
cout << (p[i].second != a[n - 1] || a[n - 1] == a[n - 2]
? ans - (p[i].first * a[n - 1])
: (ans / a[n - 1] - p[i].first) * a[n - 2])
<< ' ';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
int n, m, cnt;
int deg[1000000 + 7];
bool visit[1000000 + 7];
vector<int> edges[1000000 + 7];
vector<int> odd;
void reset() {
int i, lim = n + 2;
for (i = 0; i < lim; i++) {
edges[i].clear();
visit[i] = deg[i] = 0;
}
odd.clear();
}
int dfs(int u) {
int sz, v, ret = 0, i, j;
sz = edges[u].size();
cnt++;
for (i = 0; i < sz; i++) {
v = edges[u][i];
if (!visit[v]) {
visit[v] = 1;
ret += dfs(v);
}
}
return ret + (deg[u] % 2);
}
int main() {
int u, v, ans, sz, cur, ret, i, j, k;
while (scanf("%d %d", &n, &m) == 2) {
reset();
ans = 0;
for (i = 0; i < m; i++) {
scanf("%d %d", &u, &v);
edges[u].push_back(v);
edges[v].push_back(u);
deg[u]++;
deg[v]++;
}
visit[1] = 1;
odd.push_back(dfs(1));
for (i = 2; i <= n; i++) {
if (!visit[i]) {
visit[i] = 1;
if (edges[i].size() == 0) continue;
ret = dfs(i);
odd.push_back(ret);
}
}
sz = odd.size();
if (sz) {
cur = odd[0];
for (i = 1; i < sz; i++) {
if (cur == odd[i] and cur == 0) {
cur += 2;
ans++;
} else if (cur and odd[i]) {
cur += odd[i];
cur -= 2;
ans++;
} else if (cur == 0 and odd[i]) {
cur += odd[i];
ans++;
} else if (odd[i] == 0 and cur) {
ans++;
}
}
ans += (cur / 2);
}
printf("%d\n", ans);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int m[12] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int x, i, count = 0;
char a[15];
scanf("%d", &x);
gets(a);
if (strcmp(a, " of month") == 0) {
for (i = 0; i < 12; i++) {
if (m[i] >= x) count++;
}
printf("%d", count);
} else {
if ((x == 5) || (x == 6)) {
printf("53");
} else {
printf("52");
}
}
}
| 0 |
#include <bits/stdc++.h>
struct triple {
int x, y, z;
};
triple make_triple(int x, int y, int z) {
triple p = {x, y, z};
return p;
}
const int N = 1 << 18;
int head[N], dst[N + N], nxt[N + N], ie, n, nres;
triple result[N + N];
std::pair<int, int> v[N];
int nv;
int roots[2], pa[2], nroot;
void dfs(int cure, int parent) {
for (int i = head[cure]; i; i = nxt[i])
if (dst[i] != parent) dfs(dst[i], cure);
v[nv++] = std::make_pair(cure, parent);
}
void add_result(int cure, int parent) {
nv = 0;
dfs(cure, parent);
--nv;
int t = cure;
for (int i = 0; i != nv; ++i) {
result[nres++] = make_triple(parent, t, v[i].first);
result[nres++] = make_triple(v[i].first, v[i].second, cure);
t = v[i].first;
}
result[nres++] = make_triple(parent, t, cure);
}
void add_edge(int u, int v) {
++ie;
nxt[ie] = head[u];
head[u] = ie;
dst[ie] = v;
}
int dfs_sz(int cure, int parent) {
static int tsz;
int sz = 1;
int mx = 1;
for (int i = head[cure]; i; i = nxt[i]) {
if (dst[i] != parent) {
sz += tsz = dfs_sz(dst[i], cure);
mx = (mx < tsz ? tsz : mx);
}
}
if (sz * 2 >= n && mx * 2 <= n) {
pa[nroot] = parent;
roots[nroot++] = cure;
}
return sz;
}
void read_input() {
scanf("%d", &n);
ie = 0;
for (int i = 1; i < n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
add_edge(u, v);
add_edge(v, u);
}
}
int main() {
read_input();
nroot = 0;
dfs_sz(1, 0);
nres = 0;
pa[0] = roots[1];
pa[1] = roots[0];
for (int i = 0; i != nroot; ++i) {
int cure = roots[i], pare = pa[i];
for (int h = head[cure]; h; h = nxt[h])
if (dst[h] != pare) add_result(dst[h], cure);
}
printf("%d\n", nres);
for (int i = 0; i != nres; ++i)
printf("%d %d %d\n", result[i].x, result[i].y, result[i].z);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void prepare() {}
int n;
int a[2000];
int main() {
prepare();
cin >> n;
int i;
for (i = 0; i < n; i++) cin >> a[i];
if (n == 2) {
printf("not unique");
return 0;
}
int l = a[0] + a[n - 1];
int r = a[0] + a[n - 1] + 1;
for (i = 1; i <= n / 2; i++) {
int l1 = a[i] + a[n - 1 - i];
int r1 = a[i] + a[n - 1 - i] + 1;
if (l1 > l) {
printf("unique\n");
printf("%d", r);
return 0;
}
if (r1 < r) {
printf("unique\n");
printf("%d", l);
return 0;
}
}
printf("not unique");
return 0;
}
| 5 |
#include <bits/stdc++.h>
double PI = 3.1415926535;
const int N = (int)(1 * 1e6 + 10);
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long int x, k, y;
cin >> x >> k >> y;
vector<int> a(n + 1);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
a[n] = 0;
vector<int> b(m + 1);
for (int i = 0; i < m; i++) {
cin >> b[i];
}
b[m] = 0;
int j = 0;
int prev = 0;
int maxi = 0;
int cnt = 0;
long long int result = 0;
for (int i = 0; i <= n; i++) {
if (a[i] == b[j]) {
j++;
if (cnt < k) {
if (maxi < prev || maxi < a[i]) {
result += (cnt * y);
} else {
cout << "-1" << endl;
return 0;
}
} else {
if (maxi < prev || maxi < a[i]) {
int var = cnt / k;
result += min(var * x, var * k * y);
result += y * (cnt % k);
} else {
result += x;
cnt = cnt - k;
int var = cnt / k;
result += min(var * x, var * k * y);
result += y * (cnt % k);
}
}
maxi = 0;
prev = a[i];
cnt = 0;
} else {
cnt++;
maxi = max(maxi, a[i]);
}
}
if (j < m) {
cout << "-1" << endl;
return 0;
}
cout << result << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using namespace rel_ops;
const int inf = ~0u >> 2;
const long long INF = ~0ull >> 2;
const double err = 1e-7;
inline long long read() {
long long x;
if (scanf("%lld", &x) == -1) exit(0);
return x;
}
inline double readf() {
double x;
if (scanf("%lf", &x) == -1) exit(0);
return x;
}
template <typename _>
inline _ sqr(_ x) {
return x * x;
}
mt19937 rnd(time(0));
const int N = 200010;
const int mod = (1 ? 1000000007 : 998244353);
int n;
struct vec {
double x, y;
vec(double x = 0, double y = 0) : x(x), y(y) {}
vec operator-(vec b) { return vec(x - b.x, y - b.y); }
vec operator+(vec b) { return vec(x + b.x, y + b.y); }
vec operator*(double k) { return vec(k * x, k * y); }
bool operator<(vec b) const { return make_pair(x, y) < make_pair(b.x, b.y); }
double len() { return sqrt(x * x + y * y); }
double sqr() { return x * x + y * y; }
} a[N];
double cross(vec a, vec b) { return a.x * b.y - a.y * b.x; }
double cross(vec a, vec b, vec c) { return cross(a - b, b - c); }
double dot(vec a, vec b) { return a.x * b.x + a.y * b.y; }
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
if (n % 2 == 1) cout << "No", exit(0);
for (int i = (0), _ = (n); i < _; i++)
cin >> a[i].x >> a[i].y, a[i + n] = a[i];
bool f = 1;
for (int i = (0), _ = (n / 2); i < _; i++)
if (((a[i] - a[i + 1]) + (a[i + n / 2] - a[i + 1 + n / 2])).len() < err)
;
else
f = 0;
if (f)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
string a;
long long k, l, s;
char ma, mi;
cin >> a >> k;
if (k == 1) {
cout << a << endl;
} else {
for (int i = 0; i < k - 1; i++) {
l = a.size();
ma = a[0];
mi = a[0];
for (int j = 1; j < l; j++) {
if (a[j] > ma) {
ma = a[j];
}
}
for (int j = 1; j < l; j++) {
if (a[j] < mi) {
mi = a[j];
}
}
int ma2 = ma - '0';
int mi2 = mi - '0';
if (mi2 == 0) {
break;
} else {
stringstream ssr(a);
ssr >> s;
s += ma2 * mi2;
stringstream sr;
sr << s;
sr >> a;
}
}
cout << a << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a[21];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
a[0] = 1;
for (int i = 1; i <= 20; i++) a[i] = a[i - 1] * i;
long long ans = a[n] / a[n / 2] / a[n / 2];
ans *= a[n / 2 - 1] * a[n / 2 - 1];
cout << ans / 2 << "\n";
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool Check(int n) {
int i;
bool flag;
flag = true;
for (i = 2; i <= n / 2; i++) {
if (n % i == 0) {
flag = false;
break;
}
}
if (flag == false) {
return false;
} else {
return true;
}
}
int main() {
int n, m;
int i, j;
bool flag;
scanf("%d %d", &n, &m);
for (i = n + 1; i <= m; i++) {
flag = Check(i);
if (flag == true) {
break;
}
}
if (i == m && flag == true) {
printf("YES\n");
} else {
printf("NO\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, c, x, y;
cin >> a >> b >> c;
if (a > b)
x = 2 * b + 1;
else if (b > a)
x = 2 * a + 1;
else if (a == b)
x = 2 * a;
y = 2 * c;
cout << x + y;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char str[51234];
int L[51234][123];
int P[51234][27];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> str;
int n = strlen(str);
for (int i = 0; i < 26; ++i) {
int w = n;
P[n][i] = 0x3f3f3f3f;
for (int j = n - 1; j >= 0; --j) {
if (str[j] - 'a' == i) w = j;
P[j][i] = w;
}
}
for (int i = 0; i <= n; ++i) {
L[i][0] = i - 1;
L[i][1] = i;
}
int maxLen = 1;
for (int k = 2; k <= 100; ++k) {
L[n][k] = 0x3f3f3f3f;
for (int i = n - 1; i >= 0; --i) {
L[i][k] = L[i + 1][k];
int t = L[i + 1][k - 2] + 1;
if (t < n) {
L[i][k] = min(L[i][k], P[t][str[i] - 'a']);
}
}
if (L[0][k] < n) maxLen = k;
}
int d = maxLen;
int x = 0;
int cnt = 0;
char pa[110];
while (d > 0) {
while (L[x][d] == L[x + 1][d]) x++;
pa[cnt] = pa[maxLen - cnt - 1] = str[x];
x++;
cnt++;
d -= 2;
}
pa[maxLen] = 0;
cout << pa << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long double a, b, c;
long double len(pair<long double, long double> f,
pair<long double, long double> s) {
return sqrt((f.first - s.first) * (f.first - s.first) +
(f.second - s.second) * (f.second - s.second));
}
void go(pair<long double, long double> f, pair<long double, long double> s) {
a = f.second - s.second;
b = s.first - f.first;
c = f.first * s.second - s.first * f.second;
long double dd = sqrt(a * a + b * b);
a /= dd;
b /= dd;
c /= dd;
}
long double dist(pair<long double, long double> cur) {
return a * cur.first + b * cur.second + c;
}
signed main() {
int n;
cin >> n;
vector<pair<long double, long double> > v;
for (int i = 0; i < n; ++i) {
long double a, b;
cin >> a >> b;
v.push_back(make_pair(a, b));
}
v.push_back(v[0]);
v.push_back(v[1]);
long double ans = 1234567890123456789;
for (int i = 1; i <= n; ++i) {
ans = min(ans, len(v[i], v[i - 1]));
go(v[i - 1], v[i + 1]);
ans = min(ans, dist(v[i]));
}
cout << fixed << setprecision(10) << ans / 2 << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename S, typename T>
ostream& operator<<(ostream& out, pair<S, T> const& p) {
out << p.first << " " << p.second;
return out;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T> const& v) {
long long int l = v.size();
for (long long int i = 0; i < l - 1; i++) out << v[i] << ' ';
if (l > 0) out << v[l - 1];
return out;
}
template <typename T>
void trace(const char* name, T&& arg1) {
cout << name << " : " << arg1 << "\n";
}
template <typename T, typename... Args>
void trace(const char* names, T&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cout.write(names, comma - names) << " : " << arg1 << " | ";
trace(comma + 1, args...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n, m;
cin >> n >> m;
set<pair<long long, long long> > second;
for (long long int i = 0; i < m; i++) {
long long int u, v;
cin >> u >> v;
second.insert(make_pair(u, v));
}
for (long long int i = 0; i < 200; i++) {
vector<long long int> x;
for (long long int i = 0; i < n; i++) {
x.push_back(i + 1);
}
random_shuffle(x.begin(), x.end());
bool flag = 1;
for (long long int j = 0; j < m; j++) {
if (second.find(make_pair(x[j], x[(j + 1) % n])) == second.end() &&
second.find(make_pair(x[(j + 1) % n], x[j])) == second.end())
continue;
else {
flag = 0;
break;
}
}
if (flag == 1) {
for (long long int j = 0; j < m; j++) {
cout << x[j] << " " << x[(j + 1) % n] << "\n";
}
return 0;
}
}
cout << -1;
return 0;
}
| 8 |
#include <bits/stdc++.h>
int n, m;
int a[100005], c[100005][105];
long long num[100005][105];
int main() {
c[0][0] = 1;
for (int i = 1; i < 100005; i++) {
c[i][0] = 1;
for (int j = 1; j <= std::min(i, 100); j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % 1000000007;
}
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int l, r, k;
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &l, &r, &k);
num[l][k]++;
for (int j = k; j >= 0; j--) {
int tmp = k - j;
num[r + 1][j] =
(num[r + 1][j] - c[r - l + tmp][tmp] + 1000000007) % 1000000007;
}
}
for (int j = 100; j >= 0; j--)
for (int i = 1; i <= n; i++)
num[i][j] = ((num[i][j] + num[i][j + 1]) % 1000000007 + num[i - 1][j]) %
1000000007;
for (int i = 1; i < n; i++) printf("%I64d ", (a[i] + num[i][0]) % 1000000007);
printf("%I64d\n", (a[n] + num[n][0]) % 1000000007);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll p=1e9+7;
ll fac(ll n) {
ll ans=1;
while(n) {
ans=(ans*n)%p;
n--;
}
return ans;
}
ll power(ll a, ll x) {
ll ans=1;
while(x) {
if(x&1) {
ans=(ans*a)%p;
}
x=x>>1;
a=(a*a)%p;
}
return ans;
}
ll modInv(ll a) {
return power(a, p-2);
}
void solve() {
int n;
cin>>n;
vector<ll> a(n);
ll total=0;
for(auto &i : a) {
cin>>i;
total+=i;
}
if(total%n) {
cout<<0<<endl;
return;
}
total/=n;
int source=0, sink=0;
map<ll, int> count;
for(auto i : a) {
if(i<total) {
sink++;
}
if(i>total) {
source++;
}
count[i]++;
}
ll ans=fac(n);
for(auto i : count) {
ans=(ans*modInv(fac(i.second)))%p;
}
if(min(source, sink)>1) {
ans=(ans*2)%p;
ans=(ans*fac(source))%p;
ans=(ans*fac(sink))%p;
int filled=source+sink;
ans=(ans*modInv(fac(filled)))%p;
}
cout<<ans<<endl;
return;
}
int main() {
#ifdef bipinpathak
(void)!freopen("input.txt", "r", stdin);
(void)!freopen("output.txt", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
for(int i=0; i<t; i++) {
//cout<<"Case #"<<i+1<<": ";
solve();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void adskiy_razgon() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int MAX = 2e5 + 7;
const int MOD = 1e+9 + 7;
const long long INF = 1e+18 + 7;
int nod(int a, int b) {
if (a == 0 || b == 0) {
return 0;
} else if (a == b) {
return a;
} else if (a > b) {
return nod(a - b, b);
} else {
return nod(a, b - a);
}
}
int nok(int a, int b) { return a * b / nod(a, b); }
void sp(int a, double b) { cout << fixed << setprecision(a) << b; }
int a[1000000];
int main() {
adskiy_razgon();
string s;
cin >> s;
int cnt = 0;
for (int i = (0); i < (s.size()); i++) {
a[s[i] - 'a']++;
if (a[s[i] - 'a'] % 2 == 1) {
cnt++;
} else {
cnt--;
}
}
if (cnt <= 1 || s.size() % 2 == 1) {
cout << "First";
} else {
cout << "Second";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000 * 1000 * 1000LL * 10;
long long n, k;
long long BS(long long st, long long en) {
if (st + 1 >= en) return en;
long long m = (st + en) / 2, temp = 1, sum = 0;
while (m / temp) {
sum += (m / temp);
temp *= k;
}
if (sum >= n)
return BS(st, m);
else
return BS(m, en);
}
int main() {
cin >> n >> k;
if (k == 1)
cout << "1";
else
cout << BS(0, INF);
}
| 3 |
#include <bits/stdc++.h>
template <typename T>
bool isOdd(T num) {
return num % 2 != 0;
}
int main(int argc, char *argv[]) {
int n;
std::cin >> n;
std::vector<char> in;
short input;
long long int sum = 0;
bool oddSum = false;
int numOfWays = 0;
for (int i = 0; i < n; i++) {
std::cin >> input;
in.push_back(input);
sum += input;
}
oddSum = isOdd(sum);
for (int i = 0; i < n; i++) {
if (isOdd(in[i]) && oddSum)
numOfWays++;
else if (!isOdd(in[i]) && !oddSum)
numOfWays++;
}
std::cout << numOfWays << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char string_in_buffer[(int)260];
void fast_scan(int &first) { scanf("%d", &first); }
void fast_scan(long long &first) { scanf("%lld", &first); }
void fast_scan(unsigned long long &first) { scanf("%llu", &first); }
void fast_scan(double &first) { scanf("%lf", &first); }
void fast_scan(long double &first) { scanf("%Lf", &first); }
void fast_scan(char &first) {
scanf("%c", &first);
if (first == '\n') {
fast_scan(first);
}
}
void fast_scan(string &first) {
scanf("%s", string_in_buffer);
first = string(string_in_buffer);
}
template <class TFirst, class TSecond>
void fast_scan(pair<TFirst, TSecond> &p) {
fast_scan(p.first);
fast_scan(p.second);
}
template <class T>
void fast_scan(vector<T> &v) {
for (auto &first : v) fast_scan(first);
}
void fast_print(const int &first) { printf("%d", first); }
void fast_print(const long long &first) { printf("%lld", first); }
void fast_print(const unsigned long long &first) { printf("%llu", first); }
void fast_print(const double &first) { printf("%.15lf", first); }
void fast_print(const long double &first) { printf("%.15Lf", first); }
void fast_print(const char &first) { printf("%c", first); };
void fast_print(const string &first) { printf("%s", first.c_str()); }
void fast_print(const char v[]) { fast_print((string)v); }
template <class TFirst, class TSecond>
void fast_print(const pair<TFirst, TSecond> &p) {
fast_print(p.first);
fast_print(' ');
fast_print(p.second);
}
template <class T>
void fast_print(const vector<T> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print(' ');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const vector<vector<T>> &v) {
if (v.empty()) return;
fast_print(v[0]);
for (int i = 1; i < v.size(); i++) {
fast_print('\n');
fast_print(v[i]);
}
}
template <class T>
void fast_print(const T &v) {
for (const auto &first : v) {
fast_print(first);
fast_print(' ');
}
}
using namespace std;
namespace smart_io {
string print_start = "";
string sep = " ";
bool first_print = false;
void precall_print() {
fast_print(print_start);
print_start = "\n";
first_print = true;
}
void _print(deque<string>) {}
template <class T, class... Args>
void _print(deque<string> names, T kek, Args... args) {
if (!first_print) {
fast_print("\n");
} else {
first_print = false;
}
fast_print(names.front());
fast_print(" = ");
fast_print(kek);
names.pop_front();
_print(names, args...);
}
} // namespace smart_io
template <class T>
ostream &operator,(ostream &os, const T &object) {
if (!smart_io::first_print) {
fast_print(smart_io::sep);
} else {
smart_io::first_print = false;
}
fast_print(object);
return os;
}
template <class T>
istream &operator,(istream &is, T &object) {
fast_scan(object);
return is;
}
namespace typedefs {}
namespace numbers_operation {
template <class T>
T floor_mod(T a, T b) {
if (a % b == 0) return 0;
if (a >= 0 && b >= 0) return a % b;
if (a <= 0 && b <= 0) return a % b;
return abs(b) - (abs(a) % abs(b));
}
} // namespace numbers_operation
using namespace numbers_operation;
using namespace typedefs;
const int N = 3e5;
int n, q;
struct Node {
int l = -1, r = -1;
bool zero = false;
int tl, tr;
int value = 0;
};
vector<Node> S;
int get() {
S.push_back(Node());
return ((int)S.size()) - 1;
}
int init(int tl, int tr) {
int i = get();
S[i].tl = tl;
S[i].tr = tr;
if (tl + 1 != tr) {
int m = (tl + tr) / 2;
S[i].l = init(tl, m);
S[i].r = init(m, tr);
}
return i;
}
void push(int i) {
if (S[i].tl + 1 != S[i].tr && S[i].zero) {
S[S[i].l].zero = true;
S[S[i].r].zero = true;
}
}
int get_value(int i) {
if (S[i].zero) return S[i].tr - S[i].tl;
return S[i].value;
}
void update(int i) {
if (S[i].tl + 1 != S[i].tr) {
S[i].value = get_value(S[i].l) + get_value(S[i].r);
}
}
void aoesntuhaoesntuhaoe(int i, int ql, int qr) {
if (S[i].tr <= ql || qr <= S[i].tl) return;
push(i);
if (ql <= S[i].tl && S[i].tr <= qr) {
S[i].zero = true;
} else {
aoesntuhaoesntuhaoe(S[i].l, ql, qr);
aoesntuhaoesntuhaoe(S[i].r, ql, qr);
}
update(i);
}
int query(int i, int ql, int qr) {
if (S[i].tr <= ql || qr <= S[i].tl) return 0;
push(i);
if (ql <= S[i].tl && S[i].tr <= qr) {
return get_value(i);
} else {
return query(S[i].l, ql, qr) + query(S[i].r, ql, qr);
}
}
namespace STP {
struct Node {
int l = -1, r = -1;
int mod = -1;
int tl, tr;
int value = 0;
};
vector<Node> S;
int get() {
S.push_back(Node());
return ((int)S.size()) - 1;
}
int init(int tl, int tr) {
int i = get();
S[i].tl = tl;
S[i].tr = tr;
if (tl + 1 != tr) {
int m = (tl + tr) / 2;
S[i].l = init(tl, m);
S[i].r = init(m, tr);
}
return i;
}
void push(int i) {
if (S[i].mod == -1) return;
if (S[i].tl + 1 != S[i].tr) {
S[S[i].l].mod = S[i].mod;
S[S[i].r].mod = S[i].mod;
} else {
S[i].value = S[i].mod;
}
S[i].mod = -1;
}
void aoesntuhaoesntuhaoe(int i, int ql, int qr, int mod) {
if (S[i].tr <= ql || qr <= S[i].tl) return;
push(i);
if (ql <= S[i].tl && S[i].tr <= qr) {
S[i].mod = mod;
} else {
aoesntuhaoesntuhaoe(S[i].l, ql, qr, mod);
aoesntuhaoesntuhaoe(S[i].r, ql, qr, mod);
}
}
int query(int i, int ind) {
push(i);
if (S[i].l == -1) {
return S[i].value;
} else {
int m = (S[i].tl + S[i].tr) / 2;
if (ind < m) {
return query(S[i].l, ind);
} else {
return query(S[i].r, ind);
}
}
}
}; // namespace STP
signed main(signed argc, char *argv[]) {
cin, n, q;
vector<int> v(n);
cin, v;
vector<int> L(q + 1, 1e9);
vector<int> R(q + 1, -1e9);
vector<int> cnt(q + 1, 0);
for (int i = 0; i < ((int)v.size()); i++) {
L[v[i]] = min(L[v[i]], i);
R[v[i]] = max(R[v[i]], i);
cnt[v[i]]++;
}
int root = init(0, n + 1);
for (int i = 0; i < (n); i++) {
if (v[i] == 0) {
aoesntuhaoesntuhaoe(root, i, i + 1);
}
}
for (int i = q; i > 0; i--) {
if (R[i] == -1e9) {
if (query(root, 0, n) == 0) {
smart_io::precall_print();
cout, "NO";
return 0;
}
continue;
}
int sum = cnt[i] + query(root, L[i], R[i] + 1);
if (sum == R[i] - L[i] + 1) {
aoesntuhaoesntuhaoe(root, L[i], R[i] + 1);
} else {
smart_io::precall_print();
cout, "NO";
return 0;
}
}
{
if (R[0] == -1e9) {
smart_io::precall_print();
cout, "YES";
smart_io::precall_print();
cout, v;
return 0;
}
int root = STP::init(0, n + 1);
for (int i = 1; i <= q; i++) {
if (i == 1) {
STP::aoesntuhaoesntuhaoe(root, 0, n, 1);
} else {
if (R[i] != -1e9) {
STP::aoesntuhaoesntuhaoe(root, L[i], R[i] + 1, i);
} else {
STP::aoesntuhaoesntuhaoe(root, L[0], L[0] + 1, i);
}
}
}
vector<int> rez;
for (int i = 0; i < (n); i++) {
rez.push_back(STP::query(root, i));
}
smart_io::precall_print();
cout, "YES";
smart_io::precall_print();
cout, rez;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef long long int lli;
typedef long long ll;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
vector<int> a(n);
vector<int> b;
set<int> s;
for(int i=0;i<n;i++)
{
cin>>a[i];
if(s.find(a[i])!=s.end())
b.push_back(a[i]);
else
s.insert(a[i]);
}
for (auto it = s.begin(); it !=s.end(); ++it)
cout << *it<<" ";
for(int i=0;i<b.size();i++)
cout<<b[i]<<" ";
cout<<'\n';
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
int a[105][105] = {0}, Cnt[105] = {0};
int resenje = 0;
bool mark[105] = {0};
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int p, q;
scanf("%d%d", &p, &q);
p--;
q--;
a[p][q] = 1;
a[q][p] = 1;
Cnt[p]++;
Cnt[q]++;
}
for (int i = 0; i < n; i++) {
vector<int> izb;
for (int j = 0; j < n; j++) {
if ((!mark[j]) && (Cnt[j] == 1)) izb.push_back(j);
}
int k = izb.size();
for (int j = 0; j < k; j++) {
int tren = izb[j];
for (int z = 0; z < n; z++)
if ((!mark[z]) && (a[tren][z] == 1)) {
a[z][tren] = false;
a[tren][z] = false;
Cnt[z]--;
}
mark[tren] = true;
}
if (k > 0) resenje++;
}
printf("%d\n", resenje);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dp[1001];
int inv[5][1001], n, k, a;
int solve(int a) {
if (dp[a] != -1) return dp[a];
dp[a] = 1;
for (int b = (1); b <= (n); b++) {
bool c = 1;
for (int i = 0; i < (k); i++) c &= inv[i][b] > inv[i][a];
if (c) dp[a] = max(dp[a], solve(b) + 1);
}
return dp[a];
}
int main() {
fill(dp, dp + 1001, -1);
scanf("%d %d", &n, &k);
for (int i = 0; i < (k); i++) {
for (int j = 0; j < (n); j++) {
scanf("%d", &a);
inv[i][a] = j;
}
}
int ans = 0;
for (int i = (1); i <= (n); i++) ans = max(ans, solve(i));
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[100005];
long long power(long long x, long long m) {
long long ans = 1;
x = x % 1000000007;
while (m) {
if (m & 1) ans = (ans * x) % 1000000007;
x = (x * x) % 1000000007;
m /= 2;
}
return ans % 1000000007;
}
int main() {
long long n, x;
long long s = 0;
scanf("%I64d%I64d", &n, &x);
for (int i = 0; i < n; i++) {
scanf("%I64d", &a[i]);
s += a[i];
}
for (int i = 0; i < n; i++) {
a[i] = s - a[i];
}
a[n] = -1;
sort(a, a + n);
long long cnt = 1, ans;
for (int i = 1; i <= n; i++) {
if (a[i] != a[i - 1]) {
if (cnt % x == 0) {
cnt /= x;
a[i - 1] += 1;
i--;
} else {
ans = a[i - 1];
break;
}
} else {
cnt++;
}
}
ans = min(ans, s);
printf("%I64d\n", power(x, ans));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 510, Max = (1 << 16) + 10, Log = 16, mod = 1e9 + 7;
int cl[maxn], cr[maxn], pr[maxn], Cnt;
char type[maxn];
int dp[maxn][Max], tmp[Max], tmpl[Max], tmpr[Max];
void add(int id, int typ, int ccl, int ccr) {
type[id] = typ;
cl[id] = ccl;
cr[id] = ccr;
}
void Do(int *arr, int *start, bool bl) {
for (int i = 0; i < Max; i++) {
arr[i] = start[i];
}
for (int i = 0; i < Log; i++) {
for (int j = 0; j < (1 << Log); j++) {
if ((((j) >> (i)) & 1) == bl) arr[j] = (arr[j] + arr[j ^ (1 << i)]) % mod;
}
}
}
void dfs(int u) {
if (cl[u] == -1 && cr[u] == -1) {
for (char ch = 'A'; ch <= 'D'; ch++) {
if (type[u] != '?' && type[u] != ch) continue;
int msk = 0;
for (int j = 0; j < 16; j++) msk |= ((((j) >> (ch - 'A')) & 1) == 1) << j;
dp[u][msk]++;
}
for (char ch = 'a'; ch <= 'd'; ch++) {
if (type[u] != '?' && type[u] != ch) continue;
int msk = 0;
for (int j = 0; j < 16; j++) msk |= ((((j) >> (ch - 'a')) & 1) == 0) << j;
dp[u][msk]++;
}
return;
}
dfs(cl[u]);
dfs(cr[u]);
for (int _ = 0; _ < 2; _++) {
if (type[u] != '?' && type[u] != (_ == 0 ? '&' : '|')) continue;
Do(tmpl, dp[cl[u]], _);
Do(tmpr, dp[cr[u]], _);
for (int i = 0; i < Max; i++)
tmp[i] =
(__builtin_popcount(i) & 1 ? -1 : 1) * 1ll * tmpl[i] * tmpr[i] % mod;
Do(tmp, tmp, _);
for (int i = 0; i < Max; i++)
dp[u][i] =
(dp[u][i] + (__builtin_popcount(i) & 1 ? -1 : 1) * tmp[i]) % mod;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
memset(cl, -1, sizeof cl);
memset(cr, -1, sizeof cr);
string s;
cin >> s;
int nw = 0;
for (int i = 0; i < int((s).size()); i++) {
if (s[i] == ')') {
nw = pr[nw];
} else if (s[i] == '(') {
++Cnt;
if (cl[nw] == -1)
cl[nw] = Cnt;
else
cr[nw] = Cnt;
pr[Cnt] = nw;
nw = Cnt;
} else {
type[nw] = s[i];
}
}
dfs(0);
int n;
cin >> n;
int Yes = 0, No = 0;
for (int i = 0; i < n; i++) {
int a, b, c, d, val;
cin >> a >> b >> c >> d >> val;
int id = a + 2 * b + 4 * c + 8 * d;
if (val == 0)
No |= 1 << id;
else
Yes |= 1 << id;
}
int ans = 0;
for (int msk = 0; msk < (1 << 16); msk++) {
if ((Yes & msk) != Yes || (No & ((1 << 16) - 1 - msk)) != No) continue;
ans = (ans + dp[0][msk]) % mod;
}
if (ans < 0) ans += mod;
return cout << ans << endl, 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
string s[100] = {
"", "Washington", "Adams", "Jefferson", "Madison",
"Monroe", "Adams", "Jackson", "Van Buren", "Harrison",
"Tyler", "Polk", "Taylor", "Fillmore", "Pierce",
"Buchanan", "Lincoln", "Johnson", "Grant", "Hayes",
"Garfield", "Arthur", "Cleveland", "Harrison", "Cleveland",
"McKinley", "Roosevelt", "Taft", "Wilson", "Harding",
"Coolidge", "Hoover", "Roosevelt", "Truman", "Eisenhower",
"Kennedy", "Johnson", "Nixon", "Ford", "Carter",
"Reagan"};
int main() {
int n;
cin >> n;
cout << s[n] << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
long long n, m, h, ans[1000][1000], sh[1000], dl[1000], a[1000][1000];
int main() {
cin >> n >> m >> h;
for (int i = 1; i <= m; i++) {
cin >> dl[i];
}
for (int i = 1; i <= n; i++) {
cin >> sh[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i][j]) {
ans[i][j] = min(sh[i], dl[j]);
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cout << ans[i][j] << " ";
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[102];
int main() {
int i = 0, k = 0, j;
cin >> s;
while (s[i] != '\0') {
if (s[i] >= 'a' && s[i] <= 'z' && i != 0) k++;
i++;
}
if (k == 0 && i != 1) {
for (j = 0; j < i; j++)
if (s[j] >= 'a' && s[j] <= 'z')
s[j] = s[j] + 'A' - 'a';
else
s[j] = s[j] + 'a' - 'A';
}
if (i == 1 && (s[0] >= 'a' && s[0] <= 'z'))
s[0] = s[0] + 'A' - 'a';
else if (i == 1 && (s[0] >= 'A' && s[0] <= 'Z'))
s[0] = s[0] + 'a' - 'A';
for (k = 0; k < i; k++) cout << s[k];
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int parent[51];
int adjNums[51];
int getParent(int son) {
int sonParent = parent[son];
if (sonParent != parent[sonParent]) parent[son] = getParent(sonParent);
return parent[son];
}
int main() {
int n, m, u, v, uParent, vParent;
bool ok = true;
cin >> n >> m;
if (n == 1 && m == 0) return cout << "YES\n1\n 1 1" << flush, 0;
for (int i = 0; i <= n; i++) parent[i] = i;
for (int i = 1; i <= m; i++) {
cin >> u >> v;
if (!ok) continue;
uParent = getParent(u);
vParent = getParent(v);
adjNums[u]++;
adjNums[v]++;
if (adjNums[u] > 2 || adjNums[v] > 2) {
ok = false;
continue;
}
if (uParent != vParent)
parent[vParent] = uParent;
else
ok = false;
}
if (m > n) return cout << "NO" << endl, 0;
if (!ok) {
int count = 0;
for (int i = 1; i <= n; i++)
if (i == parent[i]) count++;
if (count > 1) return cout << "NO" << endl, 0;
return cout << "YES\n0" << endl, 0;
} else {
if (n == m) {
cout << "YES\n0" << flush;
return 0;
}
cout << "YES\n" << n - m << endl;
for (u = 1; u <= n; u++) {
if (adjNums[u] == 2) continue;
uParent = getParent(u);
for (v = u + 1; v <= n; v++) {
vParent = getParent(v);
if (adjNums[v] == 2 || vParent == uParent) continue;
cout << u << " " << v << endl;
parent[vParent] = uParent;
adjNums[u]++;
adjNums[v]++;
if (adjNums[u] > 1) break;
}
}
u = -1, v = -1;
for (int i = 1; i <= n; i++)
if (adjNums[i] == 2)
continue;
else if (u == -1)
u = i;
else {
v = i;
break;
}
cout << u << " " << v << flush;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y, z, k, xx = 0, yy = 0, zz = 0, minn;
cin >> x >> y >> z >> k;
if (k >= x + y + z - 3) {
cout << x * y * z << endl;
return 0;
}
minn = min(min(x, y), z);
minn--;
if (k - 3 * (minn) > 0) {
k = k - 3 * (minn);
xx = minn;
yy = minn;
zz = minn;
y = y - yy;
x = x - yy;
z = z - yy;
if (x == 1) {
} else if (y == 1) {
int t = x;
x = y;
y = t;
} else if (z == 1) {
int t = x;
x = z;
z = t;
}
minn = min(y, z);
minn--;
if (k - 2 * (minn) > 0) {
k = k - 2 * (minn);
yy += minn;
zz += minn;
if (y - yy == 1) {
cout << (xx + 1) * (yy + 1) * (zz + 1 + k) << endl;
} else {
cout << (xx + 1) * (yy + 1 + k) * (zz + 1) << endl;
}
} else {
if (k % 2 == 1) {
cout << (xx + 1) * (xx + k / 2 + 1 + 1) * (xx + k / 2 + 1) << endl;
} else {
cout << (xx + 1) * (xx + k / 2 + 1) * (xx + k / 2 + 1) << endl;
}
}
} else {
if (k % 3 == 1) {
cout << (k / 3 + 1) * (k / 3 + 1) * (k / 3 + 1 + 1) << endl;
} else if (k % 3 == 0) {
cout << (k / 3 + 1) * (k / 3 + 1) * (k / 3 + 1) << endl;
} else if (k % 3 == 2) {
cout << (k / 3 + 1) * (k / 3 + 1 + 1) * (k / 3 + 1 + 1) << endl;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
long long num[maxn];
int arr[maxn];
void init() {
num[0] = num[1] = 1;
for (int i = 2; i <= 50; ++i) {
num[i] = num[i - 1] + num[i - 2];
}
}
int main() {
init();
int n;
long long k;
int id = 1;
cin >> n >> k;
while (num[id] < k) id++;
for (int i = n; i > id; --i) {
arr[n - i + 1] = n - i + 1;
}
while (k) {
if (num[id] == k) {
for (int i = id; i > 0; i -= 2) {
if (i - 1 > 0) {
arr[n - i + 1] = n - i + 2;
arr[n - i + 2] = n - i + 1;
} else {
arr[n - i + 1] = n - i + 1;
}
}
break;
} else {
k -= num[id - 1];
arr[n - id + 1] = n - id + 2;
arr[n - id + 2] = n - id + 1;
id -= 2;
while (id > 0 && k <= num[id]) {
arr[n - id + 1] = n - id + 1;
id--;
}
id++;
}
}
for (int i = 1; i <= n; ++i) {
if (i == 1) {
printf("%d", arr[i]);
} else {
printf(" %d", arr[i]);
}
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 500;
struct node {
int kd, x;
} a[N * 2];
bool cmp(node a, node b) { return a.x < b.x; }
pair<int, int> ans[N], f[N * 2];
int e, s, n, m;
deque<int> q[4];
int main() {
scanf("%d%d%d%d", &e, &s, &n, &m);
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].kd, &a[i].x);
for (int i = 1; i <= m; i++)
scanf("%d", &a[i + n].x), a[i + n].kd = -i, ans[i] = make_pair(-1, -1);
sort(a + 1, a + n + m + 1, cmp);
int num = n + m;
for (; num > 0 && a[num].x > e; --num)
;
a[num + 1].x = e;
a[num + 1].kd = 3;
f[num + 1] = make_pair(0, 0);
q[3].push_back(num + 1);
for (int i = num; i; i--) {
for (int j = 1; j <= 3; j++)
while (!q[j].empty() && a[q[j].front()].x > a[i].x + s) q[j].pop_front();
if (a[i].kd < 0) {
for (int j = 3; j; j--)
if (!q[j].empty()) {
int t = q[j].front(), tmp = s - a[t].x + a[i].x;
if (j == 3) ans[-a[i].kd] = make_pair(f[t].first, f[t].second);
if (j == 2)
ans[-a[i].kd] = make_pair(f[t].first, max(f[t].second - tmp, 0));
if (j == 1)
ans[-a[i].kd] = make_pair(max(0, f[t].first - tmp), f[t].second);
break;
}
continue;
}
int t = -1, j = 3;
for (; j >= a[i].kd; j--)
if (!q[j].empty()) {
if (t == -1 || a[t].x > a[q[j].back()].x) t = q[j].back();
}
if (t == -1)
for (; j; j--)
if (!q[j].empty()) {
t = q[j].front();
break;
}
if (t == -1) break;
f[i] = f[t];
int tmp = s - a[t].x + a[i].x;
if (a[t].kd >= a[i].kd) {
if (a[i].kd == 1)
f[i].first += s - tmp;
else if (a[i].kd == 2)
f[i].second += s - tmp;
} else {
if (a[t].kd == 1)
f[i].first -= tmp;
else if (a[t].kd == 2)
f[i].second -= tmp;
if (a[i].kd == 2) f[i].second += s;
}
q[a[i].kd].push_back(i);
}
for (int i = 1; i <= m; i++) printf("%d %d\n", ans[i].first, ans[i].second);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e17 + 7;
const long long MOD = 1e7 + 9;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
long long sum[n + 1][n + 1];
memset(sum, 0, sizeof(sum));
vector<long long> dp[n + 1][n + 1];
for (long long i = 0; i <= n; i++)
for (long long j = 0; j <= n; j++) dp[i][j] = {};
for (long long i = n - 1; i >= 0; i--) {
sum[i][1LL] = a[i];
dp[i][1LL] = {a[i]};
for (long long j = i + 1; j < n; j++) {
for (long long k = 1; k <= n - j; k++) {
if ((sum[i][k + 1] < sum[j][k] + a[i]) || dp[i][k + 1].size() == 0 ||
((sum[i][k + 1] == sum[j][k] + a[i]) && (a[i] < dp[i][k + 1][k]))) {
dp[i][k + 1] = dp[j][k];
dp[i][k + 1].push_back(a[i]);
sum[i][k + 1] = sum[j][k] + a[i];
}
}
}
}
vector<long long> ans[n + 1];
for (long long i = 1; i <= n; i++) {
long long cs = 0;
for (long long j = 0; j < n; j++) {
if (cs < sum[j][i] || ans[i].size() == 0 ||
(cs == sum[j][i] && ans[i][i - 1] > a[j])) {
cs = sum[j][i];
ans[i] = dp[j][i];
}
}
}
long long t;
cin >> t;
while (t--) {
long long x, y;
cin >> x >> y;
cout << ans[x][ans[x].size() - y] << "\n" << flush;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char f[50][50];
bool used[50][50];
int dx[4] = {-1, 0, 0, 1};
int dy[4] = {0, 1, -1, 0};
int h, w;
bool check(int x, int y) {
if (x >= 0 && x < h && y >= 0 && y < w && f[x][y] == '#' && !used[x][y])
return true;
else
return false;
}
void bfs(int x, int y) {
queue<pair<int, int> > que;
que.push(pair<int, int>(x, y));
used[x][y] = true;
while (!que.empty()) {
pair<int, int> p = que.front();
que.pop();
for (int i = 0; i < 4; i++) {
int nx = p.first + dx[i];
int ny = p.second + dy[i];
if (check(nx, ny)) {
used[nx][ny] = true;
que.push(pair<int, int>(nx, ny));
}
}
}
}
bool solve(int x, int y) {
memset(used, false, sizeof(used));
int i, j;
int cnt = 0;
f[x][y] = '.';
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
if (f[i][j] == '#' && !used[i][j]) {
cnt++;
bfs(i, j);
}
}
}
f[x][y] = '#';
if (cnt >= 2)
return true;
else
return false;
}
int main() {
int i, j;
scanf("%d %d", &h, &w);
int cnt = 0;
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
scanf(" %c", &f[i][j]);
if (f[i][j] == '#') cnt++;
}
}
if (cnt <= 2) {
printf("-1\n");
return 0;
}
bool pos = false;
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
if (f[i][j] == '#') pos |= solve(i, j);
}
}
if (pos)
printf("1\n");
else
printf("2\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
set<int> edges[N];
int size[N];
int centroidParent[N];
int centroidLevel[N];
void dfsSize(int u, int p) {
size[u] = 1;
for (int v : edges[u])
if (v != p) {
dfsSize(v, u);
size[u] += size[v];
}
}
int centroid(int u, int p, int half) {
for (auto it = edges[u].begin(); it != edges[u].end(); it++)
if (*it != p && size[*it] > half) return centroid(*it, u, half);
return u;
}
void decompose(int u, int p, int level) {
dfsSize(u, u);
int c = centroid(u, p, size[u] / 2);
if (p == -1) p = c;
centroidParent[c] = p;
centroidLevel[c] = level;
for (auto it = edges[c].begin(); it != edges[c].end(); it++) {
edges[*it].erase(c);
decompose(*it, u, level + 1);
}
edges[c].clear();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d %d", &u, &v);
edges[u - 1].insert(v - 1);
edges[v - 1].insert(u - 1);
}
decompose(0, -1, 0);
for (int i = 0; i < n; i++) {
cout << (char)(centroidLevel[i] + 65) << " ";
}
cout << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
long long min = a[1] - a[0], curr = 0;
for (long long i = 0; i < n - 1; i++) {
curr = a[i + 1] - a[i];
if (curr < min) min = curr;
}
cout << min << "\n";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, k, m, d, rem;
long long *arr, *b;
vector<long long> mul_d;
struct comp {
bool operator()(pair<long long, long long> p1,
pair<long long, long long> p2) {
long long len1 = p1.second - p1.first + 1;
long long len2 = p2.second - p2.first + 1;
if (len2 == len1) {
return p1.first < p2.first;
}
return len1 > len2;
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
cin >> n;
long long val = 1;
arr = new long long[n]();
set<pair<long long, long long>, comp> pending_blancks;
pending_blancks.insert(make_pair(0, n - 1));
long long pos;
while (pending_blancks.size() != 0) {
pair<long long, long long> cur = *pending_blancks.begin();
pending_blancks.erase(cur);
long long len = cur.second - cur.first + 1;
long long mid = (cur.second + cur.first) / 2;
if (len % 2 == 0) {
pos = mid;
arr[pos] = val++;
long long si = pos + 1;
long long ei = cur.second;
if (si >= 0 && ei < n && si <= ei)
pending_blancks.insert(make_pair(si, ei));
si = cur.first;
ei = pos - 1;
if (si >= 0 && ei < n && si <= ei)
pending_blancks.insert(make_pair(si, ei));
} else {
pos = mid;
arr[pos] = val++;
long long si = cur.first;
long long ei = pos - 1;
if (si >= 0 && ei < n && si <= ei)
pending_blancks.insert(make_pair(si, ei));
si = pos + 1;
ei = cur.second;
if (si >= 0 && ei < n && si <= ei)
pending_blancks.insert(make_pair(si, ei));
}
}
for (long long i = 0; i < n; i++) {
cout << arr[i] << " ";
}
cout << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const long long MOD = 1e9 + 7;
void chmax(long long &a, long long b) { a = max(a, b); }
void chmin(long long &a, long long b) { a = min(a, b); }
template <typename T>
void print(T out) {
cout << out << '\n';
}
void print(vector<long long> A) {
for (long long i = (0); i < (A.size()); i++) {
cout << A[i];
cout << (i == A.size() - 1 ? '\n' : ' ');
}
}
template <typename T1, typename T2>
void print(pair<T1, T2> out) {
cout << out.first << ' ' << out.second << '\n';
}
long long max(vector<long long> A) {
long long res = -INF;
for (long long a : A) chmax(res, a);
return res;
}
long long min(vector<long long> A) {
long long res = INF;
for (long long a : A) chmin(res, a);
return res;
}
long long max(long long A[], int len) {
long long res = -INF;
for (long long i = (0); i < (len); i++) chmax(res, A[i]);
return res;
}
long long min(long long A[], int len) {
long long res = INF;
for (long long i = (0); i < (len); i++) chmin(res, A[i]);
return res;
}
int r, c, idx, nxt1, nxt2, nxt;
long long H, W, K, cnt;
vector<vector<int>> rows, cols;
pair<int, int> cur;
set<int> visitedr, visitedc;
bool right() {
r = cur.first;
c = cur.second;
idx =
lower_bound((rows[r]).begin(), (rows[r]).end(), c + 1) - rows[r].begin();
nxt1 = rows[r][idx] - 1;
auto itr = visitedc.lower_bound(c + 1);
nxt2 = *itr - 1;
nxt = min(nxt1, nxt2);
if (nxt <= c) {
return false;
} else {
cnt += nxt - c;
cur.second = nxt;
visitedr.insert(r);
return true;
}
}
bool down() {
r = cur.first;
c = cur.second;
idx =
lower_bound((cols[c]).begin(), (cols[c]).end(), r + 1) - cols[c].begin();
nxt1 = cols[c][idx] - 1;
auto itr = visitedr.lower_bound(r + 1);
nxt2 = *itr - 1;
nxt = min(nxt1, nxt2);
if (nxt <= r) {
return false;
} else {
cnt += nxt - r;
cur.first = nxt;
visitedc.insert(c);
return true;
}
}
bool left() {
r = cur.first;
c = cur.second;
idx = upper_bound((rows[r]).begin(), (rows[r]).end(), c - 1) -
rows[r].begin() - 1;
nxt1 = rows[r][idx] + 1;
auto itr = prev(visitedc.upper_bound(c - 1));
nxt2 = *itr + 1;
nxt = max(nxt1, nxt2);
if (nxt >= c) {
return false;
} else {
cnt += c - nxt;
cur.second = nxt;
visitedr.insert(r);
return true;
}
}
bool up() {
r = cur.first;
c = cur.second;
idx = upper_bound((cols[c]).begin(), (cols[c]).end(), r - 1) -
cols[c].begin() - 1;
nxt1 = cols[c][idx] + 1;
auto itr = prev(visitedr.upper_bound(r - 1));
nxt2 = *itr + 1;
nxt = max(nxt1, nxt2);
if (nxt >= r) {
return false;
} else {
cnt += r - nxt;
cur.first = nxt;
visitedc.insert(c);
return true;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> H >> W >> K;
rows.resize(H);
cols.resize(W);
cur = make_pair(0, 0);
cnt = 1;
for (long long i = (0); i < (K); i++) {
cin >> r >> c;
r--;
c--;
rows[r].push_back(c);
cols[c].push_back(r);
}
for (long long i = (0); i < (H); i++) {
rows[i].push_back(-1);
rows[i].push_back(W);
sort((rows[i]).begin(), (rows[i]).end());
}
for (long long i = (0); i < (W); i++) {
cols[i].push_back(-1);
cols[i].push_back(H);
sort((cols[i]).begin(), (cols[i]).end());
}
visitedr.insert(-1);
visitedr.insert(H);
visitedc.insert(-1);
visitedc.insert(W);
down();
if (cnt == H * W - K) {
print("Yes");
return 0;
} else {
cur = make_pair(0, 0);
cnt = 1;
visitedc.clear();
visitedc.insert(-1);
visitedc.insert(W);
}
while (true) {
if (!right()) break;
if (!down()) break;
if (!left()) break;
if (!up()) break;
}
if (cnt == H * W - K) {
print("Yes");
} else {
print("No");
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, long long int> > v;
int main() {
int n;
scanf("%d", &n);
long long int x1, x2;
cin >> x1 >> x2;
for (int i = 0; i < n; i++) {
long long int l, r;
long long int k, b;
cin >> k >> b;
l = x1 * k + b;
r = x2 * k + b;
v.push_back(make_pair(l, r));
}
sort(v.begin(), v.end());
long long int y = v[0].second;
for (int i = 1; i < n; i++) {
if (v[i].first != v[i - 1].first) {
if (v[i].second < y) {
printf("YES\n");
return 0;
}
} else {
}
y = v[i].second;
}
printf("NO\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
struct str {
int x0;
int y0;
int number;
} z[3010];
int a, next[3010], check[3010], DP[3010][3010], DP2[3010][3010];
long long int x[3010], y[3010];
bool cmp1(str a, str b) { return a.x0 < b.x0; }
bool cmp2(str a, str b) { return a.number < b.number; }
long long int A[3010][3010], B[3010][3010];
long long int func(int s, int t) {
if (next[t] == a + 1) return 0;
if (s == a + 1) return 0;
if (A[s][t] == 1) return B[s][t];
long long int s1 = func(s + 1, t);
long long int s2 = func(s, next[t]) +
(y[next[t]] - y[t]) * (a - s + 1 - DP2[s][t]) -
(y[next[t]] - y[t]) * (DP2[s][t]);
A[s][t] = 1;
return B[s][t] = s1 < s2 ? s1 : s2;
}
int main() {
scanf("%d", &a);
for (int i = 1; i <= a; i++) scanf("%I64d", &x[i]);
for (int i = 1; i <= a; i++) y[i] = x[i] + (a - i + 1);
int m = y[1];
for (int i = 2; i <= a; i++) m = m < y[i] ? m : y[i];
for (int i = 1; i <= a; i++) y[i] -= m;
for (int i = 1; i <= a; i++) z[i].x0 = y[i], z[i].number = i;
std::sort(z + 1, z + a + 1, cmp1);
for (int i = 1; i < a; i++) next[z[i].number] = z[i + 1].number;
next[z[a].number] = a + 1;
for (int i = 1; i <= a; i++) {
check[z[i].number] = 1;
for (int j = a; j >= 1; j--)
DP2[j][z[i].number] = DP2[j + 1][z[i].number] + 1 - check[j];
}
long long int sum = 0;
for (int i = 1; i <= a; i++) sum += y[i];
for (int i = 1; i <= a; i++) {
if (y[i] == 0) {
printf("%I64d", sum + func(1, i));
return 0;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int TT = clock();
long long int n, l;
cin >> n >> l;
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) cin >> a[i];
pair<long long int, long long int> make_pair = {-1, 1};
for (long long int i = 0; i < n; i++) {
long long int c = a[i];
for (long long int j = i; j < n; j++) {
a[j] = min(a[j], c);
c *= 2;
}
}
long long int ans = mod * mod, c = (1 << (n - 1)), val = 0;
for (long long int i = n - 1; i >= 0; i--) {
long long int req = l / c;
val += req * a[i];
ans = min(ans, val + a[i]);
l -= c * req;
c /= 2;
}
ans = min(ans, val);
cout << ans;
cerr << "\n\nTIME: " << (long double)(clock() - TT) / CLOCKS_PER_SEC
<< " sec\n";
TT = clock();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b, vector<pair<long long, long long>> &v) {
v.push_back({a, b});
if (a == 0) {
return 0;
}
if (b == 0) {
return 0;
}
if (a > b) {
return 1 + gcd(a % b, b, v);
} else {
return 1 + gcd(a, b % a, v);
}
}
vector<long long> basear(long long base, long long n) {
if (base == 1) {
return {0, n};
}
vector<long long> ans;
while (n > 0) {
ans.push_back(n % base);
n /= base;
}
return ans;
}
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
long long t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
vector<pair<long long, long long>> v1;
long long r = gcd(a, b, v1);
reverse(v1.begin(), v1.end());
vector<long long> dp(r + 1, 0);
dp[1] = 1;
for (long long i = 2; i < r + 1; i++) {
if (dp[i - 1] == 0) {
dp[i] = 1;
} else {
long long p = v1[i].first;
long long p1 = v1[i].second;
if (p > p1) {
swap(p, p1);
}
vector<long long> v = basear(p, p1);
long long count = 0;
long long pow = 1;
for (long long i = 1; i < v.size(); i++) {
count += pow * v[i];
pow *= p;
}
if ((count) % (p + 1) % 2 == 0) {
dp[i] = 1;
} else {
dp[i] = 0;
}
}
}
if (dp[r]) {
cout << "First"
<< "\n";
} else {
cout << "Second"
<< "\n";
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[200][150];
int n, m, i, c, p;
while (cin >> n) {
for (i = 1; i <= n; i++) {
cin >> s[i];
}
p = 0;
c = 0;
for (i = 1; i <= n; i++) {
if (s[i][0] == 'O' && s[i][1] == 'O') {
p = 1;
s[i][0] = '+';
s[i][1] = '+';
break;
} else if (s[i][3] == 'O' && s[i][4] == 'O') {
p = 1;
s[i][3] = '+';
s[i][4] = '+';
break;
}
}
if (p == 1) {
cout << "YES" << endl;
for (i = 1; i <= n; i++) {
cout << s[i] << endl;
}
} else
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, i, mlc;
bool prime(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return 0;
return 1;
}
int lgpow(int a, int b) {
int r = 1;
for (int i = 1; i <= b; i <<= 1) {
if (i & b) r = (1LL * r * a) % n;
a = (1LL * a * a) % n;
}
return r;
}
int main() {
cin.sync_with_stdio(false);
cin >> n;
if (n == 1) {
cout << "YES\n1\n";
return 0;
}
if (n == 4) {
cout << "YES\n1\n3\n2\n4\n";
return 0;
}
if (!prime(n)) {
cout << "NO\n";
return 0;
}
cout << "YES\n1\n";
for (i = 2; i < n; i++) {
mlc = (1LL * i * lgpow((i - 1), n - 2)) % n;
cout << mlc << '\n';
}
cout << n << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int t, n, m, a[200100], endur[200100], it[800100];
void init(int k, int l, int r) {
if (l == r) {
it[k] = a[l];
return;
}
int mid = (l + r) / 2;
init(k * 2, l, mid);
init(k * 2 + 1, mid + 1, r);
it[k] = max(it[k * 2], it[k * 2 + 1]);
}
int get(int k, int l, int r, int L, int R) {
if (l > R || r < L) return -1;
if (L <= l && r <= R) return it[k];
int mid = (l + r) / 2;
return max(get(k * 2, l, mid, L, R), get(k * 2 + 1, mid + 1, r, L, R));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
init(1, 1, n);
cin >> m;
for (int i = 1; i <= m; i++) {
int p, e;
cin >> p >> e;
endur[e] = max(endur[e], p);
}
for (int i = n; i >= 1; i--) endur[i] = max(endur[i + 1], endur[i]);
int cur = 0, res = 0;
while (cur < n) {
res++;
int l = cur + 1, r = n, pos = 0;
bool ok = 0;
while (l <= r) {
int mid = (l + r) / 2;
int tmp = get(1, 1, n, cur + 1, mid);
int power = endur[mid - cur];
if (power >= tmp) {
l = mid + 1;
pos = max(pos, mid);
ok = 1;
} else
r = mid - 1;
}
if (ok)
cur = pos;
else {
res = -1;
break;
}
}
for (int i = 1; i <= n + 1; i++) endur[i] = -1;
cout << res << "\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, serial = 0, adj[100005], S = 0, G = 0, pin = 0, ans = 0, j = 0, mx = 0;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'G') {
G++;
}
if (s[i] == 'S' || i == n - 1) {
adj[S] = G;
S++;
if (G > 0) pin++;
G = 0;
}
}
for (int i = 0; i < n; i++) {
if (s[i] == 'S' || i == n - 1) {
j++;
if (s[i - 1] == 'G' && s[i + 1] == 'G') {
if (pin > 2)
ans = adj[j - 1] + adj[j] + 1;
else
ans = adj[j - 1] + adj[j];
} else if ((s[i + 1] == 'G' || s[i - 1] == 'G') && pin >= 2) {
ans = adj[j - 1] + 1;
} else {
ans = adj[j - 1];
}
}
mx = max(mx, ans);
}
cout << mx << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = (1e6) + 5;
struct Soldier {
int value;
int index;
};
Soldier a[N];
bool Compare(Soldier p, Soldier q) { return p.value < q.value; }
int power[N], tree[N];
long long l[N], r[N];
int n;
int Query(int ind) {
int sum = 0;
while (ind >= 1) {
sum += tree[ind];
ind -= (ind & (-ind));
}
return sum;
}
int GetQuery(int low, int high) { return Query(high) - Query(low - 1); }
void Update(int ind, int delta) {
while (ind <= n) {
tree[ind] += delta;
ind += (ind & (-ind));
}
}
int main() {
int i;
long long ans;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i].value);
a[i].index = i;
}
sort(a + 1, a + n + 1, Compare);
for (i = 1; i <= n; i++) power[a[i].index] = i;
for (i = 1; i <= n; i++) {
l[i] = GetQuery(power[i] + 1, n);
Update(power[i], 1);
}
for (i = 1; i <= n; i++) r[i] = (power[i] - 1) - (i - 1 - l[i]);
ans = 0;
for (i = 1; i <= n; i++) ans += l[i] * r[i];
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#ifdef APURBA
#include "DEBUG_TEMPLATE.h"
#else
#define HERE
#define debug(args...)
#endif
const int N = 35000 +5;
typedef pair<int,int> pii;
int n,k;
int a[N];
int dp_before[N];
int dp_cur[N];
int cnt[N],l=0,r=-1,cur;
int mp[N];
struct info
{
vector<int>idx;
int p1 = -1, p2 = -1;
void add(int x)
{
int sz = idx.size();
idx.push_back(x);
mp[x] = sz;
}
int dhuka(int i)
{
int koi = mp[i];
if(p1==-1)
{
p1= koi;
p2 = koi;
return 0;
}
int prv = idx[p2]-idx[p1];
p2 = max(p2, koi);
p1 = min(p1,koi);
int now = idx[p2] - idx[p1];
return now - prv;
}
int bahir(int i)
{
int koi = mp[i];
assert(p1!=-1);
int prv = idx[p2]-idx[p1];
if(koi==p1)
{
p1++;
}
if(koi==p2)
{
p2--;
}
if(p1>p2)
{
p1 =- 1;
p2 = -1;
return -prv;
}
int now = idx[p2] - idx[p1];
return now-prv;
}
};
info bal[N];
void add(int idx)
{
cur+= bal[a[idx]].dhuka(idx);
}
void remove(int idx)
{
cur += bal[a[idx]].bahir(idx);
}
int cost(int L,int R)
{
if(L>R)
{
assert(false);
}
while (l > L)
{
l--;
add(l);
}
while (r < R)
{
r++;
add(r);
}
while (l < L)
{
remove(l);
l++;
}
while (r > R)
{
remove(r);
r--;
}
return cur;
}
void compute(int l, int r, int optl, int optr)
{
if (l > r)
return;
int mid = (l + r) >> 1;
pair<int, int> best = {2e9, -1};
for (int k = optl; k <= min(mid, optr); k++)
{
if(k+1<=mid)
{
if(best.second==-1)
{
best = {dp_before[k] +cost(k+1, mid), k};
}
else
{
best = min(best, {dp_before[k] +cost(k+1, mid), k});
}
}
}
dp_cur[mid] = best.first;
int opt = best.second;
compute(l, mid - 1, optl, opt);
compute(mid + 1, r, opt, optr);
}
int32_t main()
{
#ifndef APURBA
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
#endif
cin>>n>>k;
for(int i=0; i<n; i++)
{
cin>>a[i];
bal[a[i]].add(i);
}
for(int i=0; i<n; i++)
{
dp_before[i] = cost(0,i);
}
//debug(dp_before[n-1]);
for(int i=2; i<=k; i++)
{
//debug(i);
compute(0,n-1,0,n-1);
swap(dp_before,dp_cur);
// for(int j=0; j<n; j++)
// {
// cout<<dp_before[j]<<" ";
// }
// cout<<"\n";
}
cout<<dp_before[n-1]<<"\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long m1 = 0, m2 = 0, n, x1, x2, yy1, y2, i, j, x[3000], y[3000], d1, d2, d;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n >> x1 >> yy1 >> x2 >> y2;
for (i = 0; i < n; i++) {
cin >> x[i] >> y[i];
}
long long ans = 0ll;
for (j = 0; j < n; j++) {
d2 = (x[j] - x2) * (x[j] - x2) + (y[j] - y2) * (y[j] - y2);
ans = max(ans, d2);
}
for (i = 0; i < n; i++) {
d = (x[i] - x1) * (x[i] - x1) + (y[i] - yy1) * (y[i] - yy1);
m2 = 0;
for (j = 0; j < n; j++) {
if (i == j)
continue;
else {
d2 = (x[j] - x2) * (x[j] - x2) + (y[j] - y2) * (y[j] - y2);
d1 = (x[j] - x1) * (x[j] - x1) + (y[j] - yy1) * (y[j] - yy1);
if (d1 > d) {
m2 = max(m2, d2);
}
}
}
ans = min(ans, m2 + d);
}
cout << ans;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
string x;
cin >> x;
if (i == 0) {
for (int j = 0; j < x.size(); j++) s += '-';
}
for (int j = 0; j < x.size(); j++) {
if (x[j] == '?') continue;
if (s[j] == '-') s[j] = x[j];
if (s[j] != x[j]) s[j] = '?';
}
}
for (int i = 0; i < s.size(); i++)
if (s[i] == '-') s[i] = 'a';
cout << s << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma optimize("", off)
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma comment(linker, "/STACK:36777216")
const long long inf = 0x3f3f3f3f3f3f3f3LL;
const long long mod = 1e9 + 7;
using namespace std;
template <class T>
void smin(T& a, T val) {
if (a > val) a = val;
}
template <class T>
void smax(T& a, T val) {
if (a < val) a = val;
}
template <typename T>
inline std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
bool first = true;
os << "[";
for (auto i : v) {
if (!first) os << ", ";
os << i;
first = false;
}
return os << "]";
}
const long long N = 2 * 1e5 + 10;
long long n, m, a[N], b[N], pos1 = -1, pos2 = -1;
bool vis[N];
multiset<long long> ms;
std::vector<long long> v[N];
void yes() { cout << "YES"; }
void no() {
cout << "NO";
exit(0);
}
void dfs(long long s) {
if (s != pos1) {
if ((long long)(ms.size()) == 0) {
no();
}
a[s] = *ms.begin();
b[s] = *ms.begin();
ms.erase(ms.begin());
}
vis[s] = 1;
for (auto i : v[s]) {
if (!vis[i]) {
dfs(i);
}
}
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m;
for (long long i = 0; i < m; ++i) {
long long x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
if (n == 1) {
no();
}
for (long long i = 1; i <= n; ++i) {
sort(v[i].begin(), v[i].end());
}
long long edge1 = -1, edge2 = -1;
long long miscncdnsdcnc[N] = {0};
pos1 = -1, pos2 = -1;
for (long long i = 1; i <= n; ++i) {
if ((long long)(v[i].size()) != n - 1) {
pos1 = i;
break;
}
}
if (pos1 == -1) {
no();
}
for (auto i : v[pos1]) {
miscncdnsdcnc[i] = 1;
}
for (long long i = 1; i <= n; ++i) {
if (i != pos1 and miscncdnsdcnc[i] == 0) {
pos2 = i;
}
}
for (long long i = 1; i < n - 1; ++i) {
ms.insert(i);
}
b[pos1] = n - 1;
a[pos1] = n - 1;
a[pos2] = n;
b[pos2] = n - 1;
vis[pos2] = 1;
dfs(pos1);
cout << "YES" << '\n';
for (long long i = 1; i <= n; ++i) {
if (!vis[i]) {
dfs(i);
}
}
for (long long i = 1; i <= n; ++i) {
cout << a[i] << ' ';
}
cout << '\n';
for (long long i = 1; i <= n; ++i) {
cout << b[i] << ' ';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int Maxk = 1005;
string mul(string a, string b) {
int res[Maxk];
memset(res, 0, sizeof(res));
reverse(a.begin(), a.end());
reverse(b.begin(), b.end());
for (int i = 0; i < a.length(); i++) {
for (int j = 0; j < b.length(); j++) {
res[i + j] += (a[i] - '0') * (b[j] - '0');
}
}
for (int i = 0; i < Maxk; i++) {
if (res[i] >= 10) {
res[i + 1] += (res[i] / 10);
res[i] %= 10;
}
}
string ret;
bool flag = false;
for (int i = Maxk - 1; i >= 0; i--) {
if (flag || res[i]) {
flag = true;
ret = ret + (char)(res[i] + '0');
}
}
if (ret == "") ret = "0";
return ret;
}
string add(string a, string b) {
if (a.length() < b.length()) swap(a, b);
while (a.length() != b.length()) {
b = '0' + b;
}
for (int i = a.length() - 1; i >= 0; i--) {
a[i] += (b[i] - '0');
if (a[i] > '9' && i) {
a[i] -= 10;
a[i - 1]++;
}
}
if (a[0] > '9') {
a[0] -= 10;
a = '1' + a;
}
return a;
}
struct node {
long long siz;
node *l, *r;
long long ocr[33];
node() {
l = NULL;
r = NULL;
siz = 0LL;
for (int i = 0; i <= 30; i++) ocr[i] = 0LL;
}
} root;
const int Maxn = 50005;
const long long mod = 1000000007;
int a[Maxn];
long long final;
long long fuckyou;
int n;
long long m;
void add_occ(int val, node *&x) {
for (int i = 30; i >= 0; i--) {
if (val & (1 << i)) {
x->ocr[i]++;
}
}
}
void ADD(int val) {
node *now = &root;
now->siz++;
add_occ(val, now);
for (int i = 30; i >= 0; i--) {
if (val & (1 << i)) {
if (now->r == NULL) {
now->r = new node;
}
now = now->r;
} else {
if (now->l == NULL) {
now->l = new node;
}
now = now->l;
}
now->siz++;
add_occ(val, now);
}
}
long long query(long long val, long long lim) {
node *now = &root;
long long res = 0;
long long nv = 0;
for (int i = 30; i >= 0; i--) {
long long nb = (1 << i);
if (val & (1 << i)) {
if (nv + nb >= lim) {
if (now->l != NULL) {
res += now->l->siz;
}
if (now->r == NULL) {
break;
}
now = now->r;
} else {
if (now->l == NULL) {
break;
}
now = now->l;
nv += nb;
}
} else {
if (nv + nb >= lim) {
if (now->r != NULL) {
res += now->r->siz;
}
if (now->l == NULL) {
break;
}
now = now->l;
} else {
if (now->r == NULL) {
break;
}
now = now->r;
nv += nb;
}
}
}
return res;
}
long long query2(int val, int lim) {
node *now = &root;
long long res = 0LL;
long long nv = 0LL;
for (int i = 30; i >= 0; i--) {
long long nb = (1 << i);
if (val & (1 << i)) {
if (nv + nb >= (long long)lim) {
if (now->l != NULL) {
long long sizz = now->l->siz;
for (int j = 0; j <= 30; j++) {
if (val & (1 << j)) {
res += (long long)(1 << j) * (long long)(sizz - now->l->ocr[j]);
} else {
res += (long long)(1 << j) * (long long)now->l->ocr[j];
}
}
}
if (now->r == NULL) {
break;
}
now = now->r;
} else {
if (now->l == NULL) {
break;
}
now = now->l;
nv += nb;
}
} else {
if (nv + nb >= (long long)lim) {
if (now->r != NULL) {
long long sizz = now->r->siz;
for (int j = 0; j <= 30; j++) {
if (val & (1 << j)) {
res += (1 << j) * (long long)(sizz - now->r->ocr[j]);
} else {
res += (1 << j) * (long long)now->r->ocr[j];
}
}
}
if (now->l == NULL) {
break;
}
now = now->l;
} else {
if (now->r == NULL) {
break;
}
now = now->r;
nv += nb;
}
}
}
return res;
}
bool check(long long lim) {
long long tot = 0;
for (int i = 0; i < n; i++) {
tot += query((long long)a[i], lim);
}
tot /= 2;
fuckyou = tot;
return tot >= (long long)m;
}
void calc(int lim) {
final = 0LL;
for (int i = 0; i < n; i++) {
long long nx = query2(a[i], lim);
final += nx;
}
}
int main() {
scanf("%d %I64d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
ADD(a[i]);
}
long long l = 1, r = 2147483647;
while (l < r - 1) {
long long tmp = (long long)l + r;
tmp /= 2;
if (check(tmp)) {
l = tmp;
} else {
r = tmp;
}
}
long long md = 0;
if (check(r)) {
md = r;
} else {
md = l;
}
check(md);
long long fuckk = 0LL;
if (fuckyou > m) {
fuckk = (long long)md * (long long)(fuckyou - m);
}
calc(md);
final /= 2;
final -= fuckk;
printf("%I64d\n", final % mod);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
namespace mine {
const int MAX_N = 110000;
char s[MAX_N];
int f[2][30];
void chmax(int &x, int y) { x = x > y ? x : y; }
void main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
memset(f[i & 1], 0, sizeof f[i & 1]);
scanf("%s", s + 1);
int ln = strlen(s + 1);
int st = s[1] - 'a', ln1 = 1;
while (ln1 + 1 <= ln and s[ln1 + 1] - 'a' == st) ln1++;
int lst = st, ln2 = ln1;
for (int j = ln1 + 1; j <= ln; j++) {
if (lst != s[j] - 'a')
chmax(f[i & 1][lst], ln2), lst = s[j] - 'a', ln2 = 1;
else
ln2++;
}
chmax(f[i & 1][lst], ln2);
if (ln1 == ln)
chmax(f[i & 1][st], f[(i - 1) & 1][st] * ln1 + ln1 + f[(i - 1) & 1][st]);
else if (st == lst and f[(i - 1) & 1][st])
chmax(f[i & 1][st], 1 + ln1 + ln2);
else {
if (f[(i - 1) & 1][st]) chmax(f[i & 1][st], 1 + ln1);
if (f[(i - 1) & 1][lst]) chmax(f[i & 1][lst], 1 + ln2);
}
for (int j = 0; j < 26; j++)
if (f[(i - 1) & 1][j]) chmax(f[i & 1][j], 1);
}
int ans = 1;
for (int i = 0; i <= 25; i++) chmax(ans, f[n & 1][i]);
printf("%d", ans);
}
}; // namespace mine
int main() {
srand(time(0));
mine::main();
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
set<int> s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int x = 0, qwerty = n; x < qwerty; x++) {
int v;
cin >> v;
s.insert(v);
}
s.erase(0);
cout << ((int)(s).size()) << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, ch = 0, nch = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> m;
if (m % 2 == 0)
ch++;
else
nch++;
}
if (nch % 2 == 0)
cout << ch;
else
cout << nch;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
template <class T>
typename T::value_type arr_sum(const T& v, int n) {
typename T::value_type sum = 0;
for (int i = (0); i < (n); ++i) sum += v[i];
return sum;
}
struct Sync_stdio {
Sync_stdio() {
cin.tie(NULL);
ios_base::sync_with_stdio(false);
}
} _sync_stdio;
struct Z {
string a;
string b;
int x;
};
int main() {
int n, d;
cin >> n >> d;
set<pair<string, string>> s;
vector<Z> v;
for (int i = (0); i < (n); ++i) {
Z t;
cin >> t.a >> t.b >> t.x;
v.push_back(t);
}
for (int i = (0); i < (n); ++i) {
for (int j = (i + 1); j < (n); ++j) {
if (v[i].a != v[j].b || v[i].b != v[j].a) {
continue;
}
if (0 < v[j].x - v[i].x && v[j].x - v[i].x <= d) {
s.insert({min(v[i].a, v[i].b), max(v[i].a, v[i].b)});
}
}
}
cout << s.size() << "\n";
for (auto i : s) {
cout << i.first << " " << i.second << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
int len, p;
char s[111111], buf[111111];
void add(char ch) { buf[len++] = ch; }
void out() {
printf("<");
for (int i = 0; i < len; i++) printf("%c", buf[i]);
printf(">\n");
len = 0;
}
int main() {
gets(s);
len = p = 0;
for (p = 0; s[p]; p++) {
if (s[p] == '"') {
p++;
while (s[p] != '"') {
add(s[p]);
p++;
}
out();
} else if (s[p] == ' ') {
if (len) out();
} else
add(s[p]);
}
if (len) out();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char mp[25][25];
int val[25][25];
int st[25][25];
int cost[25][25];
int dp[1200000];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> mp[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%d", &val[i][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < n; k++)
if (mp[i][j] == mp[k][j]) {
st[i][j] += (1 << k);
if (k != i) cost[i][j] += val[k][j];
}
for (int i = 1; i < (1 << n); i++) dp[i] = 1000000000;
for (int i = 0; i < (1 << n); i++)
for (int j = 0; j < n; j++)
if (!(i & (1 << j))) {
for (int k = 0; k < m; k++) {
dp[i + (1 << j)] = min(dp[i] + val[j][k], dp[i + (1 << j)]);
dp[i | st[j][k]] = min(dp[i | st[j][k]], dp[i] + cost[j][k]);
}
}
cout << dp[(1 << n) - 1] << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 2e5 + 10;
struct Point {
int x, y;
} a[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
a[i].x += 1e7;
a[i].y += 1e7;
}
vector<int> ans;
while (1) {
int cnt[4] = {0, 0, 0, 0};
for (int i = 1; i <= n; i++) {
cnt[(a[i].x & 1) << 1 | (a[i].y & 1)]++;
}
if (cnt[0] == n || cnt[1] == n || cnt[2] == n || cnt[3] == n) {
for (int i = 1; i <= n; i++) {
a[i].x = (a[i].x + 1) / 2;
a[i].y = (a[i].y + 1) / 2;
}
continue;
}
if (cnt[0] + cnt[3] == n || cnt[1] + cnt[2] == n) {
for (int i = 1; i <= n; i++) {
if (a[i].x & 1) ans.push_back(i);
}
} else {
for (int i = 1; i <= n; i++) {
if ((a[i].x + a[i].y) & 1) ans.push_back(i);
}
}
break;
}
printf("%d\n", ans.size());
for (auto& x : ans) printf("%d ", x);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, s, e;
vector<int> b[100001];
vector<int> a;
int dp[301][100001];
int sol(int i, int j) {
if (i == 0) return -1;
if (j < 0) return m;
return dp[i][j];
}
int main() {
cin >> n >> m >> s >> e;
a = vector<int>(n);
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) {
int x;
cin >> x;
b[x].push_back(i);
}
for (int i = 0; i < n; i++) dp[0][i] = -1;
for (int i = 1; i < 301; i++) {
for (int j = 0; j < n; j++) {
int pv = sol(i - 1, j - 1);
vector<int>::iterator it =
upper_bound(b[a[j]].begin(), b[a[j]].end(), pv);
if (it == b[a[j]].end())
dp[i][j] = m;
else {
dp[i][j] = *it;
}
if (j) dp[i][j] = min(dp[i][j], sol(i, j - 1));
}
}
int mx = 0;
for (int i = 0; i < 301; i++) {
for (int j = 0; j < n; j++) {
if (dp[i][j] >= m) continue;
if (j + 2 + dp[i][j] + i * e > s) continue;
mx = i;
}
}
cout << mx << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int const siz = 1e9, bound = 1e5, mod = siz + 7;
pair<int, int> dist[bound];
vector<int> adj[bound];
map<int, vector<int> > rel;
bool vis[bound];
int n, k, mx, edg = 0;
void build(int cur, int d) {
if (rel[d].empty()) return;
int w = 1;
while (w < k) {
adj[cur].push_back(rel[d].back());
edg++;
build(rel[d].back(), d + 1);
rel[d].pop_back();
w++;
if (rel[d].empty()) break;
}
}
void dfs(int cur) {
if (vis[cur]) return;
vis[cur] = 1;
for (int(i) = 0; (i) < (adj[cur].size()); (i)++) dfs(adj[cur][i]);
}
int main() {
scanf("%d", &n), scanf("%d", &k);
for (int(i) = 0; (i) < (n); (i)++) {
scanf("%d", &dist[i].first);
dist[i].second = i;
rel[dist[i].first].push_back(i);
mx = max(mx, dist[i].first);
}
sort(dist, dist + n);
if (dist[0].first != 0) {
puts("-1");
return 0;
}
for (int(i) = 0; (i) < (mx + 1); (i)++) {
if (rel[i].empty()) {
puts("-1");
return 0;
}
}
int w = 0, cur = dist[0].second;
while (!rel[1].empty()) {
adj[cur].push_back(rel[1].back());
edg++;
w++;
rel[1].pop_back();
}
if (w > k) {
puts("-1");
return 0;
}
for (int(i) = 0; (i) < (adj[cur].size()); (i)++) build(adj[cur][i], 2);
dfs(cur);
for (int(i) = 0; (i) < (n); (i)++)
if (!vis[i]) {
puts("-1");
return 0;
}
printf("%d\n", edg);
for (int(i) = 0; (i) < (n); (i)++) {
for (int(j) = 0; (j) < (adj[i].size()); (j)++)
printf("%d %d\n", i + 1, adj[i][j] + 1);
}
return 0;
}
| 5 |
/* Code Information
* Author: little_skqliao
* Time: 2021-05-02 22:35:54
* Source:
* Problem:
**/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int T, n, l, r;
vector<int> v, f, vl, vr;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d%d", &n, &l, &r);
v.resize(n);
f.resize(n + 1);
for (auto &x : f) x = 0;
for (auto &x : v) scanf("%d", &x);
for (int i = 0; i < l; ++i) {
++f[v[i]];
}
for (int i = l; i < n; ++i) {
--f[v[i]];
}
int ans = 0, numl = 0, numr = 0;
for (int i = 1; i <= n; ++i) {
if (f[i] > 0) numl += f[i];
if (f[i] < 0) numr += -f[i];
}
if (numl > numr) {
int more = numl - numr;
for (int i = 1; i <= n; ++i) {
if (f[i] > 0) {
int tmp = min(more, f[i] / 2 * 2);
ans += tmp / 2;
more -= tmp;
numl -= tmp;
}
}
} else if (numr > numl) {
int more = numr - numl;
for (int i = 1; i <= n; ++i) {
if (f[i] < 0) {
int tmp = min(more, -f[i] / 2 * 2);
ans += tmp / 2;
more -= tmp;
numr -= tmp;
}
}
}
printf("%d\n", ans + abs(numl - numr) / 2 + (numl + numr) / 2);
}
return 0;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, xc, yc, ans;
int b[20][20], use[1024][1024], f[1024][1024];
int bitcount(int s) {
int e = 0;
while (s > 0) {
++e, s -= s & (-s);
}
return e;
}
int search(int s, int t) {
if ((s | t) != s) return f[s][t] = 0;
if ((t == 0) || (bitcount(t) == 1)) return f[s][t] = 0;
if (use[s][t] != 2139062143) return f[s][t];
use[s][t] = 0;
if (bitcount(s) == 2) {
if (s == t) {
int fc1 = 0, fc2 = 0;
for (int i = 1; i <= n; i++)
if ((t >> (i - 1)) % 2 == 1)
if (fc1 == 0)
fc1 = i;
else
fc2 = i;
if (b[fc1][fc2] == 1)
return f[s][t] = 1;
else
return f[s][t] = 0;
} else
return f[s][t] = 0;
}
int fc = 0;
for (int i = 1; i <= n; i++)
if ((t >> (i - 1)) % 2 == 1) {
fc = i;
break;
}
for (int i = 1; i <= n; i++)
if (((s >> (i - 1)) % 2 == 1) && ((t >> (i - 1)) % 2 == 0) &&
(b[fc][i] == 1))
f[s][t] +=
search(s - (1 << (fc - 1)), t - (1 << (fc - 1))) +
search(s - (1 << (fc - 1)), t + (1 << (i - 1)) - (1 << (fc - 1)));
return f[s][t];
}
int main() {
cin >> n >> m >> k;
memset(b, 0, sizeof(b));
for (int i = 1; i <= m; i++) {
cin >> xc >> yc;
b[xc][yc] = 1, b[yc][xc] = 1;
}
memset(f, 0, sizeof(f));
memset(use, 127, sizeof(use));
ans = 0;
for (int i = 0; i < (1 << n); i++)
if (bitcount(i) == k) ans += search((1 << n) - 1, i);
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, vA, m, A[100010];
inline void Read(int &digit) {
digit = 0;
char c;
for (c = getchar(); c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; digit = digit * 10 + c - '0', c = getchar())
;
}
void read() {
for (int i = 1; i <= n; ++i) Read(A[i]);
}
int LIS() {
static bool use[100010];
static int dp[100010], tmp[100010];
static int b[100010];
int cnt = 0;
for (int i = 1; i <= n; ++i) use[A[i]] = true;
for (int i = 1; i <= vA; ++i)
if (use[i]) b[++cnt] = i, use[i] = false;
if (cnt <= m) return cnt;
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= cnt; ++i) {
int minv = dp[0];
bool mark = true;
dp[0] = 1 << 30;
for (int j = 1; j <= cnt; ++j) {
int x = b[j];
tmp[x] = minv;
if (minv > dp[x]) minv = dp[x];
dp[x] = 1 << 30;
}
for (int j = n; j >= 1; --j) {
int v = A[j], x = (tmp[v] - 1 + n) % n + 1,
val = (tmp[v] - 1 + n) / n * n + j;
if (x < j) val -= n;
if (dp[v] > val) dp[v] = val;
if (dp[v] <= n * m) mark = false;
}
if (mark) return i - 1;
}
return cnt;
}
int main() {
int T;
for (Read(T), Read(n), Read(vA), Read(m); T; --T) {
read();
printf("%d\n", LIS());
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
template <typename T>
T binpow(T a, T b, T mod) {
T res = 1;
while (b) {
if (b & 1) {
res = (res * a) % mod;
}
b /= 2;
(a *= a) %= mod;
}
return res;
}
template <typename T>
T binpow(T a, T b) {
T res = 1;
while (b) {
if (b & 1) {
res = (res * a);
}
b /= 2;
a *= a;
}
return res;
}
template <typename T>
T add(T a, T b) {
return (a + b) % mod;
}
template <typename T>
T sub(T a, T b) {
return add(a, mod - b);
}
template <typename T>
T mul(T a, T b) {
return (a * b) % mod;
}
long long make_int(string s) {
long long x = 0;
reverse(s.begin(), s.end());
string tmp = s;
for (long long i = 0; i < s.length(); ++i) {
x *= 10;
x += (long long)(tmp.back() - '0');
tmp.pop_back();
}
return x;
}
string make_string(long long s) {
string x;
while (s) {
x.push_back(char(s % 10 + '0'));
s /= 10;
}
reverse(x.begin(), x.end());
return x;
}
const long long inf = 1e18 + 5;
long long calc(long long a, long long b) {
long long ans = 0;
for (long long i = 0; i < 62; ++i) {
if (((a >> i) & 1) ^ ((b >> i) & 1)) {
ans++;
}
}
return ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long tc;
cin >> tc;
while (tc--) {
long long n;
cin >> n;
long long res = 0;
long long div = 1;
while (n / div) {
res += n / div;
div *= 2;
}
cout << res << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void fastscan(int &number) {
bool negative = false;
register int c;
number = 0;
c = getchar();
if (c == '-') {
negative = true;
c = getchar();
}
for (; (c > 47 && c < 58); c = getchar()) number = number * 10 + c - 48;
if (negative) number *= -1;
}
bool comparable(pair<string, int> p1, pair<string, int> p2) {
return p1.second < p2.second;
}
int main() {
int n, mm;
cin >> n >> mm;
string m[n];
pair<string, string> h[mm];
string s, s2;
for (int i = 0; i < n; i++) {
cin >> m[i];
}
for (int i = 0; i < mm; i++) {
cin >> s >> s2;
h[i].first = s;
h[i].second = s2;
}
vector<string> best(0);
for (int i = 1; i < (1 << n); i++) {
vector<string> team;
for (int j = 0; j < n; j++)
if ((i >> j) & 1) team.push_back(m[j]);
bool cont = true;
for (int j = 0; j < mm && cont; j++)
if (find(team.begin(), team.end(), h[j].first) != team.end() &&
find(team.begin(), team.end(), h[j].second) != team.end())
cont = false;
if (cont && best.size() < team.size()) best = team;
}
sort(best.begin(), best.end());
cout << best.size() << endl;
for (int i = 0; i < best.size(); i++) cout << best[i] << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5, INF = 1e9;
int n, m, x, y;
int a[MAX], b[MAX];
int match[MAX];
bool ok[MAX];
void init(void) {
cin >> n >> m >> x >> y;
for (int i = (1), _b = (n); i <= _b; i++) cin >> a[i];
for (int i = (1), _b = (m); i <= _b; i++) cin >> b[i];
}
void process(void) {
int res = 0;
for (int i = 1, j = 1; i <= n; i++) {
while (j < m && b[j] < a[i]) j++;
if (b[j] <= a[i] || j == 1)
match[i] = j;
else {
int p = abs(b[j] - a[i]), q = abs(b[j - 1] - a[i]);
if (p < q)
match[i] = j;
else
match[i] = j - 1;
if (p == q) ok[i] = 1;
}
}
int last = 1;
for (int i = 2; i <= n; i++)
if (match[i] == match[last]) {
int j = match[i];
if (abs(a[i] - b[j]) == abs(a[last] - b[j]))
last = i;
else if (abs(a[i] - b[j]) > abs(a[last] - b[j])) {
if (ok[i]) {
match[i]++;
last = i;
} else
res++;
} else if (!ok[i]) {
res++;
last = i;
} else {
match[i]++;
last = i;
}
} else
last = i;
cout << res << endl;
}
int main(void) {
init();
process();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300001;
vector<int> adj[maxn];
int prt[maxn];
int dep[maxn];
bool leaf[maxn];
int c;
int n, m, k;
void dfs(int u);
void find(int u);
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
adj[u].push_back(v);
adj[v].push_back(u);
}
dep[1] = 1;
dfs(1);
for (int i = 1; i <= n; i++) {
if (dep[i] >= ceil((double)n / k)) {
int cur = i;
printf("PATH\n%d\n", dep[i]);
do {
printf("%d ", cur);
cur = prt[cur];
} while (cur);
return 0;
}
}
printf("CYCLES\n");
find(1);
return 0;
}
void dfs(int u) {
leaf[u] = 1;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (dep[v]) continue;
leaf[u] = 0;
prt[v] = u;
dep[v] = dep[u] + 1;
dfs(v);
}
}
void find(int u) {
if (leaf[u]) {
int cnt = 0;
int x, y;
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (v == prt[u]) continue;
(cnt++ ? y : x) = v;
}
if ((dep[u] - dep[x] + 1) % 3) {
int cur = u;
printf("%d\n", dep[u] - dep[x] + 1);
while (cur != x) {
printf("%d ", cur);
cur = prt[cur];
}
printf("%d\n", x);
} else if ((dep[u] - dep[y] + 1) % 3) {
int cur = u;
printf("%d\n", dep[u] - dep[y] + 1);
while (cur != y) {
printf("%d ", cur);
cur = prt[cur];
}
printf("%d\n", y);
} else {
if (dep[x] < dep[y]) swap(x, y);
printf("%d\n", dep[x] - dep[y] + 2);
int cur = x;
while (cur != y) {
printf("%d ", cur);
cur = prt[cur];
}
printf("%d %d\n", y, u);
}
c++;
if (c == k) exit(0);
}
for (int i = 0; i < adj[u].size(); i++) {
int v = adj[u][i];
if (u != prt[v]) continue;
find(v);
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int x, y;
string str, cache, ans;
void verify() {
if (cache == ".") {
cache = "";
ans += '0';
} else if (cache == "-.") {
cache = "";
ans += '1';
} else if (cache == "--") {
cache = "";
ans += '2';
}
}
int main() {
cache = "";
cin >> str;
for (int i = 0; i < str.length(); i++) {
cache += str[i];
verify();
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
if (n & 1) cout << 7, n -= 3;
cout << string(n / 2, 49);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long gg[100100], ww[100100], sum[6][100100], nxt[100100], dist[100010],
pre[100001], ps[100001], k;
long long ax[33], in, now, fk[20][100100], fs[20][100100], dx[100100],
bk[20][100100], bm[20][100100], nv;
int ix[33], cnt, pv;
int ans, hg, vis[100100], times, to[100100], lg[100100];
long long rmq(int l, int r, int id) {
int mk = lg[r - l + 1];
if (id == 2)
return max(0LL, max(fs[mk][l], fs[mk][r + 1 - (1 << mk)] +
sum[1][r - (1 << mk)] - sum[1][l - 1]));
else if (id == 1)
return min(0LL, min(fk[mk][r + 1 - (1 << mk)],
fk[mk][l] + sum[1][r] - sum[1][l + (1 << mk) - 1]));
else if (id == 3)
return min(0LL, min(bk[mk][r + 1 - (1 << mk)],
bk[mk][l] + sum[4][r] - sum[4][l + (1 << mk) - 1]));
}
int main() {
int i, j, s, p, q, low, high, mid, ms, up;
long long ns, mv, bv;
scanf("%d%I64d", &n, &k);
lg[1] = 0;
for (i = 2; i <= n; i++) lg[i] = lg[i / 2] + 1;
for (i = 1; i <= n - 1; i++) scanf("%I64d", &ww[i]);
for (i = 1; i <= n; i++) scanf("%I64d", &gg[i]);
for (i = 0; i < 6; i++) sum[i][0] = 0;
for (i = 1; i <= n - 1; i++) sum[0][i] = sum[0][i - 1] + gg[i] - ww[i];
for (i = 1; i <= n - 1; i++) sum[1][i] = sum[1][i - 1] + gg[i + 1] - ww[i];
for (i = 1; i <= n - 1; i++)
sum[2][i] = sum[2][i - 1] + gg[i] - ww[i] + gg[i + 1] - ww[i];
nxt[n - 1] = n;
for (i = n - 2; i >= 0; i--) {
j = i + 1;
while (j < n && sum[0][j] >= sum[0][i]) j = nxt[j];
nxt[i] = j;
}
memset(dist, 0, sizeof(dist));
memset(pre, -1, sizeof(pre));
for (i = 0; i < n; i++) {
j = nxt[i];
ps[i] = i;
dist[j] = max(dist[j], dist[i] + 1);
}
for (i = 0; i < n; i++) {
j = nxt[i];
if (dist[j] == dist[i] + 1) pre[j] = i;
}
memset(dx, 0, sizeof(dx));
for (i = 0; i < n; i++) ps[i] = i;
for (i = n - 1; i >= 0; i--) {
if (pre[i] >= 0) {
ps[pre[i]] = ps[i];
dx[i] = sum[0][i] - sum[0][pre[i]];
}
}
memset(to, -1, sizeof(to));
for (i = 0; i < n; i++) {
if (to[ps[i]] < 0) to[ps[i]] = i;
}
for (i = 1; i <= n - 1; i++) fk[0][i] = gg[i + 1] - ww[i];
for (j = 1; (1 << j) <= n; j++)
for (i = 1; i + (1 << j) <= n; i++)
fk[j][i] = min(fk[j - 1][i] + sum[1][i + (1 << j) - 1] -
sum[1][i + (1 << (j - 1)) - 1],
fk[j - 1][i + (1 << (j - 1))]);
for (i = 1; i <= n - 1; i++) fs[0][i] = gg[i + 1] - ww[i];
for (j = 1; (1 << j) <= n; j++)
for (i = 1; i + (1 << j) <= n; i++) {
nv = sum[1][i + (1 << (j - 1)) - 1] - sum[1][i - 1];
fs[j][i] = max(fs[j - 1][i], nv + fs[j - 1][i + (1 << (j - 1))]);
}
memset(vis, -1, sizeof(vis));
times = 0;
for (i = 0; i < n; i++) {
if (ps[i] == i) {
j = to[i];
if (j >= 0 && j < i) {
for (s = j; s <= i; s = nxt[s]) vis[s] = times;
for (s = j + 1; s <= i; s++) {
if (vis[s] == times) {
sum[5][s] = dx[s];
sum[4][s] = gg[s + 1] - ww[s] - dx[s];
} else {
sum[4][s] = gg[s + 1] - ww[s];
sum[5][s] = 0;
}
if (s > j + 1) {
sum[4][s] += sum[4][s - 1];
sum[5][s] += sum[5][s - 1];
}
}
for (s = j + 1; s <= i; s++) bk[0][s] = gg[s + 1] - ww[s];
for (p = 1; (1 << p) <= i - j; p++)
for (s = j + 1; s + (1 << p) <= i + 1; s++)
bk[p][s] = min(bk[p - 1][s] + sum[4][s + (1 << p) - 1] -
sum[4][s + (1 << (p - 1)) - 1],
bk[p - 1][s + (1 << (p - 1))]);
}
}
times++;
}
ans = 0;
for (i = 0; i < n; i++) {
j = i;
cnt = 0;
while (j < n) {
ix[cnt++] = j;
if (ps[j] != j)
j = ps[j];
else
j = nxt[j];
}
ix[cnt] = n;
in = pv = now = 0;
hg = -1;
for (j = 0; j < cnt; j++) {
if (ps[ix[j]] == ix[j + 1]) {
if (now + sum[5][ix[j + 1]] - sum[5][ix[j]] < -k) {
low = ix[j] + 1;
high = ix[j + 1];
while (low <= high) {
mid = (low + high) >> 1;
nv = now + sum[5][mid] - sum[5][ix[j]];
if (nv >= -k)
low = mid + 1;
else
high = mid - 1;
}
hg = min(high, n - 1);
break;
}
now += sum[5][ix[j + 1]] - sum[5][ix[j]];
} else {
if (j + 1 == cnt) {
hg = n - 1;
break;
}
if (now + sum[0][ix[j + 1]] - sum[0][ix[j]] < -k) {
hg = ix[j + 1] - 1;
break;
}
now += sum[0][ix[j + 1]] - sum[0][ix[j]];
}
}
if (hg < 0) hg = n - 1;
j = min(j, cnt - 1);
up = j;
if (j >= 1) {
ax[j + 1] = 0;
for (; j >= 0; j--) {
if (j == up) {
if (ix[j] + 1 <= hg)
ax[j] = rmq(ix[j] + 1, hg, 2);
else
ax[j] = 0;
} else
ax[j] = max(rmq(ix[j] + 1, ix[j + 1], 2),
ax[j + 1] + sum[1][ix[j + 1]] - sum[1][ix[j]]);
}
in = pv = now = 0;
for (j = 0; j <= up; j++) {
long long tin, tnow;
tin = in;
tnow = now;
if (ps[ix[j]] == ix[j + 1]) {
if (j < up) {
nv = rmq(ix[j] + 1, ix[j + 1], 3);
if (in == 0)
in = nv;
else
in = min(in + sum[4][ix[j + 1]] - sum[4][ix[j]], nv);
now += sum[5][ix[j + 1]] - sum[5][ix[j]];
} else {
if (ix[j] + 1 <= hg)
nv = rmq(ix[j] + 1, hg, 3);
else
nv = 0;
if (in == 0)
in = nv;
else if (ix[j] + 1 <= hg)
in = min(in + sum[4][hg] - sum[4][ix[j]], nv);
now += sum[5][hg] - sum[5][ix[j]];
}
} else {
ms = ix[j + 1] - 1;
if (j == up) ms = min(ms, hg);
if (ix[j] + 1 <= ms)
nv = rmq(ix[j] + 1, ms, 1);
else
nv = 0;
if (j != up) {
if (nv != 0)
nv += gg[ix[j + 1] + 1] - ww[ix[j + 1]] + sum[0][ix[j]] -
sum[0][ix[j + 1]];
else
nv = min(nv, gg[ix[j + 1] + 1] - ww[ix[j + 1]]);
mv = gg[ix[j + 1] + 1] - ww[ix[j + 1]];
if (nv > mv) nv = mv;
}
if (j == up)
bv = in + sum[1][hg] - sum[1][ix[j]];
else {
bv = in + sum[1][ix[j + 1]] - sum[1][ix[j]];
if (!(in == 0 && ix[j] + 1 == ix[j + 1]))
bv += sum[0][ix[j]] - sum[0][ix[j + 1]];
}
if (nv > bv) nv = bv;
in = nv;
if (j != up) now += sum[0][ix[j + 1]] - sum[0][ix[j]];
}
if (now + in + ax[j + 1] < -k) {
pv = j;
in = tin;
now = tnow;
break;
}
}
if (j > up) {
ans = max(ans, hg - i + 1);
continue;
}
} else
pv = in = now = 0;
low = ix[pv] + 1;
if (pv == up)
high = hg;
else
high = ix[pv + 1];
while (low <= high) {
mid = (low + high) >> 1;
bool fi = true;
if (ps[ix[pv]] == ix[pv + 1]) {
nv = 0;
if (in != 0) nv = min(nv, in + sum[4][mid] - sum[4][ix[pv]]);
nv = min(nv, rmq(ix[pv] + 1, mid, 3));
long long bfm = nv;
ns = now + bfm + sum[5][mid] - sum[5][ix[pv]];
if (pv == up)
nv = rmq(mid + 1, hg, 2);
else
nv = rmq(mid + 1, ix[pv + 1], 2);
long long bp = ns + nv;
if (bfm == 0 && nv != 0) bp += dx[mid + 1];
if (bp < -k) fi = false;
} else {
ms = min(ix[pv + 1] - 1, mid);
if (ix[pv] + 1 <= ms)
nv = rmq(ix[pv] + 1, ms, 1);
else
nv = 0;
if (mid >= ix[pv + 1]) {
if (nv != 0)
nv += gg[ix[pv + 1] + 1] - ww[ix[pv + 1]] + sum[0][ix[pv]] -
sum[0][ix[pv + 1]];
else
nv = min(nv, gg[ix[pv + 1] + 1] - ww[ix[pv + 1]]);
mv = gg[ix[pv + 1] + 1] - ww[ix[pv + 1]];
if (nv > mv) nv = mv;
}
bv = in + sum[1][mid] - sum[1][ix[pv]];
if (mid >= ix[pv + 1] && !(in == 0 && ix[pv] + 1 == ix[pv + 1]))
bv += sum[0][ix[pv]] - sum[0][ix[pv + 1]];
if (nv > bv) nv = bv;
long long bfm = nv;
ns = now + nv;
if (mid >= ix[pv + 1]) ns += sum[0][mid] - sum[0][ix[pv]];
ms = ix[pv + 1];
if (pv == up) ms = min(ms, hg);
nv = 0;
long long lv = 0;
if (mid + 1 <= ms) lv = rmq(mid + 1, ms, 2);
nv = max(0LL, lv);
if (bfm == 0 && mid + 1 == ix[pv + 1] && ix[pv + 1] < n && lv != 0)
nv += sum[0][ix[pv + 1]] - sum[0][ix[pv]];
nv = max(0LL, nv);
if (ns + nv < -k) fi = false;
}
if (fi)
low = mid + 1;
else
high = mid - 1;
}
if (ans < high - i + 1) ans = high - i + 1;
}
printf("%d\n", ans);
return 0;
}
| 12 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int prime = 999983;
const int INF = 0x3f3f3f3f;
const long long INFF = 0x3f3f;
const double pi = acos(-1.0);
const double inf = 1e18;
const double eps = 1e-8;
const long long mod = (long long)1e9 + 7;
const unsigned long long mx = 133333331;
const int ma = 1e9;
inline void RI(int &x) {
char c;
while ((c = getchar()) < '0' || c > '9')
;
x = c - '0';
while ((c = getchar()) >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0';
}
long long a[200010], b[200010];
int main() {
long long n, k;
cin >> n >> k;
for (int i = 0; i <= n; i++) {
cin >> a[i];
b[i] = a[i];
}
for (int i = 1; i <= n; i++) {
a[i] += (a[i - 1] / 2);
a[i - 1] %= 2;
if (a[i - 1] < 0) {
a[i - 1] += 2;
a[i]--;
}
}
int beg = 0;
for (int i = 0; i <= n; i++) {
if (a[i]) {
beg = i;
break;
}
}
long long sum = a[n];
int ans = 0;
for (int i = n; i >= 0; i--) {
if (i > beg) {
if (i == n) continue;
sum = sum * 2 + a[i];
if (abs(sum) >= 4 * k) break;
} else {
if (i != n) sum = 2 * sum + a[i];
if ((abs(b[i] - sum) <= k && i != n) || (i == n && a[n] != b[n])) {
ans++;
}
if (abs(sum) >= 4 * k) {
break;
}
}
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("Ofast")
#pragma GCC optimization("unroll-loops")
using namespace std;
template <class T, class U>
inline ostream& operator<<(ostream& os, const pair<T, U>& p) {
os << p.first << ' ' << p.second;
return os;
}
template <class T, class U>
inline istream& operator>>(istream& os, pair<T, U>& p) {
os >> p.first >> p.second;
return os;
}
template <class T>
inline ostream& operator<<(ostream& os, const vector<T>& v) {
if (v.empty()) return os;
if (v.begin() != v.end()) os << v.front();
for (auto it = ++v.begin(); it != v.end(); ++it) os << ' ' << *it;
return os;
}
template <class T>
inline istream& operator>>(istream& is, vector<T>& v) {
for (auto& i : v) is >> i;
return is;
}
template <class T, size_t N>
inline istream& operator>>(istream& is, array<T, N>& a) {
for (auto& i : a) is >> i;
return is;
}
struct hasher {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
void Solve(istream& is, ostream& os) {
int n;
is >> n;
vector<int> a(n), b_pos(n);
for (register int i = 0; i < n; ++i) {
is >> a[i];
--a[i];
}
for (register int i = 0; i < n; ++i) {
int next;
is >> next;
b_pos[next - 1] = i;
}
int mx = -1, res = 0;
for (register int i = 0; i < n; ++i) {
int c = b_pos[a[i]];
if (c < mx) {
++res;
} else {
mx = c;
}
}
os << res << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cout << setprecision(20) << fixed;
Solve(cin, cout);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
long long ans = 0;
for (int i = (0); i < (n); ++i) {
long long t, T, x, cost;
cin >> t >> T >> x >> cost;
if (t >= T) {
ans += cost + m * x;
continue;
}
long long aux1 = cost;
if (m > (T - t)) aux1 += m * x;
long long aux2 = (long long)ceil((double)(m - (T - t)) / (T - t)) + 1;
aux2 *= cost;
ans += min(aux1, aux2);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct iii {
int first, second, T;
};
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<int> c(n);
for (auto &i : c) cin >> i;
bool ok = true;
for (int i = 2; i <= k && ok; i++)
if (k % i == 0) {
int cnt = 0;
while (k % i == 0) ++cnt, k /= i;
ok = false;
for (int j = 0; j < n; j++) {
int x = 0;
while (c[j] % i == 0) ++x, c[j] /= i;
if (x >= cnt) ok = true;
}
}
cout << (ok ? "Yes\n" : "No\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int MAXN = 2e7 + 7;
using namespace std;
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) {
res = (res * x) % 1000000007;
}
x = (x * x) % 1000000007;
y = y >> 1;
}
return res;
}
std::vector<long long int> divi[1000004];
void divisor(int n) {
for (long long int i = 1; i <= n; i++) {
for (long long int j = i; j <= n; j += i) {
divi[i].push_back(j);
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int a, b, m;
cin >> a >> b >> m;
long long int z = 1000000000 % m;
for (long long int i = 0; i <= min(a, m); i++) {
long long int x = (i * z) % m;
if (((m - x) % m) > b) {
cout << 1 << " ";
string s = to_string(i);
int len = s.size();
for (int j = 0; j < 9 - len; j++) {
s = "0" + s;
}
cout << s << endl;
return 0;
}
}
cout << 2 << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long md = 1000000007;
long long exp(long long a, long long b) {
long long r = 1ll;
while (b > 0) {
if (b & 1) {
r = r * (a % md);
r = (r + md) % md;
}
b /= 2;
a = (a % md) * (a % md);
a = (a + md) % md;
}
return (r + md) % md;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool isPrime(long long n) {
if (n == 1) {
return false;
}
long long i = 2;
while (i * i <= n) {
if (n % i == 0) {
return false;
}
i += 1;
}
return true;
}
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
int main() {
int n;
cin >> n;
int a[1000 + 2];
int i, j;
for (i = 1; i <= n; i++) cin >> a[i];
a[++n] = 1001;
int ans = 0;
for (i = 1; i <= n; i++) {
if (a[i - 1] == a[i] - 1 && a[i + 1] == a[i] + 1) {
for (j = i; a[j - 1] == a[j] - 1 && a[j + 1] == a[j] + 1; j++)
;
ans = max(ans, j - i);
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7;
int add(int a, int b) {
long long c = (long long)a + b;
while (c < 0) c += mod;
return c % mod;
}
int mult(int a, int b) {
long long c = (long long)a * b;
return c % mod;
}
const int MAXN = 1010;
int Bell[MAXN];
void computeBell() {
vector<int> v;
v.push_back(1);
for (int i = 0; i < MAXN; i++) {
Bell[i] = v[0];
vector<int> vi;
vi.push_back(v.back());
for (int j : v) {
vi.push_back(add(vi.back(), j));
}
v = vi;
}
}
int m, n;
vector<string> v(MAXN, "");
char s[MAXN];
void load() {
scanf("%d%d", &m, &n);
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < m; j++) v[j] = v[j] + s[j];
}
}
void solve() {
computeBell();
int sol = 1;
sort(v.begin(), v.begin() + m);
string cur = "";
int br = 1;
for (string s : v) {
if (s == cur) {
++br;
} else {
sol = mult(sol, Bell[br]);
cur = s;
br = 1;
}
}
printf("%d\n", sol);
}
int main() {
load();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:336777216")
using namespace std;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, 1, -1};
int ddx[8] = {0, 0, 1, 1, 1, -1, -1, -1}, ddy[8] = {1, -1, 1, 0, -1, 1, 0, -1};
long long POW(long long a, long long b, long long MMM) {
long long ret = 1;
for (; b; b >>= 1, a = (a * a) % MMM)
if (b & 1) ret = (ret * a) % MMM;
return ret;
}
long long GCD(long long a, long long b) { return b ? GCD(b, a % b) : a; }
long long LCM(long long a, long long b) {
if (a == 0 || b == 0) return a + b;
return a * (b / GCD(a, b));
}
long long INV(long long a, long long m) {
long long m0 = m, y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
pair<long long, long long> EXGCD(long long a, long long b) {
if (b == 0) return {1, 0};
auto t = EXGCD(b, a % b);
return {t.second, t.first - t.second * (a / b)};
}
bool OOB(long long x, long long y, long long N, long long M) {
return 0 > x || x >= N || 0 > y || y >= M;
}
pair<int, int> S[4];
pair<int, int> D[4];
int board[205][205];
int sign(int x) {
if (x > 0) return 1;
return -1;
}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
int mnX, mnY, mxX, mxY;
mnX = mnY = 500;
mxX = mxY = -500;
for (int i = 0; i < 4; i++) {
cin >> S[i].first >> S[i].second;
mnX = min(mnX, S[i].first);
mxX = max(mxX, S[i].first);
mnY = min(mnY, S[i].second);
mxY = max(mxY, S[i].second);
}
for (int x = mnX; x <= mxX; x++) {
for (int y = mnY; y <= mxY; y++) board[x + 100][y + 100] = 1;
}
pair<int, int> lower = {1, 500};
for (int j = 0; j < 4; j++) {
cin >> D[j].first >> D[j].second;
if (lower.second > D[j].second) lower = D[j];
}
int k = abs(D[0].first - D[1].first);
for (int i = 0; i <= k; i++) {
for (int j = lower.first - i; j <= lower.first + i; j++) {
if (board[100 + j][100 + lower.second + i] == 1) {
cout << "YES";
return 0;
}
}
}
for (int i = 0; i <= k; i++) {
for (int j = lower.first - i; j <= lower.first + i; j++) {
if (board[100 + j][100 + lower.second + 2 * k - i] == 1) {
cout << "YES";
return 0;
}
}
}
cout << "NO";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
const long long N = 1e5 + 1;
vector<long long> adj[N];
long long n;
vector<long long> Centroid() {
vector<long long> centroid;
vector<long long> sz(n + 2);
function<void(long long, long long)> dfs = [&](long long u, long long prev) {
sz[u] = 1;
bool is_centroid = true;
for (auto v : adj[u])
if (v != prev) {
dfs(v, u);
sz[u] += sz[v];
if (sz[v] > n / 2) is_centroid = false;
}
if (n - sz[u] > n / 2) is_centroid = false;
if (is_centroid) centroid.push_back(u);
};
dfs(1, -1);
return centroid;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
cin >> n;
for (long long i = 1; i <= n; i++) adj[i].clear();
vector<pair<long long, long long>> edges;
for (long long i = 1; i <= n - 1; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
edges.push_back({u, v});
}
vector<long long> ans = Centroid();
long long nn = (long long)ans.size();
if (nn <= 1) {
cout << edges[0].first << " " << edges[0].second << "\n";
cout << edges[0].first << " " << edges[0].second << "\n";
} else {
long long u = ans[0];
long long v = ans[1];
cout << u << " ";
long long d1;
for (auto &x : adj[u]) {
if (x != v) {
d1 = x;
break;
}
}
cout << d1 << "\n";
cout << v << " " << d1 << "\n";
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, ans;
int main() {
scanf("%d%d%d%d", &a, &b, &c, &d);
scanf("\n");
while (1) {
char x = getchar();
if (x == -1) break;
if (x == '1') ans += a;
if (x == '2') ans += b;
if (x == '3') ans += c;
if (x == '4') ans += d;
}
printf("%d\n", ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
vector<pair<int, int> > vp;
vector<int> fin[2001];
vector<int> v;
map<int, int> ma;
int n, temp;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> temp;
vp.push_back(make_pair(temp, i + 1));
ma[temp]++;
}
sort(vp.begin(), vp.end());
int twocou = 0, moretwo = 0, save1 = -1, flag1 = -1, flag2 = -1;
for (map<int, int>::iterator mit = ma.begin(); mit != ma.end(); mit++) {
if (((mit)->second) == 2) {
twocou++;
} else if (((mit)->second) > 2) {
moretwo++;
}
}
if (twocou >= 2 || moretwo >= 1) {
cout << "YES\n";
temp = vp.begin()->first;
for (vector<pair<int, int> >::iterator it = vp.begin(); it != vp.end();
++it) {
cout << it->second << " ";
fin[(it->first) - 1].push_back(it->second);
}
cout << endl;
for (int i = 0; i < 2001; i++) {
int len = fin[i].size();
if (len != 0) {
if (flag1 == -1) {
if (len == 1) {
cout << fin[i][0] << " ";
} else if (len == 2) {
for (int j = 0; j < len; j++) {
cout << fin[i][(j + 1) % len] << " ";
}
flag1 = 0;
save1 = i;
} else {
for (int j = 0; j < len; j++) {
cout << fin[i][(j + 1) % len] << " ";
}
flag1 = 0;
}
} else {
for (int j = 0; j < len; j++) {
cout << fin[i][j] << " ";
}
}
}
}
cout << endl;
for (int i = 0; i < 2001; i++) {
int len = fin[i].size();
if (len != 0) {
if (flag2 == -1) {
if (i != save1) {
if (len == 1) {
cout << fin[i][0] << " ";
} else if (len == 2) {
for (int j = 0; j < len; j++) {
cout << fin[i][(j + 1) % len] << " ";
}
flag2 = 0;
} else {
for (int j = 0; j < len; j++) {
cout << fin[i][(j + 2) % len] << " ";
}
flag1 = 0;
save1 = i;
}
} else {
for (int j = 0; j < len; j++) {
cout << fin[i][j] << " ";
}
}
} else {
for (int j = 0; j < len; j++) {
cout << fin[i][j] << " ";
}
}
}
}
cout << endl;
} else {
cout << "NO\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string a[40];
int f[90000], s1[90000], s2[90000], v[90000], n;
map<string, int> u;
int score(string s) {
int ans = 0, cur;
for (int i = 0; i < s.size(); i++) ans += s[i] - 96;
cur = 0;
for (int i = 0; i < s.size(); i++) cur = max(cur, s[i] - 96);
ans *= cur;
for (int i = 1; i <= n; i++)
if (a[i].find(s) != string::npos) ans++;
return ans;
}
void dp(int x, string cur) {
if (v[x]) return;
v[x] = 1;
int endit = 0;
f[x] = 0;
s1[x] = 0;
s2[x] = 1000000000;
for (int i = 1; i <= 26; i++) {
string v = "";
v += char(i + 96);
v += cur;
if (!u.count(v)) continue;
endit = 1;
int next = u[v], now = score(v);
dp(next, v);
if (f[next] == 0 && f[x] == 0) {
f[x] = 1;
s1[x] = now + s2[next];
s2[x] = s1[next];
} else if ((f[next] ^ 1) == f[x]) {
int S1 = now + s2[next];
int S2 = s1[next];
if (S1 > s1[x] || S1 == s1[x] && S2 < s2[x]) {
s1[x] = S1;
s2[x] = S2;
}
}
}
for (int i = 1; i <= 26; i++) {
string v = cur;
v += char(i + 96);
if (!u.count(v)) continue;
endit = 1;
int next = u[v], now = score(v);
dp(next, v);
if (f[next] == 0 && f[x] == 0) {
f[x] = 1;
s1[x] = now + s2[next];
s2[x] = s1[next];
} else if ((f[next] ^ 1) == f[x]) {
int S1 = now + s2[next];
int S2 = s1[next];
if (S1 > s1[x] || S1 == s1[x] && S2 < s2[x]) {
s1[x] = S1;
s2[x] = S2;
}
}
}
if (endit == 0) {
s1[x] = 0;
s2[x] = 0;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
u.clear();
int tot = 0;
for (int i = 1; i <= n; i++)
for (int x = 0; x < a[i].size(); x++) {
string cur = "";
for (int y = x; y < a[i].size(); y++) {
cur += a[i][y];
if (!u.count(cur)) u[cur] = ++tot;
}
}
memset(v, 0, sizeof(v));
int win = 0, S1 = 0, S2 = 1000000000;
for (int i = 1; i <= 26; i++) {
string v = "";
v += char(i + 96);
if (!u.count(v)) continue;
int next = u[v], now = score(v);
dp(next, v);
if (f[next] == 0 && win == 0) {
win = 1;
S1 = s2[next] + now;
S2 = s1[next];
} else if ((f[next] ^ 1) == win)
if (s2[next] + now > S1 || s2[next] + now == S1 && s1[next] < S2) {
S1 = s2[next] + now;
S2 = s1[next];
}
}
if (win)
cout << "First" << endl;
else
cout << "Second" << endl;
cout << S1 << " " << S2 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dx[8] = {-1, -1, 0, 1, 1, 1, 0, -1}, dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
void OUTPUT() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
OUTPUT();
int n, m, k, x;
vector<int> r1;
vector<int> p1;
vector<int> p2;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
r1.push_back(x);
}
cin >> m;
for (int i = 0; i < m; i++) {
cin >> x;
p1.push_back(x);
}
cin >> k;
for (int i = 0; i < k; i++) {
cin >> x;
p2.push_back(x);
}
sort((r1).begin(), (r1).end());
sort((p1).begin(), (p1).end());
sort((p2).begin(), (p2).end());
int a, b;
cin >> a >> b;
double r2 =
sqrt((b * p1[m - 1] * pow(r1[n - 1], 2)) / (a * p2[0] + b * p1[m - 1]));
cout << fixed << setprecision(12) << r2;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int v[100010];
int main() {
int n, i, j;
cin >> n;
int k = n;
v[0] = 1;
for (i = 1, j = 1; i < n; i++) {
v[j] = 1;
while (v[j] == v[j - 1]) {
v[--j]++;
}
j++;
}
cout << v[0];
for (int i = 1; i <= j - 1; ++i) {
cout << " " << v[i];
}
cout << endl;
return 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;
}
struct matrix {
long long siz;
long long mat[6][6];
matrix(long long x) {
siz = x;
memset(mat, 0, sizeof(mat));
}
inline friend matrix operator*(matrix a, matrix b) {
matrix c(a.siz);
for (long long i = 1; i <= c.siz; ++i) {
for (long long k = 1; k <= c.siz; ++k) {
for (long long j = 1; j <= c.siz; ++j) {
c.mat[i][j] = (c.mat[i][j] + a.mat[i][k] * b.mat[k][j]) % 1000000006;
}
}
}
return c;
}
inline friend matrix operator^(matrix x, long long p) {
matrix res(x.siz);
for (long long i = 1; i <= res.siz; ++i) {
res.mat[i][i] = 1;
}
for (; p; p >>= 1, x = x * x) {
if (p & 1) res = res * x;
}
return res;
}
} A(3), B(5), x(3), y(3), z(3), w(5);
long long fastpow(long long x, long long p) {
long long res = 1;
for (; p; p >>= 1, x = x * x % 1000000007) {
if (p & 1) res = res * x % 1000000007;
}
return res;
}
signed main() {
long long n = read(), f1 = read(), f2 = read(), f3 = read(), c = read();
x.mat[3][1] = y.mat[2][1] = z.mat[1][1] = 1;
w.mat[5][1] = 2;
A.mat[1][1] = A.mat[1][2] = A.mat[1][3] = A.mat[2][1] = A.mat[3][2] = 1;
B.mat[1][1] = B.mat[1][2] = B.mat[1][3] = B.mat[1][4] = B.mat[1][5] = 1;
B.mat[2][1] = B.mat[3][2] = B.mat[4][4] = B.mat[4][5] = B.mat[5][5] = 1;
A = A ^ (n - 3);
B = B ^ (n - 3);
w = B * w;
x = A * x;
y = A * y;
z = A * z;
long long ans = fastpow(c, w.mat[1][1]) * fastpow(f1, x.mat[1][1]) %
1000000007 * fastpow(f2, y.mat[1][1]) % 1000000007 *
fastpow(f3, z.mat[1][1]) % 1000000007;
cout << ans << endl;
fclose(stdin);
fclose(stdout);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void Scanf(const vector<string> &vs, vector<T> &d) {
string str;
stringstream ss;
for (int i = 0; i < vs.size(); ++i) str += vs[i];
ss << str;
d.clear();
for (T t; ss >> t;) d.push_back(t);
}
inline void ch_max(int &x, int y) {
if (x < y) x = y;
}
inline void ch_min(int &x, int y) {
if (x > y) x = y;
}
const double pi = acos(-1.0);
const double eps = 1e-9;
const int N = 105;
int n, m;
vector<int> a[N], b[N];
int va[N], vb[N];
void dfs_a(int);
void dfs_b(int v) {
vb[v] = 1;
for (int i = (0), _t_ = (b[v].size()); i < _t_; ++i) {
int j = b[v][i];
if (va[j]) continue;
dfs_a(j);
}
}
void dfs_a(int v) {
va[v] = 1;
for (int i = (0), _t_ = (a[v].size()); i < _t_; ++i) {
int j = a[v][i];
if (vb[j]) continue;
dfs_b(j);
}
}
int main() {
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = (0), _t_ = (N); i < _t_; ++i) {
a[i].clear();
b[i].clear();
}
int sum = 0;
int cnt = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &cnt);
sum += cnt;
while (cnt--) {
int v;
scanf("%d", &v);
a[i].push_back(v);
b[v].push_back(i);
}
}
if (sum == 0) {
printf("%d\n", n);
} else {
int ans = -1;
memset(va, 0, sizeof(va));
memset(vb, 0, sizeof(vb));
for (int i = 1; i <= n; ++i) {
if (va[i]) continue;
dfs_a(i);
ans++;
}
printf("%d\n", ans);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct interval {
int x, y;
};
string s;
vector<interval> v;
int br[2048];
bool is_palindrome(int x, int y) {
if (x == y) return 1;
while (x <= y) {
if (s[x] != s[y]) return 0;
x++;
y--;
}
return 1;
}
int main() {
interval e;
int i, j, n;
cin >> s;
n = s.size();
for (i = 0; i < n; i++) {
int b = 0;
for (j = i; j < n; j++) {
if (is_palindrome(i, j)) {
b++;
e.x = i;
e.y = j;
v.push_back(e);
}
}
if (i == 0)
br[i] = b;
else
br[i] = br[i - 1] + b;
}
long long ans = 0, m = v.size();
for (i = 0; i < m; i++) {
ans += m - br[v[i].y];
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, vx[200005], vy[200005];
map<long long, long long> mapp;
map<long long, long long> map2[200005];
map<long long, long long> sum;
map<long long, long long> sum2[200005];
long long cnt2[200005];
int main() {
scanf("%lld%lld%lld", &n, &a, &b);
long long cnt = 0;
memset(cnt2, 0, sizeof(cnt2));
for (long long i = 1; i <= n; i++) {
long long x;
scanf("%lld%lld%lld", &x, &vx[i], &vy[i]);
if (mapp.count(a * vx[i] - vy[i])) {
long long tmp = mapp[a * vx[i] - vy[i]];
if (map2[tmp].count(vx[i]) == 0) {
map2[tmp][vx[i]] = cnt2[tmp]++;
sum2[tmp][cnt2[tmp] - 1] = 1;
sum[tmp]++;
} else {
sum2[tmp][map2[tmp][vx[i]]]++;
sum[tmp]++;
}
} else {
mapp[a * vx[i] - vy[i]] = cnt++;
map2[cnt - 1][vx[i]] = cnt2[cnt - 1]++;
sum2[cnt - 1][cnt2[cnt - 1] - 1] = 1;
sum[cnt - 1] = 1;
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long tmp = mapp[a * vx[i] - vy[i]];
ans += sum[tmp] - sum2[tmp][map2[tmp][vx[i]]];
}
cout << ans << endl;
return 0;
}
| 6 |
#include<bits/stdc++.h>
#define ll long long
#define dbg(x) cout<<#x<<"=="<<x<<endl;
#define bug printf("*********\n");
#define debug(x) cout<<"["<<x<<"]" <<endl;
#define rep(i,a,b) for(int i=a;i<=b;i++)
#define rrp(i,a,b) for(int i=b;i>=a;i--)
#define mem(a,b) memset(a,b,sizeof a)
#define PI acos(-1.0)
#define esp 1e-6
using namespace std;
const int maxn=3e5+5;
const int inf=0x3f3f3f3f;
const ll mod=1e9+7;
inline ll rdll(){ll x = 0;ll f=1;char ch=getchar();while(ch>'9'||ch<'0'){if(ch=='-') f=-f;ch=getchar();}while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}return f*x;}
inline int rd(){int x = 0;int f=1;char ch=getchar();while(ch>'9'||ch<'0'){if(ch=='-') f=-f;ch=getchar();}while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}return f*x;}
template <class T> void read(T &x) { T res = 0, f = 1;char c = getchar();while (!isdigit(c)) {if (c == '-') f = -1;c = getchar();} while (isdigit(c)) {res = (res << 3) + (res << 1) + c - '0';c = getchar();}x = res * f;}
void run(){
int n=rd();
string s;
cin>>s;
int num=0;
rep(i,0,s.size()-1){
if(s[i]=='M') {
num++;
}
}
if(n/3!=num){
puts("NO");
}else{
bool flag=1;
int t=0,m=0;
rep(i,0,s.size()-1){
if(s[i]=='M'){
m++;
if(n-num-t-(n/3-m)<=0){
flag=0;
//cout<<"xxxxx"<<endl;
break;
}
if(t-m<0){
flag=0;
//cout<<"xxxxx"<<endl;
break;
}
}
else t++;
}
puts(flag?"YES":"NO");
}
}
signed main(){
int _=rd();
while(_--){
run();
}
return 0;
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.