solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const double err = 1e-10;
const double PI = 3.141592653589793;
const int N = 1e3 + 5;
int dp2[N][N], dp5[N][N], r = -1, c;
char dir2[N][N], dir5[N][N];
void solve() {
int n, t;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> t;
if (t == 0) {
r = i, c = j;
dp2[i][j] = 1e9;
dp5[i][j] = 1e9;
}
while (t > 0 && t % 2 == 0) {
t /= 2;
dp2[i][j]++;
}
while (t > 0 && t % 5 == 0) {
t /= 5;
dp5[i][j]++;
}
if (i - 1 >= 0 && j - 1 >= 0) {
int mn = min(dp2[i - 1][j], dp2[i][j - 1]);
dp2[i][j] += mn;
if (mn == dp2[i - 1][j])
dir2[i][j] = 'D';
else
dir2[i][j] = 'R';
mn = min(dp5[i - 1][j], dp5[i][j - 1]);
dp5[i][j] += mn;
if (mn == dp5[i - 1][j])
dir5[i][j] = 'D';
else
dir5[i][j] = 'R';
} else if (i - 1 >= 0) {
dp2[i][j] += dp2[i - 1][j];
dp5[i][j] += dp5[i - 1][j];
dir2[i][j] = dir5[i][j] = 'D';
} else if (j - 1 >= 0) {
dp2[i][j] += dp2[i][j - 1];
dp5[i][j] += dp5[i][j - 1];
dir2[i][j] = dir5[i][j] = 'R';
}
}
}
int tens = min(dp2[n - 1][n - 1], dp5[n - 1][n - 1]);
if (r != -1 && tens > 0) {
cout << 1 << endl;
for (int i = 0; i < r; i++) cout << 'D';
for (int i = 0; i < c; i++) cout << 'R';
for (int i = r + 1; i < n; i++) cout << 'D';
for (int i = c + 1; i < n; i++) cout << 'R';
cout << endl;
} else {
cout << tens << endl;
int i = n - 1, j = n - 1;
string str = "";
if (tens == dp2[n - 1][n - 1]) {
while (i >= 0 && j >= 0) {
str += dir2[i][j];
if (dir2[i][j] == 'D')
i--;
else
j--;
}
str.pop_back();
reverse((str).begin(), (str).end());
cout << str << endl;
} else {
while (i >= 0 && j >= 0) {
str += dir5[i][j];
if (dir5[i][j] == 'D')
i--;
else
j--;
}
str.pop_back();
reverse((str).begin(), (str).end());
cout << str << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int p1 = 0, p2 = 0, p3 = 0;
int fp1[10001], fp2[10001], f[100001];
int flag = 0;
int m, n;
int p[10001];
int getfa(int x) { return f[x] == x ? x : (f[x] = getfa(f[x])); }
int main() {
int x, y;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
int fx = getfa(x), fy = getfa(y);
if (fx != fy) f[fx] = fy;
}
for (int i = 1; i <= n; i++) {
int tmp = getfa(i);
p[tmp]++;
}
for (int i = 1; i <= n; i++)
if (p[i] > 3) {
flag = 1;
break;
}
for (int i = 1; i <= n; i++)
if (p[i] == 2)
fp2[++p2] = i;
else if (p[i] == 1)
fp1[++p1] = i;
if (flag || p2 > p1)
printf("-1\n");
else {
for (int i = 1; i <= n; i++)
if (p[i] == 3) {
int ttot = 0;
for (int j = 1; j <= n; j++)
if (getfa(j) == i) {
if (ttot < 3)
printf("%d ", j);
else
printf("%d", j);
++ttot;
if (ttot == 3) break;
}
printf("\n");
}
if (p2 > p1)
printf("-1\n");
else {
for (int i = 1; i <= p2; i++) {
for (int j = 1; j <= n; j++)
if (getfa(j) == fp2[i]) printf("%d ", j);
printf("%d\n", fp1[p1]);
p1--;
}
for (int i = 1; i <= p1; i += 3)
printf("%d %d %d\n", fp1[i], fp1[i + 1], fp1[i + 2]);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a[20], bay[20], jum, maks, b;
int main() {
for (long long i = 0; i <= 13; i++) {
cin >> a[i];
bay[i] = a[i];
}
for (long long i = 0; i <= 13; i++) {
jum = 0;
b = a[i] % 14;
for (long long j = 1; j <= a[i] % 14; j++) {
bay[(i + j) % 14]++;
}
bay[i] = 0;
b = a[i] / 14;
if (b % 2 == 1) {
for (long long j = 0; j < 14; j++) {
if (bay[j] % 2 == 1) {
jum += bay[j] + b;
}
}
} else {
for (long long j = 0; j < 14; j++) {
if (bay[j] % 2 == 0) {
jum += bay[j] + b;
}
}
}
maks = max(maks, jum);
for (long long j = 0; j < 14; j++) {
bay[j] = a[j];
}
}
cout << maks << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
set<int> ans;
set<int> ans2;
set<int> areinnow;
ans2.clear();
areinnow.clear();
ans.clear();
int n, m;
cin >> n >> m;
int arr[100002] = {0};
int cmd[100002][2];
int arrinnow[100002];
memset(arrinnow, -1, sizeof arrinnow);
for (int i = 0; i < m; i++) {
char inout;
int a;
cin >> inout >> a;
cmd[i][0] = (int)inout;
cmd[i][1] = a;
arr[a] = 1;
if (inout == '-') {
arrinnow[a] = 0;
if (areinnow.find(a) != areinnow.end()) {
areinnow.erase(areinnow.find(a));
}
} else {
arrinnow[a] = 1;
areinnow.insert(a);
}
}
for (set<int>::iterator it = areinnow.begin(); it != areinnow.end(); it++) {
ans2.insert(*it);
}
set<int> whenempty;
whenempty.clear();
set<int> nopelist;
nopelist.clear();
for (int i = 1; i <= n; i++) {
if (arrinnow[i] == -1) ans.insert(i);
}
int innow = areinnow.size();
int virtualsize = ans.size();
if (innow == 1) {
ans2.insert(*(areinnow.begin()));
}
for (int i = m - 1; i >= 0; i--) {
if (innow == 0) {
ans2.clear();
}
if (cmd[i][0] == '-') {
if (innow >= 1) {
if (ans2.find(cmd[i][1]) != ans2.end())
ans2.erase(ans2.find(cmd[i][1]));
nopelist.insert(cmd[i][1]);
} else if (innow == 0) {
ans2.insert(cmd[i][1]);
whenempty.insert(cmd[i][1]);
}
if (areinnow.insert(cmd[i][1]).second) innow++;
} else {
if (innow == 1) {
whenempty.insert(cmd[i][1]);
}
if (areinnow.find(cmd[i][1]) != areinnow.end()) {
areinnow.erase(areinnow.find(cmd[i][1]));
innow--;
}
if (innow >= 1) {
nopelist.insert(cmd[i][1]);
if (ans2.find(cmd[i][1]) != ans2.end()) {
ans2.erase(ans2.find(cmd[i][1]));
}
}
}
if (innow == 1) {
ans2.clear();
ans2.insert(*(areinnow.begin()));
}
}
if (whenempty.size() > 1) {
ans2.clear();
}
for (set<int>::iterator it = ans2.begin(); it != ans2.end(); it++) {
ans.insert(*it);
}
for (set<int>::iterator it = nopelist.begin(); it != nopelist.end(); it++) {
if (ans.find(*it) != ans.end()) {
ans.erase(ans.find(*it));
}
}
cout << ans.size() << endl;
for (set<int>::iterator it = ans.begin(); it != ans.end(); it++) {
cout << *it << " ";
}
{
{};
cin.get();
{}
}
{
{};
cin.get();
{}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, A[2][25], ar[100], k, l, m, ans, tmp;
int main() {
memset(ar, 0, sizeof(ar));
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) scanf("%d", &A[0][i % n]);
for (i = 1; i <= n; i++) scanf("%d", &A[1][i % n]);
ans = 0;
ar[1] = A[0][1 % n];
m *= n;
for (i = 2; i <= 4 * n; i++) {
k = min(i + 1, 4 * n);
l = i & 1;
for (j = l; j <= k; j += 2) {
if (j == 0)
ar[j] = ar[j + 1] + A[1][i % n];
else if (j + 2 > k)
ar[j] = ar[j - 1] + A[0][i % n];
else
ar[j] = min(ar[j - 1] + A[0][i % n], ar[j + 1] + A[1][i % n]);
}
if (i == m) {
printf("%d\n", ar[0]);
return 0;
}
if (i == n * 2) tmp = ar[0];
}
m -= n * 4;
ans += (ar[0] - tmp) * (m / (n * 2));
m %= (n * 2);
for (i = 0; i <= m; i++) {
k = min(i + 1, 4 * n);
l = i & 1;
for (j = l; j <= k; j += 2) {
if (j == 0)
ar[j] = ar[j + 1] + A[1][i % n];
else if (j + 2 > k)
ar[j] = ar[j - 1] + A[0][i % n];
else
ar[j] = min(ar[j - 1] + A[0][i % n], ar[j + 1] + A[1][i % n]);
}
if (i == m) {
printf("%d\n", ar[0] + ans);
return 0;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> v[n + 1];
for (int i = 1; i <= n - 1; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
int res = 0;
vector<array<int, 2>> dp(n + 1, {0, 0});
vector<int> d(n + 1, 0);
function<void(int, int)> dfs = [&](int a, int p) {
d[a] = v[a].size();
res = max(res, d[a]);
dp[a] = {d[a] - 1, 1};
vector<int> zero, one;
int za = -1, zb = -1, oa = -1, ob = -1;
for (int to : v[a]) {
if (to == p) continue;
dfs(to, a);
int t = max(dp[to][0], dp[to][1]);
if (t > za) {
zb = za;
za = t;
} else if (t > zb)
zb = t;
if (dp[to][0] > oa) {
ob = oa;
oa = dp[to][0];
} else if (dp[to][0] > ob)
ob = dp[to][0];
dp[a][0] = max(dp[a][0], t + d[a] - 2);
dp[a][1] = max(dp[a][1], dp[to][0] + 1);
res = max({res, t + d[a] - 1, dp[to][0] + 1});
}
if (zb != -1) res = max({res, za + zb + d[a] - 2, oa + ob + 1});
};
dfs(1, 0);
cout << res << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
template <class T>
inline T biton(T n, T pos) {
return n | ((T)1 << pos);
}
template <class T>
inline T bitoff(T n, T pos) {
return n & ~((T)1 << pos);
}
template <class T>
inline T ison(T n, T pos) {
return (bool)(n & ((T)1 << pos));
}
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
inline int nxt() {
int aaa;
scanf("%d", &aaa);
return aaa;
}
inline long long int lxt() {
long long int aaa;
scanf("%lld", &aaa);
return aaa;
}
inline double dxt() {
double aaa;
scanf("%lf", &aaa);
return aaa;
}
template <class T>
inline T bigmod(T p, T e, T m) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
}
return (T)ret;
}
vector<pair<pair<int, int>, int> > v;
long long int dp[201][3002];
int go(int pos, int l) {
if (l == 0) return 1;
if (l < 0) return 0;
long long int& res = dp[pos][l];
if (res != -1) return res;
res = 0;
for (int i = 0; i < v.size(); i++) {
if (v[pos].second == v[i].second) continue;
if (v[pos].first.second == v[i].first.first) {
res += go(i, l - v[i].first.first);
if (res >= 1000000007) res -= 1000000007;
}
}
return res;
}
int main() {
int n = nxt();
int l = nxt();
for (int i = 0; i < n; i++) {
int a = nxt();
int b = nxt();
v.push_back(make_pair(make_pair(a, b), i));
if (a != b) v.push_back(make_pair(make_pair(b, a), i));
}
memset(dp, -1, sizeof(dp));
long long int res = 0;
for (int i = 0; i < v.size(); i++)
res += go(i, l - v[i].first.first), res %= 1000000007;
cout << res << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
char a[40][30];
scanf("%d", &n);
for (i = 0; i < n; i++) scanf("%s", a[i]);
int arr[26];
int arr2[676];
for (i = 0; i < 676; i++) {
if (i < 26) arr[i] = 0;
arr2[i] = 0;
}
int flag = 0;
char temp = 'a';
int j, k;
for (j = 0; j < n; j++) {
k = 0;
while (a[j][k] != '\0') {
arr[a[j][k] - 'a'] = 1;
k++;
}
}
for (i = 0; i < 26; i++) {
if (arr[i] != 1) {
flag = 1;
break;
}
}
if (flag == 1) {
printf("%c\n", 'a' + i);
return 0;
}
for (j = 0; j < n; j++) {
k = 1;
while (a[j][k] != '\0') {
arr2[26 * (a[j][k - 1] - 'a') + a[j][k] - 'a'] = 1;
k++;
}
}
for (i = 0; i < 26 * 26; i++) {
if (arr2[i] != 1) {
flag = 1;
break;
}
}
if (flag == 1) {
printf("%c%c\n", 'a' + i / 26, 'a' + i % 26);
return 0;
}
int arr3[17576];
for (i = 0; i < 26 * 26 * 26; i++) {
arr3[i] = 0;
}
for (j = 0; j < n; j++) {
k = 2;
if (a[j][k - 1] == '\0') continue;
while (a[j][k] != '\0') {
arr3[26 * 26 * (a[j][k - 2] - 'a') + 26 * (a[j][k - 1] - 'a') + a[j][k] -
'a'] = 1;
k++;
}
}
for (i = 0; i < 26 * 26 * 26; i++) {
if (arr3[i] != 1) {
flag = 1;
break;
}
}
if (flag == 1) {
printf("%c%c%c\n", 'a' + i / (26 * 26), 'a' + i / 26, 'a' + i % 26);
return 0;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else {
return gcd(b, a % b);
}
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
int main() {
long long n, k;
cin >> n >> k;
long long t = k;
long long x, player = -1;
for (long long c = 0; c < n; c++) {
cin >> x;
if (player == -1)
player = x;
else {
if (player > x)
t--;
else
player = x, t = k - 1;
if (t == 0) {
cout << player << endl;
return 0;
}
}
}
cout << player << endl;
return 0;
}
| 2 |
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops","omit-frame-pointer","inline")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,popcnt,abm,mmx,avx,avx2,fma,tune=native")
#pragma GCC option("arch=native","no-zero-upper") //Enable AVX
#include <bits/stdc++.h>
#define db(x) cout << (x) << '\n';
#define all(v) (v).begin(),(v).end()
#define allr(v) (v).rbegin(),(v).rend()
#define f first
#define s second
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll,ll> pii;
typedef pair<ld,ll> pdi;
typedef pair<ld,ld> pdd;
typedef pair<ld,pdd> pdp;
typedef pair<string,ll> psi;
typedef pair<ll,string> pls;
typedef pair<string,string> pss;
typedef pair<ll,pii> pip;
typedef pair<pii,pii> ppp;
typedef complex<ll> point;
typedef vector<point> polygon;
typedef pair<point,int> ppi;
#define prec(n) cout.precision(n); cout<<fixed
#define mod (ll)(1e9+7)
#define eps (1e-9)
const ll oo=(ll)(1e18);
#define pi acos(-1)
#define MAXN (ll)(5e5+5)
vector<int> g[MAXN];
int cantf[MAXN];
int cantp[MAXN];
int backs[MAXN];
bool mk[MAXN];
int n,k;
vector<vector<int>> scc_gabow(vector<int>* adj)
{
vector<vector<int>> scc;
vector<int> S, B, I(n);
function<void(int)> dfs = [&](int u)
{
B.push_back(I[u] = S.size());
S.push_back(u);
for (int v : adj[u])
if (!I[v]) dfs(v);
else while (I[v] < B.back()) B.pop_back();
if (I[u] == B.back())
{
scc.push_back({});
for (B.pop_back(); I[u] < S.size(); S.pop_back())
{
scc.back().push_back(S.back());
I[S.back()] = n + scc.size();
}
}
};
for (int u = 0; u < n; ++u)
if (!I[u]) dfs(u);
return scc; // in reverse topological order
}
int32_t main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
int root=0;
vector<int> pre(n);
for(int i=0;i<n;i++)
{
int p;
cin >> p;
pre[i]=p;
if(p==0)
{
root=i;
continue;
}
p--;
g[p].push_back(i);
}
for(int i=0;i<n;i++)
backs[i]=-1;
for(int i=0;i<k;i++)
{
int x,y;
cin >> x >> y;
x--,y--;
g[x].push_back(y);
cantp[x]++;
cantf[y]++;
backs[x]=y;
}
int es=0;
vector<int> ts;
for(int i=0;i<n;i++)
if(!cantf[i] && cantp[i])
ts.push_back(i);
vector<int> points(n);
for(int i=0;i<n;i++)
points[i]=i;
for(auto y : ts)
{
int u=y;
vector<int> ps;
ps.push_back(u);
while(backs[u]!=-1)
{
u=backs[u];
ps.push_back(u);
es++;
}
for(auto y : ps)
points[y]=ps.back();
}
if(es!=k)
{
db(0)
return 0;
}
for(auto y : ts)
{
int u=y;
vector<int> ps;
ps.push_back(u);
mk[u]=1;
while(backs[u]!=-1)
{
u=backs[u];
mk[u]=1;
ps.push_back(u);
}
for(auto y : ps)
{
if(pre[y] && !mk[pre[y]-1])
g[points[pre[y]-1]].push_back(ps[0]);
}
for(auto y : ps)
mk[y]=0;
}
vector<vector<int>> res;
res=scc_gabow(g);
reverse(all(res));
if(res.size()==n)
{
mk[0]=1;
bool ok=1;
vector<int> rres;
for(auto y : res)
{
// for(auto v : y)
// cout << v << ' ';
// cout << '\n';
if(mk[y[0]+1])
continue;
ok&=(mk[pre[y[0]]]);
mk[y[0]+1]=1;
int u=y[0];
rres.push_back(u);
while(backs[u]!=-1)
{
u=backs[u];
ok&=(mk[pre[u]]);
mk[u+1]=1;
rres.push_back(u);
}
}
if(ok)
{
for(auto y : rres)
cout << y+1 << ' ';
cout << '\n';
}
else
db(0)
}
else
db(0)
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 200;
const long long INF = 2e16 + 7;
const double eps = 1e-8;
int n;
struct node {
long long dis;
char s;
} d[3][3];
;
int sgn(int x, int xx) {
if (x == xx) return 1;
if (x < xx) return 2;
return 0;
}
int main() {
long long x, y, xx, yy;
char op[10];
scanf("%d", &n);
scanf("%I64d%I64d", &x, &y);
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) d[i][j].dis = INF;
for (int i = 0; i < n; i++) {
scanf("%s", op);
scanf("%I64d%I64d", &xx, &yy);
if (x == xx || y == yy) {
int dx = sgn(x, xx), dy = sgn(y, yy);
if (d[dx][dy].dis > abs(x - xx) + abs(y - yy)) {
d[dx][dy].dis = abs(x - xx) + abs(y - yy);
d[dx][dy].s = op[0];
}
} else if (abs(x - xx) == abs(y - yy)) {
int dx = sgn(x, xx), dy = sgn(y, yy);
if (d[dx][dy].dis > abs(x - xx) + abs(y - yy)) {
d[dx][dy].dis = abs(x - xx) + abs(y - yy);
d[dx][dy].s = op[0];
}
}
}
int f = 0;
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
if ((i + j) % 2 == 1 && d[i][j].dis != INF && d[i][j].s != 'B')
f = 1;
else if ((i + j) % 2 == 0 && d[i][j].dis != INF && d[i][j].s != 'R')
f = 1;
printf("%s\n", f ? "YES" : "NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
const int Max = 1e5 + 5;
double t[Max], a, b, c, d;
int n;
int main() {
while (~scanf("%d%lf%lf", &n, &a, &b)) {
t[0] = 0;
for (int(i) = 1; (i) <= (n); (i)++) {
scanf("%lf%lf", &c, &d);
if (((d) * (d)) * 1.0 / 2.0 / a >= b)
t[i] = c * 1.0 + sqrt(2.0 * b / a);
else
t[i] = c * 1.0 + d * 1.0 / a + (b - ((d) * (d)) * 1.0 / 2.0 / a) / d;
t[i] = max(t[i], t[i - 1]);
printf("%.5f\n", t[i]);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
const int MOD = 1e9 + 7;
int n;
char s[2 * MAXN];
int pref[MAXN];
int rmq[MAXN][23];
int farthest[MAXN];
int nearest[MAXN];
int low[MAXN];
int ha[MAXN][23];
int pow29[MAXN];
vector<int> pos[3 * MAXN];
int getmin(int a, int b) {
int zz = low[b - a + 1];
return min(rmq[a][zz], rmq[b - (1 << zz) + 1][zz]);
}
int lcp(int a, int b) {
int xx = a;
for (int g = 22; g >= 0; g--) {
if (a + (1 << g) > n + 1 || b + (1 << g) > n + 1) continue;
if (ha[a][g] == ha[b][g]) a += (1 << g), b += (1 << g);
}
return a - xx;
}
int main() {
pow29[0] = 1;
for (int g = 1; g < MAXN; g++) pow29[g] = (1LL * pow29[g - 1] * 29) % MOD;
for (int g = 1; g < MAXN; g++) {
int y;
for (y = 0; y <= 20; y++) {
if ((1 << y) > g) break;
}
y--;
low[g] = y;
}
scanf("%d", &n);
scanf("%s", s + 1);
for (int g = 1; g <= n; g++)
pref[g] = (pref[g - 1] + ((s[g] == ')') ? (-1) : (1)));
for (int g = 1; g <= n; g++) rmq[g][0] = pref[g];
for (int g = 1; g <= 22; g++) {
for (int y = 1; y <= n; y++) {
int f = rmq[y][g - 1];
int s;
if (y + (1 << (g - 1)) > n)
s = 1e9;
else
s = rmq[y + (1 << (g - 1))][g - 1];
f = min(f, s);
rmq[y][g] = f;
}
}
for (int g = 1; g <= n; g++) {
if (s[g] == ')') {
farthest[g] = g;
continue;
}
if (getmin(g, n) >= pref[g - 1]) {
farthest[g] = n;
continue;
}
int lo = g + 1, hi = n;
while (hi > lo) {
int mid = (hi + lo) / 2;
if (getmin(g, mid) >= pref[g - 1])
lo = mid + 1;
else
hi = mid;
}
farthest[g] = lo - 1;
}
for (int g = 1; g <= n; g++) ha[g][0] = ((s[g] - '(' + 1)) % MOD;
for (int g = 1; g <= 22; g++) {
for (int y = 1; y <= n; y++) {
ha[y][g] =
ha[y][g - 1] +
(1LL * ((pow29[1 << (g - 1)])) *
((y + (1 << (g - 1)) > n) ? (0) : ha[y + (1 << (g - 1))][g - 1])) %
MOD;
ha[y][g] %= MOD;
}
}
vector<int> sarray;
for (int g = 1; g <= n; g++) sarray.push_back(g);
sort(sarray.begin(), sarray.end(), [&](const int& a, const int& b) -> bool {
int k = lcp(a, b);
int ff = a + k, ss = b + k;
if (ff == n + 1) return 1;
if (ss == n + 1) return 0;
return s[ff] < s[ss];
});
nearest[sarray[0]] = sarray[0];
for (int g = 1; g < sarray.size(); g++) {
nearest[sarray[g]] = sarray[g] + lcp(sarray[g], sarray[g - 1]);
}
long long ans = 0;
for (int g = n; g >= 1; g--) {
if (s[g] == ')') {
pos[MAXN + pref[g]].push_back(g);
continue;
}
int f = nearest[g], s = farthest[g];
if (f > s) continue;
vector<int>& gu = pos[MAXN + pref[g - 1]];
if (gu.size() == 0) continue;
if (gu.back() > s) continue;
int lo = 0, hi = gu.size() - 1;
while (hi > lo) {
int mid = (hi + lo) / 2;
if (s >= gu[mid])
hi = mid;
else
lo = mid + 1;
}
if (gu[0] < f) continue;
int lo2 = 0, hi2 = gu.size() - 1;
while (hi2 > lo2) {
int mid = (hi2 + lo2 + 1) / 2;
if (gu[mid] >= f)
lo2 = mid;
else
hi2 = mid - 1;
}
if (lo2 >= lo) ans += lo2 - lo + 1;
}
printf("%I64d", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int MOD = 1000000007;
const double PI = acos(-1.0);
const double EPS = 1e-8;
const int dir[4][2] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
inline void II(int &n) {
char ch = getchar();
n = 0;
bool t = 0;
for (; ch < '0'; ch = getchar())
if (ch == '-') t = 1;
for (; ch >= '0'; n = n * 10 + ch - '0', ch = getchar())
;
if (t) n = -n;
}
inline void OO(int a) {
if (a < 0) {
putchar('-');
a = -a;
}
if (a >= 10) OO(a / 10);
putchar(a % 10 + '0');
}
inline int sgn(double x) { return (x > EPS) - (x < -EPS); }
int n;
struct node {
double t;
bool s;
node() {}
node(double _t, bool _s) {
t = _t;
s = _s;
}
bool operator<(const node &rhs) const { return t < rhs.t; }
} a[100];
int h, m, s, t1, t2;
int main() {
scanf("%d%d%d", &h, &m, &s);
if (h == 12) h = 0;
int hs = h * 3600 + m * 60 + s;
int ms = m * 60 + s;
int ss = s;
double ha = hs * 1.0 / 12 / 3600;
double ma = ms * 1.0 / 3600;
double sa = ss * 1.0 / 60;
scanf("%d%d", &t1, &t2);
if (t1 == 12) t1 -= 12;
if (t2 == 12) t2 -= 12;
double a1 = t1 * 1.0 / 12;
double a2 = t2 * 1.0 / 12;
a[1] = node(ha, 0);
a[2] = node(ma, 0);
a[3] = node(sa, 0);
a[4] = node(a1, 1);
a[5] = node(a2, 1);
sort(a + 1, a + 1 + 5);
bool ok = 0;
for (int i = 1; i <= 4; ++i)
if (a[i].s && a[i + 1].s) ok = 1;
if (a[1].s && a[5].s) ok = 1;
puts(ok ? "YES" : "NO");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 500;
const long long mod = 1e9 + 7;
const long long cmod = 998244353;
const long long inf = 1LL << 61;
const int M = 1e6 + 500;
const long long int ths = 1LL << 40;
const int NN = 5e3 + 6;
void solve() {
long long int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
long long int pre[n][207], suf[207][n + 10];
memset(pre, 0, sizeof pre);
memset(suf, 0, sizeof suf);
for (int i = 0; i < n; i++) {
if (i != 0) {
for (int j = 1; j <= 26; j++) {
pre[i][j] = pre[i - 1][j];
}
}
pre[i][a[i]]++;
}
long long int f[207] = {};
for (int i = n - 1; i >= 0; i--) {
f[a[i]]++;
suf[a[i]][f[a[i]]] = i;
}
long long int ans = 0;
for (int i = 1; i <= 200; i++) {
ans = max(ans, pre[n - 1][i]);
for (int j = 0; j < n; j++) {
long long int l = j;
long long int cnt = pre[j][i];
long long int r = suf[i][cnt];
if (r <= l) continue;
for (int k = 1; k <= 200; k++) {
long long int x = pre[r - 1][k] - pre[l][k];
long long int t = cnt * 2 + x;
ans = max(ans, cnt * 2 + x);
}
}
}
cout << ans;
cout << "\n";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char s[500010];
int main() {
scanf("%s", s);
int n = strlen(s);
for (int l = 1; l <= n / 2; l++) {
int match = 0, newn = l;
for (int i = l; i < n; i++) {
match = (s[i] == s[i - l] ? match + 1 : 0);
if (match == l) match = 0, newn -= l;
s[newn++] = s[i];
}
n = newn;
}
s[n] = 0;
printf("%s\n", s);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100001;
vector<pair<int, pair<int, int> > > adj;
int N;
int dad[MAXN];
int size[MAXN];
bool sets[MAXN];
inline bool ishap(int x) {
while (x > 0) {
int dig = x % 10;
if (dig != 7 && dig != 4) return false;
x /= 10;
}
return true;
}
inline int find_set(int x) {
if (dad[x] == x) return x;
return dad[x] = find_set(dad[x]);
}
bool cmp(pair<int, pair<int, int> > a, pair<int, pair<int, int> > b) {
return a.first < b.first;
}
int main() {
cin >> N;
for (int i = 0; i + 1 < N; ++i) {
int a, b, c;
cin >> a >> b >> c;
--a;
--b;
if (ishap(c)) c = -1;
adj.push_back(make_pair(c, pair<int, int>(a, b)));
}
sort(adj.begin(), adj.end(), cmp);
for (int i = 0; i < N; ++i) {
dad[i] = i;
size[i] = 1;
sets[i] = 1;
}
for (int k = adj.size() - 1; k >= 0; --k) {
if (adj[k].first < 0) break;
int x = adj[k].second.first;
int y = adj[k].second.second;
int xx = find_set(x);
int yy = find_set(y);
if (xx != yy) {
dad[yy] = xx;
size[xx] += size[yy];
sets[yy] = 0;
}
}
long long sol = 0LL;
for (int i = 0; i < N; ++i) {
if (!sets[i]) continue;
long long all = N - size[i];
sol += (long long)size[i] * all * (all - 1);
}
cout << sol << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int r, j, n, i, c[12];
char s[1000007];
int main() {
gets(s + 1);
n = strlen(s + 1);
for (i = 1; i <= n; i++) c[s[i] - 48]++;
c[1]--;
c[6]--;
c[8]--;
c[9]--;
r = 0;
for (i = 1; i <= 9; i++) {
for (j = 1; j <= c[i]; j++) {
printf("%d", i);
r = r * 10 + i;
r = r % 7;
}
}
if (r == 0)
printf("1869");
else if (r == 1)
printf("6198");
else if (r == 2)
printf("1896");
else if (r == 3)
printf("1689");
else if (r == 4)
printf("1986");
else if (r == 5)
printf("1968");
else if (r == 6)
printf("1698");
for (i = 1; i <= c[0]; i++) printf("0");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename TT>
ostream& operator<<(ostream& s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, vector<T> t) {
for (int i = 0; i < t.size(); i++) s << t[i] << " ";
return s;
}
int b[30], k[30], p[30], n, m, a[32][30], r;
long long cal(int u) {
long long s = 0;
for (int i = 0; i < n; i++) s += (long long)a[u][i] * k[i];
return s;
}
long long solve(int u, bool first) {
long long mx = -1e18;
if ((m - u) % 2 == 0) mx = cal(u);
if (u == m) return mx;
if (!first) {
for (int i = 0; i < n; i++) a[u + 1][i] = a[u][i] ^ b[i];
mx = max(mx, solve(u + 1, 1));
}
for (int i = 0; i < n; i++) a[u + 1][i] = a[u][p[i] - 1] + r;
mx = max(mx, solve(u + 1, 0));
return mx;
}
int main() {
int i, j;
while (~scanf("%d%d%d", &n, &m, &r)) {
for (i = 0; i < n; i++) scanf("%d", &a[0][i]);
for (i = 0; i < n; i++) scanf("%d", &b[i]);
for (i = 0; i < n; i++) scanf("%d", &k[i]);
for (i = 0; i < n; i++) scanf("%d", &p[i]);
long long ans = solve(0, 0);
printf("%I64d\n", ans);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.141592653689793238460;
const long long inf = 0x3f3f3f3f3f3f;
const int N = 2e5 + 5;
const int pr = 31;
using ld = long double;
int mod = 1e9 + 7;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
int fact(int n) {
int res = 1;
for (int i = 2; i <= n; i++) res = res * i % mod;
return res % mod;
}
int ncr(int n, int r) { return fact(n) / (fact(r) * fact(n - r)); }
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (1ll * res * x) % p;
y = y >> 1;
x = (1ll * x * x) % p;
}
return res;
}
unsigned long long modInverse(unsigned long long n, int p) {
return power(n, p - 2, p);
}
unsigned long long ncrm(unsigned long long n, int r, int p) {
if (n < r) return 0;
if (r == 0) return 1;
unsigned long long fac[2043];
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
unsigned int setbit(long long n) {
unsigned long long count = 0;
while (n) {
n &= (n - 1);
count++;
}
return count;
}
int sub(string s1, string s2) {
int M = s1.length();
int N = s2.length();
for (int i = 0; i <= N - M; i++) {
int j;
for (j = 0; j < M; j++)
if (s2[i + j] != s1[j]) break;
if (j == M) return i;
}
return -1;
}
bool subse(string str1, string str2) {
int j = 0;
for (int i = 0; i < str2.length() && j < str1.length(); i++)
if (str1[j] == str2[i]) j++;
return (j == str1.length());
}
unsigned P2(unsigned x) {
x |= x >> 1;
x |= x >> 2;
x |= x >> 4;
x |= x >> 8;
x |= x >> 16;
return x ^ (x >> 1);
}
void phi_1n(int n) {
vector<int> phi(n + 1);
phi[0] = 0;
phi[1] = 1;
for (int i = 2; i <= n; i++) phi[i] = i;
for (int i = 2; i <= n; i++) {
if (phi[i] == i) {
for (int j = i; j <= n; j += i) phi[j] -= phi[j] / i;
}
}
}
long long largestpower(long long n, long long p) {
long long x = 0;
long long curr = n;
while (curr) {
curr /= p;
x += curr;
}
return x;
}
struct DSU {
vector<int> e;
DSU(int N) { e = vector<int>(N, -1); }
int get(int x) { return e[x] < 0 ? x : e[x] = get(e[x]); }
bool same_set(int a, int b) { return get(a) == get(b); }
int size(int x) { return -e[get(x)]; }
bool unite(int x, int y) {
x = get(x), y = get(y);
if (x == y) return false;
if (e[x] > e[y]) swap(x, y);
e[x] += e[y];
e[y] = x;
return true;
}
};
const long long INF = 1e18;
int n, m, q;
bool used[300005];
int p[300005], sz[300005], dia[300005];
int maxi, maxiV;
vector<int> a[300005];
void dfs(int v, int depth, int p) {
if (depth > maxi) {
maxi = depth;
maxiV = v;
}
for (auto u : a[v]) {
if (u != p) {
dfs(u, depth + 1, v);
}
}
}
int finddia(int v) {
maxi = -1;
dfs(v, 0, -1);
maxi = -1;
dfs(maxiV, 0, -1);
return maxi;
}
void init() {
for (int i = (int)1; i <= (int)n; ++i) {
p[i] = i;
sz[i] = 1;
dia[i] = 0;
}
}
int getset(int v) {
if (p[v] == v) return v;
return p[v] = getset(p[v]);
}
void unionset1(int x, int y) {
x = getset(x);
y = getset(y);
if (sz[x] > sz[y]) swap(x, y);
sz[y] += sz[x];
p[x] = y;
}
int rad(int v) { return (dia[v] + 1) / 2; }
void unionset2(int x, int y) {
x = getset(x);
y = getset(y);
if (x == y) return;
if (sz[x] > sz[y]) swap(x, y);
sz[y] += sz[x];
p[x] = y;
dia[y] = max(rad(x) + rad(y) + 1, max(dia[x], dia[y]));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> q;
init();
for (int i = 0; i < (int)m; i++) {
int x, y;
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
unionset1(x, y);
}
for (int i = (int)1; i <= (int)n; ++i) {
int pp = getset(i);
if (!used[pp]) {
used[pp] = 1;
dia[pp] = finddia(i);
}
}
while (q--) {
int d;
cin >> d;
if (d == 2) {
int x, y;
cin >> x >> y;
unionset2(x, y);
} else {
int x;
cin >> x;
cout << dia[getset(x)] << '\n';
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, MOD = 1e9 + 7, MAX = 1e5;
int n, c;
int a[N], seg[4 * N];
long long pref[N], memo[N];
void build(int indx, int l, int r) {
if (l == r) {
seg[indx] = a[l];
return;
}
build(indx * 2, l, (l + r) / 2);
build(indx * 2 + 1, (l + r) / 2 + 1, r);
seg[indx] = min(seg[indx * 2], seg[indx * 2 + 1]);
}
int get(int indx, int l, int r, int i, int j) {
if (i > r || j < l) {
return MOD;
}
if (l >= i && j >= r) return seg[indx];
return min(get(indx * 2, l, (l + r) / 2, i, j),
get(indx * 2 + 1, (l + r) / 2 + 1, r, i, j));
}
long long solve(int indx) {
if (indx == n + 1) return 0;
long long &ret = memo[indx];
if (ret != -1) return ret;
ret = 1e18;
ret = min(ret, a[indx] + solve(indx + 1));
if ((indx + c) <= (n + 1)) {
long long wa =
pref[indx + c - 1] - pref[indx - 1] - get(1, 1, n, indx, indx + c - 1);
ret = min(ret, wa + solve(indx + c));
} else
ret = min(ret, pref[n] - pref[indx - 1]);
return ret;
}
int main() {
scanf("%d %d", &n, &c);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pref[i] = pref[i - 1] + a[i];
}
memset(memo, -1, sizeof(memo));
build(1, 1, n);
printf("%lld\n", solve(1));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, i, c, x;
cin >> n;
vector<bool> v(n + 1);
vector<int> a;
fill(v.begin(), v.end(), 0);
for (i = 0; i < n; i++) {
cin >> x;
a.push_back(x);
}
for (i = n - 1; i >= 0; i--) {
if (!v[a[i]]) {
v[a[i]] = 1;
c = a[i];
}
}
cout << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
;
long long t, i, j, r, k, x, y, n, m, l, a, b, c, d = 0;
cin >> t;
string s, cm = "abacaba";
while (t--) {
cin >> l >> r;
if (2 * l <= r) {
cout << l << " " << 2 * l << "\n";
} else
cout << "-1 -1\n";
}
return 0;
}
| 0 |
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,m,n) for(int i=(m);i<(n);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()
using ll = long long;
constexpr int INF = 0x3f3f3f3f;
constexpr long long LINF = 0x3f3f3f3f3f3f3f3fLL;
constexpr double EPS = 1e-8;
constexpr int MOD = 1000000007;
// constexpr int MOD = 998244353;
constexpr int dy[] = {1, 0, -1, 0}, dx[] = {0, -1, 0, 1};
constexpr int dy8[] = {1, 1, 0, -1, -1, -1, 0, 1}, dx8[] = {0, -1, -1, -1, 0, 1, 1, 1};
template <typename T, typename U> inline bool chmax(T &a, U b) { return a < b ? (a = b, true) : false; }
template <typename T, typename U> inline bool chmin(T &a, U b) { return a > b ? (a = b, true) : false; }
struct IOSetup {
IOSetup() {
std::cin.tie(nullptr);
std::ios_base::sync_with_stdio(false);
std::cout << fixed << setprecision(20);
}
} iosetup;
struct UnionFind {
UnionFind(int n) : data(n, -1) {}
int root(int ver) { return data[ver] < 0 ? ver : data[ver] = root(data[ver]); }
bool unite(int u, int v) {
u = root(u);
v = root(v);
if (u == v) return false;
if (data[u] > data[v]) std::swap(u, v);
data[u] += data[v];
data[v] = u;
return true;
}
bool same(int u, int v) { return root(u) == root(v); }
int size(int ver) { return -data[root(ver)]; }
private:
std::vector<int> data;
};
int main() {
int n; cin >> n;
vector<int> x(n), y(n), a(n); REP(i, n) cin >> x[i] >> y[i] >> a[i], --a[i];
vector<int> ord;
REP(i, n) {
if (a[i] != i) ord.emplace_back(i);
}
if (ord.empty()) {
cout << 0 << '\n';
return 0;
}
sort(ALL(ord), [&](int l, int r) -> bool {
return x[l] < x[r] || (x[l] == x[r] && y[l] < y[r]);
});
int root = ord.front();
sort(ord.begin() + 1, ord.end(), [&](int l, int r) -> bool {
int lx = x[l] - x[root], ly = y[l] - y[root];
int rx = x[r] - x[root], ry = y[r] - y[root];
return atan2(ly, lx) < atan2(ry, rx);
});
vector<pair<int, int>> ans;
auto swp = [&](int i, int j) -> void {
swap(a[i], a[j]);
ans.emplace_back(i, j);
};
UnionFind uf(n);
for (int i : ord) uf.unite(i, a[i]);
FOR(i, 2, ord.size()) {
if (uf.unite(ord[i - 1], ord[i])) swp(ord[i - 1], ord[i]);
}
FOR(i, 1, ord.size()) swp(root, a[root]);
assert(is_sorted(ALL(a)));
cout << ans.size() << '\n';
for (auto [i, j] : ans) cout << i + 1 << ' ' << j + 1 << '\n';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long f = 1, x = 0;
char c = getchar();
while (c < '0' || '9' < c) {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return f * x;
}
void Exgcd(int a, int b, long long &x, long long &y) {
if (!b) {
x = 1, y = 0;
return;
}
Exgcd(b, a % b, y, x), y -= a / b * x;
return;
}
vector<pair<int, int> > G[500000 + 5];
void Addedge(int u, int v, int w) {
G[u].push_back(make_pair(v, w));
G[v].push_back(make_pair(u, w));
return;
}
int n, lca;
int fa[500000 + 5];
int dep[500000 + 5], siz[500000 + 5], Maxson[500000 + 5];
long long m, ans, p10[500000 + 5], inv10[500000 + 5], down[500000 + 5],
up[500000 + 5];
void DFS1(int u) {
siz[u] = 1;
for (int i = 0; i < (int)G[u].size(); i++) {
int v = G[u][i].first, w = G[u][i].second;
if (v == fa[u]) continue;
fa[v] = u, dep[v] = dep[u] + 1;
up[v] = (up[u] * 10 + w) % m, down[v] = (down[u] + p10[dep[u]] * w) % m;
DFS1(v), siz[u] += siz[v];
if (siz[v] > siz[Maxson[u]]) Maxson[u] = v;
}
return;
}
int Son;
map<long long, int> Map1, Map2;
void Addson(int u, int val) {
if (val == 1) {
long long tmp =
(up[lca] * p10[dep[lca]] % m + m -
up[u] * p10[2 * dep[lca]] % m * inv10[dep[u]] % m + down[lca]) %
m;
if (Map1.count(tmp)) ans += Map1[tmp];
tmp = (up[lca] * inv10[dep[lca]] % m + m -
(down[u] - down[lca] + m) % m * inv10[2 * dep[lca]] % m) %
m;
if (Map2.count(tmp)) ans += Map2[tmp];
} else {
Map1[down[u]]++;
Map2[up[u] * inv10[dep[u]] % m]++;
}
for (int i = 0; i < (int)G[u].size(); i++) {
int v = G[u][i].first;
if (v == fa[u] || v == Son) continue;
Addson(v, val);
}
return;
}
void DFS2(int u, int kep) {
for (int i = 0; i < (int)G[u].size(); i++) {
int v = G[u][i].first;
if (v == fa[u] || v == Maxson[u]) continue;
DFS2(v, 0);
}
if (Maxson[u]) DFS2(Maxson[u], 1), Son = Maxson[u];
lca = u;
for (int i = 0; i < (int)G[u].size(); i++) {
int v = G[u][i].first;
if (v == fa[u] || v == Maxson[u]) continue;
Addson(v, 1);
Addson(v, 0);
}
long long tmp =
(up[lca] * p10[dep[lca]] % m + m -
up[u] * p10[2 * dep[lca]] % m * inv10[dep[u]] % m + down[lca]) %
m;
if (Map1.count(tmp)) ans += Map1[tmp];
tmp = (up[lca] * inv10[dep[lca]] % m + m -
(down[u] - down[lca] + m) % m * inv10[2 * dep[lca]] % m) %
m;
if (Map2.count(tmp)) ans += Map2[tmp];
Map1[down[u]]++;
Map2[up[u] * inv10[dep[u]] % m]++;
if (!kep) Map1.clear(), Map2.clear();
return;
}
long long inv;
int main() {
n = read(), m = read();
long long y;
Exgcd(10, m, inv, y);
inv = (inv % m + m) % m;
p10[0] = inv10[0] = 1;
for (int i = 1; i <= 2 * n; i++)
p10[i] = p10[i - 1] * 10 % m, inv10[i] = inv10[i - 1] * inv % m;
for (int i = 2; i <= n; i++) {
int u = read() + 1, v = read() + 1, w = read();
Addedge(u, v, w);
}
DFS1(1);
DFS2(1, 0);
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long n;
int main() {
cin >> n;
long long i = 1;
long long total_need = 2;
long long res = 0;
while (total_need <= n) {
if ((n - total_need) % 3 == 0) ++res;
i++;
total_need += 2 * i + (i - 1);
}
cout << res;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T>
using vv = vector<vector<T>>;
template <class T>
inline bool MX(T &l, const T &r) {
return l < r ? l = r, 1 : 0;
}
template <class T>
inline bool MN(T &l, const T &r) {
return l > r ? l = r, 1 : 0;
}
const ll MOD = 1e9 + 7;
vector<pii> solve(vector<int> p) {
int n = p.size();
vector<pii> re;
auto do_swap = [&](int i, int j) {
if (i == j) return;
re.emplace_back(i, j);
assert(abs(i - j) * 2 >= n);
swap(p[i], p[j]);
};
auto mv = [&](int src, int dst) {
vector<int> vs{src, (src * 2 >= n ? 0 : n - 1), (dst * 2 >= n ? 0 : n - 1),
dst};
(vs).erase(unique((vs).begin(), (vs).end()), (vs).end());
;
for (int(i) = 0; (i) < (vs.size() - 1); ++(i))
if (vs[i] == vs.back()) vs.resize(i + 1);
for (int(i) = 1; (i) < (vs.size()); ++(i)) do_swap(vs[i - 1], vs[i]);
for (int(i) = (vs.size() - 1) - 1; (i) >= (1); --(i))
do_swap(vs[i - 1], vs[i]);
};
for (int(i) = 0; (i) < (n); ++(i))
while (p[i] != i) {
;
int tmp = re.size();
mv(p[i], i);
;
}
return re;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(0);
if (0) {
for (int(_) = 0; (_) < (10000); ++(_)) {
int n = rand() % 20 + 2;
if (n % 2) ++n;
vector<int> p{4, 5, 0, 7, 1, 3, 6, 2};
random_shuffle((p).begin(), (p).end());
int tmp = solve(p).size();
assert(tmp < 5 * n);
}
return 0;
}
int n;
cin >> n;
vector<int> p(n);
for (int(i) = 0; (i) < (n); ++(i)) cin >> p[i], --p[i];
vector<pii> re = solve(p);
cout << re.size() << "\n";
for (auto [a, b] : re) cout << a + 1 << " " << b + 1 << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, c[12], d[12], a[12], b[12], num[12], dp[1002];
while (cin >> n >> m >> c[0] >> d[0]) {
memset(dp, 0, sizeof(dp));
num[0] = n / c[0];
for (int i = 1; i <= m; i++) {
cin >> a[i] >> b[i] >> c[i] >> d[i];
num[i] = a[i] / b[i];
}
for (int i = 0; i <= m; i++)
for (int j = 1; j <= num[i]; j++)
for (int k = n; k >= c[i]; k--) dp[k] = max(dp[k], dp[k - c[i]] + d[i]);
cout << dp[n] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int sum[110][110], a[110][110], ans[110];
bool cmp(int a, int b) { return a > b; }
int main() {
int i, j, n, m;
scanf("%d", &n);
int r = 0;
int C = 0, J = 0;
for (i = 0; i < n; i++) {
scanf("%d", &m);
scanf("%d", &a[i][0]);
sum[i][0] = a[i][0];
for (j = 1; j < m; j++) {
scanf("%d", &a[i][j]);
sum[i][j] = sum[i][j - 1] + a[i][j];
}
if (m & 1) {
ans[r++] = a[i][m / 2];
J += sum[i][m - 1] - sum[i][m / 2];
} else
J += sum[i][m - 1] - sum[i][m / 2 - 1];
C += sum[i][m / 2 - 1];
}
sort(ans, ans + r, cmp);
for (i = 0; i < r; i++)
if ((i & 1) == 0)
C += ans[i];
else
J += ans[i];
printf("%d %d\n", C, J);
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int com(const void* a, const void* b) { return *(int*)a - *(int*)b; }
int main(void) {
int c, d, n, m, k, z;
scanf("%d%d%d%d%d", &c, &d, &n, &m, &k);
z = n * m - k;
if (z <= 0)
printf("0");
else {
int m1, m2, m3;
m1 = z / n;
if ((double)z / n == m1 * k)
m2 = m1 *= c;
else {
m1 = m1 * c + c;
m2 = (z - z / n * n) * d + (z / n) * c;
}
m3 = z * d;
printf("%d", min(m1, min(m2, m3)));
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
if (min(n, m) & 1) {
cout << "Akshat" << endl;
} else {
cout << "Malvika" << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 20;
int n, m;
int dis[maxn][maxn], du[maxn];
int dp[1 << maxn];
void Floyd() {
for (int k = 0; k < n; k++) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
}
}
for (int i = 0; i < n; i++) dis[i][i] = 0;
}
int Solve() {
int state = 1 << n;
for (int i = 1; i < n; i++) {
if (du[i] && dis[0][i] == 0x3f3f3f3f) return -1;
}
for (int i = 0; i < state; i++) dp[i] = 0x3f3f3f3f;
dp[0] = 0;
int i;
for (int t = 0; t < state; t++) {
for (i = 0; i < n; i++) {
if ((1 & du[i]) && (t & (1 << i))) break;
}
if (i == n) dp[t] = 0;
for (i = 0; i < n; i++) {
if (!(1 & du[i]) || (t & (1 << i))) continue;
for (int j = i + 1; j < n; j++) {
if (!(1 & du[j]) || (t & (1 << j))) continue;
dp[t | (1 << i) | (1 << j)] =
min(dp[t | (1 << i) | (1 << j)], dp[t] + dis[i][j]);
}
}
}
return dp[state - 1];
}
int main() {
cin >> n >> m;
memset(dis, 0x3f, sizeof dis);
int ans = 0;
while (m--) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
u--, v--;
dis[u][v] = dis[v][u] = min(dis[u][v], w);
du[u]++, du[v]++;
ans += w;
}
Floyd();
int res = Solve();
if (res == -1)
cout << res << endl;
else
cout << ans + res << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9;
const long long inf64 = 1e18;
const long long MOD = inf + 7;
const long long N = 2e5 + 5;
vector<long long> g[N];
long long dp[N][3];
void dfs(long long node, long long par) {
dp[node][0] = 1;
if ((long long)(g[node]).size() == 1) dp[node][1] = inf;
vector<long long> v[2];
for (long long u : g[node]) {
if (u != par) {
dfs(u, node);
dp[node][0] += min(dp[u][0], dp[u][2]);
dp[node][2] += min(dp[u][0], dp[u][1]);
v[0].push_back(dp[u][0]);
v[1].push_back(dp[u][1]);
}
}
if ((long long)(v[0]).size() == 0) return;
long long cnt = 0;
for (long long i = 0; i < (long long)(v[0]).size(); i++)
cnt += v[0][i] <= v[1][i];
if (cnt != 0) {
for (long long i = 0; i < (long long)(v[0]).size(); i++) {
dp[node][1] += min(v[0][i], v[1][i]);
}
} else {
long long extra = inf64;
for (long long i = 0; i < (long long)(v[0]).size(); i++) {
dp[node][1] += v[1][i];
extra = min(extra, v[0][i] - v[1][i]);
}
dp[node][1] += extra;
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
g[u].push_back(v);
g[v].push_back(u);
}
long long ans = 0;
for (long long u : g[1]) {
dfs(u, 1);
ans += dp[u][0] - 1;
}
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ans[1000000];
int gr[1000000][26];
int merge(vector<int> a) {
int res = a.size() - 1, i, j;
for (j = 0; j < 26; j++) {
vector<int> s;
for (i = 0; i < a.size(); i++) {
if (gr[a[i]][j]) s.push_back(gr[a[i]][j]);
}
if (s.size() <= 1) continue;
res = res + merge(s);
}
return res;
}
void dfs(int e, int dep) {
int i;
vector<int> s;
for (i = 0; i < 26; i++)
if (gr[e][i]) s.push_back(gr[e][i]);
ans[dep] += merge(s) + 1;
for (i = 0; i < 26; i++)
if (gr[e][i]) dfs(gr[e][i], dep + 1);
}
using namespace std;
int main() {
int n, i;
cin >> n;
for (i = 0; i < n - 1; i++) {
int u, v;
char ch;
cin >> u >> v >> ch;
gr[u][ch - 'a'] = v;
}
dfs(1, 1);
int max = 0, val = 0;
for (i = 1; i <= n; i++)
if (ans[i] > max) {
max = ans[i];
val = i;
}
cout << (n - max) << endl << val << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
constexpr int N = 2e5 + 5;
int t, a, b, p;
string s;
void Solve() {
cin >> t;
while (t--) {
cin >> a >> b >> p >> s;
s.pop_back();
vector<ll> suf;
suf.resize(s.size());
char last = '0';
for (int i = s.size() - 1; i >= 0; i--) {
if (s[i] != last) suf[i] = (s[i] == 'A' ? a : b);
last = s[i];
}
for (int i = suf.size() - 2; i >= 0; i--) suf[i] += suf[i + 1];
int id = 0;
while (id < suf.size() && suf[id] > p) id++;
cout << id + 1 << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
Solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
vector<pair<std::pair<int, int>, int>> e[1000000];
int pt[1000000];
std::vector<int> l, r;
int main() {
const int INF = 2e9;
int n, m;
scanf("%d %d", &n, &m);
std::vector<int> tmin(n, INF);
l.resize(m);
r.resize(m);
std::vector<int> t(2 * n, -1);
t[0] = 0;
set<std::pair<int, int>> ev;
ev.insert(make_pair(0, 0));
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d %d %d", &u, &v, &l[i], &r[i]);
u--;
v--;
e[2 * u].push_back(make_pair(make_pair(l[i], r[i]), 2 * v + 1));
e[2 * u + 1].push_back(make_pair(make_pair(l[i], r[i]), 2 * v));
e[2 * v].push_back(make_pair(make_pair(l[i], r[i]), 2 * u + 1));
e[2 * v + 1].push_back(make_pair(make_pair(l[i], r[i]), 2 * u));
}
for (int i = 0; i < 2 * n; i++) sort((e[i]).begin(), (e[i]).end());
while (!ev.empty()) {
int v = ev.begin()->second;
int curt = ev.begin()->first;
tmin[v / 2] = min(tmin[v / 2], curt);
ev.erase(ev.begin());
while (pt[v] < e[v].size() && e[v][pt[v]].first.first <= t[v]) {
auto x = e[v][pt[v]];
pt[v]++;
int tgo = max(curt, x.first.first);
if (tgo % 2 != curt % 2) tgo++;
if (tgo >= x.first.second) continue;
int nt = tgo + 1;
int to = x.second;
ev.insert(make_pair(nt, to));
t[to] = max(t[to], x.first.second);
if (t[to] % 2 != nt % 2) t[to]--;
}
}
int ans = tmin[n - 1];
if (ans == INF) ans = -1;
cout << ans;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int sum;
int main() {
int n;
cin >> n;
int a[n][n];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
cin >> a[i][j];
if (i == j || i == n - j + 1 || i == n / 2 + 1 || j == n / 2 + 1)
sum += a[i][j];
}
}
cout << sum;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp[101];
long long n, k, s, ans, q[100001], sum[100001];
inline void dfsx(long long x, long long y, long long S, long long num) {
if (num > k) {
return;
}
if (x > y) {
++mp[num][S];
return;
}
dfsx(x + 1, y, S, num);
dfsx(x + 1, y, S + q[x], num);
if (q[x] <= 20) {
dfsx(x + 1, y, S + sum[q[x]], num + 1);
}
}
inline void dfsy(long long x, long long y, long long S, long long num) {
if (num > k) {
return;
}
if (S > s) {
return;
}
if (x > y) {
for (register int i = 0; i <= k - num; ++i) {
ans += mp[i][s - S];
}
return;
}
dfsy(x + 1, y, S, num);
dfsy(x + 1, y, S + q[x], num);
if (q[x] <= 20) {
dfsy(x + 1, y, S + sum[q[x]], num + 1);
}
}
int main() {
scanf("%lld %lld %lld", &n, &k, &s);
sum[1] = 1;
for (register int i = 2; i <= 20; ++i) {
sum[i] = sum[i - 1] * i;
}
for (register int i = 1; i <= n; ++i) {
scanf("%lld", &q[i]);
}
dfsx(1, (n + 1) / 2, 0, 0);
dfsy((n + 1) / 2 + 1, n, 0, 0);
printf("%lld", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[30], pref[100007];
string s;
map<pair<long long, char>, long long> prefs;
void solve() {
for (long long let = 0; let < (26); ++let) cin >> a[let];
cin >> s;
n = ((long long)(s).size());
s = '#' + s;
long long rst = 0;
pref[1] = a[s[1] - 'a'];
++prefs[make_pair(pref[1], s[1])];
for (long long i = 2; i <= n; ++i) {
pref[i] = pref[i - 1] + a[s[i] - 'a'];
rst += prefs[make_pair(pref[i - 1], s[i])];
++prefs[make_pair(pref[i], s[i])];
}
cout << rst;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
const int INF = 0x3f3f3f3f;
const long long mod = 998244353;
int a[maxn], n, m;
long long dp[maxn][maxn];
long long Cal(int x) {
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= m; ++j) dp[i][j] = 0;
dp[0][0] = 1;
for (int j = 1; j <= m; ++j) {
long long pre = 0;
for (int i = 1, k = 0; i <= n; ++i) {
while (k < i && a[i] - a[k] >= x) {
pre += dp[k][j - 1];
k++;
}
dp[i][j] += pre;
dp[i][j] %= mod;
}
}
long long res = 0;
for (int i = 1; i <= n; ++i) res += dp[i][m];
return res % mod;
}
int main() {
scanf("%d %d", &n, &m);
int mx = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
mx = max(mx, a[i]);
}
a[0] = -INF;
sort(a, a + 1 + n);
long long ans = 0;
mx /= (m - 1);
for (int i = 1; i <= mx; ++i) ans += Cal(i);
printf("%lld\n", ans % mod);
}
| 8 |
#include <bits/stdc++.h>
char s[100], p;
int main() {
p = 0;
scanf("%s", s);
if (s[0] == 'f') {
printf("ftp://");
p += 3;
} else {
printf("http://");
p += 4;
}
int l = strlen(s);
for (int i = p + 1; i < l - 1; ++i) {
if (s[i] == 'r' && s[i + 1] == 'u') {
for (int j = p; j < i; ++j) {
printf("%c", s[j]);
}
printf(".ru");
p = i + 2;
break;
}
}
if (p < l) {
printf("/%s", s + p);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4e5 + 15;
int a[N], b[N], sz[N], ord[N], scc[N], sid = 1, p = 1;
bool v[N];
stack<int> st;
vector<int> adj[N];
int dfs(int x, int par) {
int u, ind, i, ret;
ord[x] = p++;
ret = ord[x];
st.push(x);
for (i = 0; i < adj[x].size(); ++i) {
ind = adj[x][i];
u = a[ind] ^ b[ind] ^ x;
if (u != par) {
if (!ord[u])
ret = min(ret, dfs(u, x));
else if (!scc[u])
ret = min(ret, ord[u]);
if (!v[ind]) a[ind] = x, b[ind] = u, v[ind] = 1;
}
}
if (ret == ord[x]) {
while (1) {
u = st.top();
st.pop();
++sz[sid];
scc[u] = sid;
if (u == x) break;
}
++sid;
}
return ret;
}
void dfs2(int x) {
int i, u, ind;
v[x] = 1;
for (i = 0; i < adj[x].size(); ++i) {
ind = adj[x][i];
u = a[ind] ^ b[ind] ^ x;
if (!v[u]) {
if (scc[u] != scc[x]) a[ind] = u, b[ind] = x;
dfs2(u);
}
}
}
int main() {
int n, m, i, u, ind = 0, j, maxi = 0;
cin >> n >> m;
for (i = 0; i < m; ++i)
scanf("%d%d", &a[i], &b[i]), adj[a[i]].push_back(i), adj[b[i]].push_back(i);
dfs(n, 0);
for (i = 1; i <= n; ++i) {
if (sz[scc[i]] > maxi) maxi = sz[scc[i]], ind = i;
v[i] = 0;
}
dfs2(ind);
cout << maxi << endl;
for (i = 0; i < m; ++i) printf("%d %d\n", a[i], b[i]);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
string t, s, e;
vector<int> starts, fucks;
unordered_map<long long, int> m[2009];
int main() {
cin >> t >> s >> e;
int itr = 0;
int sz = t.size();
int tsz = e.size();
for (; itr < sz;) {
int pos = t.find(s, itr);
if (pos == string::npos) {
break;
}
itr = pos + 1;
starts.push_back(pos);
}
itr = 0;
for (; itr < sz;) {
int pos = t.find(e, itr);
if (pos == string::npos) {
break;
}
itr = pos + 1;
fucks.push_back(pos + tsz - 1);
}
if (fucks.empty()) {
cout << 0 << endl;
return 0;
}
long long rol = 0;
long long ret = 0;
int mxlen = max(s.size(), e.size());
for (typeof(starts.begin()) it = (starts.begin()); it != starts.end(); it++) {
int pos = *it, temp;
typeof(fucks.begin()) itr = (fucks.begin());
itr = lower_bound(fucks.begin(), fucks.end(), pos);
rol = 0;
int cur = pos;
while (itr != fucks.end()) {
temp = (*itr) - tsz + 1;
int len = (*itr) - pos + 1;
if (temp < pos || len < mxlen) {
itr++;
continue;
}
while (cur <= (*itr)) {
rol = (rol * (111181111) + (t[cur] - 'a' + 1)) % (9999999900000001L);
cur++;
}
if (m[len][rol] == 0) {
ret++;
m[len][rol] = 1;
}
itr++;
}
}
cout << ret << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> used;
int main() {
int mask, i, j, n, a[51], k, ans = 0, temp, c;
cin >> n >> k;
for (i = 1; i <= n; i++) cin >> a[i];
sort(a + 1, a + n + 1, greater<int>());
for (i = 1; i <= n; i++) {
for (j = i; j <= n; j++) {
ans++;
cout << i << ' ';
for (int k = 1; k < i; k++) cout << a[k] << ' ';
cout << a[j] << ' ';
cout << endl;
if (ans == k) return 0;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double eps = 1e-8;
const double PI = acos(-1.0);
const int MAXN = 1e5 + 5;
const int MAXM = 2e6 + 5;
const int MOD = 1e9 + 7;
int sgn(double x) {
if (fabs(x) < eps) return 0;
if (x < 0)
return -1;
else
return 1;
}
long long pw(long long a, long long n, long long mod) {
long long ret = 1;
while (n) {
if (n & 1) ret = ret * a % mod;
a = a * a % mod;
n >>= 1;
}
return ret;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
void inc(long long &a, long long b) {
a += b;
if (a >= MOD) a -= MOD;
}
void dec(long long &a, long long b) {
a -= b;
if (a < 0) a += MOD;
}
int mul(int a, int b) {
long long c = 1ll * a * b;
return c - c / MOD * MOD;
}
int n, ans;
set<pair<int, int> > S;
int main() {
scanf("%d", &n);
ans = 0;
int l, r;
while (n--) {
scanf("%d%d", &l, &r);
auto it = S.lower_bound(make_pair(l, 0));
while (it != S.end()) {
int L = (*it).second, R = (*it).first;
int len = min(r, R) - max(l, L) + 1;
if (len > 0) {
l = min(l, L), r = max(r, R);
S.erase(it);
ans--;
it = S.lower_bound(make_pair(l, 0));
} else
break;
}
ans++;
S.insert(make_pair(r, l));
printf("%d ", ans);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
double sqrtt(double x) {
if (x < 0)
return -sqrt(-x);
else
return sqrt(x);
}
int main() {
double a, b, c;
double x1, x2;
while (cin >> a >> b >> c) {
if (a == 0 && b == 0) {
if (c == 0)
printf("-1\n");
else
printf("0\n");
} else if (a == 0 && c == 0) {
printf("1\n0\n");
} else if (b == 0 && c == 0) {
printf("1\n0\n");
} else if (a == 0) {
printf("1\n");
printf("%.6lf\n", -c / b);
} else {
double tem = b * b - 4 * a * c;
if (tem < 0)
printf("0\n");
else if (tem == 0) {
printf("1\n");
printf("%.6lf\n", (-b / (2 * a)));
} else {
printf("2\n");
x1 = (-b - sqrtt(tem)) / (2 * a);
x2 = (-b + sqrtt(tem)) / (2 * a);
if (x1 > x2) swap(x1, x2);
printf("%.6lf\n%.6f\n", x1, x2);
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
string s, f;
cin >> n;
cin >> s;
std::vector<int> v[26];
for (size_t i = 0; i < n; i++) {
v[s[i] - 'a'].push_back(i + 1);
}
long long int m;
std::cin >> m;
while (m--) {
std::cin >> f;
vector<int> cnt(26);
for (auto &c : f) {
cnt[c - 'a'] = cnt[c - 'a'] + 1;
}
int ans = -1;
for (size_t i = 0; i < 26; i++) {
if (cnt[i] > 0) {
ans = max(ans, v[i][cnt[i] - 1]);
}
}
std::cout << ans << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool eq(char a, char b) {
a = tolower(a);
b = tolower(b);
return a == b or (a == 'o' and b == '0') or (a == '0' and b == 'o') or
((a == 'l' or a == '1' or a == 'i') and
(b == 'l' or b == '1' or b == 'i'));
}
int main() {
string s;
cin >> s;
int n;
cin >> n;
string z1 = "";
bool F = 0;
for (int i = 0; i < n; i++) {
string t;
cin >> t;
if (s.size() != t.size()) continue;
bool g = 1;
for (int j = 0; j < t.size(); j++) {
if (!eq(s[j], t[j])) {
g = 0;
break;
}
}
if (g) {
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[n + 1];
for (int i = 1; i <= n; i++) {
cin >> arr[i];
}
int min = INT_MAX;
int x = 0, y = 0;
for (int i = 1; i <= n; i++) {
if (i != n) {
if (abs(arr[i] - arr[i + 1]) < min) {
min = abs(arr[i] - arr[i + 1]);
x = i;
y = i + 1;
}
}
if (i == n) {
if (abs(arr[i] - arr[1]) < min) {
min = abs(arr[i] - arr[1]);
x = i;
y = 1;
}
}
}
cout << x << " " << y << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
struct aa {
int l, r;
} pp[201000];
vector<pair<int, int> > _hash;
vector<pair<int, int> >::iterator it;
int color[201000];
struct node {
int t, nxt;
} edge[201000 << 3];
int headline[201000], E;
inline void add(int f, int t) {
edge[E].t = t;
edge[E].nxt = headline[f];
headline[f] = E++;
edge[E].t = f;
edge[E].nxt = headline[t];
headline[t] = E++;
}
void dfs(int u, int c) {
color[u] = c;
for (int i = headline[u]; ~i; i = edge[i].nxt) {
int v = edge[i].t;
if (color[v] == -1) dfs(v, c ^ 1);
}
}
void solve(void) {
_hash.clear();
memset(headline, -1, sizeof(headline));
E = 0;
for (int i = 0; i < (n); i++) {
scanf("%d%d", &pp[i].l, &pp[i].r);
add(i << 1, i << 1 | 1);
_hash.push_back(pair<int, int>(pp[i].l << 1, i << 1));
_hash.push_back(pair<int, int>(pp[i].r << 1 | 1, i << 1 | 1));
}
sort(_hash.begin(), _hash.end());
int ss = _hash.size();
for (int i = 0; i < ss; i += 2) {
add(_hash[i].second, _hash[i + 1].second);
}
memset(color, -1, sizeof(color));
for (int i = 0; i < (2 * n); i++) {
if (color[i] == -1) dfs(i, 0);
}
for (int i = 0; i < (n); i++) {
printf("%d%c", color[i << 1], (i == n - 1) ? '\n' : ' ');
}
}
int main(void) {
while (EOF != scanf("%d", &n)) solve();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, cnt;
cin >> n;
long long a[n + 1];
for (int i = 0; i < n; ++i) cin >> a[i];
multiset<long long> S;
multiset<long long>::iterator it;
for (int i = 1; i <= n; ++i) {
S.insert(-i);
}
cout << 1 << " ";
for (int i = 0; i < n; ++i) {
S.erase(-a[i]);
if (S.size()) {
it = S.begin();
cnt = n + *it;
cout << (i + 1 + 1 - cnt) << " ";
} else
cout << 1 << "\n";
}
cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> vec(110);
const long long mod = (int)1e9 + 7;
struct matrix {
vector<vector<long long>> arr;
matrix(size_t n, size_t m) {
vector<long long> line(m);
arr.resize(n, line);
}
const vector<long long>& operator[](size_t index) const { return arr[index]; }
vector<long long>& operator[](size_t index) { return arr[index]; }
matrix operator*(const matrix& other) const {
matrix res(arr.size(), other.arr[0].size());
for (int i = 0; i < (int)res.arr.size(); ++i) {
for (int k = 0; k < (int)arr[0].size(); ++k) {
for (int j = 0; j < (int)res[0].size(); j++) {
res[i][j] += arr[i][k] * other.arr[k][j];
if (res[i][j] >= mod) res[i][j] %= mod;
}
}
}
return res;
}
};
int popcount(long long x) {
int res = 0;
while (x) {
res += x & 1;
x >>= 1;
}
return res;
}
int check(long long a, long long b) { return popcount(a ^ b) % 3 == 0; }
matrix one(size_t n) {
matrix res(n, n);
for (int i = 0; i < n; i++) res[i][i] = 1;
return res;
}
matrix binpow(const matrix& a, long long p) {
if (p == 0) {
return one(a[0].size());
} else if (p % 2 == 0) {
matrix t = binpow(a, p >> 1);
return t * t;
}
return binpow(a, p - 1) * a;
}
int main() {
ios_base::sync_with_stdio(false);
long long n, k;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> vec[i];
}
matrix b(n, n);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
b[j][i] = check(vec[i], vec[j]);
}
}
matrix p(1, n);
for (int i = 0; i < n; i++) p[0][i] = 1;
b = binpow(b, k - 1);
p = p * b;
long long ans = 0;
for (int i = 0; i < n; i++) {
ans += p[0][i];
if (ans >= mod) ans -= mod;
}
cout << ans << "\n";
}
| 5 |
#include <bits/stdc++.h>
int bin_1(long long int x) {
int r = 0;
while (x) {
r++;
x &= x - 1;
}
return r;
}
long long int exgcd(long long int a, long long int b, long long int &x,
long long int &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long int x1, y1, __gcd = exgcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return __gcd;
}
long long int modpow(long long int b, long long int e, long long int m) {
long long int r = 1;
b = b % m;
while (e > 0) {
if (e % 2 == 1) r = (r * b) % m;
e /= 2;
b = (b * b) % m;
}
return r;
}
long long int modinverse(long long int a, long long int mod) {
return modpow(a, mod - 2, mod);
}
long long int modinverse2(long long int a, long long int m) {
long long int x, y;
exgcd(a, m, x, y);
while (x < 0) x += m;
return x;
}
long long int nCrmod(long long int n, long long int r, long long int m) {
if (r > n) r = n - r;
long long int res = 1;
for (long long int i = r; i >= 1; i--) {
res = (res * (n - i + 1)) % m;
res = (res * modinverse(i, m));
}
return res;
}
long long int power(long long int b, long long int e) {
if (e == 0) return 1;
if (e % 2 == 0) return power(b * b, e / 2);
return b * power(b * b, e / 2);
}
double powerf(double b, int e) {
if (e == 0) return 1;
if (e % 2 == 0)
return powerf(b * b, e / 2);
else {
if (e > 0)
return b * powerf(b * b, e / 2);
else
return powerf(b * b, e / 2) / b;
}
}
long long int totient(long long int n) {
long long int res = n, p;
for (p = 2; p * p <= n; p++) {
if (n % p == 0) {
while (n % p == 0) n /= p;
res -= res / p;
}
}
if (n > 1) res -= res / n;
return res;
}
bool prime[1000010 + 1];
void sieve() {
long long int x, y;
prime[0] = prime[1] = true;
for (x = 2; x * x <= 1000010; x++) {
if (!prime[x])
for (y = x * x; y <= 1000010; y += x) prime[y] = true;
}
}
int dx[] = {0, 0, -1, 1};
int dy[] = {-1, 1, 0, 0};
using namespace std;
void gcj() {
long long int t;
cin >> t;
for (long long int c = 1; c <= t; c++) {
cout << "Case #" << c << ": ";
cout << endl;
}
}
long long int n, m;
vector<long long int> a[300010];
int v[300010];
void dfs(long long int s) {
long long int cnt = 0;
for (long long int i = 0; i < a[s].size(); i++)
if (v[a[s][i]] == v[s]) cnt++;
if (cnt >= 2) {
v[s] ^= 1;
for (long long int i = 0; i < a[s].size(); i++)
if (v[a[s][i]] == v[s]) dfs(a[s][i]);
}
}
void judge() {
long long int x, y;
cin >> n >> m;
for (long long int i = 1; i < m + 1; i++) {
cin >> x >> y;
a[x].push_back(y);
a[y].push_back(x);
}
for (long long int i = 1; i < n + 1; i++) dfs(i);
for (long long int i = 1; i < n + 1; i++) cout << v[i];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long int t = 1;
while (t--) {
judge();
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int ans;
vector<int> vct[100099];
int dfs(int u, int p) {
int sz = 1;
for (int i = 0; i < vct[u].size(); i++) {
int v = vct[u][i];
if (v != p) sz += dfs(v, u);
}
if (u != 1 && sz % 2 == 0) ans++;
return sz;
}
int main() {
long long int n, m, k;
scanf("%lld", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d", &u);
scanf("%d", &v);
vct[u].push_back(v);
vct[v].push_back(u);
}
if (n % 2 == 1) {
cout << -1 << endl;
return 0;
}
dfs(1, 0);
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long nChooseR(int n, int k);
long long gcd(long long a, long long b);
void strCountsort(string& arr);
void intCountSort(vector<int>& arr);
vector<string> split(string target, char c);
long long n, k, r, l, a[100005], b[100005], t, x, y, m;
long long ans;
bool isPrime(long long g);
int main() {
cin >> n >> m;
set<long long> s;
for (int i = 0; i < (int)(m); i++) {
cin >> a[i];
b[a[i]]++;
}
b[0] = b[n + 1] = 1;
for (int i = 0; i < (int)(m); i++) {
if (s.find(a[i]) != s.end()) {
b[a[i]]--;
continue;
}
if (!b[a[i] + 1]) ans++;
if (!b[a[i] - 1]) ans++;
b[a[i]]--;
s.insert(a[i]);
if (s.size() == n) return cout << ans, 0;
}
for (int i = 0; i < (int)(m); i++) b[a[i]]++;
for (int i = (2); i < (int)(n); i++) {
if (!b[i]) ans += 3;
}
if (!b[1]) ans += 2;
if (!b[n]) ans += 2;
cout << ans;
return 0;
}
long long nChooseR(int n, int k) {
if (k > n) return 0;
if (k * 2 > n) k = n - k;
if (k == 0) return 1;
long long result = n;
for (int i = 2; i <= k; ++i) {
result *= (n - i + 1);
result /= i;
}
return result;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
void strCountsort(string& arr) {
string output = arr;
int max = *max_element(arr.begin(), arr.end());
int min = *min_element(arr.begin(), arr.end());
int range = max - min + 1;
vector<int> count(range);
int n = arr.size();
for (int i = 0; i < n; i++) count[arr[i] - min]++;
n = count.size();
for (int i = 1; i < n; i++) count[i] += count[i - 1];
n = arr.size();
for (int i = n - 1; i >= 0; i--) {
output[--count[arr[i] - min]] = arr[i];
}
arr = output;
}
void intCountSort(vector<int>& arr) {
int max = *max_element(arr.begin(), arr.end());
int min = *min_element(arr.begin(), arr.end());
int range = max - min + 1;
vector<int> count(range), output(arr.size());
int n = arr.size();
for (int i = 0; i < n; i++) count[arr[i] - min]++;
n = count.size();
for (int i = 1; i < n; i++) count[i] += count[i - 1];
n = arr.size();
for (int i = n - 1; i >= 0; i--) {
output[--count[arr[i] - min]] = arr[i];
}
for (int i = 0; i < n; i++) arr[i] = output[i];
}
vector<string> split(string target, char c) {
string d = "";
vector<string> arr;
for (auto n : target) {
if (n != c)
d += n;
else if (d != "")
arr.push_back(d), d = "";
}
if (d != "") arr.push_back(d), d = "";
return arr;
}
bool isPrime(long long g) {
if ((g % 2 == 0 && g > 2) || g == 1) return 0;
for (int i = 3; i * i <= g; i += 2)
if (g % i == 0) return 0;
return 1;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (1e9) + 7;
const long long inf = 1e17;
const int offset = 3000;
string s;
int check(int w) {
char c = w + 'a';
int pre = -1;
int i;
int temp = INT_MIN;
for (i = 0; i < s.size(); i++) {
if (s[i] == c) {
temp = max(temp, i - pre);
pre = i;
}
}
temp = max(temp, i - pre);
return temp;
}
int main() {
cin >> s;
int ans = INT_MAX;
for (int i = 0; i < 26; i++) {
ans = min(ans, check(i));
}
cout << ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
pair<int, int> a[200005];
int cmp(pair<int, int> a, pair<int, int> b) {
if (a.second != b.second)
return a.second > b.second;
else
return a.first < b.first;
}
int bit[200005];
void update(int u) {
for (int i = u; i <= n; i += i & (-i)) bit[i]++;
}
int getval(int u) {
int ans = 0;
for (int i = u; i >= 1; i -= i & (-i)) ans = ans + bit[i];
return ans;
}
vector<int> compress;
map<int, int> M;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a[i].first, &a[i].second);
compress.push_back(a[i].first);
}
sort(compress.begin(), compress.end());
sort(a + 1, a + n + 1, cmp);
int stt = 1, pre_pos = 0;
long long COUNT = 0;
for (int i = 1; i <= n; i++) {
pre_pos = 0;
while (stt <= n && a[i].second == a[stt].second) {
int now = upper_bound(compress.begin(), compress.end(), a[stt].first) -
compress.begin();
if (!M[now]) {
update(now);
M[now] = 1;
}
int cur = getval(now - 1) - getval(pre_pos);
pre_pos = now;
COUNT = COUNT - 1ll * cur * (cur + 1) / 2;
++stt;
}
int all = getval(n);
int r = all - getval(pre_pos);
COUNT = COUNT - 1ll * r * (r + 1) / 2;
COUNT = COUNT + 1ll * all * (all + 1) / 2;
}
cout << COUNT;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, n;
cin >> q;
while (q--) {
cin >> n;
if (n == 2) {
cout << "2" << endl;
} else if (n % 4 == 0 || n % 2 == 0) {
cout << "0" << endl;
} else if (n % 2 == 1) {
cout << "1" << endl;
} else
continue;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 100002;
int n;
struct Card {
int ax, ay, bx, by;
int index;
};
bool operator<(const Card &a, const Card &b) { return a.ax < b.ax; }
Card v[N_MAX];
int SGT[N_MAX * 4];
void compute(int node) {
int lSon = (node << 1), rSon = (lSon | 1);
if (v[SGT[lSon]].ay < v[SGT[rSon]].ay)
SGT[node] = SGT[lSon];
else
SGT[node] = SGT[rSon];
}
void build(int node, int l, int r) {
if (l == r) {
SGT[node] = l;
return;
}
int mid = ((l + r) >> 1), lSon = (node << 1), rSon = (lSon | 1);
build(lSon, l, mid);
build(rSon, mid + 1, r);
compute(node);
}
void update(int node, int l, int r, int upos) {
if (l == r) {
SGT[node] = 0;
return;
}
int mid = ((l + r) >> 1), lSon = (node << 1), rSon = (lSon | 1);
if (upos <= mid)
update(lSon, l, mid, upos);
else
update(rSon, mid + 1, r, upos);
compute(node);
}
int query(int node, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr) return SGT[node];
int mid = ((l + r) >> 1), lSon = (node << 1), rSon = (lSon | 1);
if (ql <= mid && mid + 1 <= qr) {
int q1 = query(lSon, l, mid, ql, qr);
int q2 = query(rSon, mid + 1, r, ql, qr);
if (v[q1].ay < v[q2].ay)
return q1;
else
return q2;
}
if (ql <= mid)
return query(lSon, l, mid, ql, qr);
else
return query(rSon, mid + 1, r, ql, qr);
}
queue<int> q;
int step[N_MAX];
vector<int> ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> v[i].ax >> v[i].ay >> v[i].bx >> v[i].by;
v[i].index = i;
}
sort(v + 1, v + n + 1);
build(1, 1, n);
v[0].ay = INT_MAX;
for (int i = 1; i <= n; i++)
if (v[i].ax == 0 && v[i].ay == 0) {
q.push(i);
update(1, 1, n, i);
}
while (!q.empty()) {
int f = q.front();
q.pop();
if (v[f].index == n) {
for (int i = f; i != 0; i = step[i]) ans.push_back(i);
reverse(ans.begin(), ans.end());
cout << ans.size() << "\n";
for (int i : ans) cout << v[i].index << " ";
cout << "\n";
return 0;
}
int l = 0, r = n;
while (l < r) {
int mid = ((l + r + 1) >> 1);
if (v[f].bx < v[mid].ax)
r = mid - 1;
else
l = mid;
}
if (l == 0) continue;
while (true) {
int pos = query(1, 1, n, 1, l);
if (pos == 0 || v[f].by < v[pos].ay) break;
step[pos] = f;
q.push(pos);
update(1, 1, n, pos);
}
}
cout << "-1\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int n;
cin >> n;
for (int(i) = (0); (i) < (n); ++i)
if (i % 4 == 0)
s += 'a';
else if (i % 4 == 1)
s += 'b';
else if (i % 4 == 2)
s += 'c';
else if (i % 4 == 3)
s += 'd';
cout << s << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16000000")
using namespace std;
const int Maxn = 100005;
int n, k;
vector<pair<int, int> > neigh[Maxn];
int dp[Maxn][2];
void Solve(int v, int p) {
vector<pair<int, int> > vals;
for (int i = 0; i < neigh[v].size(); i++) {
pair<int, int> u = neigh[v][i];
if (u.first == p) continue;
Solve(u.first, v);
vals.push_back(
pair<int, int>(dp[u.first][0] + u.second, dp[u.first][1] + u.second));
}
sort(vals.rbegin(), vals.rend());
for (int i = 0; i < vals.size() && i < k - 1; i++) dp[v][0] += vals[i].first;
for (int i = 0; i < vals.size(); i++)
if (i < k - 1) {
int cand = dp[v][0] - vals[i].first + vals[i].second;
if (k - 1 < vals.size()) cand += vals[k - 1].first;
dp[v][1] = max(dp[v][1], cand);
} else
dp[v][1] = max(dp[v][1], dp[v][0] + vals[i].second);
}
int main() {
scanf("%d %d", &n, &k);
for (int i = 0; i < n - 1; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
neigh[a].push_back(pair<int, int>(b, c));
neigh[b].push_back(pair<int, int>(a, c));
}
Solve(0, -1);
printf("%d\n", dp[0][1]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T x, T y) {
if (x < y) swap(x, y);
while (y > 0) {
T f = x % y;
x = y;
y = f;
}
return x;
}
int n;
char s[222222];
const int MX = 9 * 222222;
pair<int, int> sol[MX];
int inStack[MX];
bool solve(long long r, int lp);
bool xsolve(int lp, pair<int, int>& s, int addFlag, int flagMask, const char* c,
int val, int last, bool canAddPlus) {
if (!*c) {
auto x = make_pair(addFlag, val);
if (val < 10) {
s = x;
return true;
} else {
if (solve(val, lp - 1)) {
s = x;
return true;
}
}
} else {
if (canAddPlus) {
if (xsolve(lp, s, addFlag | flagMask, flagMask * 2, c + 1, val + *c - '0',
*c - '0', *c != '0'))
return true;
}
if (xsolve(lp, s, addFlag, flagMask * 2, c + 1,
(val - last) + last * 10 + *c - '0', last * 10 + *c - '0',
*c != '0'))
return true;
}
return false;
}
bool solve(long long r, int lp) {
if (lp < 1 || r >= MX) return false;
char s[20];
sprintf(s, "%d", r);
if (inStack[r]) return false;
inStack[r] = true;
bool ret = xsolve(lp, sol[r], 0, 1, s, 0, 0, false);
inStack[r] = false;
return ret;
}
char pp[222222];
long long pprr = 0;
bool xxsolve(char* c, char* plus, long long val, long long last,
bool canAddPlus) {
if (!*c) {
if (solve(val, 2)) {
pprr = val;
return true;
}
} else {
if (canAddPlus) {
*plus = 1;
int nskip = 1;
while (*(c + nskip - 1) == '0' && *(c + nskip) == '0')
*(plus + nskip) = 0, nskip++;
if (xxsolve(c + nskip, plus + nskip, val + *c - '0', *c - '0',
1 || *c != '0'))
return true;
}
if (last < 100000000000000ll) {
*plus = 0;
if (xxsolve(c + 1, plus + 1, (val - last) + last * 10 + *c - '0',
last * 10 + *c - '0', 1 || *c != '0'))
return true;
}
}
return false;
}
int main(int argc, char* argv[]) {
std::cin.sync_with_stdio(false);
std::cin.tie(nullptr);
cin >> n >> s;
{
memset(pp, 0, sizeof(pp));
if (!xxsolve(s, pp, 0, 0, false)) {
printf("No solution :(\n");
return 0;
}
for (int i = 0; i < n; i++) {
if (pp[i]) putchar('+');
putchar(s[i]);
}
putchar('\n');
long long rr = pprr;
sprintf(s, "%lld", rr);
for (int l = 0; l < 2; l++) {
auto ss = sol[rr];
sprintf(s, "%lld", rr);
int si = 0;
for (char* c = s; *c; c++) {
if (c != s && (ss.first & (1 << si))) {
putchar('+');
}
putchar(*c);
si++;
}
printf("\n");
fflush(stdout);
rr = ss.second;
sprintf(s, "%lld", rr);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int black = 0, white = 1000000001;
cout << 0 << ' ' << 0 << endl;
cout << flush;
string S;
cin >> S;
if (S == "white") swap(white, black);
for (int i = 1; i < N; i++) {
int mid = (white + black) / 2;
cout << mid << ' ' << 0 << endl;
cout << flush;
cin >> S;
if (S == "black") {
black = mid;
} else {
white = mid;
}
}
if (black + 1 < white || white + 1 < black)
cout << (black + white) / 2 << ' ' << 1 << ' ' << (black + white) / 2 << ' '
<< 2 << endl;
else {
if (black < white) {
if (black > 0)
cout << black << ' ' << 1 << ' ' << black - 1 << ' ' << 3 << endl;
else
cout << black + 1 << ' ' << 1 << ' ' << black + 2 << ' ' << 3 << endl;
} else {
if (white > 0)
cout << white << ' ' << 1 << ' ' << white - 1 << ' ' << 3 << endl;
else
cout << white + 1 << ' ' << 1 << ' ' << white + 2 << ' ' << 3 << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 12;
const int M = 105;
int w[12], a[N], c[N], n, b[N][M];
char s[15];
int get_x() {
scanf("%s", s);
int x = 0;
for (int j = n - 1; j >= 0; j--) {
x <<= 1;
x |= (s[j] == '1');
}
return x;
}
int main() {
int m, q, x, k, ans;
scanf("%d%d%d", &n, &m, &q);
for (int i = 0; i < n; i++) scanf("%d", &w[i]);
for (int i = 0; i < N; i++)
for (int j = 0; j < 12; j++)
if (!((i >> j) & 1)) a[i] += w[j];
for (int i = 0; i < m; i++) c[get_x()]++;
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++)
if (a[i ^ j] < M) b[i][a[i ^ j]] += c[j];
for (int i = 0; i < N; i++)
for (int j = 1; j < M; j++) b[i][j] += b[i][j - 1];
while (q--) {
x = get_x();
scanf("%d", &k);
printf("%d\n", b[x][k]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using LL = int64_t;
const int INF = 0x3fffffff;
const double EPS = 1e-9;
const double PI = 2 * asin(1);
const int MX = 4000 + 10;
LL g_xn, g_yn;
void pretreat() {}
bool input() {
cin >> g_xn >> g_yn;
if (cin.eof()) return false;
return true;
}
void solve() {
LL ans = (g_xn + g_xn % 2) * (g_yn + g_yn % 2) * (g_xn / 2) * (g_yn / 2) / 4;
cout << ans << endl;
}
int main() {
pretreat();
while (input()) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int arr[] = {0, 4, 10, 20, 35, 56, 83,
116, 155, 198, 244, 292, 341};
long long int n;
cin >> n;
if (n < 12)
cout << arr[n];
else {
long long int k = n - 12;
long long int p = ((k * 49) % LLONG_MAX + arr[12] % LLONG_MAX) % LLONG_MAX;
cout << p;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2000005;
long long n, m, ans;
long long z[maxn], t1[maxn], t2[maxn], pre[maxn], suf[maxn];
string a, b, s;
string getrev(string s) {
string res = s;
reverse(res.begin(), res.end());
return res;
}
void getZ(string s) {
long long l = 0, r = 0;
z[0] = 0;
for (long long i = 1; i < s.size(); i++) {
if (i <= r)
z[i] = min(z[i - l], r - i + 1);
else
z[i] = 0;
while (i + z[i] < s.size() && s[z[i]] == s[i + z[i]]) z[i]++;
if (i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
}
z[0] = m;
}
void update(long long x, long long v1, long long v2) {
x++;
for (long long i = x; i <= m + 1; i += i & -i) t1[i] += v1, t2[i] += v2;
}
long long query(long long x, long long k) {
long long res = 0;
x++;
for (long long i = x; i; i -= i & -i) res += k * t2[i] + t1[i];
return res;
}
signed main() {
scanf("%lld%lld", &n, &m);
cin >> a >> b >> s;
getZ(s + "#" + a);
for (long long i = 1; i <= n; i++) pre[i] = min(z[m + i], m - 1);
getZ(getrev(s) + "#" + getrev(b));
for (long long i = 1; i <= n; i++) suf[i] = min(z[m + n - i + 1], m - 1);
for (long long i = 1; i <= n; i++) {
if (i - m + 1 > 0) update(m - pre[i - m + 1], -pre[i - m + 1], -1);
update(m - pre[i], pre[i], 1);
ans += query(suf[i], suf[i] - m + 1);
}
printf("%lld\n", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long n, ans;
long long sum[1000011], cnt[1000011];
stack<long long> ops;
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> s;
n = s.length();
for (long long i = 0; i < n; i++) {
if (s[i] == '(')
ops.push(i);
else {
if (ops.empty()) continue;
long long idx = ops.top();
ops.pop();
long long len = i - idx + 1;
if (idx > 0) sum[i] = sum[idx - 1];
sum[i] += len;
ans = max(ans, sum[i]);
cnt[sum[i]]++;
}
}
cnt[0] = 1;
cout << ans << " " << cnt[ans] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
long long int n;
cin >> n;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
long long int sum = a[0], ans = 1;
for (int i = 1; i < n; i++) {
if (sum <= a[i]) ans++, sum += a[i];
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[5 * 100001], bb;
long long cost[1000001];
long long ans, x, y;
int prime[1000001];
vector<pair<int, int>> vec;
long long even(int xx) {
long long l = 0;
for (int i = 0; i < n; i++) {
if (a[i] % xx == 0)
continue;
else {
long long cost = xx - (a[i] % xx);
cost *= y;
if (x > cost)
l += cost;
else
l += x;
}
}
return l;
}
void fact(int m) {
for (int i = 1; i * i <= m; i++) {
if (m % i == 0) {
cost[i]++;
if (m / i != i) cost[m / i]++;
}
}
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
for (int i = 2; i <= 1e6; i++) {
if (!prime[i]) {
for (long long j = i * 2; j <= 1e6; j += i) prime[j] = true;
}
}
cin >> n >> x >> y;
for (int i = 0; i < n; i++) {
cin >> a[i];
fact(a[i]);
}
ans = min(even(2), min(even(3), even(5)));
for (int i = 2; i <= 1e6; i++) {
if (cost[i] && !prime[i]) vec.push_back(make_pair(cost[i], i));
}
sort(vec.rbegin(), vec.rend());
int siz = vec.size();
for (int i = 0; i < min(100, siz); i++) ans = min(ans, even(vec[i].second));
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e7 + 5;
int sqf[N], rt[N];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
for (int i = 1; i < N; i++) sqf[i] = i, rt[i] = 1;
for (int i = 2; i * i < N; i++)
for (int j = i * i; j < N; j += i * i)
while (sqf[j] % (i * i) == 0) sqf[j] /= i * i, rt[j] *= i;
for (int i = 1; i < N; i++) rt[i] *= sqf[i];
int l, r, n;
cin >> n >> l >> r;
if (n <= 2) {
int k = r - l + 1;
if (n == 1)
cout << k << endl;
else
cout << 1LL * k * (k - 1) << endl;
return 0;
}
long long ans = 0;
for (int ff = l; ff <= r; ff++) {
int bs = sqf[ff];
for (int i = 1; bs * i * i <= r; i++) {
int ss = i * rt[ff];
if (ss <= ff) continue;
long long cur = bs * i * i;
bool bad = false;
for (int i = 4; i <= n; i++) {
cur *= ss;
if (cur % ff) {
bad = true;
break;
}
cur /= ff;
if (cur < l || cur > r) {
bad = true;
break;
}
}
if (!bad) ans++;
}
}
cout << ans * 2 << endl;
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-funroll-loops")
#pragma GCC target("avx,sse4")
using namespace std;
const int N = 1000005, P = 1e9 + 7;
int S[N], n, fail[N], e[N][26], len[N], ec, last, anc[N], diff[N], m, dp[N],
val[N];
char s[N];
inline int newnode(int l) {
len[++ec] = l;
return ec;
}
inline void init() {
last = 1;
while (n) S[n--] = 0;
S[0] = -1;
while (~ec)
len[ec] = fail[ec] = 0, memset(e[ec], 0, sizeof((e[ec])[0]) * (26)), ec--;
newnode(0);
newnode(-1);
fail[0] = 1;
}
inline int match(int p) {
while (S[n] != S[n - len[p] - 1]) p = fail[p];
return p;
}
inline void extend(int c) {
S[++n] = c;
int cur = match(last);
if (!e[cur][c]) {
int p = newnode(len[cur] + 2);
fail[p] = e[match(fail[cur])][c];
e[cur][c] = p;
diff[p] = len[p] - len[fail[p]];
anc[p] = diff[p] == diff[fail[p]] ? anc[fail[p]] : fail[p];
}
last = e[cur][c];
}
int main() {
scanf("%s", s + 1);
m = strlen(s + 1);
for (register int i = 1, _lim_ = m >> 1; i <= _lim_; i++)
S[(i << 1) - 1] = s[i] - 'a';
for (register int i = 1, _lim_ = m >> 1; i <= _lim_; i++)
S[i << 1] = s[m - i + 1] - 'a';
init();
dp[0] = 1;
for (register int i = 1, _lim_ = m; i <= _lim_; i++) {
extend(S[i]);
for (int x = last; x; x = anc[x]) {
if (anc[x] != fail[x])
val[x] = val[fail[x]];
else
val[x] = 0;
int p = i - len[anc[x]] - diff[x];
val[x] = (val[x] + dp[p]) % P;
if ((~i & 1)) dp[i] = (dp[i] + val[x]) % P;
}
}
printf("%d\n", dp[m]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-ffloat-store")
#pragma GCC optimize("-fno-defer-pop")
long long int power(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long int t = power(a, b / 2, m) % m;
t = (t * t) % m;
if (b & 1) t = ((t % m) * (a % m)) % m;
return t;
}
long long int modInverse(long long int a, long long int m) {
return power(a, m - 2, m);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int a, b, c, i, j, l;
cin >> a >> b >> c;
long long int k = min(a / 3, min(b / 2, c / 2));
long long int w = 7 * k;
a = a - 3 * k;
b = b - 2 * k;
c = c - 2 * k;
long long int mx = 0, ar[4];
long long int fl[8] = {0, 1, 2, 3, 1, 3, 2, 1};
for (i = 1; i <= 7; i++) {
ar[1] = a;
ar[2] = b;
ar[3] = c;
long long int ct = 0;
for (j = i; j <= i + 7;) {
if (ar[fl[j]] > 0) {
ar[fl[j]]--;
} else
break;
j = j + 1;
ct++;
if (j == 8) j = 1;
}
if (ct > mx) {
mx = ct;
}
}
mx += w;
cout << mx;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3f;
long long a[100010];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= m; i++) {
cin >> a[i];
}
long long en = k;
long long ans = 0;
for (int i = 1; i <= m;) {
while (i <= m) {
long long t = 0;
while (i <= m && a[i] <= en) {
t++;
i++;
}
if (t == 0) break;
ans++;
en += t;
}
long long p = (a[i] - en - 1) / k;
en += (p + 1) * k;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[2006];
int Gcd(int m, int n) {
if (n == 0) return m;
return Gcd(n, m % n);
}
int main() {
int n;
scanf("%d", &n);
int yi = 0;
int flag = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] == 1) yi++;
}
if (yi != 0) {
printf("%d\n", n - yi);
return 0;
}
int min = 5000;
for (int i = 0; i < n; i++) {
int sum = 0, mod = a[i];
for (int j = i + 1; j < n; j++) {
mod = Gcd(mod, a[j]);
sum++;
if (mod == 1) {
flag = 1;
if (sum < min) min = sum;
break;
}
}
}
if (flag == 1)
printf("%d\n", min + n - 1);
else
printf("-1\n");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
constexpr double pi = 3.141592653589793238462643383279502884L;
const int sz = 1e5;
struct Iv {
int start;
int t;
Iv(int s, int tt) : start(s), t(tt) {}
bool operator<(const Iv& r) const {
if (t != r.t) {
return t < r.t;
}
return start < r.start;
}
};
int main() {
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
long long int b, inc, d;
cin >> b >> inc >> d;
vector<long long int> mh(n);
vector<long long int> sh(n);
vector<long long int> rh(n);
for (int i = 0; i < n; ++i) {
cin >> mh[i] >> sh[i] >> rh[i];
}
vector<pair<long long int, pair<long long int, long long int> > > update(m);
for (pair<long long int, pair<long long int, long long int> >& v : update) {
cin >> v.second.first >> v.first >> v.second.second;
--v.first;
}
for (int i = 0; i < n; ++i) {
update.push_back(make_pair(i, make_pair(0, sh[i])));
}
sort(update.begin(), update.end());
vector<Iv> iv;
long long int acc = 0;
vector<bool> kill(n);
for (int i = 0; i < update.size(); ++i) {
if (kill[update[i].first]) {
continue;
}
if (d >= mh[update[i].first]) {
++acc;
kill[update[i].first] = true;
continue;
}
if (d < update[i].second.second) {
continue;
}
long long int et = 1e10;
if (rh[update[i].first] != 0) {
et = (d - update[i].second.second) / rh[update[i].first];
}
et += update[i].second.first;
if (i != update.size() - 1 && update[i + 1].first == update[i].first) {
et = min(et, update[i + 1].second.first - 1);
}
iv.emplace_back(0, update[i].second.first);
if (et < 1e10) {
iv.emplace_back(1, et);
}
}
sort(iv.begin(), iv.end());
long long int ans = 0;
for (int i = 0; i < iv.size(); ++i) {
if (iv[i].start == 0) {
++acc;
} else {
ans = max(ans, acc * (b + iv[i].t * inc));
--acc;
}
}
if (acc != 0) {
if (inc != 0) {
cout << -1 << endl;
} else {
cout << max(acc * b, ans) << endl;
}
} else {
cout << ans << endl;
}
}
| 8 |
#include <bits/stdc++.h>
const int MAXN = 1e3;
const int mod = 1e9 + 7;
using namespace std;
void solution_AC() {
int n;
cin >> n;
set<int> st;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
st.insert(x);
}
cout << n - st.size() + 1;
}
int main() {
cin.tie();
ios_base::sync_with_stdio(false);
cout.tie(0);
;
long long test = 1;
while (test--) {
solution_AC();
cout << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int pw(long long int a, long long int b, long long int mod) {
if (!b) return 1;
if (b & 1) return a * pw(a * a % mod, b / 2, mod) % mod;
return pw(a * a % mod, b / 2, mod) % mod;
}
constexpr long long int N = 310;
constexpr long long int MOD = 1e9 + 7;
constexpr long long int INF = 1e18;
int n, timer;
vector<int> ans[N * N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 0; i < n - 4; i += 2) {
int m = n - i - 3;
for (int j = 0; j < m; j++) {
ans[timer++] = {i, i + 2 + j, i + 1, i + 2 + (j + 1) % m};
}
ans[timer++] = {i, i + 1, n - 1};
ans[timer++] = {i, i + 1, n - 1};
}
if (n & 1) {
ans[timer++] = {n - 1, n - 2, n - 3};
ans[timer++] = {n - 1, n - 2, n - 3};
} else {
ans[timer++] = {n - 1, n - 2, n - 3};
ans[timer++] = {n - 1, n - 2, n - 4};
ans[timer++] = {n - 1, n - 3, n - 4};
ans[timer++] = {n - 2, n - 3, n - 4};
}
cout << timer << endl;
for (int i = 0; i < timer; i++) {
cout << ans[i].size() << ' ';
for (int j : ans[i]) cout << j + 1 << ' ';
cout << '\n';
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) {
if (!y) return x;
return gcd(y, x % y);
}
int expo(int x, int y, int m) {
int res = 1LL;
while (y) {
if (y & 1) res = (res * x) % m;
x = (x * x) % m;
y /= 2;
}
return res;
}
class matrix {
public:
int a[3][3];
matrix() { memset(a, 0, sizeof a); }
int *operator[](int i) { return a[i]; }
matrix operator*(matrix b) {
matrix c;
int i, j, k;
for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
for (k = 0; k < 3; k++)
c[i][j] = (c[i][j] + (a[i][k] * b[k][j]) % 1000000007) % 1000000007;
return c;
}
};
matrix expo(matrix x, int y) {
matrix res;
int i;
for (i = 0; i < 3; i++) res[i][i] = 1;
while (y) {
if (y & 1) res = (res * x);
x = (x * x);
y /= 2;
}
return res;
}
int bits(int x) {
int ans = 0;
while (x) {
if (x & 1) ans++;
x >>= 1;
}
return ans;
}
map<int, int> BIT;
const int M = 1000000001;
void upd(int idx, int val) {
while (idx <= M) BIT[idx] += val, idx += idx & -idx;
}
int query(int idx) {
int res = 0;
while (idx) res += BIT[idx], idx -= idx & -idx;
return res;
}
const int N = 100003;
int a[N], P[N], Q[N];
vector<pair<pair<int, int>, int> > v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, i, x1, x2, y, ans, pre, j = 0;
cin >> n >> m;
a[0] = 0;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 0; i < m; i++) {
cin >> x1 >> x2 >> y;
if (x1 != 1) continue;
v.push_back(make_pair(make_pair(x1, 0), i));
v.push_back(make_pair(make_pair(x2, 1), i));
P[i] = x1;
Q[i] = x2;
}
sort(a, a + n + 1);
sort(v.begin(), v.end());
ans = n + m;
pre = 0;
a[n + 1] = 1000000000;
for (i = 1; i <= n + 1; i++) {
while (j < v.size() && v[j].first.first < a[i]) {
if (v[j].first.second == 0)
upd(v[j].first.first, 1);
else
upd(P[v[j].second], -1);
j++;
}
while (j < v.size() && v[j].first.first <= a[i] && v[j].first.second == 0)
upd(v[j].first.first, 1), j++;
ans = min(ans, i - 1 + query(pre + 1));
pre = a[i];
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void _init() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
_init();
int n;
cin >> n;
string s;
cin >> s;
vector<int> divisors;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) {
if (n / i == i)
divisors.push_back(i);
else {
divisors.push_back(i);
divisors.push_back(n / i);
}
}
}
sort(divisors.begin(), divisors.end());
for (int i : divisors) {
string temp = s.substr(0, i);
reverse(temp.begin(), temp.end());
for (int j = 0; j < temp.length(); ++j) {
s[j] = temp[j];
}
}
cout << s << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, i, j, a[505], mx = 0, f[1000005], head, tail, t;
long long k;
int main() {
cin >> n >> k;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
mx = max(mx, a[i]);
f[i] = a[i];
}
if (k > n) {
cout << mx;
return 0;
}
t = 0;
head = 1;
tail = n;
while (t < k) {
if (f[head] < f[head + 1]) {
t = 1;
f[++tail] = f[head];
head++;
} else {
t++;
f[++tail] = f[head + 1];
f[head + 1] = f[head];
head++;
}
}
cout << f[head];
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double pi = acos(-1);
int dx[] = {0, 0, 1, -1, 1, 1, -1, -1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
string a[2];
int solve() {
int n = (int)a[0].size(), cnt = 0, ret = 0, ones = 0;
for (int j = 0; j < n; ++j) {
if (a[0][j] == '0' && a[1][j] == '0') {
++cnt;
if (ones) ret++, cnt--;
ones = 0;
} else if (a[0][j] == 'X' && a[1][j] == 'X') {
if (cnt == 2)
ret++;
else if (cnt >= 3) {
ret += ((cnt / 3) * 2);
cnt %= 3;
if (cnt == 2) ret++;
}
cnt = 0;
ones = 0;
} else {
if (ones) ones = 0;
if (cnt == 1) {
ret++;
} else if (cnt == 2) {
ret++, ones++;
} else if (cnt >= 3) {
ret += ((cnt / 3) * 2);
cnt %= 3;
if (cnt == 1)
ret++;
else if (cnt == 2)
ret++, ones++;
else
ones++;
} else
ones++;
cnt = 0;
}
}
ret += ((cnt / 3) * 2);
cnt %= 3;
if (cnt == 2) ret++;
return ret;
}
int main() {
for (int i = 0; i < 2; ++i) cin >> a[i];
cout << solve() << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 7;
double dp[2][N][N];
double prei[N], prej[N], prek[N];
int data[N];
double c2(int n) { return (n * (n - 1)) >> 1; }
int main() {
int n, m;
scanf("%d%d", &n, &m);
m = min(m, 900);
for (int i = (1); i < (n + 1); ++i) scanf("%d", &data[i]);
for (int i = (1); i < (n + 1); ++i)
for (int j = (i + 1); j < (n + 1); ++j) dp[0][i][j] = (data[i] > data[j]);
for (int cas = (0); cas < (m); ++cas) {
int zt = (cas & 1);
memset(dp[zt ^ 1], 0, sizeof(dp[zt ^ 1]));
for (int i = (1); i < (n + 1); ++i)
for (int j = (i + 1); j < (n + 1); ++j) {
for (int k = (1); k < (n + 1); ++k) {
prei[k] = prei[k - 1] + dp[zt][i][k];
prej[k] = prej[k - 1] + dp[zt][k][j];
if (k + j - i <= n) prek[k] = prek[k - 1] + 1 - dp[zt][k][k + j - i];
}
double all = c2(n) + n, cnt = 0;
dp[zt ^ 1][i][j] +=
dp[zt][i][j] * (c2(i - 1) + c2(j - i - 1) + c2(n - j) + n - 2);
cnt += (c2(i - 1) + c2(j - i - 1) + c2(n - j) + n - 2);
for (int k = (i); k < (j); ++k)
dp[zt ^ 1][i][j] += (prej[k] - prej[k - i]), cnt += i;
for (int k = (i + 1); k < (j + 1); ++k)
dp[zt ^ 1][i][j] += (prei[k + n - j] - prei[k - 1]), cnt += n - j + 1;
for (int k = (j); k < (n + 1); ++k)
dp[zt ^ 1][i][j] += (prek[k - j + i] - prek[k - j]), cnt += i;
dp[zt ^ 1][i][j] /= all;
}
}
double ans = 0;
for (int i = (1); i < (n + 1); ++i)
for (int j = (i + 1); j < (n + 1); ++j) ans += dp[m & 1][i][j];
printf("%.10lf\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
const int maxn = 1000010, MOD = 1e9 + 7;
int n, k, fac[maxn], fav[maxn], D[maxn], h[maxn];
void gcd(int a, int b, int& x, int& y) {
if (!b) {
x = 1;
y = 0;
} else {
gcd(b, a % b, y, x);
y -= x * (a / b);
}
}
int inv(int a) {
int x, y;
gcd(a, MOD, x, y);
return (x % MOD + MOD) % MOD;
}
int main() {
scanf("%d%d", &n, &k);
fac[0] = 1;
for (int i = 1; i <= n; i++)
fac[i] = 1ll * fac[i - 1] * i % MOD, fav[i] = inv(fac[i]);
for (int i = 1; i <= n; i++)
if (i > k) {
D[i] = 1ll * fac[i - 2] * ((i - k - 1) + h[i - 1] - h[i - k - 1] + MOD) %
MOD;
h[i] = (h[i - 1] + 1ll * D[i] * fav[i - 1]) % MOD;
}
printf("%lld", 1ll * h[n] * fac[n - 1] % MOD);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
int dat[2222];
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> dat[i];
for (int i = 0; i <= n; ++i) {
for (int j = 0; j < n; ++j) {
if (j % 2 == 0)
dat[j]++;
else
dat[j]--;
if (dat[j] < 0) dat[j] += n;
if (dat[j] == n) dat[j] = 0;
}
int ff = true;
for (int j = 0; j < n; ++j)
if (dat[j] != j) {
ff = 0;
break;
}
if (ff) {
return puts("Yes");
}
}
cout << "No";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 200001;
vector<int> G[maxN];
int in[maxN], inctr;
struct Three {
int a, b, c;
Three(int e = 0, int f = 0, int g = 0) : a(e), b(f), c(g) {}
};
vector<Three> res;
void f(int& dep, int newv, int v) {
if (dep == 0)
dep = newv;
else
res.push_back(Three(dep, v, newv)), dep = 0;
}
bool dfs(int v, int father) {
in[v] = ++inctr;
int dep = 0;
for (int u : G[v]) {
if (u == father or in[u] > in[v]) continue;
if (in[u] != 0) {
f(dep, u, v);
continue;
}
if (dfs(u, v)) f(dep, u, v);
}
if (father != 0) f(dep, father, v);
return dep != 0;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
for (int i = 1; i <= n; i++)
if (in[i] == 0) dfs(i, 0);
printf("%d\n", (int)res.size());
for (Three t : res) printf("%d %d %d\n", t.a, t.b, t.c);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int64_t m, t, n, k, z, i, j, l, h, r, s;
cin >> n;
vector<int64_t> v;
r = n;
while (n % 2 == 0) {
v.push_back(2);
n = n / 2;
}
for (i = 3; i <= sqrt(n); i = i + 2) {
while (n % i == 0) {
v.push_back(i);
n = n / i;
}
}
if (n > 2) v.push_back(n);
k = v.size();
int64_t flag = 0;
for (int64_t i = int64_t(1); i < int64_t(k); ++i)
if (v[i] != v[i - 1]) {
cout << "1\n";
return 0;
}
if (k)
cout << v.front() << "\n";
else
cout << r << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
putchar('\n');
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
const int N = 100005;
const long long sj = 6e9, inf = 9e18;
long long a[N], c[N];
pair<long long, int> q[N << 1];
int n;
inline void change(int pos, long long de) {
for (int i = pos; i < N; i += i & -i) c[i] += de;
}
inline long long ask(int pos) {
long long ans = 0;
for (int i = pos; i; i -= i & -i) ans += c[i];
return ans;
}
pair<long long, long long> Get(long long x) {
int qq = 0;
for (int i = 1; i <= n; i++) {
q[++qq] = make_pair(a[i - 1], -i);
q[++qq] = make_pair(a[i] - x, i);
c[i] = 0;
}
long long sum = 0, ans = 0;
sort(&q[1], &q[qq + 1]);
for (int i = 1; i <= qq; i++)
if (q[i].second < 0)
change(-q[i].second, 1);
else {
long long t = ask(q[i].second);
sum += t;
ans += t * a[q[i].second];
}
for (int i = 1; i <= n; i++) c[i] = 0;
for (int i = 1; i <= qq; i++)
if (q[i].second < 0)
change(-q[i].second, q[i].first);
else
ans -= ask(q[i].second);
return make_pair(sum, ans);
}
pair<long long, long long> dp[N], Dp[N], cf[N];
long long mn[N];
pair<long long, long long> askf(int pos) {
pos = n - pos;
pair<long long, long long> ans = make_pair(-inf, 0);
for (int i = pos; i; i -= i & -i) ans = max(ans, cf[i]);
return ans;
}
void chf(int pos, pair<long long, long long> de) {
pos = n - pos;
for (int i = pos; i <= n; i += i & -i) cf[i] = max(cf[i], de);
}
bool cmp(long long a, long long b) { return a > b; }
pair<long long, long long> get(long long x) {
for (int i = 1; i <= n; i++) cf[i] = make_pair(-inf, 0);
chf(0, dp[0]);
for (int i = 1; i <= n; i++) {
int pos = lower_bound(&mn[0], &mn[i], a[i] - x, cmp) - mn;
dp[i] = askf(pos);
if (pos)
dp[i] = max(dp[i], make_pair(Dp[pos - 1].first + a[i] - x,
Dp[pos - 1].second + 1));
if (i < n) chf(i, dp[i]);
mn[i] = min(mn[i - 1], a[i]);
Dp[i] = max(Dp[i - 1], make_pair(dp[i].first - mn[i], dp[i].second));
}
pair<long long, long long> ttt = Get(x);
dp[n].first += ttt.second - ttt.first * x;
dp[n].second += ttt.first;
return dp[n];
}
int main() {
n = read();
long long k = read();
for (int i = 1; i <= n; i++) a[i] = read() + a[i - 1];
long long l = -sj, r = sj;
while (l < r) {
long long mid = (l + r) >> 1;
mid++;
if (get(mid).second >= k)
l = mid;
else
r = mid - 1;
}
cout << get(l).first + k * l << endl;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5, mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
vector<vector<int> > v(n, vector<int>(m + 1));
vector<vector<int> > target(n, vector<int>(m + 1));
for (int i = 0; i < n; i++) {
for (int j = 1; j <= m; j++) {
cin >> v[i][j];
target[i][j] = i * m + j;
}
}
map<int, int> mp;
int ans = 0;
for (int i = 1; i <= m; i++) {
for (int j = 0; j < n; j++) {
if (v[j][i] % m != i % m || v[j][i] > n * m) continue;
int pos = (v[j][i] - 1) / m;
int dif = (j - pos + n) % n;
mp[dif]++;
}
int mn = n;
for (int j = 0; j < n; j++) mn = min(mn, (n - mp[j]) + j);
ans += mn;
mp.clear();
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[60], b[60];
int tota, totb;
int ans[10000];
int tot = 0;
int convert(int base, int *arr, int size) {
int ans = 0, k = 1;
for (int i = size - 1; i >= 0; i--) {
ans += k * arr[i];
k = k * base;
}
return ans;
}
int main() {
char tmp;
int Max = 0;
while (scanf("%c", &tmp), tmp != ':') {
if (tmp >= 'A')
tmp = tmp - 'A' + 10;
else
tmp = tmp - '0';
a[tota++] = tmp;
Max = Max > tmp ? Max : tmp;
}
while (scanf("%c", &tmp) != EOF) {
if (tmp == '\n') break;
if (tmp >= 'A')
tmp = tmp - 'A' + 10;
else
tmp = tmp - '0';
b[totb++] = tmp;
Max = Max > tmp ? Max : tmp;
}
int beforeA = 0, beforeB = 0;
for (int i = Max + 1;; i++) {
int A, B;
A = convert(i, a, tota);
B = convert(i, b, totb);
if (A == beforeA && B == beforeB) {
printf("-1\n");
return 0;
}
beforeA = A, beforeB = B;
if (A < 24 && B < 60)
ans[tot++] = i;
else
break;
}
for (int i = 0; i < tot; i++)
printf("%d%c", ans[i], i == tot - 1 ? '\n' : ' ');
if (tot == 0) printf("0\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long arr[105], k;
int n;
bool check(long long x) {
long long sum = 0;
for (int i = 0; i < n; i++) {
sum += (arr[i] + x - 1LL) / x;
}
return x * sum <= k;
}
int main(int argc, char const *argv[]) {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> arr[i], k += arr[i];
long long ans = 0;
for (long long i = 1; i <= sqrt(k) + 1; i++) {
if (check(i)) ans = max(ans, i);
if (check(k / i)) ans = max(ans, k / i);
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool sorting(pair<long, long> a, pair<long, long> b) {
long m = a.first + a.second;
long n = b.first + b.second;
if (m != n)
return m < n;
else
return (a.first > b.first);
}
int main() {
long n;
cin >> n;
bool val = false;
vector<pair<long, long> > vec;
for (long i = 0; i <= n / 7; i++) {
if ((n - 7 * i) % 4 == 0) {
val = true;
vec.push_back(make_pair((n - 7 * i) / 4, i));
}
}
if (!val) {
cout << -1 << endl;
return 0;
}
sort(vec.begin(), vec.end(), sorting);
for (long i = 0; i < vec[0].first; i++) cout << 4;
for (long i = 0; i < vec[0].second; i++) cout << 7;
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void die() {
vector<int> a;
a[-1] = 1;
}
const int K = 510;
bool dp[K][K][K];
void solve() {
int n, k;
cin >> n >> k;
vector<int> coins(n);
for (auto &i : coins) scanf("%d", &i);
for (int i = 0; i < n; i++) {
dp[i][coins[i]][coins[i]] = true;
dp[i][coins[i]][0] = true;
}
for (int i = 0; i < n - 1; i++) {
for (int l = 0; l <= k; l++) {
for (int j = 0; j <= k; j++) {
if (dp[i][j][l]) {
dp[i + 1][j][l] = true;
if (j + coins[i + 1] < K) {
dp[i + 1][j + coins[i + 1]][l] = true;
if (l + coins[i + 1] < K) {
dp[i + 1][j + coins[i + 1]][l + coins[i + 1]] = true;
}
}
}
}
}
}
vector<int> ans;
for (int x = 0; x <= k; x++) {
if (dp[n - 1][k][x]) ans.push_back(x);
}
cout << ((int)(ans).size()) << endl;
for (auto x : ans) printf("%d ", x);
}
int main() {
if (0) {
freopen("mushrooms.in", "r", stdin);
freopen("mushrooms.out", "w", stdout);
}
solve();
cerr << endl << "Time: " << clock() / 1000.0 << " ms";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, k, l, cnt = 0, t;
cin >> t;
while (t--) {
cin >> k;
if (k >= 15) {
if (k % 14 <= 6 && k % 14 != 0)
cout << "YES" << endl;
else
cout << "NO" << endl;
} else
cout << "NO" << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[5];
int u[4];
bool f[5], falg;
void dfs(int dep) {
if (dep == 4) {
if (u[1] + u[2] > u[3] && u[1] + u[3] > u[2] && u[2] + u[3] > u[1]) {
printf("TRIANGLE");
exit(0);
}
if (u[1] + u[2] >= u[3] && u[1] + u[3] >= u[2] && u[2] + u[3] >= u[1])
falg = true;
return;
}
for (int i = 1; i <= 4; i++)
if (f[i] == false) {
f[i] = true;
u[dep] = a[i];
dep++;
dfs(dep);
dep--;
u[dep] = 0;
f[i] = false;
}
}
int main() {
scanf("%d%d%d%d", a + 1, a + 2, a + 3, a + 4);
dfs(1);
if (falg == true)
printf("SEGMENT");
else
printf("IMPOSSIBLE");
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct $ {
$() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
} $;
const int Maxn = 200005;
class RoundHouse {
public:
int LastEntrance(int n, int a, int b) {
return ((a - 1 + b) % n + n) % n + 1;
}
};
int main() {
int n, a, b;
cin >> n >> a >> b;
RoundHouse obj;
cout << obj.LastEntrance(n, a, b) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int f_min(int x, int y) {
if (x < y)
return x;
else
return y;
}
int f_max(int x, int y) {
if (x < y)
return y;
else
return x;
}
void swap(int& x, int& y) {
x = x ^ y;
y = x ^ y;
x = x ^ y;
}
int f_abs(int x) { return (x) > (0) ? (x) : (-x); }
int lowbit(int x) { return (x) & (-x); }
using namespace std;
const int MM = 511111;
const double Pi = acos(-1.0);
const double lep = 1e-6;
const double inf = 1000000000.00;
int dx[4] = {1, 0, 0, -1};
int dy[4] = {0, 1, -1, 0};
int N, M, Q;
int num[MM], sum, all, cnt;
bool vis[MM];
int ans[MM];
struct Pos {
int x, y;
} p[MM];
queue<Pos> que;
vector<int> edge[MM];
void get_data() {
int i, j, k, tt;
for (i = 0; i <= N; i++) edge[i].clear();
for (i = 1; i <= N; i++) {
if (i == M)
continue;
else {
scanf("%d", &tt);
edge[i].push_back(tt);
edge[tt].push_back(i);
}
}
}
void dfs(int u) {
int i, j, k, v;
vis[u] = true;
for (i = 0; i < edge[u].size(); i++) {
v = edge[u][i];
if (!vis[v]) ans[v] = u, dfs(v);
}
}
void solve() {
int i, j, k;
memset(vis, false, sizeof(vis));
dfs(Q);
for (i = 1; i <= N; i++) {
if (i == Q)
continue;
else
printf("%d ", ans[i]);
}
printf("\n");
}
int main() {
while (scanf("%d%d%d", &N, &M, &Q) != EOF) get_data(), solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b;
cin >> n >> m >> a >> b;
if ((float)b / m >= a)
cout << n * a << endl;
else {
int f = b * (n / m) + (n % m) * a;
int s = b * ceil((float)n / m);
cout << min(f, s) << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double g = 10.0, eps = 1e-12;
const int N = 100000 + 10, maxn = 100000 + 10, inf = 0x3f3f3f3f,
INF = 0x3f3f3f3f3f3f3f3f;
int main() {
int n, ans = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
ans += abs(x);
}
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct fastIO {
inline fastIO operator>>(int& num) {
num = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
bool foo = 0;
if (c == '-') {
foo = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
if (foo) num = -num;
return *this;
}
inline fastIO operator>>(long long& num) {
num = 0;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
bool foo = 0;
if (c == '-') {
foo = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
if (foo) num = -num;
return *this;
}
inline fastIO operator>>(float& num) {
scanf("%f", &num);
return *this;
}
inline fastIO operator>>(double& num) {
scanf("%lf", &num);
return *this;
}
inline fastIO operator>>(long double& num) {
scanf("%Lf", &num);
return *this;
}
inline fastIO operator>>(char& num) {
num = getchar();
while (num == ' ' || num == '\n') num = getchar();
return *this;
}
inline fastIO operator>>(char* num) {
int cnt = 0;
char c = getchar();
while (c == ' ' || c == '\n') c = getchar();
while (c != ' ' && c != '\n') {
num[cnt++] = c;
c = getchar();
}
num[cnt] = 0;
return *this;
}
inline fastIO operator>>(string& num) {
cin >> num;
return *this;
}
inline void printInt(const int& num) {
if (num < 10) {
putchar(num + '0');
return;
}
printInt(num / 10);
putchar((num % 10) + '0');
}
inline void printINT(const long long& num) {
if (num < 10) {
putchar(num + '0');
return;
}
printINT(num / 10);
putchar((num % 10) + '0');
}
inline fastIO operator<<(const int& num) {
if (num < 0)
putchar('-'), printInt(-num);
else
printInt(num);
return *this;
}
inline fastIO operator<<(const long long& num) {
if (num < 0)
putchar('-'), printINT(-num);
else
printINT(num);
return *this;
}
inline fastIO operator<<(const float& num) {
printf("%.10f", num);
return *this;
}
inline fastIO operator<<(const double& num) {
printf("%.16lf", num);
return *this;
}
inline fastIO operator<<(const long double& num) {
printf("%.20Lf", num);
return *this;
}
inline fastIO operator<<(const char& num) {
putchar(num);
return *this;
}
inline fastIO operator<<(const char* num) {
for (int i = 0; num[i]; i++) putchar(num[i]);
return *this;
}
inline fastIO operator<<(const string& num) {
cout << num;
return *this;
}
} fio;
int n, m, k;
int a[15][15];
int dy[15], dy2[15];
int fi11[15][15];
int dp[15][15];
int dfs(int x, int y, int used) {
if (x == n) {
memset((void*)dy, 0, sizeof(dy));
memset((void*)dy2, 0, sizeof(dy2));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j]) {
if (dy[fi11[i][j]] && dy[fi11[i][j]] != a[i][j]) {
return 0;
}
if (dy2[a[i][j]] && dy2[a[i][j]] != fi11[i][j]) {
return 0;
}
dy[fi11[i][j]] = a[i][j];
dy2[a[i][j]] = fi11[i][j];
}
}
}
int kb = k - used, kk = k;
for (int i = 1; i <= used; i++) {
if (dy[i]) {
kk--;
}
}
int ans = 1;
for (int i = kk; i > kb; i--) {
ans *= i;
}
return ans;
}
dp[x][y] = ((x > 0 ? dp[x - 1][y] : 0) | (y > 0 ? dp[x][y - 1] : 0));
int cnt = 0;
for (int i = 1; i <= min(used + 1, k); i++) {
if (!(((dp[x][y]) >> (i)) & 1)) {
dp[x][y] ^= (1 << (i));
fi11[x][y] = i;
if (y < m - 1) {
cnt += dfs(x, y + 1, min(max(used, i), k));
} else {
cnt += dfs(x + 1, 0, min(max(used, i), k));
}
if (cnt > 1000000007) {
cnt -= 1000000007;
}
fi11[x][y] = 0;
dp[x][y] ^= (1 << (i));
}
}
return cnt;
}
int main() {
fio >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
fio >> a[i][j];
}
}
fio << dfs(0, 0, 0) << '\n';
return 0;
}
| 9 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.