solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long a[110];
int main() {
int i, n;
long long ans;
while (scanf("%d", &n) != EOF) {
for (i = 0; i < n; ++i) cin >> a[i];
for (ans = i = 0; i < n; ++i) {
ans += (a[i] - 1) * (i + 1) + 1;
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
std::map<int, int> s;
std::vector<int> p[200001];
int i, j, k, n, m, x, L, mid, R, a[200001], b[200001];
int main() {
for (scanf("%d", &n), i = 1; i <= n; ++i)
scanf("%d%d", &j, b + i), p[j].push_back(i);
for (i = 1; i <= n; ++i)
if (!p[i].empty()) s[p[i].back()] = i;
for (scanf("%d", &m); m; m--) {
for (scanf("%d", &k), i = 0; i < k; ++i) {
if (scanf("%d", a + i), p[a[i]].empty())
--i, --k;
else
s.erase(p[a[i]].back());
}
if (s.empty())
puts("0 0");
else {
x = s.rbegin()->second, s.erase(s.rbegin()->first);
if (s.empty())
j = 0;
else
j = s.rbegin()->first;
for (L = 0, R = p[x].size() - 1; L < R;)
if (p[x][mid = L + R >> 1] < j)
L = mid + 1;
else
R = mid;
printf("%d %d\n", x, b[p[x][L]]), s[p[x].back()] = x;
}
for (i = 0; i < k; ++i) s[p[a[i]].back()] = a[i];
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n;
scanf("%d", &n);
int a[n], b[n], o[n];
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n; i++) {
scanf("%d", &b[i]);
}
for (i = 1; i <= n; i++) {
o[a[i]] = b[i];
}
for (i = 1; i <= n; i++) printf("%d ", o[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
//PROBLEM D
const ll N=5e3+5;
ll n,t,score[N],tag[N],wt[N],cache[N];
int32_t main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin>>t;
while(t--)
{
cin>>n;
for(ll i=1;i<=n;i++)
cin>>tag[i];
for(ll i=1;i<=n;i++)
cin>>score[i];
ll ans=0;
memset(cache,0,sizeof(cache));
for(ll i=2;i<=n;i++)
{
for(ll j=i-1;j>0;j--)
{
if(tag[i]==tag[j])
continue;
ll cachei=cache[i],cachej=cache[j];
cache[j]=max(cache[j],cachei+abs(score[i]-score[j]));
cache[i]=max(cache[i],cachej+abs(score[i]-score[j]));
}
}
ans=*max_element(cache+1,cache+n+1);
cout<<ans<<endl;
}
return 0;
} | 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000;
vector<pair<int, int>> v;
bool mark[maxn], ans;
int n, a, u, y, ck;
void dfs(int x, int y) {
mark[x] = 1;
if (x == y) {
ans = true;
return;
}
for (int i = 0; i < v.size(); i++) {
if (!mark[i] && ((v[i].first < v[x].first && v[x].first < v[i].second) ||
(v[i].first < v[x].second && v[x].second < v[i].second))) {
dfs(i, y);
}
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ck >> u >> y;
if (ck == 1)
v.push_back({u, y});
else {
ans = false;
memset(mark, 0, sizeof(mark));
dfs(u - 1, y - 1);
if (ans)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q, x;
cin >> q >> x;
vector<int> arr(x, 0);
int r = 0;
for (int i = 0; i < q; i++) {
int n;
cin >> n;
arr[n % x] += 1;
while (arr[r % x] != 0) {
arr[r % x] -= 1;
r += 1;
}
cout << r << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> grafo[100001];
vector<int> grafo2[100001];
bool visitado[100001];
bool termino[100001];
bool hayciclo[100001];
bool ciclo;
int t;
void dfs(int u) {
visitado[u] = true;
for (int i = 0; i < grafo[u].size(); i++) {
int v = grafo[u][i];
if (!visitado[v])
dfs(v);
else if (!termino[v])
hayciclo[v] = true;
}
termino[u] = true;
}
void dfs2(int u) {
visitado[u] = true;
t++;
if (hayciclo[u]) ciclo = true;
for (int i = 0; i < grafo[u].size(); i++) {
int des = grafo[u][i];
if (!visitado[des]) dfs2(des);
}
for (int i = 0; i < grafo2[u].size(); i++) {
int des = grafo2[u][i];
if (!visitado[des]) dfs2(des);
}
}
int main() {
scanf("%d", &n);
scanf("%d", &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d", &a);
scanf("%d", &b);
a--;
b--;
grafo[a].push_back(b);
grafo2[b].push_back(a);
}
memset(visitado, false, sizeof(visitado));
memset(termino, false, sizeof(termino));
memset(hayciclo, false, sizeof(hayciclo));
int res = 0;
for (int i = 0; i < n; i++) {
if (!visitado[i]) {
dfs(i);
}
}
memset(visitado, false, sizeof(visitado));
for (int i = 0; i < n; i++) {
if (!visitado[i]) {
ciclo = false;
t = 0;
dfs2(i);
if (ciclo)
res += t;
else
res += t - 1;
}
}
printf("%d\n", res);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 0.0000001;
const double PI = acos(-1);
const long long INFLL = 0x7FFFFFFFFFFFFFFF;
const int INF = 0x7FFFFFFF;
template <typename T>
inline void next(T &num) {
char c;
num = 0;
do {
c = getchar_unlocked();
} while (c != EOF && c == ' ' && c == '\n' && c == '\t');
int sign = (c == '-' ? -1 : 1);
if (c != '-') num += (c - '0');
while ((c = getchar_unlocked()) != EOF && c != '\n' && c != '\t' &&
c != ' ') {
num *= 10;
num += (c - '0');
}
num *= sign;
}
int n, k, m, node[305];
bitset<305> mark;
int main() {
scanf("%d%d%d", &n, &m, &k);
if (k == n || m > n * (n - 1) / 2 - k + 1) {
printf("-1");
return 0;
}
int cnt = n;
for (int i = int(0), _b = int(k - 1); i <= _b; ++i) {
scanf("%d", &node[--cnt]);
mark[node[cnt]] = 1;
}
for (int i = int(n), _b = int(1); i >= _b; --i)
if (!mark[i]) node[--cnt] = i;
for (int i = int(1), _b = int(n - 1); i <= _b; ++i)
printf("%d %d\n", node[0], node[i]);
m -= n - 1;
for (int i = int(1), _b = int(n - 2); i <= _b; ++i) {
for (int j = int(1), _b = int(i - 1); j <= _b; ++j) {
if (!m) return 0;
printf("%d %d\n", node[j], node[i]);
m--;
}
}
for (int i = int(1), _b = int(n - k - 1); i <= _b; ++i) {
if (!m) return 0;
printf("%d %d\n", node[n - 1], node[i]);
m--;
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int inf = (1ll << 30) - 1;
const int maxn = (int)1e5 + 10;
using namespace std;
int n, m;
vector<int> g[5050];
char op[5050];
int dp[5050];
string val[5050];
map<string, int> M;
int get(int pos, int d) {
dp[0] = d;
int sum = 0;
for (int i = 1; i <= n; i++) {
if (val[i].size()) {
dp[i] = val[i][pos] - '0';
} else {
int j = g[i][0];
int k = g[i][1];
if (op[i] == 'A') {
dp[i] = dp[j] & dp[k];
} else if (op[i] == 'X') {
dp[i] = dp[j] ^ dp[k];
} else {
dp[i] = dp[j] | dp[k];
}
}
sum += dp[i];
}
return sum;
}
void solve() {
string second;
getline(cin, second);
std::stringstream ss(second);
ss >> n >> m;
M["?"] = 0;
for (int i = 1; i <= n; i++) {
getline(cin, second);
std::stringstream ss(second);
vector<string> cur;
while (ss >> second) {
cur.push_back(second);
}
M[cur[0]] = i;
if (cur.size() == 3) {
val[i] = cur[2];
} else {
g[i].push_back(M[cur[2]]);
op[i] = cur[3][0];
g[i].push_back(M[cur[4]]);
}
}
string mi, mx;
for (int i = 0; i < m; i++) {
int c1 = get(i, 0);
int c2 = get(i, 1);
mi += (c1 <= c2) ? "0" : "1";
mx += (c1 >= c2) ? "0" : "1";
}
cout << mi << endl << mx << endl;
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, cnt = 0, flag, Min;
char a[200001];
int b[200001];
int c[200001];
while (~scanf("%d", &n)) {
flag = 0;
Min = 0x3f3f3f3f;
memset(a, 0, sizeof(a));
memset(b, 0, sizeof(b));
memset(c, 0, sizeof(c));
scanf("%s", a);
for (i = 0; i < n; i++) {
scanf("%d", &b[i]);
}
for (i = 0; i < n; i++) {
if (a[i] == 'L' && a[i - 1] == 'R') {
flag = 1;
Min = min(Min, abs(b[i] - b[i - 1]) / 2);
}
}
if (flag == 0) {
printf("-1\n");
continue;
} else
printf("%d\n", Min);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
string tos(T a) {
stringstream ss;
string ret;
ss << a;
ss >> ret;
return ret;
}
void read(int &_a) { int temp = scanf("%d", &_a); }
void read(int &_a, int &_b) { int temp = scanf("%d %d", &_a, &_b); }
void read(int &_a, int &_b, int &_c) {
int temp = scanf("%d %d %d", &_a, &_b, &_c);
}
const int SZ = 3e5 + 7;
string ST;
vector<int> AJ[SZ];
pair<int, int> P[SZ];
int COST[SZ][2], result, LN[SZ], N;
pair<int, int> get_p(int u) {
int t = 0;
while (u != P[u].first) {
t ^= P[u].second;
u = P[u].first;
}
return make_pair(u, t);
}
int main() {
int m;
while (cin >> N >> m) {
int c, v;
cin >> ST;
for (int(x) = (0); (x) < (SZ); (x)++) AJ[x].clear();
result = 0;
for (int(x) = (0); (x) < (m); (x)++) {
read(c);
for (int(xx) = (0); (xx) < (c); (xx)++) {
read(v);
v--;
AJ[v].push_back(x);
}
COST[x][0] = 0;
COST[x][1] = 1;
P[x] = make_pair(x, 0);
LN[x] = 1;
}
for (int(x) = (0); (x) < (N); (x)++) {
if (AJ[x].size() == 0) {
} else if (AJ[x].size() == 1) {
int u = AJ[x][0];
pair<int, int> p = get_p(u);
u = p.first;
int t = p.second;
result -= min(COST[u][0], COST[u][1]);
if (ST[x] == '0') t ^= 1;
COST[u][1 ^ t] = N;
result += min(COST[u][0], COST[u][1]);
} else {
int u = AJ[x][0];
int v = AJ[x][1];
pair<int, int> pu = get_p(u);
pair<int, int> pv = get_p(v);
u = pu.first;
v = pv.first;
int t = pu.second ^ pv.second;
if (ST[x] == '0') t ^= 1;
if (u != v) {
if (LN[u] < LN[v]) swap(u, v);
result -= min(COST[u][0], COST[u][1]);
result -= min(COST[v][0], COST[v][1]);
LN[u] += LN[v];
P[v] = make_pair(u, t);
for (int(d) = (0); (d) < (2); (d)++) {
COST[u][d] += COST[v][d ^ t];
COST[u][d] = min(COST[u][d], N);
}
result += min(COST[u][0], COST[u][1]);
}
}
printf("%d\n", result);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[][33] = {
1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0,
0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0,
1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1,
0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0,
1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0,
1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0,
1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1,
1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0,
0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0,
1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1,
0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0,
0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0,
0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 1,
1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0,
0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1,
1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0,
0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1,
1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0,
1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1,
1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0,
0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1,
1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,
1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0,
1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1,
0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1,
0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1,
1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1,
1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1,
0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1,
1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0,
1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1,
0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 1,
1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0,
0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1,
0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0,
0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1,
1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0,
0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1};
int main() {
int x, y;
cin >> x >> y;
cout << a[x][y];
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, A[100010], IT[4 * 100010], moc, tmp;
long long res;
inline int check(const int &a, const int &b) {
int pp = (1LL * a * b) % k;
return (pp == 0);
}
void build(int id, int l, int r) {
if (l == r) {
IT[id] = A[l] % k;
return;
}
build(id << 1, l, (l + r) >> 1);
build((id << 1) + 1, ((l + r) >> 1) + 1, r);
IT[id] = (1LL * IT[id << 1] * IT[(id << 1) + 1]) % k;
}
void get(int id, int l, int r, const int &L, const int &R) {
if (r < L || l > R) return;
if (L <= l && R >= r) {
if (l == r) {
tmp = (1LL * tmp * IT[id]) % k;
if (tmp == 0) moc = l;
return;
}
if (check(tmp, IT[id << 1]))
get(id << 1, l, (l + r) >> 1, L, R);
else {
tmp = (1LL * tmp * IT[id << 1]) % k;
get((id << 1) + 1, ((l + r) >> 1) + 1, r, L, R);
}
return;
}
get(id << 1, l, (l + r) >> 1, L, R);
if (tmp == 0) return;
get((id << 1) + 1, ((l + r) >> 1) + 1, r, L, R);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &A[i]);
build(1, 1, n);
res = 0;
for (int i = 1; i <= n; ++i) {
moc = n + 1;
tmp = 1;
get(1, 1, n, i, n);
res += (n - moc + 1);
}
printf("%lld", res);
return 0;
}
| 5 |
#include <bits/stdc++.h>
struct Point {
int xx;
bool is_left;
int number;
};
struct comp {
bool operator()(const Point& first, const Point& second) const {
if (first.xx != second.xx) {
return first.xx < second.xx;
} else if (first.is_left != second.is_left) {
return first.is_left;
} else {
return first.number < second.number;
}
}
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int n, k;
std::cin >> n >> k;
std::vector<Point> points;
for (int i = 0; i < n; ++i) {
int l, r;
std::cin >> l >> r;
points.push_back({l, true, i});
points.push_back({r, false, i});
}
std::sort(points.begin(), points.end(), comp());
std::vector<std::pair<int, int>> ans;
int covered = 0;
bool flag = false;
int left, right;
for (const auto& point : points) {
if (point.is_left) {
++covered;
} else {
--covered;
}
if (covered == k && !flag) {
flag = true;
left = point.xx;
} else if (covered < k && flag) {
flag = false;
right = point.xx;
ans.push_back({left, right});
}
}
std::cout << ans.size() << '\n';
if (!ans.empty()) {
for (const auto& elem : ans) {
std::cout << elem.first << " " << elem.second << '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long UNDEF = -1;
const int INF = 1 << 30;
template <typename T>
inline bool chkmax(T& aa, T bb) {
return aa < bb ? aa = bb, true : false;
}
template <typename T>
inline bool chkmin(T& aa, T bb) {
return aa > bb ? aa = bb, true : false;
}
static char stdinBuffer[1024];
static char* stdinDataEnd = stdinBuffer + sizeof(stdinBuffer);
static const char* stdinPos = stdinDataEnd;
void readAhead(size_t amount) {
size_t remaining = stdinDataEnd - stdinPos;
if (remaining < amount) {
memmove(stdinBuffer, stdinPos, remaining);
size_t sz = fread(stdinBuffer + remaining, 1,
sizeof(stdinBuffer) - remaining, stdin);
stdinPos = stdinBuffer;
stdinDataEnd = stdinBuffer + remaining + sz;
if (stdinDataEnd != stdinBuffer + sizeof(stdinBuffer)) *stdinDataEnd = 0;
}
}
int rint() {
readAhead(16);
int x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
char rch() {
readAhead(16);
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
char ans = *stdinPos;
++stdinPos;
return ans;
}
long long rlong() {
readAhead(32);
long long x = 0;
bool neg = false;
while (*stdinPos == ' ' || *stdinPos == '\n') ++stdinPos;
if (*stdinPos == '-') {
++stdinPos;
neg = true;
}
while (*stdinPos >= '0' && *stdinPos <= '9') {
x *= 10;
x += *stdinPos - '0';
++stdinPos;
}
return neg ? -x : x;
}
const int MAXN = 1e6 + 4;
const int MAXP = MAXN;
bool sieve_array[MAXP + 1];
int sp[MAXP + 1];
vector<int> gpv;
void sieve() {
for (int i = 0; i <= MAXP; i++) {
sieve_array[i] = true;
sp[i] = INF;
}
sieve_array[0] = false;
sieve_array[1] = false;
int lim = sqrt(MAXP) + 1;
for (int i = 2; i <= lim; i++) {
if (sieve_array[i]) {
for (int j = i * i; j <= MAXP; j += i) {
sieve_array[j] = false;
chkmin(sp[j], i);
}
}
}
for (int i = 2; i <= MAXP; i++) {
if (sieve_array[i]) {
gpv.push_back(i);
chkmin(sp[i], i);
}
}
}
const int mn = 5004;
int a[mn];
int n, k;
const int mx = 1e6 + 4;
int mid[mx];
void f(int m) {
int have = 0;
for (int i = 0; i < n; i++) {
int x = a[i];
if (x >= m) x %= m;
if (mid[x] != m) {
mid[x] = m;
} else {
if (have >= k) return;
++have;
}
}
printf("%d\n", m);
exit(0);
}
int target[5000];
int getfac(int x) {
int sz = 1;
target[0] = 1;
while (x > 1) {
int p = sp[x];
x /= p;
int elim = 1;
while (0 == x % p) {
x /= p;
elim++;
}
int pp = 1;
int psz = sz;
for (int e = 1; e <= elim; e++) {
pp *= p;
for (int i = 0; i < psz; i++) {
target[sz++] = target[i] * pp;
}
}
}
return sz;
}
const int MK = 10;
const int OVF = 1 << 30;
typedef struct LimitedSetStruct {
int a[MK];
int sz;
void ins(int val) {
if (sz >= MK) {
sz = OVF;
return;
} else {
for (int i = 0; i < sz; i++) {
if (a[i] == val) return;
}
a[sz++] = val;
}
}
bool ovf() { return sz == OVF; }
void setovf() { sz = OVF; }
} LimitedSet;
int ufp[mx];
int ufs[mx];
void ufinit(int n) {
for (int x = 0; x < n; x++) {
ufp[x] = x;
ufs[x] = 1;
}
}
int uffind(int x) {
if (ufp[x] != x) {
ufp[x] = uffind(ufp[x]);
}
return ufp[x];
}
void ufunion(int x, int y) {
if (rand() & 1) swap(x, y);
int xr = uffind(x);
int yr = uffind(y);
if (xr == yr) return;
ufp[xr] = yr;
ufs[yr] += ufs[xr];
}
LimitedSet tmp[mx], cand[mx];
int seen[mx];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
sieve();
n = rint(), k = rint();
for (int i = 0; i < n; i++) a[i] = rint();
for (int x = 0; x < n; x++) {
for (int y = 0; y < x; y++) {
int diff = abs(a[x] - a[y]);
if (diff) {
tmp[diff].ins((x << 16) | y);
}
}
}
for (int diff = 1; diff < mx; diff++) {
if (tmp[diff].sz) {
int sz = getfac(diff);
for (int i = 0; i < sz; i++) {
int t = target[i];
if (tmp[diff].ovf())
cand[t].setovf();
else {
for (int q = 0; q < tmp[diff].sz; q++) {
cand[t].ins(tmp[diff].a[q]);
}
}
}
}
}
ufinit(mx);
for (int id = 1; id < mx; id++) {
if (cand[id].ovf()) continue;
for (int q = 0; q < cand[id].sz; q++) {
auto edge = cand[id].a[q];
int x = edge >> 16, y = edge & 0xffff;
ufunion(x, y);
}
int need = 0;
for (int q = 0; q < cand[id].sz; q++) {
auto edge = cand[id].a[q];
int x = edge >> 16, y = edge & 0xffff;
if (ufp[x] == x) {
need += ufs[x] - 1;
ufs[x] = 1;
}
if (ufp[y] == y) {
need += ufs[y] - 1;
ufs[y] = 1;
}
}
if (need <= k) {
printf("%d\n", id);
return 0;
}
for (int q = 0; q < cand[id].sz; q++) {
auto edge = cand[id].a[q];
int x = edge >> 16, y = edge & 0xffff;
ufp[x] = x;
ufs[x] = 1;
ufp[y] = y;
ufs[y] = 1;
}
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (1LL << 30) - 1;
const long long int LINF = (1LL << 62) - 1;
const int NMAX = (1e5) + 5;
int N, M;
int pile[NMAX];
bool check(long long int time) {
int i, k;
long long int curr;
int P[NMAX];
memcpy(P, pile, sizeof(pile));
for (i = N, k = 1; k <= M; k++) {
while (P[i] == 0 && i >= 1) i--;
if (i == 0) return 1;
curr = i;
while (curr < time) {
if (curr + P[i] <= time) {
curr += P[i];
P[i] = 0;
} else {
P[i] -= time - curr;
curr = time;
}
while (P[i] == 0 && i >= 1) i--;
if (i == 0) return 1;
}
}
return 0;
}
int main() {
int i;
long long int lo = 0, hi = 0, mi;
long long int sol;
cin.sync_with_stdio(false);
scanf("%d%d", &N, &M);
hi += N;
for (i = 1; i <= N; i++) {
scanf("%d", &pile[i]);
hi += pile[i];
}
sol = hi;
while (lo <= hi) {
mi = (lo + hi) / 2;
if (check(mi)) {
sol = min(sol, mi);
hi = mi - 1;
} else
lo = mi + 1;
}
printf("%lld\n", sol);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, d, k;
long long dist[400400], spot[400400];
int nxt;
vector<pair<int, int> > edges;
void solve(int lvl, int node) {
if (lvl == 0) return;
for (int i = 0; i < k - 1; i++) {
if (n == 0) return;
edges.push_back(pair<int, int>(node, nxt++));
n--;
solve(lvl - 1, nxt - 1);
}
}
int main() {
scanf("%d %d %d", &n, &d, &k);
if (k == 1) {
if (n > 2 || d > n - 1) {
printf("NO\n");
} else {
printf("YES\n");
if (n == 2) printf("1 2\n");
}
} else {
if (d > n - 1) {
printf("NO\n");
return 0;
}
for (int i = 1; i <= d; i++) {
edges.push_back(pair<int, int>(i, i + 1));
dist[i + 1] = min(i, d - i);
}
n -= d + 1;
if (n == 0) {
printf("YES\n");
for (pair<int, int> p : edges) printf("%d %d\n", p.first, p.second);
return 0;
}
if (k == 2)
printf("NO\n");
else {
spot[0] = 1;
for (int i = 1; i < 400400; i++) {
spot[i] = spot[i - 1] * (k - 1);
spot[i] = min(400400ll, spot[i]);
}
for (int i = 1; i < 400400; i++) {
spot[i] += spot[i - 1];
spot[i] = min(400400ll, spot[i]);
}
long long aux = 0;
for (int i = 2; i <= d; i++) {
aux += (k - 2) * spot[dist[i] - 1];
if (aux >= n) break;
}
if (aux < n) {
printf("NO\n");
return 0;
}
nxt = d + 2;
int pos = 2;
while (n) {
for (int i = 0; i < k - 2; i++) {
edges.push_back(pair<int, int>(pos, nxt));
n--;
nxt++;
solve(dist[pos] - 1, nxt - 1);
if (n == 0) break;
}
pos++;
}
printf("YES\n");
for (pair<int, int> p : edges) printf("%d %d\n", p.first, p.second);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 100;
const double PI = 3.14159;
vector<pair<long long, long long> > v;
long long n, m, k, c, ans = 2 * 1e9, l, r, x, y, t, a[N], b, price[105];
set<string> st;
string s, d;
bool flag, vis[105][105];
set<string>::iterator it;
map<int, char> mp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> price[i];
}
for (int i = 0; i < m; i++) {
cin >> x >> y;
x--;
y--;
vis[x][y] = true;
vis[y][x] = true;
v.push_back({x, y});
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (j != v[i].second && j != v[i].first && vis[v[i].first][j] &&
vis[v[i].second][j]) {
ans = min(ans, price[v[i].first] + price[v[i].second] + price[j]);
}
}
}
if (ans == (2 * 1e9))
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<char> > g;
int n, m;
vector<vector<int> > nxtcol1, prvcol1, nxtrow1, prvrow1;
int solve(int r, int c) {
int ret = 0;
while (true) {
if (r >= n || c >= m) break;
ret++;
int i = r, j = c;
if (g[r][c] == 'L') {
c = prvcol1[r][j];
nxtcol1[r][c] = nxtcol1[r][j];
prvcol1[r][nxtcol1[r][j]] = c;
nxtrow1[prvrow1[r][j]][j] = nxtrow1[r][j];
prvrow1[nxtrow1[r][j]][j] = prvrow1[r][j];
} else if (g[r][c] == 'R') {
c = nxtcol1[r][j];
prvcol1[r][c] = prvcol1[r][j];
nxtcol1[r][prvcol1[r][j]] = c;
nxtrow1[prvrow1[r][j]][j] = nxtrow1[r][j];
prvrow1[nxtrow1[r][j]][j] = prvrow1[r][j];
} else if (g[r][c] == 'U') {
r = prvrow1[r][c];
nxtrow1[r][c] = nxtrow1[i][c];
prvrow1[nxtrow1[i][c]][c] = r;
nxtcol1[i][prvcol1[i][c]] = nxtcol1[i][c];
prvcol1[i][nxtcol1[i][c]] = prvcol1[i][c];
} else if (g[r][c] == 'D') {
r = nxtrow1[r][c];
prvrow1[r][c] = prvrow1[i][c];
nxtrow1[prvrow1[i][c]][c] = r;
nxtcol1[i][prvcol1[i][c]] = nxtcol1[i][c];
prvcol1[i][nxtcol1[i][c]] = prvcol1[i][c];
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
g.resize(n + 5);
vector<vector<int> > nxtcol(n + 5, vector<int>(m + 5));
vector<vector<int> > prvcol(n + 5, vector<int>(m + 5));
vector<vector<int> > nxtrow(n + 5, vector<int>(m + 5));
vector<vector<int> > prvrow(n + 5, vector<int>(m + 5));
for (int i = 0; i < n; i++) {
g[i].resize(m + 5);
for (int j = 0; j < m; j++) cin >> g[i][j];
}
for (int i = 0; i < n; i++) {
int last = m;
for (int j = m - 1; j >= 0; j--) {
if (g[i][j] != '.') {
nxtcol[i][j] = last;
prvcol[i][last] = j;
last = j;
}
}
prvcol[i][last] = m + 1;
}
for (int i = 0; i < m; i++) {
int last = n;
for (int j = n - 1; j >= 0; j--) {
if (g[j][i] != '.') {
nxtrow[j][i] = last;
prvrow[last][i] = j;
last = j;
}
}
prvrow[last][i] = n + 1;
}
int ans = 0, cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (g[i][j] != '.') {
nxtcol1 = nxtcol;
prvcol1 = prvcol;
nxtrow1 = nxtrow;
prvrow1 = prvrow;
int temp = solve(i, j);
if (ans < temp)
ans = temp, cnt = 1;
else if (ans == temp)
cnt++;
}
}
}
cout << ans << " " << cnt << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool mini(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool maxi(T &a, T b) {
return a < b ? (a = b, true) : false;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
cout << fixed;
int test;
cin >> test;
while (test--) {
int n;
cin >> n;
vector<int> a(n);
vector<int> pos(n);
for (int i = 0; i < (int)(n); i++) cin >> a[i], a[i]--, pos[a[i]] = i;
vector<vector<int> > join(n);
vector<int> p(n);
for (int i = 0; i < (int)(n); i++) p[i] = i, join[i].push_back(i);
for (int i = 0; i < (int)(n); i++) {
int t = pos[i];
if (t > 0 && a[t - 1] < i) {
int u = p[t], v = p[t - 1];
if (u != v) {
if (join[u].size() > join[v].size()) swap(u, v);
for (int x : join[u]) p[x] = v, join[v].push_back(x);
}
}
if (t < n - 1 && a[t + 1] < i) {
int u = p[t], v = p[t + 1];
if (u != v) {
if (join[u].size() > join[v].size()) swap(u, v);
for (int x : join[u]) p[x] = v, join[v].push_back(x);
}
}
cout << ((int)join[p[t]].size() == i + 1);
}
cout << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] <= i + 1) ans = i + 1;
}
cout << ans + 1 << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[110], k;
int main() {
cin >> a[0] >> a[1] >> k;
for (int i = 2; i <= k; i++) a[i] = a[i - 1] + a[i - 2];
cout << a[k] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n], i, s, t, sum = 0, sum1 = 0, sum2 = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
sum = sum + a[i];
}
cin >> s >> t;
for (i = min(s, t) - 1; i < max(s, t) - 1; i++) {
sum2 = sum2 + a[i];
}
sum1 = sum - sum2;
cout << min(sum1, sum2);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; ++i) cin >> arr[i];
vector<int> best_by_dist(n);
int truecenter = n / 2 - (1 - n % 2);
for (int i = 1; i < n - 1; ++i) {
int dist = (1 - n % 2);
if (n % 2)
dist += abs(truecenter - i) * 2;
else
dist += min(abs(truecenter - i), abs(truecenter + 1 - i)) * 2;
int opt = max(best_by_dist[dist],
max(min(arr[i - 1], arr[i]), min(arr[i], arr[i + 1])));
best_by_dist[dist] = max(best_by_dist[dist], opt);
}
for (int i = 1; i < n - 2; ++i) {
int dist = n % 2;
if (n % 2)
dist += min(abs(truecenter - i), abs(truecenter - 1 - i)) * 2;
else
dist += abs(truecenter - i) * 2;
int opt = max(min(max(arr[i - 1], arr[i]), max(arr[i], arr[i + 1])),
min(max(arr[i], arr[i + 1]), max(arr[i + 1], arr[i + 2])));
best_by_dist[dist] = max(best_by_dist[dist], opt);
}
for (int i = 2; i < n; ++i) {
best_by_dist[i] = max(best_by_dist[i - 2], best_by_dist[i]);
}
int mx = *max_element(arr.begin(), arr.end());
best_by_dist[n - 2] = mx;
best_by_dist[n - 1] = mx;
for (auto i : best_by_dist) cout << i << " ";
cout << endl;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
const int INF = 0x3f;
int n, m, l, maxn;
int a[MAXN], b[MAXN], L[MAXN], R[MAXN], dp[MAXN];
int main() {
scanf("%d%d", &n, &m);
for (register int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (register int i = 1; i <= m; ++i) scanf("%d", &b[i]);
sort(a + 1, a + n + 1);
sort(b + 1, b + m + 1);
a[0] = a[1] - INF;
a[n + 1] = a[n] + INF;
for (register int i = 1; i <= n; ++i)
if (a[i] == a[i - 1] + 1)
L[i] = L[i - 1];
else
L[i] = i;
for (register int i = n; i >= 1; --i)
if (a[i] == a[i + 1] - 1)
R[i] = R[i + 1];
else
R[i] = i;
int limit = 0;
for (register int i = 1; i <= n; ++i) {
while (limit < m && b[limit + 1] <= a[i]) ++limit;
if (L[i] == i)
maxn = dp[i - 1] + (a[i] == b[limit]);
else
maxn = -0x3f3f3f3f;
if (maxn > dp[i]) dp[i] = maxn;
for (register int j = limit; j >= 1; --j) {
int k = i - a[i] + b[j];
if (k <= 0) break;
k = L[k];
if (dp[k - 1] + limit - j + 1 > dp[i]) dp[i] = dp[k - 1] + limit - j + 1;
if (dp[k - 1] + limit - j + 1 > maxn) maxn = dp[k - 1] + limit - j + 1;
}
for (register int j = limit + (b[limit] < a[i]); j <= m; ++j) {
int k = i - a[i] + b[j];
if (k > n) break;
k = R[k];
if (maxn + j - limit > dp[k]) dp[k] = maxn + j - limit;
}
if (dp[i] > dp[i + 1]) dp[i + 1] = dp[i];
}
printf("%d", dp[n]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long sum = 0, ff = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') ff = -1;
ch = getchar();
}
while (isdigit(ch)) sum = sum * 10 + (ch ^ 48), ch = getchar();
return sum * ff;
}
const long long N = 1e6 + 5;
const long long M = 1e4 + 5;
long long n, m, d[M], R, G, dis[M][1005], ans;
deque<pair<long long, long long> > q;
signed main() {
n = read();
m = read();
for (long long i = 1; i <= m; i++) d[i] = read();
G = read();
R = read();
sort(d + 1, d + m + 1);
memset(dis, -1, sizeof(dis));
q.push_front(make_pair(1, 0));
dis[1][0] = 0;
while (!q.empty()) {
pair<long long, long long> v = q.front();
q.pop_front();
if (v.first > 1) {
long long del = d[v.first] - d[v.first - 1] + v.second;
if (del < G) {
if (dis[v.first - 1][del] < 0) {
dis[v.first - 1][del] = dis[v.first][v.second];
q.push_front(make_pair(v.first - 1, del));
}
}
if (del == G) {
if (dis[v.first - 1][0] < 0) {
dis[v.first - 1][0] = dis[v.first][v.second] + 1;
q.push_back(make_pair(v.first - 1, 0));
}
}
}
if (v.first < m) {
long long del = d[v.first + 1] - d[v.first] + v.second;
if (del < G) {
if (dis[v.first + 1][del] < 0) {
dis[v.first + 1][del] = dis[v.first][v.second];
q.push_front(make_pair(v.first + 1, del));
}
}
if (del == G) {
if (dis[v.first + 1][0] < 0) {
dis[v.first + 1][0] = dis[v.first][v.second] + 1;
q.push_back(make_pair(v.first + 1, 0));
}
}
}
}
long long ans = -1;
for (long long i = 0; i < G; i++) {
if (dis[m][i] < 0) continue;
long long gs = dis[m][i];
long long tim = 1ll * gs * (R + G) + i;
if (!i && dis[m][i]) tim -= R;
if (ans < 0 || ans > tim) ans = tim;
}
printf("%lld\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <typename T>
struct segtree {
using Type = T;
using DeltaType = T;
const T zero;
const function<T(T, T)> combine;
const int size;
vector<T> tree;
segtree(T zero, const function<T(T, T)>& combine, int size)
: zero(zero),
combine(combine),
size(size + 1),
tree(2 * (size + 1), zero) {}
void update(int i, T x) {
for (tree[i += size] = x; i >>= 1;)
tree[i] = combine(tree[i << 1], tree[(i << 1) | 1]);
}
T query(int a, int b) {
T ans_l = zero, ans_r = zero;
for (a += size, b += size + 1; a < b; a >>= 1, b >>= 1) {
if (a & 1) ans_l = combine(ans_l, tree[a++]);
if (b & 1) ans_r = combine(tree[--b], ans_r);
}
return combine(ans_l, ans_r);
}
};
template <typename T>
ostream& operator<<(ostream& os, segtree<T>& t) {
os << "[";
bool comma = false;
for (int i = 0; i <= t.size; i++) {
if (comma)
os << ", ";
else
comma = true;
os << t.query(i, i);
}
os << "]";
return os;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k;
cin >> n >> k;
vector<segtree<int>> s_min(1 << k,
segtree<int>(
numeric_limits<int>::max(),
[](int x, int y) { return min(x, y); }, n));
vector<segtree<int>> s_max(1 << k,
segtree<int>(
numeric_limits<int>::min(),
[](int x, int y) { return max(x, y); }, n));
auto read_point = [&](int i) {
vector<int> pt(k);
for (int j = 0; j < k; j++) {
cin >> pt[j];
}
for (int mask = 0; mask < 1 << k; mask++) {
int val = 0;
for (int j = 0; j < k; j++) {
val += (mask & (1 << j)) ? pt[j] : -pt[j];
}
s_min[mask].update(i, val);
s_max[mask].update(i, val);
}
};
for (int i = 1; i <= n; i++) {
read_point(i);
}
int q;
cin >> q;
while (q--) {
int type;
cin >> type;
if (type == 1) {
int i;
cin >> i;
read_point(i);
} else {
int L, R;
cin >> L >> R;
int ans = 0;
for (int mask = 0; mask < 1 << k; mask++) {
ans = max(ans, abs(s_min[mask].query(L, R) - s_max[mask].query(L, R)));
}
cout << ans << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100005], pos[100005];
void solve() {
cin >> n;
for (int i = 1; i < n + 1; i++) {
cin >> a[i];
pos[a[i]] = i;
}
int last = n;
for (int i = 1; i < n + 1; i++) {
int cur = i, p = pos[i];
while (p <= last and pos[cur] == p) cur++, p++;
if (p != last + 1) {
cout << "No" << '\n';
return;
}
last = pos[i] - 1;
i = cur - 1;
}
cout << "Yes" << '\n';
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct prs {
int s1, s2;
prs operator+(prs u) const { return (prs){s1 + u.s1, s2 + u.s2}; }
prs operator-(prs u) const { return (prs){s1 - u.s1, s2 - u.s2}; }
void operator+=(prs u) { *this = *this + u; }
bool operator<(prs u) const {
if (s1 != u.s1) return s1 < u.s1;
return s2 < u.s2;
}
};
int n;
vector<pair<int, int> > G[100010];
int s[100010];
prs dp[100010][2];
prs ans[100010];
int ans1, ans2;
int to[100010];
int dep[100010];
int up[100010];
int m;
void solve(int x, int p) {
dp[x][0] = dp[x][1] = (prs){0, 0};
for (int i = 0; i < (int)G[x].size(); i++) {
int y = G[x][i].first, id = G[x][i].second;
if (id == p || id == m) continue;
solve(y, id);
dp[x][0] += max(dp[y][0], dp[y][1]);
}
for (int i = 0; i < (int)G[x].size(); i++) {
int y = G[x][i].first, id = G[x][i].second;
if (id == p || id == m) continue;
prs t = (prs){1, s[x] != s[y]};
prs val = dp[x][0] + dp[y][0] - max(dp[y][0], dp[y][1]) + t;
if (dp[x][1] < val) dp[x][1] = val, to[x] = y;
}
}
void getans(int x, int st, int p) {
for (int i = 0; i < (int)G[x].size(); i++) {
int y = G[x][i].first, id = G[x][i].second;
if (id == p || id == m) continue;
if (!st || to[x] != y) {
if (dp[y][1] < dp[y][0])
getans(y, 0, id);
else
getans(y, 1, id);
} else {
ans[++ans1] = (prs){x, y};
if (s[x] != s[y]) ans2++;
getans(y, 0, id);
}
}
}
void dfs(int x, int p) {
dep[x]++;
for (int i = 0; i < (int)G[x].size(); i++) {
int y = G[x][i].first, id = G[x][i].second;
if (id == p) continue;
if (!dep[y]) {
up[y] = id;
dep[y] = dep[x];
dfs(y, id);
} else if (dep[y] < dep[x]) {
prs r1, r2;
int s1, s2;
m = id;
solve(x, 0);
if (dp[x][1] < dp[x][0])
r1 = dp[x][0], s1 = 0;
else
r1 = dp[x][1], s1 = 1;
m = up[x];
solve(x, 0);
if (dp[x][1] < dp[x][0])
r2 = dp[x][0], s2 = 0;
else
r2 = dp[x][1], s2 = 1;
if (r2 < r1) {
m = id;
solve(x, 0);
getans(x, s1, 0);
} else
getans(x, s2, 0);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int f;
scanf("%d%d", &f, s + i);
G[f].push_back(make_pair(i, i));
G[i].push_back(make_pair(f, i));
}
for (int i = 1; i <= n; i++) {
if (dep[i]) continue;
dfs(i, 0);
}
printf("%d %d\n", ans1, ans2);
for (int i = 1; i <= ans1; i++) printf("%d %d\n", ans[i].s1, ans[i].s2);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int n, q, a[5005], mxf[5005][5005];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", a + i);
}
for (int i = 1; i <= n; ++i) mxf[i][i] = a[i];
for (int i = 1; i < n; ++i) mxf[i][i + 1] = a[i] ^ a[i + 1];
for (int k = 1; (1 << k) <= n; ++k) {
for (int i = 1; i <= (1 << k); ++i) {
for (int l = 1; l + (1 << k) + i - 1 <= n; ++l) {
mxf[l][l + (1 << k) + i - 1] =
mxf[l][l + i - 1] ^ mxf[l + (1 << k)][l + (1 << k) + i - 1];
}
}
}
for (int sz = 2; sz <= n; ++sz) {
for (int l = 1; l + sz - 1 <= n; ++l) {
mxf[l][l + sz - 1] = max(mxf[l][l + sz - 1],
max(mxf[l + 1][l + sz - 1], mxf[l][l + sz - 2]));
}
}
scanf("%d", &q);
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", mxf[l][r]);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int id, val;
} a[200005], b[200005];
bool cmp1(node x, node y) { return x.val > y.val; }
bool cmp2(node x, node y) { return x.val < y.val; }
bool cmp3(node x, node y) { return x.id < y.id; }
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i].val;
a[i].id = i;
}
for (int i = 0; i < n; i++) {
cin >> b[i].val;
b[i].id = i;
}
sort(a, a + n, cmp1);
sort(b, b + n, cmp2);
for (int i = 0; i < n; i++) {
b[i].val = a[i].val;
}
sort(b, b + n, cmp3);
for (int i = 0; i < n; i++) {
cout << b[i].val << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 20;
const long long inf = 1e16;
void print(vector<long long> v, long long n) {
for (long long i = 0; i < n; i++) {
cout << v[i] << " ";
}
}
void run() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
}
int32_t main() {
run();
long long n, x, y;
cin >> n >> x >> y;
long long z = x;
z = z - (n - 1);
z = ceil(sqrt(z));
if (x <= n and y >= n) z = 1;
if (y >= (z + n - 1) and z > 0) {
cout << z;
cout << "\n";
for (long long i = 0; i < n - 1; i++) cout << 1 << endl;
} else
cout << -1;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 2e5 + 10;
int a;
int n;
int L[N];
int po[N];
double p[N];
double rp[N];
int cnt[N];
double ans = 0;
void init() {
for (int i = 1; i < N; i++) {
cnt[i] = cnt[i >> 1] + (i & 1);
}
}
void solve() {
int mask = (1 << n) - 1;
p[0] = 1;
for (int i = 0; i < n; i++) p[1 << i] = po[i] / 10.0;
for (int i = 1; i <= mask; i++) p[i] = p[i - (i & -i)] * p[i & -i];
rp[0] = 1;
for (int i = 0; i < n; i++) rp[1 << i] = 1.0 - po[i] / 10.0;
for (int i = 1; i <= mask; i++) rp[i] = rp[i - (i & -i)] * rp[i & -i];
double sum = 0;
for (int i = 0; i <= mask; i++) {
double tot = p[i] * rp[mask ^ i];
if (cnt[i] * 2 > n)
sum += tot;
else {
int s = 0;
for (int j = 0; j < n; j++) {
if (i >> j & 1) continue;
s += L[j];
}
sum += tot * a / (a + s);
}
}
ans = max(ans, sum);
}
void dfs(int cur, int k) {
if (cur == n) {
if (k != 0) return;
solve();
return;
}
int maxv = min(k, 10 - po[cur]);
for (int i = 0; i <= maxv; i++) {
po[cur] = po[cur] + i;
dfs(cur + 1, k - i);
po[cur] = po[cur] - i;
}
}
int main() {
init();
int k;
cin >> n >> k >> a;
int tot = 0;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
y /= 10;
L[i] = x;
po[i] = y;
tot += 10 - y;
}
k = min(tot, k);
dfs(0, k);
printf("%.15f\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 5, inf = 1e9 + 7;
long long n, k, i, j;
long long A[N], pre[N], ans[N];
unordered_map<long long, long long> m;
std::vector<pair<pair<long long, long long>, long long> > v;
vector<long long> bit(N);
void upd(long long first, long long val) {
for (; first <= n; first += (first & -first)) bit[first] ^= val;
}
long long qu(long long first) {
long long res = 0;
for (; first > 0; first -= (first & -first)) res ^= bit[first];
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long i, j, a, b;
cin >> n;
m.reserve(128);
m.max_load_factor(0.25);
for (i = 1; i < n + 1; i++) cin >> A[i], pre[i] = pre[i - 1] ^ A[i];
cin >> k;
for (i = 0; i < k; i++) {
cin >> a >> b;
v.emplace_back(pair<pair<long long, long long>, long long>(
pair<long long, long long>(b, a), i));
}
sort(v.begin(), v.end());
long long cur = 1;
for (auto q : v) {
while (cur <= q.first.first) {
if (m[A[cur]]) upd(m[A[cur]], A[cur]);
upd(cur, A[cur]);
m[A[cur]] = cur;
cur++;
}
ans[q.second] = qu(q.first.first) ^ qu(q.first.second - 1) ^
pre[q.first.first] ^ pre[q.first.second - 1];
}
for (i = 0; i < k; i++) cout << ans[i] << "\n";
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
mt19937 gen(chrono::system_clock::now().time_since_epoch().count());
const int M = 1e9 + 7;
const int FFTM = 998244353;
const int N = 1e5 + 7;
int X;
struct node {
long long res;
vector<pair<int, int> > pref, suff;
node() { res = 0; }
node(int x) {
res = (x >= X);
pref.push_back({x, 1});
suff.push_back({x, 1});
}
node operator+(const node &r) {
node ret;
ret.res = res + r.res;
ret.pref = pref;
for (auto it : r.pref) {
if (!ret.pref.empty() &&
(it.first | ret.pref.back().first) == ret.pref.back().first)
ret.pref.back().second += it.second;
else
ret.pref.push_back(
{it.first | (ret.pref.empty() ? 0 : ret.pref.back().first),
it.second});
}
ret.suff = r.suff;
for (auto it : suff) {
if (!ret.suff.empty() &&
(it.first | ret.suff.back().first) == ret.suff.back().first)
ret.suff.back().second += it.second;
else
ret.suff.push_back(
{it.first | (ret.suff.empty() ? 0 : ret.suff.back().first),
it.second});
}
int j = suff.size() - 1;
int cur = 0;
for (auto it : r.pref) {
while (j >= 0 && (it.first | suff[j].first) >= X) cur += suff[j--].second;
ret.res += 1ll * it.second * cur;
}
return ret;
}
};
struct segtree {
int tn = 1;
vector<node> t;
void resize(int n) {
tn = 1;
while (tn <= n) tn <<= 1;
t.resize(tn << 1 | 1);
}
segtree() {}
void upd(int p, int x) {
for (t[p += tn] = node(x); p > 1; p >>= 1)
t[p >> 1] = ((p & 1) ? t[p ^ 1] + t[p] : t[p] + t[p ^ 1]);
}
node q(int v, int tl, int tr, int l, int r) {
if (tr <= l || r <= tl) return node();
if (l <= tl && tr <= r) return t[v];
int m = (tl + tr) >> 1;
return q(v << 1, tl, m, l, r) + q(v << 1 | 1, m, tr, l, r);
}
node q(int l, int r) { return q(1, 0, tn, l, r); }
};
int n, q, p, x, l, r, T;
segtree t;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> q >> X;
t.resize(n);
for (int i = 0; i < n; i++) cin >> x, t.upd(i, x);
while (q--) {
cin >> T;
if (T == 1) {
cin >> p >> x;
p--;
t.upd(p, x);
}
if (T == 2) {
cin >> l >> r;
l--;
cout << t.q(l, r).res << '\n';
}
}
return 0;
}
| 9 |
#include <iostream>
using namespace std;
typedef long long ll;
int MOD = 1;
struct Modint {
ll val;
Modint (ll _val = 0)
: val(_val % MOD) {}
Modint operator+ (Modint other) const {
return Modint(val + other.val);
}
void operator+= (Modint other) {
val += other.val;
val %= MOD;
}
Modint operator- () const {
return Modint(MOD - val);
}
Modint operator- (Modint other) const {
return Modint(val + MOD - other.val);
}
void operator-= (Modint other) {
val += MOD - other.val;
val %= MOD;
}
Modint operator* (Modint other) const {
return Modint(val * other.val);
}
void operator*= (Modint other) {
val *= other.val;
val %= MOD;
}
bool operator== (Modint other) const {
return val == other.val;
}
bool operator!= (Modint other) const {
return val != other.val;
}
};
Modint exp (Modint a, int k) {
if (k == 0) {
return Modint(1);
} else if (k % 2 == 0) {
Modint half = exp(a, k / 2);
return half * half;
} else {
return a * exp(a, k - 1);
}
}
Modint inv (Modint a) {
return exp(a, MOD - 2);
}
ostream& operator<< (ostream& out, Modint p) {
out << p.val;
return out;
}
const int MAX_N = 405;
Modint choose [MAX_N][MAX_N];
Modint conc [MAX_N]; // # of concave permutations length n
Modint dp [MAX_N][MAX_N][2]; // length, # picked, last picked
int main () {
ios::sync_with_stdio(false);
int n;
cin >> n >> MOD;
choose[0][0] = Modint(1);
for (int i = 1; i < MAX_N; i++) {
choose[i][0] = Modint(1);
for (int j = 1; j < MAX_N; j++) {
choose[i][j] = choose[i - 1][j - 1] + choose[i - 1][j];
}
}
for (int i = 1; i < MAX_N; i++) {
for (int j = 0; j < i; j++) {
int l = j;
int r = i - j - 1;
conc[i] += choose[l + r][l];
}
}
dp[0][0][0] = Modint(1);
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= i; j++) {
dp[i][j][0] = dp[i - 1][j][1];
for (int k = 1; k <= j; k++) {
dp[i][j][1] += dp[i - k][j - k][0] * choose[j][k] * conc[k];
}
}
}
Modint ans (0);
for (int j = 0; j <= n; j++) {
ans += dp[n][j][1];
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[111][111];
bool f, f1, f2;
int main(void) {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int x = 1; x <= m; x++)
for (int y = x; y <= m; y++) {
f = true;
for (int d = 1; d <= n; d++) {
f1 = false;
swap(a[d][x], a[d][y]);
for (int i = 1; i <= m; i++)
for (int j = i; j <= m; j++)
if (f1 == false) {
swap(a[d][i], a[d][j]);
f2 = true;
for (int p = 1; p <= m; p++)
if (a[d][p] != p) {
f2 = false;
break;
}
swap(a[d][i], a[d][j]);
if (f2 == true) {
f1 = true;
break;
}
}
swap(a[d][x], a[d][y]);
if (f1 == false) {
f = false;
break;
}
}
if (f == true) {
cout << "YES" << endl;
return 0;
}
}
cout << "NO" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
long long int power(long long int a, long long int b,
long long int m = 1000000007) {
long long int ans = 1;
a = a % m;
while (b > 0) {
if (b & 1) ans = (1LL * a * ans) % m;
b >>= 1;
a = (1LL * a * a) % m;
}
return ans;
}
long long int ncr(long long int n, long long int r) {
long long int res = 1;
if (r > n - r) r = n - r;
for (long long int i = 0; i < r; i++) {
res *= n - i;
res /= i + 1;
}
return res;
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
bool check(double d, vector<double> &a) {
double f = a.front();
for (long long int i = 0; i < 3; i++) {
auto it = lower_bound(a.begin(), a.end(), f + 2 * d);
if (it == a.end())
return true;
else {
if (*it > f + 2 * d)
f = *it;
else {
it++;
if (it == a.end())
return true;
else
f = *it;
}
}
}
return false;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int tt = 1;
long long int ii = 0;
while (tt-- && ++ii) {
long long int n;
cin >> n;
set<long long int> temp;
for (long long int i = 0; i < n; i++) {
long long int x;
cin >> x;
temp.insert(x);
}
vector<double> a;
for (auto x : temp) a.emplace_back(x);
double lo = 0, hi = a.back();
while ((hi - lo) > 1e-7) {
double mid = (hi + lo) / 2;
if (check(mid, a))
hi = mid;
else
lo = mid;
}
double val = hi;
cout << fixed << setprecision(7) << val << "\n";
double f = a.front();
for (long long int i = 0; i < 3; i++) {
cout << f + val << " ";
auto it = lower_bound(a.begin(), a.end(), f + 2 * val);
if (*it - (f + 2 * val) > 1e-7)
f = *it;
else {
it++;
if (it == a.end())
f = a.back();
else
f = *it;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, coe = 1, res = 0;
cin >> n;
--n;
do {
res += (n + 1) / 2 * coe;
n >>= 1;
coe <<= 1;
} while (n);
return cout << res, 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int Maxn = 5e5 + 5;
const int N = 4e5 + 5;
const int M = 26;
int read() {
int s = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
s = s * 10 + c - '0';
c = getchar();
}
return s * f;
}
char s[N];
long long Ans[Maxn];
vector<int> G[N];
int n, m, pos[N], Len[N], Root[N], p[N][20];
struct Tree {
int l, r;
long long sum;
};
struct Segment_Tree {
int tot;
Tree t[N * 20];
void Update(int x, int &p, int l, int r) {
if (!p) p = ++tot;
t[p].sum++;
if (l == r) return;
int mid = (l + r) >> 1;
if (x <= mid) Update(x, t[p].l, l, mid);
if (x > mid) Update(x, t[p].r, mid + 1, r);
}
int Merge(int x, int y) {
if (!x || !y) return x | y;
t[x].sum += t[y].sum;
t[x].l = Merge(t[x].l, t[y].l);
t[x].r = Merge(t[x].r, t[y].r);
return x;
}
long long Query(int x, int y, int p, int l, int r) {
if (y < l || x > r || !p) return 0;
if (x <= l && r <= y) return t[p].sum;
int mid = (l + r) >> 1;
return Query(x, y, t[p].l, l, mid) + Query(x, y, t[p].r, mid + 1, r);
}
} tree;
struct SAM {
int tot = 1, lst = 1, root = 1;
int fa[N], ch[N][M], len[N];
void Insert(int num, int id) {
int x = lst, fx = ++tot;
len[fx] = len[x] + 1;
while (x && !ch[x][num]) {
ch[x][num] = fx;
x = fa[x];
}
if (!x)
fa[fx] = root;
else {
int y = ch[x][num];
if (len[y] == len[x] + 1)
fa[fx] = y;
else {
int fy = ++tot;
len[fy] = len[x] + 1;
fa[fy] = fa[y];
fa[y] = fa[fx] = fy;
memcpy(ch[fy], ch[y], sizeof(ch[fy]));
while (x && ch[x][num] == y) {
ch[x][num] = fy;
x = fa[x];
}
}
}
lst = fx;
tree.Update(id, Root[lst], 1, n);
}
void Build() {
for (int i = 2; i <= tot; i++) G[fa[i]].push_back(i);
for (int i = 1; i <= tot; i++) p[i][0] = fa[i];
for (int j = 1; j < 20; j++) {
for (int i = 1; i <= tot; i++) p[i][j] = p[p[i][j - 1]][j - 1];
}
}
} sam;
struct Node {
int l, r, id;
};
vector<Node> Q[N];
void DFS(int x) {
for (auto y : G[x]) {
DFS(y);
Root[x] = tree.Merge(Root[x], Root[y]);
}
for (auto F : Q[x]) Ans[F.id] = tree.Query(F.l, F.r, Root[x], 1, n);
}
int main() {
n = read();
m = read();
for (int i = 1; i <= n; i++) {
scanf("%s", s + 1);
int len = strlen(s + 1);
sam.lst = 1;
for (int j = 1; j <= len; j++) sam.Insert(s[j] - 'a', i);
pos[i] = sam.lst;
Len[i] = len;
}
sam.Build();
for (int i = 1; i <= n; i++) {
for (int j = 19; j >= 0; j--) {
if (sam.len[p[pos[i]][j]] >= Len[i]) pos[i] = p[pos[i]][j];
}
}
for (int i = 1; i <= m; i++) {
int l = read(), r = read(), k = read();
Q[pos[k]].push_back((Node){l, r, i});
}
DFS(1);
for (int i = 1; i <= m; i++) printf("%lld\n", Ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
long long oll = 0;
bool comp(const pair<int, int> &a, const pair<int, int> &b) {
return a.first < b.first;
}
int degree[200000 + 1], power[200000 + 1];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (long long i = (int)0; i < (int)m; i++) {
int u, v;
cin >> u >> v;
int mx = max(u, v);
int mn = min(u, v);
degree[mx]++, degree[mn]++;
power[mx]++;
}
int cnt = 0;
for (long long i = (int)1; i < (int)n + 1; i++)
if (degree[i] == power[i]) cnt++;
int q;
cin >> q;
while (q--) {
int mode;
cin >> mode;
if (mode == 1) {
int u, v;
cin >> u >> v;
if (degree[u] == power[u]) cnt--;
if (degree[v] == power[v]) cnt--;
degree[u]++, degree[v]++;
power[max(u, v)]++;
if (degree[u] == power[u]) cnt++;
if (degree[v] == power[v]) cnt++;
} else if (mode == 2) {
int u, v;
cin >> u >> v;
if (degree[u] == power[u]) cnt--;
if (degree[v] == power[v]) cnt--;
degree[u]--, degree[v]--;
power[max(u, v)]--;
if (degree[u] == power[u]) cnt++;
if (degree[v] == power[v]) cnt++;
} else if (mode == 3) {
cout << cnt << "\n";
}
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std ;
#define rep( i, s, t ) for( register int i = (s); i <= (t); ++ i )
#define drep( i, s, t ) for( register int i = (t); i >= (s); -- i )
#define re register
#define mp make_pair
#define pi pair<int, int>
#define pb push_back
#define vi vector<int>
#define int long long
int gi() {
char cc = getchar() ; int cn = 0, flus = 1 ;
while( cc < '0' || cc > '9' ) { if( cc == '-' ) flus = - flus ; cc = getchar() ; }
while( cc >= '0' && cc <= '9' ) cn = cn * 10 + cc - '0', cc = getchar() ;
return cn * flus ;
}
const int P = 998244353 ;
int fpow(int x, int k) {
int ans = 1, base = x ;
while(k) {
if(k & 1) ans = ans * base % P ;
base = base * base % P, k >>= 1 ;
} return ans ;
}
const int N = 1000 + 5 ;
int n, m, a[N] ;
void inc(int &x, int y) { ((x += y) >= P) && (x -= P) ; }
void dec(int &x, int y) { ((x -= y) < 0) && (x += P) ; }
signed main() {
m = gi() ; int ans = 0 ;
rep( i, 1, m ) a[i] = gi(), n += a[i] ;
rep( i, 1, m ) {
int pre = 1, f = 1, g = 1 ;
for(int x = 1; x < a[i]; ++ x) {
f = f * (n - x) % P,
g = g * (n - x) % P,
pre = pre * (2 * n - x) % P,
inc(f, pre) ;
}
ans = (ans + f * fpow(g, P - 2)) % P ;
}
int pre = 1, f = 1, g = 1 ;
for(int x = 1; x < n; ++ x) {
f = f * (n - x) % P,
g = g * (n - x) % P,
pre = pre * (2 * n - x) % P,
inc(f, pre) ;
}
ans = (f * fpow(g, P - 2) + P - ans) % P ;
cout << ans * 2 % P << endl ;
return 0 ;
} | 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 111;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int main() {
int c, d, n, m, k;
cin >> c >> d >> n >> m >> k;
int s = n * m - k;
int ans;
if (s <= 0) {
ans = 0;
} else {
ans = (s / n) * min(c, d * n) + min(c, (s % n) * d);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
long laws[200010];
long long s[200010];
struct node {
long long maxx;
int id;
};
node sp[200010];
void Input() {
memset(s, 0, sizeof(s));
cin >> n >> k;
for (int i = 1; i <= n; i++) {
cin >> laws[i];
s[i] = laws[i];
}
for (int i = 2; i <= n; i++) {
s[i] += s[i - 1];
}
memset(sp, 0, sizeof(sp));
}
void solve() {
long long sum = 0;
int pos1 = 0, pos2 = 0;
for (int i = k; i <= n; i++) {
if (s[i] - s[i - k] > sp[i - 1].maxx) {
sp[i].maxx = s[i] - s[i - k];
sp[i].id = i;
} else {
sp[i].maxx = sp[i - 1].maxx;
sp[i].id = sp[i - 1].id;
}
if (s[i] - s[i - k] + sp[i - k].maxx > sum) {
sum = s[i] - s[i - k] + sp[i - k].maxx;
pos1 = sp[i - k].id - k + 1;
pos2 = i - k + 1;
}
}
cout << pos1 << ' ' << pos2 << endl;
}
int main() {
Input();
solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int ans = 0;
for (long long int i = 1; i <= n; i++) {
ans += pow(2, i);
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 210, B = 1e9 + 7;
int n;
long long x[N], y[N], d[N][N];
bool fl[N][N];
long long cross(long long x, long long y, long long xx, long long yy) {
return x * yy - xx * y;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%lld%lld", x + i, y + i);
x[n] = x[0];
y[n] = y[0];
long long area = 0;
for (int k = 0; k < n; ++k) area += cross(x[k], y[k], x[k + 1], y[k + 1]);
if (area < 0) {
reverse(x, x + n + 1);
reverse(y, y + n + 1);
}
for (int i = 0; i < n; ++i) {
d[i][i + 1] = 1;
}
for (int k = 2; k < n; ++k) {
for (int i = 0; i + k <= n; ++i) {
int b = i + k;
for (int j = i; j <= b; ++j) {
if (cross(x[i] - x[j], y[i] - y[j], x[b] - x[j], y[b] - y[j]) < 0)
d[i][b] = (d[i][b] + d[i][j] * d[j][b] % B) % B;
}
}
}
printf("%lld\n", d[0][n - 1]);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char n[12], m[12];
cin >> n >> m;
if (n[0] == '0') {
if (strcmp(m, "0") == 0)
cout << "OK";
else
cout << "WRONG_ANSWER";
return 0;
}
if (m[0] == '0') {
cout << "WRONG_ANSWER";
return 0;
}
sort(n, n + strlen(n));
int zero = 0;
for (int i = 0; i < strlen(n); ++i)
if (n[i] == '0') zero++;
char sol[12];
int k = 0;
for (int i = 0; i < strlen(n); ++i) {
if (k != 0) {
sol[k++] = n[i];
} else if (k == 0 && n[i] != '0') {
sol[k++] = n[i];
for (int j = 0; j < zero; ++j) sol[k++] = '0';
}
}
sol[k] = '\0';
if (strcmp(m, sol) == 0)
cout << "OK";
else
cout << "WRONG_ANSWER";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 33;
double f[N][N], g[N][N];
int T[N], p[N];
int main() {
int n, K;
scanf("%d%d", &n, &K);
for (int i = 1; i <= n; ++i) scanf("%d", T + i);
memset(f, 0, sizeof(f));
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) f[i][j] = T[i] > T[j];
for (int k = 1; k <= K; ++k) {
memset(g, 0, sizeof(g));
for (int a = 1; a <= n; ++a) {
for (int b = a; b <= n; ++b) {
for (int i = 1; i <= n; ++i) p[i] = i;
for (int i = a, j = b; i <= j; ++i, --j) swap(p[i], p[j]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) g[p[i]][p[j]] += f[i][j];
}
}
int tot = n * (n + 1) / 2;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) f[i][j] = g[i][j] / tot;
}
double ans = 0;
for (int i = 1; i <= n; ++i)
for (int j = i; j <= n; ++j) ans += f[i][j];
printf("%.13f\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long max3 = 1003;
const long long max4 = 10004;
const long long max5 = 100005;
const long long max6 = 1000006;
const long long max7 = 10000007;
const long long lg4 = 13;
const long long lg5 = 17;
const long long lg6 = 20;
const long long INF = 2LL * 1000000000;
const long long INFLL = 9LL * 1000000000 * 1000000000;
const long long M = 1e9 + 7;
long long powmod(long long a, long long b, long long mod) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
}
return res;
}
long long gcd(long long a, long long b) {
while (b > 0) {
long long t = a % b;
a = b, b = t;
}
return a;
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long is_prime(long long n) {
if (n <= 1 || n > 3 && (n % 2 == 0 || n % 3 == 0)) return 0;
for (long long i = 5, t = 2; i * i <= n; i += t, t = 6 - t)
if (n % i == 0) return 0;
return 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
long long p, k;
cin >> p >> k;
vector<long long> v;
long long base = -k;
while (p != 0) {
long long rem = p % base;
p /= base;
if (rem < 0) {
rem += -base;
p++;
}
v.push_back(rem);
}
cout << (int)v.size() << "\n";
for (int i = 0; i < (int)v.size(); i++) cout << v[i] << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int power(int a, int b) {
int x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = y * x;
}
y = y * y;
b /= 2;
}
return x;
}
int main() {
int k, b, n, t;
cin >> k >> b >> n >> t;
long long int x = 1;
while (n) {
x = k * x + b;
if (x > t) break;
n--;
}
cout << n;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, P = 998244353;
int T, n, jc[N], jcv[N];
char s[N];
int main() {
int up = 1e5; jc[0] = 1; for(int i = 1; i <= up; i++) jc[i] = 1ll * jc[i - 1] * i % P;
jcv[up] = 812950533; for(int i = up - 1; i >= 0; i--) jcv[i] = 1ll * jcv[i + 1] * (i + 1) % P;
scanf("%d", &T);
while(T--) {
scanf("%d%s", &n, s + 1); int c0 = 0, c1 = 0;
for(int i = 1; i <= n; i++) {
if(s[i] == '0') c0++;
else if(s[i + 1] == '1') c1++, i++;
}
printf("%d\n", 1ll * jc[c0 + c1] * jcv[c0] % P * jcv[c1] % P);
}
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
int a[10000000], b[10000000], memo[10000000], pos[10000000];
int min(int l, int r) {
if (l <= r) {
return l;
}
return r;
}
int main() {
int n, m, i, j, k, ind, p, l, x;
fscanf(stdin, "%d %d", &n, &m);
for (i = 1; i <= n; i++) {
fscanf(stdin, "%d", &a[i]);
}
i = 1;
ind = 1;
while (i <= n) {
j = i;
k = a[i];
memo[ind] = k;
pos[ind] = i;
while (j <= n && a[j] == k) {
b[j] = ind;
j++;
}
i = j;
ind++;
}
for (i = 1; i <= m; i++) {
fscanf(stdin, "%d %d %d", &p, &l, &x);
if (b[p] == b[l]) {
if (x == a[p]) {
cout << "-1" << endl;
} else {
cout << p << endl;
}
} else {
ind = b[p];
if (memo[b[p]] != x) {
cout << p << endl;
} else {
ind = 1;
while (pos[b[p] + ind] == x) {
ind++;
}
cout << pos[b[p] + ind] << endl;
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, ans = 0;
cin >> n;
vector<pair<long long, long long>> a(n);
for (int i = 0; i < n; i++) cin >> a[i].first >> a[i].second;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (i != j && a[i].second == a[j].first) {
a[j].first = -1;
ans++;
}
cout << n - ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int s(long long int x) {
long long int ret = 0;
while (x != 0) {
ret += x % 10;
x /= 10;
}
return ret;
}
long long int d(long long int x) {
if (x <= 9)
return x;
else
return d(s(x));
}
bool isprime[1000005];
long long int spf[1000005];
void sieve() {
for (long long int i = 2; i < 1000005; i++) {
if (spf[i] == 0) {
for (long long int j = i; j < 1000005; j += i) {
if (spf[j] == 0) spf[j] = i;
}
}
}
}
long long int num_divisors(long long int n) {
map<long long int, long long int> ma;
while (n != 1) {
ma[spf[n]]++;
n = n / spf[n];
}
long long int ret = 1;
for (auto i : ma) ret *= (1 + i.second);
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int TESTS = 1;
while (TESTS--) {
long long int n;
cin >> n;
long long int arr[10];
memset(arr, 0, sizeof(arr));
for (long long int i = 1; i <= n; i++) arr[d(i)]++;
long long int ans = 0;
for (long long int i = 1; i <= 9; i++) {
for (long long int j = 1; j <= 9; j++) {
ans += arr[i] * arr[j] * arr[d(i * j)];
}
}
sieve();
for (long long int i = 1; i <= n; i++) ans -= num_divisors(i);
cout << ans;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
map<int, int> sum_sweets;
vector<int> sweets;
for (int i = 0; i < n; i++) {
int s;
cin >> s;
sweets.push_back(s);
}
for (int i = 0; i < sweets.size() - 1; i++) {
for (int j = i + 1; j < sweets.size(); j++) {
int sum = sweets[i] + sweets[j];
if (sum_sweets.count(sum) == 0)
sum_sweets.insert(pair<int, int>(sum, 1));
else
sum_sweets[sum]++;
}
}
int m = 0;
for (auto i : sum_sweets) {
m = max(m, i.second);
}
cout << m;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void _fill_int(int* p, int val, int rep) {
int i;
for (i = 0; i < rep; i++) p[i] = val;
}
signed long long GETi() {
signed long long i;
scanf("%lld", &i);
return i;
}
int H, W, T;
int P, U, D;
int V[301][301];
int ML[301][301], MR[301][301], MU[301][301], MD[301][301];
void solve() {
int f, i, j, k, l;
int x, y, x1, x2, y1, y2;
int best = 1 << 30;
int bx1, bx2, by1, by2;
cin >> H >> W >> T;
cin >> P >> U >> D;
for (y = 0; y < H; y++)
for (x = 0; x < W; x++) cin >> V[y][x];
for (y = 0; y < H; y++) {
for (x = 1; x < W; x++) {
if (V[y][x] < V[y][x - 1]) MR[y][x] = MR[y][x - 1] + D;
if (V[y][x] == V[y][x - 1]) MR[y][x] = MR[y][x - 1] + P;
if (V[y][x] > V[y][x - 1]) MR[y][x] = MR[y][x - 1] + U;
}
for (x = W - 2; x >= 0; x--) {
if (V[y][x] < V[y][x + 1]) ML[y][x] = ML[y][x + 1] + D;
if (V[y][x] == V[y][x + 1]) ML[y][x] = ML[y][x + 1] + P;
if (V[y][x] > V[y][x + 1]) ML[y][x] = ML[y][x + 1] + U;
}
}
for (x = 0; x < W; x++) {
for (y = 1; y < H; y++) {
if (V[y][x] < V[y - 1][x]) MD[y][x] = MD[y - 1][x] + D;
if (V[y][x] == V[y - 1][x]) MD[y][x] = MD[y - 1][x] + P;
if (V[y][x] > V[y - 1][x]) MD[y][x] = MD[y - 1][x] + U;
}
for (y = H - 2; y >= 0; y--) {
if (V[y][x] < V[y + 1][x]) MU[y][x] = MU[y + 1][x] + D;
if (V[y][x] == V[y + 1][x]) MU[y][x] = MU[y + 1][x] + P;
if (V[y][x] > V[y + 1][x]) MU[y][x] = MU[y + 1][x] + U;
}
}
for (y1 = 0; y1 < H - 2; y1++)
for (y2 = y1 + 2; y2 < H; y2++)
for (x1 = 0; x1 < W - 2; x1++)
for (x2 = x1 + 2; x2 < W; x2++) {
int sc = (MR[y1][x2] - MR[y1][x1]) + (MD[y2][x2] - MD[y1][x2]) +
(ML[y2][x1] - ML[y2][x2]) + (MU[y1][x1] - MU[y2][x1]);
if (abs(sc - T) < best)
best = abs(sc - T), bx1 = x1, bx2 = x2, by1 = y1, by2 = y2;
}
(void)printf("%d %d %d %d\n", by1 + 1, bx1 + 1, by2 + 1, bx2 + 1);
}
int main(int argc, char** argv) {
string s;
if (argc == 1) ios::sync_with_stdio(false);
for (int i = 1; i < argc; i++) s += argv[i], s += '\n';
for (int i = s.size() - 1; i >= 0; i--) ungetc(s[i], stdin);
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
long long GCD(long long a, long long b) { return b ? GCD(b, a % b) : a; }
long long LCM(long long a, long long b) { return a / GCD(a, b) * b; }
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
char dir[4] = {'u', 'l', 'd', 'r'};
long long int cmp1(pair<long long int, string> a,
pair<long long int, string> b) {
if (a.first != b.first)
return a.first < b.first;
else
return a.second < b.second;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
long long int n, x;
cin >> n >> x;
bool abc = 0;
vector<long long int> a(n);
for (long long int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] == x) {
if (abc == 0) {
cout << 1 << endl;
abc = 1;
}
}
}
if (abc == 1) continue;
sort((a).begin(), (a).end());
if (x < a[n - 1]) {
cout << 2 << endl;
} else {
long long int tmp = x / a[n - 1];
if (x % a[n - 1] != 0) tmp++;
cout << tmp << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, s, a[210000];
int main() {
scanf("%d%d", &n, &s);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
sort(a + 1, a + n + 1);
int t = (n + 1) / 2;
long long ans = 0;
if (a[t] >= s) {
for (int i = 1; i <= t; i++)
if (a[i] >= s) ans += a[i] - s;
} else {
for (int i = t; i <= n; i++)
if (a[i] < s) ans += s - a[i];
}
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dist(int x, int y) {
if (y > x)
return (y - x);
else
return (12 - x + y);
}
int main() {
int i, j, q, r, t;
string a, b, c;
cin >> a >> b >> c;
map<string, int> m;
m["C"] = 1;
m["C#"] = 2;
m["D"] = 3;
m["D#"] = 4;
m["E"] = 5;
m["F"] = 6;
m["F#"] = 7;
m["G"] = 8;
m["G#"] = 9;
m["A"] = 10;
m["B"] = 11;
m["H"] = 12;
int x, y, z;
x = m[a];
y = m[b];
z = m[c];
if (dist(x, y) == 3 && dist(y, z) == 4)
cout << "minor";
else if (dist(x, y) == 4 && dist(y, z) == 3)
cout << "major";
else if (dist(x, z) == 3 && dist(z, y) == 4)
cout << "minor";
else if (dist(x, z) == 4 && dist(z, y) == 3)
cout << "major";
else if (dist(y, x) == 3 && dist(x, z) == 4)
cout << "minor";
else if (dist(y, x) == 4 && dist(x, z) == 3)
cout << "major";
else if (dist(y, z) == 3 && dist(z, x) == 4)
cout << "minor";
else if (dist(y, z) == 4 && dist(z, x) == 3)
cout << "major";
else if (dist(z, x) == 3 && dist(x, y) == 4)
cout << "minor";
else if (dist(z, x) == 4 && dist(x, y) == 3)
cout << "major";
else if (dist(z, y) == 3 && dist(y, x) == 4)
cout << "minor";
else if (dist(z, y) == 4 && dist(y, x) == 3)
cout << "major";
else
cout << "strange";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int t[1020304];
int n;
void ins(int x, int val) {
for (int z = x; z <= 1000000; z += (z & -z)) t[z] = (t[z] + val) % 1000000007;
}
int Ask(int x) {
int ret = 0;
for (int z = x; z; z -= (z & -z)) ret = (ret + t[z]) % 1000000007;
return ret;
}
int a[1020304], f[1020304];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
int ans = 0;
for (int i = 1; i <= n; ++i) {
int t = Ask(a[i]), t0 = Ask(a[i] - 1);
int pre = (t + 1000000007 - t0) % 1000000007;
int tA = ((long long)t0 * a[i] % 1000000007 + a[i] + 1000000007 - pre) %
1000000007;
int tB = (long long)pre * a[i] % 1000000007;
f[i] = (tA + tB) % 1000000007;
ans = (ans + f[i]) % 1000000007;
ins(a[i], f[i]);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long V;
cin >> V;
while (V--) {
double a[250];
for (long long i = 0; i < 250; i++) cin >> a[i];
double exp = 0;
for (long long i = 0; i < 250; i++) exp += a[i];
exp /= 250;
double var = 0;
for (long long i = 0; i < 250; i++) var += (a[i] - exp) * (a[i] - exp);
var /= 250;
double k = exp / var;
double err = 0.50;
if (1.0 - err <= k && k <= 1.0 + err)
cout << "poisson" << endl;
else
cout << "uniform" << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char lower[110000], upper[110000];
int a, temp, init, dp[2][110000], mod = 1000000007, value[110000], n,
ex[110000], ten[110000], three[110000];
long long test;
int count(char num[]) {
int i, j, s, p, q, res = 0;
n = strlen(num);
for (i = 0; i < n; i++) value[i] = num[n - 1 - i] - '0' - 4;
while (n >= 1 && value[n - 1] == 0) n--;
dp[0][0] = (int)((long long)init * (long long)(init + 3) % mod);
dp[1][0] = (2 * init % mod + 3) % mod;
for (i = 1; i <= n; i++) {
dp[0][i] = (dp[0][i - 1] << 1) % mod;
dp[0][i] += (int)((long long)((init + three[i]) % mod) *
(long long)((init + ten[i]) % mod) % mod);
dp[0][i] %= mod;
dp[0][i] -= (int)((long long)((init + three[i - 1]) % mod) *
(long long)((init + ten[i - 1]) % mod) % mod);
dp[0][i] = (dp[0][i] + mod) % mod;
dp[0][i] += (int)((long long)ten[i - 1] * (long long)dp[1][i - 1] % mod);
dp[0][i] %= mod;
temp = (init << 1) % mod;
temp = (temp + three[i - 1]) % mod;
temp = (temp + ten[i - 1]) % mod;
temp = (int)((long long)temp * (long long)ten[i - 1] % mod);
dp[0][i] = (dp[0][i] - temp + mod) % mod;
temp = (int)((long long)ten[i - 1] * (long long)ten[i - 1] % mod);
temp =
(int)((long long)temp * (long long)((ex[i - 1] - 1 + mod) % mod) % mod);
dp[0][i] = (dp[0][i] + temp) % mod;
dp[1][i] =
(dp[1][i - 1] << 1) % mod + (int)((long long)((ex[i] - 2 + mod) % mod) *
(long long)ten[i - 1] % mod);
dp[1][i] %= mod;
dp[1][i] = (dp[1][i] + three[i]) % mod;
dp[1][i] = (dp[1][i] + ten[i]) % mod;
dp[1][i] = (dp[1][i] - three[i - 1] + mod) % mod;
dp[1][i] = (dp[1][i] - ten[i - 1] + mod) % mod;
}
a = 0;
for (i = n - 1; i >= 0; i--) {
if (value[i] == 3) {
res = (res + dp[0][i]) % mod;
res = (res + (int)((long long)dp[1][i] * (long long)a % mod)) % mod;
temp = (int)((long long)a * (long long)a % mod);
temp = (int)((long long)temp * (long long)ex[i] % mod);
res = (res + temp) % mod;
a = (a + ten[i]) % mod;
}
}
return res;
}
int main() {
int tst = 1000, i, j, s, p, q, res1, res2, cnt;
while (scanf("%s%s", lower, upper) == 2) {
n = strlen(lower);
ex[0] = 1;
ten[0] = 3;
three[0] = 0;
init = 0;
for (i = 1; i <= n; i++) {
init = (int)((long long)init * (long long)10 % mod);
init = (init + 4) % mod;
ex[i] = (ex[i - 1] << 1) % mod;
ten[i] = (int)((long long)ten[i - 1] * (long long)10 % mod);
three[i] = (three[i - 1] + ten[i - 1]) % mod;
}
printf("%d\n", (count(upper) - count(lower) + mod) % mod);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vi = vector<int>;
using vii = vector<ii>;
using vs = vector<string>;
const double PI = acos(-1.0);
const double EPS = 1e-14;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll INFLL = 4e18;
const int MAX = 50;
struct data {
int fast, slow;
double ch;
};
int N, R;
data arr[MAX + 5];
double memo[MAX + 5][6000];
double top = 1e18, bot = 0.0, mid;
void read() {
cin >> N >> R;
for (int i = 0; i < (int)N; i++) {
cin >> arr[i].fast >> arr[i].slow >> arr[i].ch;
arr[i].ch /= 100.0;
}
}
double dp(int pos, int cur) {
double &ret = memo[pos][cur];
if (ret <= -0.8) {
if (cur > R)
ret = mid;
else if (pos == N)
ret = 0.0;
else {
ret = arr[pos].ch * (arr[pos].fast + dp(pos + 1, cur + arr[pos].fast)) +
(1.0 - arr[pos].ch) *
(arr[pos].slow + dp(pos + 1, cur + arr[pos].slow));
ret = min(ret, mid);
}
}
return ret;
}
void solve() {
for (int loop = 0; loop < (int)200; loop++) {
mid = (top + bot) / 2.0;
for (int i = 0; i < (int)MAX + 5; i++)
for (int j = 0; j < (int)6000; j++) memo[i][j] = -1.0;
if (dp(0, 0) >= mid)
bot = mid;
else
top = mid;
}
cout << fixed << setprecision(10) << (top + bot) / 2.0 << "\n";
}
int main() {
int TC = 1;
while (TC--) {
read();
solve();
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int nm = 1002;
int m, n, k;
bool a[nm][nm];
int main() {
cin >> m >> n >> k;
for (int i = 1; i <= k; ++i) {
int u, v;
cin >> u >> v;
if ((u < m && a[u + 1][v] && v < n && a[u][v + 1] && a[u + 1][v + 1]) ||
(v > 1 && a[u][v - 1] && u < m && a[u + 1][v] && a[u + 1][v - 1]) ||
(u > 1 && a[u - 1][v] && v < n && a[u][v + 1] && a[u - 1][v + 1]) ||
(u > 1 && a[u - 1][v] && v > 1 && a[u][v - 1] && a[u - 1][v - 1])) {
printf("%d\n", i);
return 0;
}
a[u][v] = 1;
}
printf("0\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 2 * acos(0);
const int mod = 1000000007;
const int N = 20007;
void solve() {
int n;
cin >> n;
string s;
cin >> s;
int c = 0, a = 0, b = 0;
for (int i = 0; i < n; i++) {
if (i & 1) {
if (s[i] == 'b')
c++;
else
b++;
} else {
if (s[i] == 'r')
c++;
else
a++;
}
}
int s1 = c + min(a, b);
c = 0, a = 0, b = 0;
for (int i = 0; i < n; i++) {
if (i & 1) {
if (s[i] == 'r')
c++;
else
a++;
} else {
if (s[i] == 'b')
c++;
else
b++;
}
}
int s2 = c + min(a, b);
int ans = n - max(s1, s2);
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q = 1;
while (q--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
const int M = 1000000007;
const double PI = atan(1) * 4;
const int oo = 1000000000;
struct state {
int x, y, d;
state() {}
state(int a, int b, int c) {
x = a;
y = b;
d = c;
}
};
int n, m, vis[501][501][2];
state P[501][501][2];
vector<vector<int> > v;
vector<int> ans1, ans2;
void solve() {
int x = n - 1, y = 0, d = 0;
ans1.push_back(x);
ans2.push_back(y);
while (x || y != n - 1 || d) {
state &p = P[x][y][d];
x = p.x;
y = p.y;
d = p.d;
if (!d)
ans1.push_back(x);
else
ans2.push_back(y);
}
for (int i = ans1.size() - 1; i >= 0; --i) printf("%d ", ans1[i] + 1);
printf("\n");
for (int i = ans2.size() - 1; i >= 0; --i) printf("%d ", ans2[i] + 1);
printf("\n");
}
void bfs() {
queue<state> q;
q.push(state(0, n - 1, 0));
vis[0][n - 1][0] = 1;
for (int i = 0; i < n; ++i) vis[i][i][0] = 1;
while (!q.empty()) {
state p = q.front();
q.pop();
int x = p.x, y = p.y, d = p.d, cst = vis[x][y][d];
if (x == n - 1 && !y && !d) {
printf("%d\n", cst - 1);
solve();
return;
}
if (!d)
for (int i = 0; i < v[x].size(); ++i) {
int nx = v[x][i];
if (vis[nx][y][1]) continue;
vis[nx][y][1] = cst;
P[nx][y][1] = p;
q.push(state(nx, y, 1));
}
else
for (int j = 0; j < v[y].size(); ++j) {
int ny = v[y][j];
if (vis[x][ny][0]) continue;
vis[x][ny][0] = cst + 1;
P[x][ny][0] = p;
q.push(state(x, ny, 0));
}
}
cout << -1 << endl;
}
int main() {
cin >> n >> m;
v.resize(n);
for (int a, b, i = 0; i < m; ++i) {
scanf("%d%d", &a, &b);
--a;
--b;
v[a].push_back(b);
v[b].push_back(a);
}
bfs();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
void reader() {}
void IOFast() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
void solve() {
string s;
cin >> s;
long long n = s.length();
bool dp[n][n];
memset(dp, 0, sizeof dp);
for (long long l = 0; l < n; l++) {
for (long long i = 0; i < n; i++) {
long long j = i + l;
if (j >= n) continue;
if (l == 0)
dp[i][j] = 1;
else if (l == 1 && s[i] == s[j])
dp[i][j] = 1;
else if (s[i] == s[j])
dp[i][j] = dp[i + 1][j - 1];
}
}
long long ans[n];
memset(ans, 0, sizeof(ans));
long long fans = 0;
for (long long j = 0; j < n; j++) {
for (long long i = 0; i <= j; i++) {
if (dp[i][j]) {
ans[j]++;
if (i >= 1) fans += ans[i - 1];
}
}
if (j >= 1) ans[j] += ans[j - 1];
}
cout << fans;
cout << "\n";
}
signed main() {
reader();
IOFast();
long long t = 1;
while (t--) solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t = 1;
for (int z = 0; z < t; z++) {
int n, k;
string s;
cin >> n >> s;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
reverse(&s[0], &s[i]);
}
}
cout << s;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000;
long long Move1[maxn];
long long Move2[maxn];
inline void op1(int Lay, long long move, long long x, long long times) {
if (x != 0) Lay = log2(x) + 1;
long long Base = 1LL << (Lay - 1);
if (times == -1)
move %= Base;
else
move = ((move % Base) * (times % Base)) % Base;
Move1[Lay] = ((Move1[Lay] + move) + Base) % Base;
Move2[Lay] = ((Move2[Lay] - move) + Base) % Base;
}
inline void op2(long long move, long long x) {
int Lay = log2(x) + 1;
for (int i = Lay, j = 0; i <= 65; i++, j++) op1(i, move, 0, 1LL << j);
}
inline void op3(long long x) {
if (x == 1LL) {
puts("1");
return;
}
printf("%I64d", x);
int Lay = log2(x) + 1;
long long Base = 1LL << (Lay - 1);
long long pos = (((x - Base) + Move1[Lay]) + Base) % Base + Base;
while (!(pos == 3LL || pos == 2LL)) {
if (pos & 1)
pos = (pos - 1) >> 1;
else
pos = pos >> 1;
Lay = log2(pos) + 1;
Base = 1LL << (Lay - 1);
printf(" %I64d", ((pos - Base + Move2[Lay]) + Base) % Base + Base);
}
puts(" 1");
}
int main(void) {
int Q;
scanf("%d", &Q);
while (Q--) {
int command;
long long X, K;
scanf("%d", &command);
if (command == 1) {
scanf("%I64d %I64d", &X, &K);
op1(-1, K, X, -1);
} else if (command == 2) {
scanf("%I64d %I64d", &X, &K);
op2(K, X);
} else {
scanf("%I64d", &X);
op3(X);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int mu[2003 + 3], prime[2003 + 3], pd[2003 + 3], n, m, t, g[2003][2003];
void init() {
mu[1] = 1;
for (int i = 2; i <= 2003; i++) {
if (!pd[i]) {
prime[++prime[0]] = i;
mu[i] = -1;
}
for (int j = 1; j <= prime[0]; j++) {
if (i * prime[j] > 2003) break;
pd[i * prime[j]] = 1;
if (i % prime[j] == 0) {
mu[i * prime[j]] = 0;
break;
}
mu[i * prime[j]] = -mu[i];
}
}
}
int gcd(int x, int y) {
if (g[x][y]) return g[x][y];
int r;
int X = x;
int Y = y;
while (y) {
r = x % y;
x = y;
y = r;
}
g[X][Y] = x;
return x;
}
int calc(int n, int d, int k) {
int ans = 0;
for (int i = 1; i <= n; i++)
if (gcd(d * i, k) == 1) ans += (n / i);
return ans;
}
int main() {
scanf("%d%d%d", &n, &m, &t);
if (n > m) swap(n, m);
if (n > t) swap(n, t);
init();
int ans = 0;
for (int k = 1; k <= t; k++)
for (int d = 1; d <= n; d++)
ans += mu[d] * (t / k) * calc(n / d, d, k) * calc(m / d, d, k);
printf("%d\n", (ans % 1073741824 + 1073741824) % 1073741824);
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const long long I1 = 1e9;
const long long I2 = 1e18;
const int32_t M1 = 1e9 + 7;
const int32_t M2 = 998244353;
template <typename T, typename T1>
T maxn(T &a, T1 b) {
if (b > a) a = b;
return a;
}
template <typename T, typename T1>
T minn(T &a, T1 b) {
if (b < a) a = b;
return a;
}
vector<long long int> par(200005), ord(200005);
set<long long int> s;
long long int parent(long long int i) {
if (par[i] == i)
return i;
else
return par[i] = parent(par[i]);
}
bool pfind(long long int x, long long int y) { return parent(x) == parent(y); }
void merge(long long int x, long long int y) {
x = parent(x);
y = parent(y);
if (x == y) return;
if (ord[x] > ord[y]) {
par[y] = x;
ord[x] += ord[y];
} else {
par[x] = y;
ord[y] += ord[x];
}
}
void clear_dsu(int n) {
for (long long int i = 0; i < n; i++) par[i] = i;
}
void solve() {
int n, q;
cin >> n >> q;
for (long long int i = 0; i < n; i++) s.insert(i);
s.insert(I1);
clear_dsu(n);
while (q--) {
int p, a, b;
cin >> p >> a >> b;
a--;
b--;
if (p == 1) {
merge(a, b);
} else if (p == 2) {
auto it = s.lower_bound(a);
vector<int> v;
while (*it <= b) {
v.push_back(*it);
it++;
}
for (int i = 1; i < (long long int)v.size() - 1; i++) s.erase(v[i]);
for (long long int i = 1; i <= (long long int)v.size() - 1; i++)
merge(v[i - 1], v[i]);
} else {
cout << (pfind(a, b) ? "YES" : "NO") << '\n';
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int testcase = 1;
while (testcase--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool g[25][25];
void run() {
for (long long i = 0; i < 25; ++i) {
for (long long j = 0; j < 25; ++j) {
g[i][j] = 0;
}
}
long long n;
cin >> n;
vector<char> a, b;
for (long long i = 0; i < n; ++i) {
char c;
cin >> c;
a.push_back(c - 'a');
}
for (long long i = 0; i < n; ++i) {
char c;
cin >> c;
b.push_back(c - 'a');
}
for (long long i = 0; i < n; ++i) {
if (a[i] > b[i]) {
cout << -1 << endl;
return;
}
if (a[i] < b[i]) {
g[a[i]][b[i]] = 1;
}
}
long long kol = 0;
for (long long i = 0; i < 20; ++i) {
for (long long j = i + 1; j < 20; ++j) {
if (g[i][j]) {
kol++;
for (long long elem = j + 1; elem < 20; ++elem) {
if (g[i][elem]) {
g[j][elem] = 1;
}
}
break;
}
}
}
cout << kol << endl;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) run();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[3000000];
int main() {
int i, j, n, tmp, tmp1;
scanf("%d", &n);
for (i = 0; i < n; i++) a[i] = i + 1;
for (i = 0; i < n - 1; i++) {
tmp = a[i];
for (j = i + (i + 2); j < i + n; j += (i + 2)) {
tmp1 = tmp;
tmp = a[j];
a[j] = tmp1;
}
a[i + n] = tmp;
}
for (i = n - 1; i < n - 1 + n; i++) {
if (i != n - 1) printf(" ");
printf("%d", a[i]);
}
printf("\n");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
char a[100001];
scanf("%s", a);
int c1 = -1, s = 0;
for (int i = 0; a[i] != '\0'; i++) {
s++;
}
for (int i = 0; a[i] != '\0'; i++) {
if (a[i] % 2 == 0) {
c1 = i;
if (a[i] < a[s - 1]) {
break;
}
}
}
if (c1 == -1) {
cout << "-1";
return 0;
} else {
char temp = a[s - 1];
a[s - 1] = a[c1];
a[c1] = temp;
}
for (int i = 0; a[i] != '\0'; i++) {
cout << a[i];
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
double long l;
cin >> k >> l;
int n;
for (n = 0; l > k; n++) {
l = l / k;
}
if (k == l) {
cout << "YES" << endl;
cout << n;
} else {
cout << "NO";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
string vowels = "aoyeui";
string ans;
cin >> s;
for (int i = 0; i < s.length(); i++) {
s[i] = tolower(s[i]);
if (vowels.find(s[i]) == string::npos) {
ans += ".";
ans += s[i];
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
struct Point {
public:
T x, y;
Point() : x(0), y(0) {}
Point(T x_, T y_) : x(x_), y(y_) {}
template <typename U>
explicit Point(const Point<U>& p) : x(p.x), y(p.y) {}
Point(const std::pair<T, T>& p) : x(p.first), y(p.second) {}
Point(const std::complex<T>& p) : x(real(p)), y(imag(p)) {}
explicit operator std::pair<T, T>() const { return std::pair<T, T>(x, y); }
explicit operator std::complex<T>() const { return std::complex<T>(x, y); }
friend std::ostream& operator<<(std::ostream& o, const Point& p) {
return o << '(' << p.x << ',' << p.y << ')';
}
friend std::istream& operator>>(std::istream& i, Point& p) {
return i >> p.x >> p.y;
}
friend bool operator==(const Point& a, const Point& b) {
return a.x == b.x && a.y == b.y;
}
friend bool operator!=(const Point& a, const Point& b) { return !(a == b); }
friend bool operator<(const Point& a, const Point& b) {
return (a.x != b.x ? a.x < b.x : a.y < b.y);
}
friend T norm(const Point& a) { return a.x * a.x + a.y * a.y; }
friend T abs(const Point& p) { return std::hypot(p.x, p.y); }
friend T unit(const Point& a) {
if (a == Point()) return a;
return a / abs(a);
}
friend Point conj(const Point& a) { return Point(a.x, -a.y); }
friend Point perp(const Point& a) { return Point(-a.y, a.x); }
friend long double arg(const Point& p) { return atan2(p.y, p.x); }
friend Point dir(long double angle) { return Point(cos(angle), sin(angle)); }
Point& operator+=(const Point& p) {
x += p.x, y += p.y;
return *this;
}
Point& operator-=(const Point& p) {
x -= p.x, y -= p.y;
return *this;
}
Point& operator*=(const T& t) {
x *= t, y *= t;
return *this;
}
Point& operator/=(const T& t) {
x /= t, y /= t;
return *this;
}
Point& operator*=(const Point& t) {
Point res = Point(x, y) * t;
x = res.x, y = res.y;
return *this;
}
Point& operator/=(const Point& t) {
Point res = Point(x, y) / t;
x = res.x, y = res.y;
return *this;
}
friend Point operator+(const Point& a, const Point& b) {
return Point(a.x + b.x, a.y + b.y);
}
friend Point operator-(const Point& a, const Point& b) {
return Point(a.x - b.x, a.y - b.y);
}
friend Point operator*(const Point& a, const T& t) {
return Point(a.x * t, a.y * t);
}
friend Point operator*(const T& t, const Point& a) {
return Point(t * a.x, t * a.y);
}
friend Point operator/(const Point& a, const T& t) {
return Point(a.x / t, a.y / t);
}
friend Point operator*(const Point& a, const Point& b) {
return Point(a.x * b.x - a.y * b.y, a.y * b.x + a.x * b.y);
}
friend Point operator/(const Point& a, const Point& b) {
return Point(a * conj(b) / norm(b));
}
friend T int_norm(const Point& a) { return __gcd(a.x, a.y); }
friend T int_unit(const Point& a) {
if (a == Point()) return a;
return a / int_norm(a);
}
friend T cross(const Point& a, const Point& b) {
return a.x * b.y - a.y * b.x;
}
friend T dot(const Point& a, const Point& b) { return a.x * b.x + a.y * b.y; }
friend T area(const Point& a, const Point& b, const Point& c) {
return cross(b - a, c - a);
}
friend Point rotation(const Point& a, const Point& b) {
return Point(dot(a, b), cross(a, b));
}
friend bool same_dir(const Point& a, const Point& b) {
return cross(a, b) == 0 && dot(a, b) > 0;
}
friend bool is_reflex(const Point& a, const Point& b) {
auto c = cross(a, b);
return c ? (c < 0) : (dot(a, b) < 0);
}
friend bool angle_less(const Point& base, const Point& second,
const Point& t) {
int r = is_reflex(base, second) - is_reflex(base, t);
return r ? (r < 0) : (0 < cross(second, t));
}
friend bool angle_cmp(const Point& base) {
return [base](const Point& second, const Point& t) {
return angle_less(base, second, t);
};
}
friend bool angle_cmp_center(const Point& center, const Point& dir) {
return [center, dir](const Point& second, const Point& t) -> bool {
return angle_less(dir, second - center, t - center);
};
}
friend int angle_between(const Point& second, const Point& t,
const Point& p) {
if (same_dir(p, second) || same_dir(p, t)) return 0;
return angle_less(second, p, t) ? 1 : -1;
}
};
int main() {
int n;
cin >> n;
auto query = [&](int t, int x, int y, int z) {
cout << t << " " << y + 1 << " " << z + 1 << " " << x + 1 << endl;
long long ret;
cin >> ret;
return ret;
};
int e1 = 0;
int e2 = 1;
vector<int> L, R;
vector<long long> A(n);
for (int i = 2; i < n; i++) {
if (query(2, e1, i, e2) > 0) {
R.push_back(i);
} else {
L.push_back(i);
}
}
int nl = (int)(L).size();
int nr = (int)(R).size();
for (int i = 2; i < n; i++) {
A[i] = query(1, e1, e2, i);
}
vector<int> hull;
hull.push_back(e2);
{
sort((L).begin(), (L).end(), [&](int x, int y) { return A[x] < A[y]; });
deque<int> d;
int big = -1;
if ((int)(L).size()) big = L.back();
while ((int)(L).size()) {
int x = L.back();
L.pop_back();
if ((int)(d).size() == 0) {
d.push_back(x);
} else {
if (query(2, e2, x, big) > 0) {
d.push_front(x);
} else {
d.push_back(x);
}
}
}
for (int x : d) hull.push_back(x);
hull.push_back(e1);
}
{
sort((R).begin(), (R).end(), [&](int x, int y) { return A[x] < A[y]; });
deque<int> d;
int big = -1;
if ((int)(R).size()) big = R.back();
while ((int)(R).size()) {
int x = R.back();
R.pop_back();
if ((int)(d).size() == 0) {
d.push_back(x);
} else {
if (query(2, e1, x, big) > 0) {
d.push_front(x);
} else {
d.push_back(x);
}
}
}
for (int x : d) hull.emplace_back(x);
}
cout << 0 << " ";
vector<int> res;
int id = 0;
for (int i = 0; i < n; i++) {
if (hull[i] == 0) id = i;
}
for (int i = 0; i < n; i++) {
res.emplace_back(hull[(id + i) % n]);
}
for (int x : res) {
cout << x + 1 << " ";
}
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (a == 0) return b;
return gcd(b % a, a);
}
int main() {
int n, m;
int x2, h = 0, x1, k;
cin >> n >> m;
int m1[101] = {0};
int m2[101] = {0};
cin >> x1;
for (int i = 0; i < x1; i++) {
cin >> k;
m1[k]++;
}
cin >> x2;
for (int i = 0; i < x2; i++) {
cin >> k;
m2[k]++;
}
int h1 = gcd(n, m);
if (h1 == 1) {
cout << "Yes";
} else {
for (int i = 0; i < 101; i++) {
int j, l, g = 0, g1 = 0;
if (m1[i] == 0) {
j = i % h1;
l = j;
while (j < 101) {
if (m1[j] == 1) {
g = 1;
break;
}
j += h1;
}
if (g != 1) {
while (l < 101) {
if (m2[l] == 1) {
g1 = 1;
break;
}
l += h1;
}
if (g1 == 0) {
h = 1;
break;
}
}
}
}
if (h == 1) {
cout << "No";
} else {
cout << "Yes";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int i, j, n, k, m, u;
vector<int> a[101];
set<int> s[101];
int main() {
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &m);
for (j = 0; j < m; j++) {
scanf("%d", &k);
a[i].push_back(k);
s[i].insert(k);
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i == j) continue;
for (u = 0; u < a[j].size(); u++) {
if (s[i].find(a[j][u]) == s[i].end()) break;
}
if (u == a[j].size()) break;
}
if (j != n) {
printf("NO\n");
} else
printf("YES\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
int ans = 0;
vector<int> v;
int x = 1, y = 0;
while (1) {
if (x <= n && n - x - y > x) {
ans++;
v.push_back(x);
y += x;
x++;
if (y == n) break;
} else {
v.push_back(n - y);
ans++;
break;
}
}
cout << ans << endl;
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int k, a, len, sum[5000];
char s[5000];
map<int, long long> T;
long long ans;
long long C2(int k) { return (long long)k * (k + 1) / 2; }
int main() {
scanf("%d", &a);
scanf("%s", s);
len = strlen(s);
sum[0] = 0;
ans = 0;
for (int i = 0; i < len; i++) sum[i + 1] = s[i] - '0' + sum[i];
for (int i = 1; i <= len; i++)
for (int j = i; j <= len; j++) {
k = sum[j] - sum[i - 1];
if (k > a) break;
if (k == 0 || a % k == 0) {
if (T.count(k) == 0)
T[k] = 1;
else
T[k]++;
}
}
if (a == 0) {
if (T.count(0))
ans = (long long)C2(len) * C2(len) -
(long long)(C2(len) - T[0]) * (C2(len) - T[0]);
} else
for (int i = 1; i <= int(sqrt(a)); i++) {
if (a % i == 0) {
if (T.count(i) && T.count(a / i))
ans += (long long)(T[i]) * (long long)(T[a / i]) * (1 + (i * i != a));
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 5;
int n, t[MAXN];
int ans = 0;
bool done[MAXN];
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> t[i + 1];
for (int i = n; i >= 1; --i) {
if (!done[i]) {
ans++;
done[i] = 1;
}
done[t[i]] = 1;
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
inline long long fpow(long long x, long long p) {
register long long ret = 1;
while (p) {
if (p & 1) ret = ret * x % 998244353;
x = x * x % 998244353;
p >>= 1;
}
return ret;
}
long long n, p, _, q[2010][2010], g[2010], f[2010];
int main() {
scanf("%lld%lld%lld", &n, &p, &_);
p = p * fpow(_, 998244353 - 2) % 998244353;
q[1][0] = q[1][1] = 1;
for (long long i = 2; i <= n; i++) {
q[i][0] = 1;
for (long long j = 1; j <= i; j++) {
q[i][j] =
(q[i - 1][j] * fpow((1 - p + 998244353) % 998244353, j) % 998244353 +
q[i - 1][j - 1] * fpow(p, i - j)) %
998244353;
}
}
g[1] = 1;
for (long long i = 2; i <= n; i++) {
g[i] = 1;
for (long long j = 1; j < i; j++)
g[i] = (g[i] + 998244353 - (g[j] * q[i][j]) % 998244353) % 998244353;
}
for (long long i = 2; i <= n; i++) {
long long temp = 0;
for (long long j = 1; j < i; j++)
temp = (temp + g[j] * q[i][j] % 998244353 *
((j * (i - j) % 998244353 +
(j * (j - 1) / 2) % 998244353 + f[j] + f[i - j]) %
998244353) %
998244353) %
998244353;
temp = (temp + g[i] * q[i][i] % 998244353 *
((i * (i - 1) / 2) % 998244353) % 998244353) %
998244353;
f[i] = temp *
fpow((998244353 + 1 - (g[i] * q[i][i]) % 998244353) % 998244353,
998244353 - 2) %
998244353;
}
printf("%lld\n", f[n]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a;
cin >> b;
int count_47 = 0;
int count_74 = 0;
for (int i = 0; i < a.length(); ++i) {
if (a[i] == '4' && b[i] == '7')
++count_47;
else if (a[i] == '7' && b[i] == '4')
++count_74;
}
cout << max(count_47, count_74);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[2000000];
int cnt = 0;
int main() {
gets(s);
int l = strlen(s);
for (int i = 0; i < l; i++) {
if (s[i] == '0') continue;
int j = i + 1;
vector<int> v;
while (j < l) {
if (s[j] == '1')
j++;
else if (i != j - 1 && j + 1 < l && s[j + 1] == '1')
v.push_back(j++);
else
break;
}
j--;
if (i == j)
cnt++;
else
cnt += v.size() + 2;
i = j;
}
cout << cnt << endl;
for (int i = 0; i < l; i++) {
if (s[i] == '0') continue;
int j = i + 1;
vector<int> v;
while (j < l) {
if (s[j] == '1')
j++;
else if (i != j - 1 && j + 1 < l && s[j + 1] == '1')
v.push_back(j++);
else
break;
}
j--;
if (i == j)
printf("+2^%d\n", l - i - 1);
else {
printf("+2^%d\n", l - i);
for (int k = 0; k < v.size(); k++) {
printf("-2^%d\n", l - v[k] - 1);
}
printf("-2^%d\n", l - j - 1);
}
i = j;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const bool ready = []() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout << fixed << setprecision(12);
return true;
}();
const double PI = acos(-1);
using ll = long long;
using pii = pair<ll, ll>;
using pdd = pair<double, double>;
using vd = vector<double>;
using vb = vector<bool>;
using vi = vector<ll>;
using vvi = vector<vi>;
using vs = vector<string>;
void solve() {
ll n;
cin >> n;
;
ll ten = 1;
ll cnt = 1;
while (ten * 9 * cnt < n) {
n -= ten * 9 * cnt;
ten *= 10;
cnt++;
}
ll nn = (n - 1) / cnt;
ll dig = (n - 1) % cnt;
ll num = ten + nn;
vi d;
while (num) {
d.push_back(num % 10);
num /= 10;
}
reverse((d).begin(), (d).end());
cout << d[dig] << endl;
}
signed main() { solve(); }
| 5 |
#include <bits/stdc++.h>
using namespace std;
char s[2003][2003], have[2003][2003];
int way[8][2] = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1},
{0, 1}, {1, -1}, {1, 0}, {1, 1}};
int read() {
int cnt = 0;
char ch = getchar();
while (ch < '0' || '9' < ch) ch = getchar();
while ('0' <= ch && ch <= '9') {
cnt = cnt * 10 + ch - '0';
ch = getchar();
}
return cnt;
}
int main() {
int n = read(), m = read();
for (int i = 1; i <= n; ++i) cin >> s[i];
for (int i = 2; i < n; ++i)
for (int j = 1; j < m - 1; ++j) {
bool flag = false;
for (int k = 0; k < 8; ++k)
if (s[i + way[k][0]][j + way[k][1]] == '.') {
flag = true;
break;
}
if (flag == false)
for (int k = 0; k < 8; ++k) have[i + way[k][0]][j + way[k][1]] = true;
}
bool ans = false;
for (int i = 1; i <= n; ++i)
for (int j = 0; j < m; ++j)
if (s[i][j] == '#' && !have[i][j]) {
ans = true;
break;
}
if (!ans)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const long long INF = numeric_limits<long long>::max();
vector<long long> readVec(long long n) {
vector<long long> result;
result.resize(static_cast<std::size_t>(n));
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
result[static_cast<std::size_t>(i)] = a;
}
return result;
}
vector<pair<long long, long long> > positions;
vector<pair<long long, long long> > swaps;
vector<long long> perm;
void swapme(long long a, long long b) {
swaps.push_back({a, b});
swap(perm[a], perm[b]);
positions[perm[a]].second = a;
positions[perm[b]].second = b;
}
void solve() {
long long n;
cin >> n;
perm = readVec(n);
for (long long i = 0; i < n; i++) perm[i]--;
for (long long i = 0; i < n; i++) {
positions.push_back({perm[i], i});
}
sort(positions.begin(), positions.end());
vector<long long> &temp = perm;
auto &t2 = positions;
for (long long i = 1; i < n - 1; i++) {
long long pos = positions[i].second;
long long d1 = abs(pos);
long long d2 = abs(n - 1 - pos);
if (d1 < d2) {
swapme(pos, n - 1);
swapme(0, n - 1);
} else {
swapme(pos, 0);
}
d1 = abs(i);
d2 = abs(n - 1 - i);
if (d1 < d2) {
swapme(0, n - 1);
swapme(n - 1, i);
} else {
swapme(0, i);
}
}
if (perm[0] != 0) {
swaps.push_back({0, n - 1});
}
cout << swaps.size() << endl;
for (auto a : swaps) {
cout << a.first + 1 << " " << a.second + 1 << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int t = 1;
for (int i = 0; i < t; i++) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%i %i", &n, &m);
printf("%i", n * 2 / m + 1 - (m - n * 2 % m) / m + n * 8 / m + 1 -
(m - n * 8 % m) / m + n * 5 / m + 1 - (m - n * 5 % m) / m);
return (0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, lcp[10001], dp[101][101][101];
string s[2001];
long str(string t, string s) {
long qrt = 0;
for (int k = 0; k < t.size(); ++k) {
if (k >= s.size()) break;
if (t[k] == s[k])
++qrt;
else
break;
}
return qrt;
}
int main() {
cin >> n >> m;
for (int k = 1; k <= n; ++k) cin >> s[k];
sort(s + 1, s + n + 1);
for (int k = 1; k <= n - 1; ++k) {
lcp[k] = str(s[k], s[k + 1]);
}
dp[1][1][1] = 0;
dp[1][2][2] = lcp[1];
int maxx = 0;
for (int k = n - 1; k >= 1; --k) {
for (int i = k + 1; i <= n; ++i) {
long ind = k;
for (int j = k; j <= i - 1; ++j)
if (lcp[j] < lcp[ind]) ind = j;
for (int j = 1; j <= m; ++j) {
for (int q = 0; q <= j; ++q) {
if (q > ind - k + 1) continue;
dp[k][i][j] = max(
dp[k][ind][q] + dp[ind + 1][i][j - q] + (j - q) * q * lcp[ind],
dp[k][i][j]);
}
if (i - k + 1 < j) dp[k][i][j] = 0;
if (j == m) maxx = max(maxx, dp[k][i][j]);
}
}
}
cout << maxx;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[100010], b[100010];
int main() {
long long m, n, i, j, sum = 0, ch = 0;
scanf("%lld %lld", &m, &n);
for (i = 0; i < m; i++) scanf("%lld", &a[i]), sum += (a[i] * n);
sort(a, a + m);
for (i = 0; i < n; i++) {
scanf("%lld", &b[i]);
if (b[i] < a[m - 1]) {
printf("-1");
return 0;
}
if (b[i] == a[m - 1]) ch = 1;
}
if (ch == 0) {
for (i = 0; i < n; i++) {
sum += (b[i] - a[m - 1]);
}
sum += (a[m - 1] - a[m - 2]);
printf("%lld", sum);
return 0;
}
for (i = 0; i < n; i++) {
sum += (b[i] - a[m - 1]);
}
printf("%lld", sum);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7, inf = 5e9;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
set<long long> s;
long long l = -1, r = inf;
s.insert(l);
s.insert(r);
long long ans = 1;
while (n--) {
string act;
long long val;
cin >> act >> val;
if (act[1] == 'D') {
s.insert(val);
} else {
if (val < l || val > r) {
ans = 0;
break;
}
if (val != l && val != r) {
ans = (ans * 2) % mod;
}
auto it = s.find(val);
it--;
l = *it;
it++;
it++;
r = *it;
it--;
s.erase(it);
}
}
int cnt = 1;
for (long long x : s)
if (l < x && x < r) cnt++;
ans = (ans * cnt) % mod;
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const long long int INF = 1e18;
const int N = 21;
long long int n, k;
long long int dp[2001][2001];
long long int foo(long long int cn, long long int curr) {
if (curr > n) return 0;
if (cn == k) {
return 1;
}
if (dp[cn][curr] != -1) return dp[cn][curr];
long long int res = 0;
for (int i = curr; i <= n; i += curr) {
res = (res + foo(cn + 1, i)) % mod;
}
return dp[cn][curr] = res % mod;
}
void solve(int t) {
cin >> n >> k;
long long int ans = 0;
memset(dp, -1, sizeof(dp));
cout << foo(0, 1) << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
for (int i = 1; i <= t; i++) {
solve(i);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> p[101];
vector<int> vx[1001];
vector<int> vy[1001];
int used[101];
queue<int> q;
void dfs() {
while (!q.empty()) {
int r = q.front();
q.pop();
used[r] = 1;
for (auto &i : vx[p[r].first]) {
if (used[i] == 0) {
used[i] = 1;
q.push(i);
}
}
for (auto &i : vy[p[r].second]) {
if (used[i] == 0) {
used[i] = 1;
q.push(i);
}
}
}
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i].first >> p[i].second;
vx[p[i].first].push_back(i);
vy[p[i].second].push_back(i);
}
int ans = -1;
for (int i = 1; i <= n; i++) {
if (used[i] == 0) {
ans++;
q.push(i);
dfs();
}
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100];
bool vis[100];
bool dfs(int v, int now, int u) {
if (v == n) return true;
if (a[v] - 1 == now) {
if (u != 1)
return dfs(v + 1, 0, 0);
else
return false;
}
int la = -1;
for (int i = 0; i < n; i++)
if (!vis[i] && a[v] >= a[i] + now && a[i] != la) {
la = a[i];
vis[i] = true;
if (dfs(v, now + a[i], u + 1)) return true;
vis[i] = false;
}
return false;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
vis[i] = false;
}
sort(a, a + n);
if (a[n - 1] != n) {
printf("NO\n");
return 0;
}
if (dfs(0, 0, 0))
printf("YES\n");
else
printf("NO");
scanf("%d");
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int S = 100003, M = 17, inf = 0x7fffffff;
char buf[1000000], *p1, *p2;
char gc() {
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, S, stdin), p1 == p2)
? EOF
: *p1++;
}
int rd() {
int f = 0;
char c = gc();
while (c < 48 || c > 57) c = gc();
while (c > 47 && c < 58) f = f * 10 + (c ^ 48), c = gc();
return f;
}
struct query {
int k, p, o;
} q[S];
struct splay {
int p, d[2], s;
} e[S];
int a[S], b[S], l[S], f[S][M], g[S][M], h[S], m;
vector<int> v[S];
int operator<(query x, query y) { return x.k < y.k; }
int min(int x, int y) { return x < y ? x : y; }
int max(int x, int y) { return x > y ? x : y; }
int qmn(int x, int y) {
int i = l[y - x + 1];
return min(f[x][i], f[y - (1 << i) + 1][i]);
}
int qmx(int x, int y) {
int i = l[y - x + 1];
return max(g[x][i], g[y - (1 << i) + 1][i]);
}
int nrt(int x) { return e[e[x].p].d[0] == x || e[e[x].p].d[1] == x; }
void psu(int x) { e[x].s = e[e[x].d[0]].s + e[e[x].d[1]].s + 1; }
void rtt(int x) {
int f = e[x].p, g = e[f].p, b = e[f].d[1] == x, c = e[x].d[!b];
if (nrt(f)) e[g].d[e[g].d[1] == f] = x;
if (c) e[c].p = f;
e[f].p = x, e[x].p = g, e[x].d[!b] = f, e[f].d[b] = c, psu(f);
}
void spl(int x) {
for (int f, g; nrt(x); rtt(x)) {
f = e[x].p, g = e[f].p;
if (nrt(f)) rtt((e[g].d[1] == f) ^ (e[f].d[1] == x) ? x : f);
}
psu(x);
}
void acc(int x) {
for (int y = 0; x; x = e[y = x].p) spl(x), e[x].d[1] = y, psu(x);
}
int frt(int x) {
while (e[x].d[0]) x = e[x].d[0];
return x;
}
void cut(int x) { acc(x), spl(x), e[e[x].d[0]].p = 0, e[x].d[0] = 0, psu(x); }
int fnd(int x, int k) {
int l = x + 1, r = m, m;
for (m = l + r >> 1; l < r; m = l + r >> 1)
qmx(x, m) - qmn(x, m) > k ? r = m : l = m + 1;
return m;
}
int main() {
int n = rd(), W = rd(), Q = rd(), p = sqrt(n), i, j, k, t, s, o;
for (m = n + 1, i = 1; i <= n; ++i) a[i] = f[i][0] = g[i][0] = rd();
a[m] = f[m][0] = g[m][0] = inf, l[1] = 0;
for (i = 2; i <= m; ++i) l[i] = l[i >> 1] + 1;
for (i = 1, k = 2; k <= m; ++i, k <<= 1)
for (j = 1; j + k - 1 <= m; ++j)
f[j][i] = min(f[j][i - 1], f[j + (k >> 1)][i - 1]),
g[j][i] = max(g[j][i - 1], g[j + (k >> 1)][i - 1]);
for (i = 1; i <= Q; ++i) q[i].p = i, q[i].k = W - rd();
sort(q + 1, q + Q + 1);
for (i = 1; i <= n; ++i) h[i] = i, e[i].p = i + 1, v[1].push_back(i);
for (i = 1; i <= Q; ++i) {
for (o = 0, t = 0, s = v[i].size(); t < s; ++t) {
j = v[i][t], cut(j);
for (k = h[j] + 1;
qmx(j, k) - qmn(j, k) <= q[i].k && k - j <= p && k <= n; ++k)
;
if (k - j > p)
b[j] = 1;
else
h[j] = k, e[j].p = h[j],
v[lower_bound(q + 1, q + 1 + Q,
(query){qmx(j, h[j]) - qmn(j, h[j]), 0}) -
q]
.push_back(j);
}
for (j = 1;; j = fnd(j, q[i].k), ++o) {
if (!b[j]) acc(j), spl(j), o += e[j].s - 1, j = frt(j);
if (j > n) break;
}
q[q[i].p].o = o - 1;
}
for (i = 1; i <= Q; ++i) printf("%d\n", q[i].o);
return 0;
}
| 13 |
#include <bits/stdc++.h>
const int N = 5e5 + 7;
int n, m, sx, sy, fx, fy;
int tot, to[N << 1], nex[N << 1], head[N], val[N << 1];
int vis[N];
int dis[N];
inline int read() {
int x = 0;
char c = getchar();
while (!isdigit(c)) c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
return x;
}
struct node {
int x, y, op;
} a[N];
void add(int x, int y, int z) {
to[++tot] = y;
nex[tot] = head[x];
val[tot] = z;
head[x] = tot;
}
bool cmp1(node a, node b) { return a.x < b.x; }
bool cmp2(node a, node b) { return a.y < b.y; }
std::priority_queue<std::pair<int, int> > q;
int dijkstra() {
memset(dis, 0x7f, sizeof dis);
dis[0] = 0;
q.push(std::make_pair(0, 0));
while (!q.empty()) {
int x = q.top().second;
q.pop();
vis[x] = 1;
for (int i = head[x]; i; i = nex[i]) {
int v = to[i];
if (dis[x] + val[i] < dis[v]) {
dis[v] = dis[x] + val[i];
q.push(std::make_pair(-dis[v], v));
}
}
while (!q.empty() && vis[q.top().second]) q.pop();
}
return dis[m + 1];
}
int main() {
n = read(), m = read();
sx = read(), sy = read(), fx = read(), fy = read();
for (int i = 1; i <= m; ++i) {
a[i].x = read(), a[i].y = read();
a[i].op = i;
add(0, i, std::min(abs(a[i].x - sx), abs(a[i].y - sy)));
add(i, m + 1, abs(a[i].x - fx) + abs(a[i].y - fy));
}
add(0, m + 1, abs(fx - sx) + abs(fy - sy));
std::sort(a + 1, a + 1 + m, cmp1);
for (int i = 2; i <= m; ++i) {
add(a[i - 1].op, a[i].op, a[i].x - a[i - 1].x);
add(a[i].op, a[i - 1].op, a[i].x - a[i - 1].x);
}
std::sort(a + 1, a + 1 + m, cmp2);
for (int i = 2; i <= m; ++i) {
add(a[i - 1].op, a[i].op, a[i].y - a[i - 1].y);
add(a[i].op, a[i - 1].op, a[i].y - a[i - 1].y);
}
printf("%d\n", dijkstra());
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const long long N = 155, M = N * N / 2;
const long long INF = 2e9;
long long a[N];
long long dp[2][N][M];
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, k, s;
cin >> n >> k >> s;
s = min(s, n * (n - 1) / 2);
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
vector<pair<long long, long long>> before, after;
for (long long i = 0; i < k; i++) {
before.push_back(make_pair(k - i, a[i]));
}
for (long long i = k; i < n; i++) {
after.push_back(make_pair(i - k, a[i]));
}
auto build = [&](long long ind) {
vector<pair<long long, long long>> cur = (ind == 0 ? before : after);
for (long long i = 0; i < N; i++) {
for (long long j = 0; j < M; j++) {
dp[ind][i][j] = (ind == 0 ? -INF : INF);
}
}
dp[ind][0][0] = 0;
for (auto it : cur) {
long long d, val;
tie(d, val) = it;
for (long long i = N - 1; i > 0; i--) {
for (long long j = d; j < M; j++) {
if (ind == 0) {
dp[ind][i][j] = max(dp[ind][i][j], dp[ind][i - 1][j - d] + val);
} else {
dp[ind][i][j] = min(dp[ind][i][j], dp[ind][i - 1][j - d] + val);
}
}
for (long long j = 1; j < M; j++) {
if (ind == 0) {
dp[ind][i][j] = max(dp[ind][i][j], dp[ind][i][j - 1]);
} else {
dp[ind][i][j] = min(dp[ind][i][j], dp[ind][i][j - 1]);
}
}
}
}
};
build(0);
build(1);
long long sum = accumulate(a, a + k, 0);
long long ans = sum;
for (long long i = 1;
i <= min((long long)after.size(), (long long)before.size()); i++) {
long long cur = INF;
for (long long j = 0; j <= s; j++) {
long long val = sum - dp[0][i][j] + dp[1][i][s - j];
cur = min(cur, val);
}
ans = min(ans, (long long)cur);
}
cout << ans << '\n';
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int inf = ~0U >> 1;
const long long LINF = ~(((long long)0x1) << 63) / 2;
template <class T>
bool get_max(T& a, T& b) {
return b > a ? a = b, 1 : 0;
}
template <class T>
bool get_min(T& a, T& b) {
return b < a ? a = b, 1 : 0;
}
int n, x[1003], y[1003];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d%d", x + i, y + i);
double l, r;
if (x[1] > x[2])
l = x[2], r = x[1];
else
r = x[2], l = x[1];
for (int i = 3; i < n; ++i) {
double dx = x[i + 1] - x[i];
double dy = y[i + 1] - y[i];
double d = y[1] - y[i];
double xx;
if (!dy)
xx = 1e10;
else
xx = x[i] + d / dy * dx;
if (d * dx - dy * (r - x[i]) > 0 && r > xx) r = xx;
if (d * dx - dy * (l - x[i]) > 0 && l < xx) l = xx;
}
r = floor(r), l = ceil(l);
if (r >= l)
printf("%.0lf\n", r - l + 1.1);
else
puts("0");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
long long k;
cin >> k;
long long n = ceil(sqrt(k));
long long r = 0, c = 0;
if (n * n - k >= n) {
r = n - (n * n - k - n) - 1;
c = n;
} else {
r = n;
c = n * n - k + 1;
}
cout << r << ' ' << c << endl;
}
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.