solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 20;
vector<int> children[maxn];
int N, depth[maxn], max_dep;
void dfs(int n, int dep) {
depth[dep]++;
max_dep = max(max_dep, dep);
for (int i = 0; i < children[n].size(); i++) {
int t = children[n][i];
dfs(t, dep + 1);
}
}
int main() {
while (cin >> N) {
memset(depth, 0, sizeof(depth));
for (int i = 0; i <= N; i++) children[i].clear();
max_dep = 0;
for (int i = 2; i <= N; i++) {
int a;
cin >> a;
children[a].push_back(i);
}
dfs(1, 0);
int res = 0;
for (int i = 0; i <= max_dep; i++) {
if (depth[i] % 2) res++;
}
cout << res << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long ans = 0, n, b, c, i, j, x, y;
int main() {
scanf("%lld%lld%lld%lld", &n, &x, &y, &c);
b = x / 2 + y;
for (i = 0; i <= b; i++) {
for (j = 0; j <= c; j++) {
if (i + j * 2 == n) {
if (j * 2 == n) {
ans++;
continue;
}
if (max(x / 2, y) >= i)
ans += min(i + 1, min(x / 2, y) + 1);
else
ans += min(x / 2, y) - (i - max(x / 2, y)) + 1;
}
}
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a, b, h;
cin >> a >> b >> h;
cout << (h/2)*(a+b);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
char tunnel[3][N];
bool vis[3][N];
int n, k;
int sx, sy;
int main() {
int cases;
scanf("%d", &cases);
for (int cas = 1; cas <= cases; cas++) {
scanf("%d %d", &n, &k);
memset(vis, 0, sizeof(vis));
for (int row = 0; row <= 2; row++) {
scanf("%s", tunnel[row]);
for (int col = 0; col < n; col++) {
if (tunnel[row][col] == 's') {
sx = row, sy = col;
vis[row][col] = 1;
}
}
}
for (int i = 1; i < n; i++) {
if (vis[0][i - 1] && tunnel[0][i] == '.') {
vis[0][i] = 1;
if (tunnel[1][i] == '.') vis[1][i] = 1;
}
if (vis[1][i - 1] && tunnel[1][i] == '.') {
vis[1][i] = 1;
if (tunnel[0][i] == '.') vis[0][i] = 1;
if (tunnel[2][i] == '.') vis[2][i] = 1;
}
if (vis[2][i - 1] && tunnel[2][i] == '.') {
vis[2][i] = 1;
if (tunnel[1][i] == '.') vis[1][i] = 1;
}
for (int j = 0; j < 3; j++) {
for (int k = 2; k < n; k++) {
tunnel[j][k - 2] = tunnel[j][k];
tunnel[j][k] = '.';
}
for (int k = 0; k < n; k++) {
if (tunnel[j][k] != '.') vis[j][k] = 0;
}
}
}
if (vis[0][n - 1] || vis[1][n - 1] || vis[2][n - 1])
puts("YES");
else
puts("NO");
}
return 0;
}
| 2 |
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <cstdio>
#include <iostream>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P > PP;
int tx[] = {0,1,0,-1};
int ty[] = {-1,0,1,0};
static const double EPS = 1e-8;
static const int MAX_SIZE = 500;
int check_paper(bitset<MAX_SIZE>* usagi_horizontal_flags,
bitset<MAX_SIZE>* usagi_virtical_flags,
bitset<MAX_SIZE>* usagi_diagonal_flags,
bitset<MAX_SIZE>* neko_horizontal_flags,
bitset<MAX_SIZE>* neko_virtical_flags,
bitset<MAX_SIZE>* neko_diagonal_flags,
int square_size,
int usagi_num,
int neko_num){
int usagi_sum = 0;
int neko_sum = 0;
for(int i=0;i<square_size;i++){
if(usagi_horizontal_flags[i].none()) usagi_sum++;
if(usagi_virtical_flags[i].none()) usagi_sum++;
if(neko_horizontal_flags[i].none()) neko_sum++;
if(neko_virtical_flags[i].none()) neko_sum++;
}
if(usagi_diagonal_flags[0].none()) usagi_sum++;
if(usagi_diagonal_flags[1].none()) usagi_sum++;
if(neko_diagonal_flags[0].none()) neko_sum++;
if(neko_diagonal_flags[1].none()) neko_sum++;
if(square_size == 1){
usagi_sum /= 3;
neko_sum /= 3;
}
bool is_usagi_clear = false;
bool is_neko_clear = false;
if(usagi_sum >= usagi_num) is_usagi_clear = true;
if(neko_sum >= neko_num) is_neko_clear = true;
if(is_usagi_clear && is_neko_clear){
//draw
return 0;
}
else if(is_usagi_clear && !is_neko_clear){
return 1;
}
else if(!is_usagi_clear && is_neko_clear){
return 2;
}
else {
return -1;
}
}
int usagi_paper[1000001];
int neko_paper[1000001];
int main(){
int square_size,usagi_num,neko_num,total_cards;
while(~scanf("%d %d %d %d",&square_size,&usagi_num,&neko_num,&total_cards)){
memset(usagi_paper,-1,sizeof(usagi_paper));
memset(neko_paper,-1,sizeof(neko_paper));
for(int y=0;y<square_size;y++){
for(int x=0;x<square_size;x++){
int num;
scanf("%d",&num);
usagi_paper[num] = y * square_size + x;
}
}
for(int y=0;y<square_size;y++){
for(int x=0;x<square_size;x++){
int num;
scanf("%d",&num);
neko_paper[num] = y * square_size + x;
}
}
bitset<MAX_SIZE> usagi_horizontal_flags[square_size];
bitset<MAX_SIZE> usagi_virtical_flags[square_size];
bitset<MAX_SIZE> usagi_diagonal_flags[2];
bitset<MAX_SIZE> neko_horizontal_flags[square_size];
bitset<MAX_SIZE> neko_virtical_flags[square_size];
bitset<MAX_SIZE> neko_diagonal_flags[2];
for(int pos=0;pos<square_size;pos++){
for(int bit_idx=0;bit_idx<square_size;bit_idx++){
usagi_horizontal_flags[pos][bit_idx] = true;
usagi_virtical_flags[pos][bit_idx] = true;
usagi_diagonal_flags[0][bit_idx] = true;
usagi_diagonal_flags[1][bit_idx] = true;
neko_horizontal_flags[pos][bit_idx] = true;
neko_virtical_flags[pos][bit_idx] = true;
neko_diagonal_flags[0][bit_idx] = true;
neko_diagonal_flags[1][bit_idx] = true;
}
}
const string status[] = {"DRAW","USAGI","NEKO"};
int res = 0;
for(int card_idx=0;card_idx<total_cards;card_idx++){
int num;
scanf("%d",&num);
if(usagi_paper[num] == -1 && neko_paper[num] == -1) continue;
if(usagi_paper[num] != -1){
int usagi_x = usagi_paper[num] % square_size;
int usagi_y = usagi_paper[num] / square_size;
// y:
//x:0 1 2 ... 3 4 ...
// 1
// 2
usagi_horizontal_flags[usagi_y][usagi_x] = false;
usagi_virtical_flags[usagi_x][usagi_y] = false;
if(usagi_x==usagi_y){
usagi_diagonal_flags[0][usagi_x] = false;
}
if(((square_size - 1) - usagi_x) == usagi_y){
usagi_diagonal_flags[1][usagi_x] = false;
}
}
if(neko_paper[num] != -1){
int neko_x = neko_paper[num] % square_size;
int neko_y = neko_paper[num] / square_size;
// y:
//x:0 1 2 ... 3 4 ...
// 1
// 2
neko_horizontal_flags[neko_y][neko_x] = false;
neko_virtical_flags[neko_x][neko_y] = false;
if(neko_x==neko_y){
neko_diagonal_flags[0][neko_x] = false;
}
if(((square_size - 1) - neko_x) == neko_y){
neko_diagonal_flags[1][neko_x] = false;
}
}
int winner = check_paper(usagi_horizontal_flags,
usagi_virtical_flags,
usagi_diagonal_flags,
neko_horizontal_flags,
neko_virtical_flags,
neko_diagonal_flags,
square_size,
usagi_num,
neko_num);
if(res == 0 && winner != -1 ) res = winner;
}
printf("%s\n",status[res].c_str());
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int t, n, p;
int main() {
cin.sync_with_stdio(0);
cin.tie();
cin.exceptions(cin.failbit);
cin >> t;
while (t--) {
cin >> n;
vector<int> vec;
for (int i = 1; i <= n; i++) {
cin >> p;
vec.push_back(p);
}
reverse(begin(vec), end(vec));
for (auto& k : vec) cout << k << " ";
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
char ar[2010][2010];
inline void f(int k, int l) {
if (k < 1 || l < 1 || k > N || l > M) return;
if (ar[k][l] != '.') return;
int res = 0;
if (k + 1 <= N && ar[k + 1][l] == '.') res++;
if (k - 1 >= 1 && ar[k - 1][l] == '.') res++;
if (l + 1 <= M && ar[k][l + 1] == '.') res++;
if (l - 1 >= 1 && ar[k][l - 1] == '.') res++;
if (res == 1) {
if (k + 1 <= N && ar[k + 1][l] == '.') {
ar[k][l] = '^';
ar[k + 1][l] = 'v';
}
if (k - 1 >= 1 && ar[k - 1][l] == '.') {
ar[k - 1][l] = '^';
ar[k][l] = 'v';
}
if (l + 1 <= M && ar[k][l + 1] == '.') {
ar[k][l] = '<';
ar[k][l + 1] = '>';
}
if (l - 1 >= 1 && ar[k][l - 1] == '.') {
ar[k][l - 1] = '<';
ar[k][l] = '>';
}
for (int i = -2; i <= 2; i++)
for (int j = -2; j <= 2; j++) f(k + i, l + j);
}
}
int main() {
cin >> N >> M;
for (int i = 1; i <= N; i++) scanf(" %s", ar[i] + 1);
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++) f(i, j);
for (int i = 1; i <= N; i++)
for (int j = 1; j <= M; j++)
if (ar[i][j] == '.') {
printf("Not unique\n");
return 0;
}
for (int i = 1; i <= N; i++) printf("%s\n", ar[i] + 1);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long calc(long long n, long long x) {
long long z = 0;
while (n) {
z += n / x;
n /= x;
}
return z;
}
long long mul(long long x, long long y) {
x %= mod;
y %= mod;
return (x * y) % mod;
}
long long pp(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = mul(res, x);
x = mul(x, x);
y >>= 1;
}
return res;
}
int main(int argc, char const *argv[]) {
long long x, n;
cin >> x >> n;
;
const long long MX = 2 * sqrt(x);
std::vector<bool> v(MX, 0);
std::vector<long long> p;
v[1] = 1;
for (int i = 1; i < MX; ++i) {
if (v[i]) continue;
if (x % i == 0) p.push_back(i);
for (int j = 2 * i; j < MX; j += i) v[j] = 1;
}
set<long long> P;
long long tmp = x;
for (long long xx : p) {
if (tmp % xx == 0) {
while (tmp % xx == 0) tmp /= xx;
}
}
if (tmp > 1) p.push_back(tmp);
long long ans = 1;
for (long long xx : p) {
ans = mul(ans, pp(xx, calc(n, xx)));
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, a, b, x[100001], y[100001], j;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (i = 0; i < n; i++) {
cin >> a;
x[a]++;
cin >> y[i];
}
for (i = 0; i < n; i++) {
a = n - 1 + x[y[i]];
b = 2 * (n - 1) - a;
cout << a << " " << b << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 3046201;
string s;
bool use[150];
int main() {
while (getline(cin, s)) {
long long ans = 1;
int cnt = 0;
int len = s.size() - 1;
memset(use, false, sizeof(use));
int c = 10;
if (s[0] == '?')
ans = 9;
else if (s[0] >= 'A' && s[0] <= 'J') {
ans = 9;
use[(int)s[0]] = true;
c--;
}
for (int i = 1; i <= len; i++) {
if (s[i] >= '0' && s[i] <= '9') continue;
if (s[i] == '?')
cnt++;
else {
if (use[(int)s[i]] == false) {
ans *= c;
c--;
use[(int)s[i]] = true;
}
}
}
cout << ans;
for (int i = 0; i < cnt; i++) cout << 0;
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool ok(const string& a, const string& b) {
if (a.size() != b.size()) return false;
for (int i = 0; i < a.size(); i++)
if (not(b[i] == '.' or b[i] == a[i])) return false;
return true;
}
int main() {
vector<string> P = {"vaporeon", "jolteon", "flareon", "espeon",
"umbreon", "leafeon", "glaceon", "sylveon"};
int n;
string s;
cin >> n >> s;
for (auto& cand : P)
if (ok(cand, s)) {
cout << cand << endl;
break;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s, t;
int P[2000000];
bool VIS[2000000];
int C[2000000], E[2000000];
int brute[50][50][50];
int L[2000000];
void dfs(int v, int len) {
if (v == -1) return;
if (VIS[v] && len == 0) return;
if (VIS[v]) {
C[v] = len;
return;
}
VIS[v] = true;
dfs(P[v], len + 1);
if (P[v] != -1 && C[P[v]] != 0) {
C[v] = C[P[v]];
} else {
E[v] = (P[v] != -1) ? E[P[v]] + 1 : 0;
L[E[v]] = v;
}
}
string solve(int k, int d) {
int c = -1;
for (int i = 0; i < d; i++) {
for (int j = i; j < k; j += d) {
C[j] = 0;
VIS[j] = false;
E[j] = 0;
L[j] = 0;
P[j] = c++;
}
}
t = s;
dfs(k - 1, 0);
for (int i = 0; i < k; i++) {
bool pv = VIS[i];
dfs(i, 0);
if (C[i] == 0) {
if (i != k - 1) {
if (n - k + 1 >= E[i]) {
t[E[i]] = s[i];
} else {
t[n - k + 1 + L[E[i] - (n - k + 1)]] = s[i];
}
}
} else if (!pv) {
int x = (n - k + 1) % C[i];
int v = i, w = i;
for (int j = 0; j < x; j++) v = P[v];
for (int j = 0; j < C[i]; j++) {
t[v + n - k + 1] = s[w];
v = P[v];
w = P[w];
}
}
}
for (int i = k - 1; i < n; i++) {
if (n - i < E[k - 1]) {
int go = E[k - 1] - (n - i);
t[n + L[go] - (k - 1)] = s[i];
} else {
t[i + E[k - 1] - k + 1] = s[i];
}
}
s = t;
return t;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> s;
string l = s;
n = (int)s.size();
if (n < 50) {
for (int d = 1; d <= n; d++) {
for (int k = d; k <= n; k++) {
for (int i = 0; i < n; i++) s[i] = i;
solve(k, d);
for (int i = 0; i < n; i++) brute[d][k][i] = s[i];
}
}
}
int m;
cin >> m;
s = l;
for (int i = 0; i < m; i++) {
int k, d;
cin >> k >> d;
if (n >= 50) {
cout << solve(k, d) << "\n";
} else {
for (int i = 0; i < n; i++) {
t[i] = s[brute[d][k][i]];
}
cout << t << "\n";
s = t;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long w[100005];
int n, m;
bool cmp(long long A, long long B) { return A > B; }
bool can(long long K) {
if (K & 1) return K * (K - 1) / 2 <= n - 1;
return K * K / 2 <= n;
}
int binary(int r) {
while (r) {
if (can(r)) return r;
r--;
}
}
int main() {
cin >> n >> m;
int t;
for (int i = 0; i < m; i++) scanf("%d %I64d", &t, &w[i]);
sort(w, w + m, cmp);
for (int i = 1; i < m; i++) w[i] += w[i - 1];
cout << w[binary(m) - 1] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
string s;
cin >> s;
if (k == 0)
cout << s << endl;
else if (n == 1 && k > 0)
cout << "0" << endl;
else if (k >= n && n > 1) {
cout << 1;
for (int i = 1; i < n; i++) cout << 0;
cout << endl;
} else if (k < n && n > 1) {
if (s[0] == '1') {
int j = 1, i = 1;
while (j <= k && i < n) {
if (s[i] - '0' != 0) {
s[i] = '0';
j++;
}
i++;
}
cout << s << endl;
} else {
s[0] = '1';
int j = 1, i = 1;
while (i < n && j < k) {
if (s[i] - '0' != 0) {
s[i] = '0';
j++;
}
i++;
}
cout << s << endl;
}
}
}
| 2 |
#include<iostream>
#include<string>
using namespace std;
struct dice{
int num[10];
};
dice d, d2, t, z;
dice hoge(dice d){
int temp = d.num[6];
d.num[6] = d.num[2];
d.num[2] = d.num[1];
d.num[1] = d.num[5];
d.num[5] = temp;
return d;
}
dice fuga(dice d){
int temp = d.num[6];
d.num[6] = d.num[3];
d.num[3] = d.num[1];
d.num[1] = d.num[4];
d.num[4] = temp;
return d;
}
dice foo(dice d){
int temp = d.num[2];
d.num[2] = d.num[3];
d.num[3] = d.num[5];
d.num[5] = d.num[4];
d.num[4] = temp;
return d;
}
bool equal(dice a, dice b){
for(int i = 1; i <= 6; i++){
if(a.num[i] != b.num[i]) return false;
}
return true;
}
bool same(dice a, dice b){
for(int i = 0; i < 4; i++){
a = hoge(a);
for(int j = 0; j < 4; j++){
a = foo(a);
if(equal(a,b))return true;
}
}
a = fuga(a);
for(int j = 0; j < 4; j++){
a = foo(a);
if(equal(a,b))return true;
}
a = fuga(a);
a = fuga(a);
for(int j = 0; j < 4; j++){
a = foo(a);
if(equal(a,b))return true;
}
return false;
}
int main(){
int n, q, a;
string s;
for(int i = 1; i <= 6; i++){
cin>>d.num[i];
}
for(int i = 1; i <= 6; i++){
cin>>d2.num[i];
}
cout<<(same(d,d2)?"Yes":"No")<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, ans, az;
double et[21][21], f[1 << 19];
int main() {
scanf("%d", &n);
for (int i = (1); i <= n; i++)
for (int j = (1); j <= n; j++) scanf("%lf", &et[i][j]);
f[(1 << n) - 1] = 1;
for (int s = ((1 << n) - 2); s >= 1; s--) {
ans = 0, az = s;
while (az) ans += (az & 1), az >>= 1;
for (int i = (1); i <= n; i++) {
if (!(s & (1 << (i - 1)))) {
for (int j = (1); j <= n; j++) {
if (s & (1 << (j - 1))) {
f[s] += f[s | (1 << (i - 1))] * et[j][i] / (ans * (ans + 1) / 2);
}
}
}
}
}
for (int i = (1); i <= n; i++) printf("%0.6lf ", f[1 << (i - 1)]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int vis[N];
int ans;
int n, m;
char s[N];
void dfs(int x, int y) {
if (ans) return;
if (x == n - 1 && y == m - 1) {
ans++;
return;
}
if (x + 1 < n && vis[(x + 1) * m + y] == 0) {
vis[(x + 1) * m + y] = 1;
dfs(x + 1, y);
}
if (ans) return;
if (y + 1 < m && vis[x * m + y + 1] == 0) {
vis[x * m + y + 1] = 1;
dfs(x, y + 1);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
scanf("%s", s);
for (int j = 0; j < m; j++) {
if (s[j] == '#') vis[i * m + j] = 1;
}
}
vis[0] = 1, vis[(n - 1) * m + m - 1] = 0;
dfs(0, 0);
if (ans == 0)
puts("0");
else {
ans = 0;
vis[0] = 1, vis[(n - 1) * m + m - 1] = 0;
dfs(0, 0);
if (ans == 0)
puts("1");
else
puts("2");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 5;
long long int power(long long int base, long long int exp) {
long long int res = 1;
while (exp) {
if (exp % 2) res *= base;
base *= base;
res %= mod;
base %= mod;
exp /= 2;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int p, k;
clock_t st = clock();
cin >> p >> k;
if (p < k) {
cout << "1\n" << p << "\n";
return 0;
}
long long int r = p;
vector<long long int> v;
while (true) {
long long int curr = 0;
if (r > 0)
curr = (r - k) / k + 1;
else {
curr = (-r) / k;
if (r % k) curr++;
curr = -curr;
}
v.push_back(-curr);
r = -curr;
if (r >= 0 && r < k) {
break;
}
if (1.0 * (clock() - st) / CLOCKS_PER_SEC > 0.85) {
cout << -1;
return 0;
}
}
reverse(v.begin(), v.end());
cout << int(v.size()) + 1 << "\n";
long long int l = 0;
vector<long long int> ans;
for (long long int i = 0; i < int(v.size()); i++) {
ans.push_back(l + v[i]);
l = v[i] * k;
}
ans.push_back(l + p);
reverse(ans.begin(), ans.end());
for (auto it : ans) cout << it << " ";
return 0;
}
| 2 |
#include <cstdio>
#include <cstdlib>
#define fo(i,a,b) for(int i=a;i<=b;i++)
#define fod(i,a,b) for(int i=a;i>=b;i--)
#define min(q,w) ((q)>(w)?(w):(q))
#define abs(q) ((q)<0?-(q):(q))
using namespace std;
const int N=500500;
int read(int &n)
{
char ch=' ';int q=0,w=1;
for(;(ch!='-')&&((ch<'0')||(ch>'9'));ch=getchar());
if(ch=='-')w=-1,ch=getchar();
for(;ch>='0' && ch<='9';ch=getchar())q=q*10+ch-48;n=q*w;return n;
}
int m,n,ans;
int f[N],a[N],c[N];
int main()
{
int q,w;
read(n),read(m);
c[0]=m;
fo(i,1,n)read(a[i]),c[i]=min(c[i-1],abs(c[i-1]-a[i]));
f[n+1]=0;
fod(i,n,1)f[i]=f[i+1]+(f[i+1]*2+1>=a[i]?a[i]:0);
read(m);
fo(i,1,m)
{
read(q);
if(c[q-1]>f[q+1])printf("YES\n");else printf("NO\n");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
string s;
for (i = 1; s.size() < 11000; i++) {
s = s + to_string(i);
}
cout << s[n - 1] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAXN = 305;
int a[MAXN], cnt[MAXN], vis[MAXN], C[MAXN][MAXN], fac[MAXN], f[MAXN][MAXN];
vector<int> size;
int n, N, total = 0;
void init() {
C[0][0] = 1;
for (int i = 1; i < MAXN; i++) C[i][0] = C[i][i] = 1;
for (int i = 2; i < MAXN; i++)
for (int j = 1; j < i; j++) C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % MOD;
fac[0] = 1;
for (int i = 1; i < MAXN; i++) fac[i] = (long long)fac[i - 1] * i % MOD;
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
cnt[i] = 1;
for (int j = i + 1; j <= n; j++) {
long long x = sqrt((long long)a[i] * a[j]);
if (x * x == (long long)a[i] * a[j]) vis[j] = 1, cnt[i]++;
}
}
size.push_back(0);
for (int i = 1; i <= n; i++)
if (cnt[i] > 0) size.push_back(cnt[i]);
N = size.size() - 1;
init();
f[1][size[1] - 1] = fac[size[1]];
for (int i = 1; i < N; i++) {
total += size[i];
for (int j = 0; j < total; j++) {
if (!f[i][j]) continue;
for (int S = 1; S <= min(size[i + 1], total + 1); S++) {
for (int D = 0; D <= min(S, j); D++) {
int &now = f[i + 1][j - D + size[i + 1] - S];
now = (now + (long long)f[i][j] * fac[size[i + 1]] % MOD *
C[size[i + 1] - 1][S - 1] % MOD * C[j][D] % MOD *
C[total + 1 - j][S - D]) %
MOD;
}
}
}
}
cout << f[N][0] << endl;
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
string a;
cin>>a;
if((a.length()%2==1)^(a[a.length()-1]==a[0])==1)cout<<"First\n";
else cout<<"Second\n";
return 0;
} | 0 |
#include <bits/stdc++.h>
const int INF = 0x3f3f3f3f;
const int MAX_N = 1e6 + 7;
int n, k;
std::vector<int> gr[MAX_N];
std::pair<int, int> drev[MAX_N];
int d[MAX_N];
int pre[2][MAX_N], dep[MAX_N], po = 0;
int dfs(const int& cur, const int& depth) {
pre[0][cur] = po++;
dep[cur] = depth;
for (const auto& nei : gr[cur]) dfs(nei, depth + 1);
pre[1][cur] = po;
return 0;
}
int go(const int& cur) {
if (pre[0][cur] + 1 == pre[1][cur]) {
drev[cur].first = dep[cur] - k;
drev[cur].second = 1;
return 0;
}
drev[cur].first = INF;
for (const auto& nei : gr[cur]) {
go(nei);
drev[cur].first = std::min(drev[cur].first, drev[nei].first);
if (drev[nei].first <= dep[cur]) drev[cur].second += drev[nei].second;
}
return 0;
}
int despacito(const int& cur) {
if (pre[0][cur] + 1 == pre[1][cur]) {
return d[cur] = 1;
}
d[cur] = drev[cur].second;
for (const auto& nei : gr[cur]) {
despacito(nei);
d[cur] = std::max(d[cur],
drev[cur].second -
(drev[nei].first <= dep[cur] ? drev[nei].second : 0) +
d[nei]);
}
return d[cur];
}
int main(void) {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
std::cin >> n >> k;
for (int i = 1, p; i < n; ++i) {
std::cin >> p;
gr[p - 1].push_back(i);
}
std::cout << (dfs(0, 0) + go(0) + despacito(0)) << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3fffffff;
int main() {
int a, b, n;
cin >> n;
while (n--) {
cin >> a >> b;
cout << b * 2 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool bfs(string s[], int n, int m, map<pair<int, int>, bool> &vis) {
if (s[n - 1][m - 1] == '#') return 0;
queue<pair<int, int> > q;
q.push({n - 1, m - 1});
vis[{n - 1, m - 1}] = 1;
while (!q.empty()) {
pair<int, int> p = q.front();
int i = p.first;
int j = p.second;
q.pop();
if (i + 1 < n && s[i + 1][j] != '#' && vis[{i + 1, j}] == 0) {
vis[{i + 1, j}] = 1;
q.push({i + 1, j});
}
if (i - 1 >= 0 && s[i - 1][j] != '#' && vis[{i - 1, j}] == 0) {
vis[{i - 1, j}] = 1;
q.push({i - 1, j});
}
if (j - 1 >= 0 && s[i][j - 1] != '#' && vis[{i, j - 1}] == 0) {
vis[{i, j - 1}] = 1;
q.push({i, j - 1});
}
if (j + 1 < m && s[i][j + 1] != '#' && vis[{i, j + 1}] == 0) {
vis[{i, j + 1}] = 1;
q.push({i, j + 1});
}
}
return 1;
}
void solve() {
int n, m;
cin >> n >> m;
int countG = 0;
string s[n];
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < m; j++) {
if (s[i][j] == 'G') countG++;
}
}
if (countG == 0) {
cout << "Yes" << endl;
return;
} else {
bool f = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == 'B') {
if (i + 1 < n && s[i + 1][j] != 'B') {
if (s[i + 1][j] == 'G') f = 1;
s[i + 1][j] = '#';
}
if (i - 1 >= 0 && s[i - 1][j] != 'B') {
if (s[i - 1][j] == 'G') f = 1;
s[i - 1][j] = '#';
}
if (j + 1 < m && s[i][j + 1] != 'B') {
if (s[i][j + 1] == 'G') f = 1;
s[i][j + 1] = '#';
}
if (j - 1 >= 0 && s[i][j - 1] != 'B') {
if (s[i][j - 1] == 'G') f = 1;
s[i][j - 1] = '#';
}
}
}
}
if (f) {
cout << "No" << endl;
return;
}
map<pair<int, int>, bool> vis;
if (!bfs(s, n, m, vis)) {
cout << "No" << endl;
return;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (s[i][j] == 'G' && vis[{i, j}] == 0) {
cout << "No" << endl;
return;
}
}
}
cout << "Yes" << endl;
return;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int x, y, g, s;
edge() : x(0), y(0), g(0), s(0) {}
edge(int x_, int y_, int g_, int s_) : x(x_), y(y_), g(g_), s(s_) {}
void operator=(const edge& rhs) {
x = rhs.x;
y = rhs.y;
g = rhs.g;
s = rhs.s;
}
};
int n, m, uf[205];
bool f[50005];
long long g, s, res = -1;
edge edges[50005];
void ufinit() {
for (int i = 0; i < 205; i++) uf[i] = i;
}
int uffind(int x) { return uf[x] == x ? x : uf[x] = uffind(uf[x]); }
inline bool cmp1(const edge& lhs, const edge& rhs) { return lhs.g < rhs.g; }
inline bool cmp2(const edge& lhs, const edge& rhs) { return lhs.s < rhs.s; }
int main() {
int x, y, p, cnt, k, gi, si;
edge cur;
scanf("%d %d %I64d %I64d", &n, &m, &g, &s);
for (int i = 0; i < m; i++) {
scanf("%d %d %d %d", &x, &y, &gi, &si);
x--;
y--;
edges[i] = edge(x, y, gi, si);
}
sort(edges, edges + m, cmp1);
p = 0;
for (int i = 0; i < m; i++) {
cur = edges[i];
edges[p++] = cur;
inplace_merge(edges, edges + p - 1, edges + p, cmp2);
int j = 0;
k = 0;
cnt = 0;
ufinit();
memset(f, false, sizeof(f));
while (j < p) {
x = uffind(edges[j].x);
y = uffind(edges[j].y);
if (x != y)
uf[x] = y, cnt++;
else
f[j] = true;
if (cnt == n - 1) break;
j++;
}
if (cnt == n - 1) {
long long cur_res = cur.g * g + edges[j].s * s;
if (res == -1 || res > cur_res) res = cur_res;
}
for (j = 0; j < p; j++)
if (!f[j]) edges[k++] = edges[j];
p = k;
}
printf("%I64d\n", res);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
double p, a, b, ans = 1e18;
pair<double, double> w[2003];
long long poww(long long x, long long y) {
if (x == 0) return 0;
if (x == 1) return 1;
if (y == 0) return 1;
if (y == 1) return x;
long long d = poww(x, y / 2);
d *= d;
if (y % 2) return (x * d);
return d;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
long long d1, d2;
cin >> d1 >> d2;
w[i].first = d1;
w[i].second = d2;
}
for (int i = 1; i <= n; i++) {
long long d1 = i - 1, d2 = i + 1;
if (i == 1) d1 = n;
if (i == n) d2 = 1;
double dx = w[d1].first - w[d2].first;
double dy = w[d1].second - w[d2].second;
if (dx == 0) {
ans = min(ans, abs(w[i].first - w[d1].first));
continue;
}
if (dy == 0) {
ans = min(ans, abs(w[i].second - w[d1].second));
continue;
}
double m = dy / dx;
double c = w[d1].second - m * w[d1].first;
double bs = abs(w[i].second - m * w[i].first - c);
double mq = sqrt(1 + m * m);
bs /= mq;
ans = min(ans, bs);
}
ans /= 2;
printf("%.10lf\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long infl = 1e8 + 5;
long long int n, m, k, q, x, y, mx = -1, mn = infl, f, val, sz, sm, cnt, ans,
t = 1, i, j, ind = -1;
char a[104][104];
int dist[104][104];
int xa[] = {0, 1, 0, -1};
int ya[] = {1, 0, -1, 0};
std::map<pair<long long int, long long int>,
pair<long long int, long long int> >
prv;
std::map<char, char> mp;
std::vector<char> v;
int main() {
memset(dist, -1, sizeof(dist));
cin >> n >> m;
pair<long long int, long long int> z;
for (i = 1; i < n + 1; i++) {
for (j = 1; j < m + 1; j++) {
cin >> a[i][j];
if (a[i][j] == 'F') {
dist[i][j] = infl;
z = make_pair(i, j);
}
}
}
queue<pair<long long int, long long int> > q;
dist[1][1] = 0;
q.push({1, 1});
prv[{1, 1}] = make_pair(1, 1);
while (true) {
x = q.front().first;
y = q.front().second;
for (i = 0; i < 4; i++) {
int u = x + xa[i];
int v = y + ya[i];
if (u <= 0 || u > n || v <= 0 || v > m) continue;
if (dist[u][v] == infl) {
dist[u][v] = dist[x][y] + 1;
prv[make_pair(u, v)] = q.front();
f = 1;
break;
}
if (dist[u][v] != -1 || a[u][v] == '*') continue;
dist[u][v] = dist[x][y] + 1;
prv[make_pair(u, v)] = q.front();
q.push(make_pair(u, v));
}
q.pop();
if (f) break;
}
pair<long long int, long long int> z1 = z;
while (prv[z] != z) {
if (z.first == prv[z].first) {
if (prv[z].second == z.second - 1)
v.push_back('R');
else
v.push_back('L');
} else {
if (prv[z].first == z.first - 1)
v.push_back('D');
else
v.push_back('U');
}
z = prv[z];
}
z = z1;
reverse(v.begin(), v.end());
mp['R'] = 'R';
mp['L'] = 'L';
mp['U'] = 'U';
mp['D'] = 'D';
if (a[1][2] == '.') {
cout << "R\n";
fflush(stdout);
cin >> x >> y;
if (make_pair(x, y) == z) return 0;
if (x == 1 && y == 1) {
mp['R'] = 'L';
mp['L'] = 'R';
} else {
cout << "L\n";
fflush(stdout);
cin >> x >> y;
if (make_pair(x, y) == z) return 0;
}
for (i = 1; i < m + 1; i++) {
if (a[2][i] != '*') {
cout << "D\n";
fflush(stdout);
cin >> x >> y;
if (make_pair(x, y) == z) return 0;
if (x == 1 && y == i) {
mp['U'] = 'D';
mp['D'] = 'U';
} else {
cout << "U\n";
fflush(stdout);
cin >> x >> y;
if (make_pair(x, y) == z) return 0;
}
while (cnt > 0) {
cout << mp['L'] << "\n";
fflush(stdout);
cin >> x >> y;
if (make_pair(x, y) == z) return 0;
cnt--;
}
break;
} else {
cout << mp['R'] << "\n";
fflush(stdout);
cin >> x >> y;
if (make_pair(x, y) == z) return 0;
}
cnt++;
}
} else {
cout << "D\n";
fflush(stdout);
cin >> x >> y;
if (make_pair(x, y) == z) return 0;
if (x == 1 && y == 1) {
mp['D'] = 'U';
mp['U'] = 'D';
} else {
cout << "U\n";
fflush(stdout);
cin >> x >> y;
if (make_pair(x, y) == z) return 0;
}
for (i = 1; i < n + 1; i++) {
if (a[i][2] != '*') {
cout << "R\n";
fflush(stdout);
cin >> x >> y;
if (make_pair(x, y) == z) return 0;
if (x == i && y == 1) {
mp['R'] = 'L';
mp['L'] = 'R';
} else {
cout << "L\n";
fflush(stdout);
cin >> x >> y;
if (make_pair(x, y) == z) return 0;
}
while (cnt > 0) {
cout << mp['U'] << "\n";
fflush(stdout);
cin >> x >> y;
if (make_pair(x, y) == z) return 0;
cnt--;
}
break;
} else {
cout << mp['D'] << "\n";
fflush(stdout);
cin >> x >> y;
if (make_pair(x, y) == z) return 0;
}
cnt++;
}
}
for (i = 0; i < (long long int)v.size(); i++) {
cout << mp[v[i]] << "\n";
fflush(stdout);
cin >> x >> y;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n, m, f[153][53][53][53], v[151][3], z, p = 51123987, u;
char s[160];
void inc(int &x, int y) { x = (x + y) % p; }
int K(int x, int y) { return x - y < 2 && y - x < 2; }
int main() {
scanf("%d%s", &n, s + 1);
for (int i = n; i; i--)
v[i][0] = v[i + 1][0], v[i][1] = v[i + 1][1], v[i][2] = v[i + 1][2],
v[i][s[i] - 'a'] = i;
f[1][0][0][0] = 1;
m = n / 3 + 2;
for (int i = 1; i <= n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < m; k++)
for (int l = 0; l < m; l++)
if (u = f[i][j][k][l]) {
if (j + k + l == n && K(j, k) && K(k, l) && K(l, j)) inc(z, u);
inc(f[v[i][0]][j + 1][k][l], u);
inc(f[v[i][1]][j][k + 1][l], u);
inc(f[v[i][2]][j][k][l + 1], u);
}
printf("%d", z);
}
| 3 |
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
typedef long long ll;
inline int rd(){
char c=getchar();int x=0,flag=1;
for(;c<'0'||c>'9';c=getchar())if(c=='-')flag=-1;
for(;c>='0'&&c<='9';c=getchar())x=x*10+c-'0';
return x*flag;
}
int len,sz[26]={0},nw[26]={0},c[200010],st[200010]={0},vec[26][200010];
char str[200010];bool vis[200010]={false};
inline void update(int x,int v){
for(;x<=len;x+=x&-x)
st[x]+=v;
return;
}
inline int ask(int x){
int res=0;
for(;x;x-=x&-x)
res+=st[x];
return res;
}
int main(){
scanf("%s",str+1);
len=strlen(str+1);
for(int i=1;i<=len;i++)
c[i]=str[i]-'a';
for(int i=1;i<=len;i++)
vec[c[i]][++sz[c[i]]]=i;
int flag=0;
for(int i=0;i<26;i++)
flag+=sz[i]&1;
if((len%2==0&&flag)||flag>1){
puts("-1");
return 0;
}
for(int i=1;i<=len;i++)
update(i,1);
ll ans=0;int num=0,sum=len;
for(int i=1;i<=len;i++){
if(vis[i])
continue;
nw[c[i]]++;num++;
if(nw[c[i]]>(sz[c[i]]>>1)){
ans+=(len>>1)+1-num;
continue;
}
ans+=sum-ask(vec[c[i]][sz[c[i]]-nw[c[i]]+1]);
update(i,-1);update(vec[c[i]][sz[c[i]]-nw[c[i]]+1],-1);
vis[i]=vis[vec[c[i]][sz[c[i]]-nw[c[i]]+1]]=true;
sum-=2;
}
printf("%lld\n",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
char s[1010];
int main() {
int n;
scanf("%d", &n);
scanf(" %s", s);
for (int i = 0; i < n; ++i) {
for (int j = 1; j <= n; ++j) {
bool ok = 1;
for (int k = 0; k < 5; ++k) {
int t = i + j * k;
if (t >= n || s[t] == '.') {
ok = 0;
break;
}
}
if (ok) {
puts("yes");
return 0;
}
}
}
puts("no");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
inline int rand(int x, int y) {
++y;
return (rng() % (y - x)) + x;
}
int TC, N, M;
int A[1000010], B[1000010];
pair<int, int> C[1000010];
int D[1000010];
struct node {
int second, e, m, lazy = 0;
pair<int, int> val;
node *l, *r;
node(int ss, int ee) {
second = ss;
e = ee;
m = (second + e) / 2;
if (second != e) {
l = new node(second, m);
r = new node(m + 1, e);
val = min(l->val, r->val);
} else
val = pair<int, int>(0, second);
}
void prop() {
if (lazy == 0 || second == e) return;
l->lazy += lazy;
r->lazy += lazy;
l->val.first += lazy;
r->val.first += lazy;
lazy = 0;
}
void upd(int a, int b, int c) {
prop();
if (a <= second && e <= b) {
val.first += c;
lazy += c;
} else if (a > e || second > b)
return;
else {
l->upd(a, b, c);
r->upd(a, b, c);
val = min(l->val, r->val);
}
}
} * root;
void upd(int x, int p) {
root->upd(x, N, -D[x]);
D[x] = p;
root->upd(x, N, D[x]);
}
vector<int> ans[1000010];
int fw[1000010 * 2];
void fwupd(int x, int p) {
for (int i = x; i <= N + M; i += i & (-i)) fw[i] += p;
}
int fwqry(int x) {
int ans = 0;
for (int i = x; i > 0; i -= i & (-i)) ans += fw[i];
return ans;
}
void solve() {
cin >> N >> M;
for (int i = 1; i <= int(N); ++i) {
cin >> A[i];
C[i] = pair<int, int>(A[i], i);
}
for (int i = 1; i <= int(M); ++i) cin >> B[i];
sort(B + 1, B + M + 1);
sort(C + 1, C + N + 1);
root = new node(0, N);
for (int i = 1; i <= int(N); ++i) D[i] = 0;
for (int i = 1; i <= int(N); ++i) upd(i, 1);
for (int i = 0; i <= int(N); ++i) ans[i].clear();
int k = 1;
for (int i = 1; i <= int(M); ++i) {
while (k <= N && C[k].first < B[i]) {
upd(C[k].second, -1);
k++;
}
if (i == 1 || B[i] != B[i - 1]) {
for (int j = k; j <= N && C[j].first == B[i]; j++) upd(C[j].second, 0);
}
ans[root->val.second].push_back(B[i]);
}
vector<int> v;
for (auto i : ans[0]) v.push_back(i);
for (int i = 1; i <= int(N); ++i) {
v.push_back(A[i]);
for (auto j : ans[i]) v.push_back(j);
}
vector<int> v2;
for (auto i : v) v2.push_back(i);
sort((v2).begin(), (v2).end());
v2.erase(unique((v2).begin(), (v2).end()), v2.end());
for (int i = 1; i <= int(N + M); ++i) fw[i] = 0;
for (int i = 0; i <= int(v.size() - 1); ++i)
v[i] = lower_bound((v2).begin(), (v2).end(), v[i]) - v2.begin() + 1;
long long ans = 0;
for (auto i : v) {
ans += fwqry(N + M) - fwqry(i);
fwupd(i, 1);
}
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(0);
cin >> TC;
while (TC--) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
int B[n / 2];
for (int i = 0; i < n / 2; i++) {
B[i] = a[i] + a[n - i - 1];
}
long long int total = 0;
for (int i = 0; i < n / 2; i++) {
total += B[i] * B[i];
}
cout << total;
}
| 3 |
#include <bits/stdc++.h>
int t;
char a[2010], b[2010];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%s%s", a + 1, b + 1);
int n = strlen(a + 1), m = strlen(b + 1);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m && i + j - 1 <= n; j++)
if (a[i + j - 1] != b[j])
break;
else {
if (i + j - 1 - 1 < m - j) continue;
int bk = 1;
for (int p = j + 1, q = i + j - 1 - 1; q && p <= m; q--, p++)
if (a[q] != b[p]) {
bk = 0;
break;
}
if (bk) {
puts("YES");
goto fo;
}
}
}
puts("NO");
fo:;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
const int inf = 0x3f3f3f3f;
int n, m, S[maxn], M[maxn], R[maxn], b[maxn], c[maxn];
long long sumM[maxn];
inline pair<long long, long long> operator+(pair<long long, long long> a,
pair<long long, long long> b) {
return make_pair(a.first + b.first, a.second + b.second);
}
struct CM {
int op, rt[maxn], ls[maxn * 20], rs[maxn * 20], sz;
long long val[maxn * 20], sum[maxn * 20], w[maxn * 20];
void update(int &x, int y, int l, int r, int pos, int p) {
x = ++sz;
ls[x] = ls[y];
rs[x] = rs[y];
val[x] = val[y] + R[p];
sum[x] = sum[y] + M[p] - ((op == 0) ? S[p] : 0);
if (l == r) return;
int mid = (l + r) >> 1;
if (pos <= mid)
update(ls[x], ls[y], l, mid, pos, p);
else
update(rs[x], rs[y], mid + 1, r, pos, p);
}
pair<long long, long long> query(int u, int v, int L, int R, int l, int r) {
if (L <= l && r <= R) return make_pair(val[v] - val[u], sum[v] - sum[u]);
int mid = (l + r) >> 1;
pair<long long, long long> ans = make_pair(0, 0);
if (L <= mid) ans = ans + query(ls[u], ls[v], L, R, l, mid);
if (R > mid) ans = ans + query(rs[u], rs[v], L, R, mid + 1, r);
return ans;
}
} T[2];
struct node {
int l, r, val;
node(int _l = 0, int _r = 0, int _val = 0) : l(_l), r(_r), val(_val) {}
};
set<node> s;
inline bool operator<(const node &a, const node &b) { return a.l < b.l; }
inline set<node>::iterator split(int x) {
set<node>::iterator it = s.lower_bound(node(x));
if (it != s.end() && it->l == x) return it;
it--;
int l = it->l, r = it->r, val = it->val;
s.erase(it);
s.insert(node(l, x - 1, val));
return s.insert(node(x, r, val)).first;
}
inline long long ask(int t, int x, int y) {
set<node>::iterator R = split(y + 1), L = split(x);
int l, r, val;
long long ans = sumM[y] - sumM[x - 1];
pair<long long, long long> res;
for (set<node>::iterator it = L; it != R; it++) {
l = it->l;
r = it->r;
val = it->val;
if (val == 0)
res = T[0].query(T[0].rt[l - 1], T[0].rt[r], min(100001, t - val + 1),
100001, 0, 100001);
else
res = T[1].query(T[1].rt[l - 1], T[1].rt[r], min(100001, t - val + 1),
100001, 0, 100001);
ans += res.first * (t - val) - res.second;
}
s.erase(L, R);
s.insert(node(x, y, t));
return ans;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d%d%d", &S[i], &M[i], &R[i]);
for (int i = 1; i <= n; i++) {
b[i] = (R[i] == 0) ? 100001
: (M[i] - S[i]) / R[i] + ((M[i] - S[i]) % R[i] > 0);
c[i] = (R[i] == 0) ? 100001 : M[i] / R[i] + (M[i] % R[i] > 0);
sumM[i] = sumM[i - 1] + M[i];
}
T[0].op = 0;
T[1].op = 1;
for (int i = 1; i <= n; i++)
T[0].rt[i] = T[0].rt[i - 1],
T[0].update(T[0].rt[i], T[0].rt[i], 0, 100001, b[i], i);
for (int i = 1; i <= n; i++)
T[1].rt[i] = T[1].rt[i - 1],
T[1].update(T[1].rt[i], T[1].rt[i], 0, 100001, c[i], i);
s.insert(node(1, n, 0));
s.insert(node(n + 1, n + 1, 0));
scanf("%d", &m);
int t, l, r;
while (m--) {
scanf("%d%d%d", &t, &l, &r);
printf("%I64d\n", ask(t, l, r));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
std::mt19937 rnd(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 500000;
const int MAXQ = 100000;
const int MAXS = 4 * MAXN;
struct Val {
int sz, prefl, prefr, suffl, suffr, preflr, prefrl, sufflr, suffrl, insidelr,
insiderl;
};
int n, nq;
char s[MAXN + 1];
int ql[MAXQ], qr[MAXQ], qans[MAXQ];
Val smake(char c) {
Val ret;
ret.sz = 1, ret.preflr = ret.prefrl = ret.sufflr = ret.suffrl = ret.insidelr =
ret.insiderl = 1;
if (c == '<')
ret.prefl = 1, ret.prefr = 0, ret.suffl = 1, ret.suffr = 0;
else if (c == '>')
ret.prefl = 0, ret.prefr = 1, ret.suffl = 0, ret.suffr = 1;
else
assert(false);
return ret;
}
Val smerge(const Val& a, const Val& b) {
Val ret;
ret.sz = a.sz + b.sz;
ret.prefl = a.prefl + (a.prefl == a.sz ? b.prefl : 0);
ret.prefr = a.prefr + (a.prefr == a.sz ? b.prefr : 0);
ret.suffl = b.suffl + (b.suffl == b.sz ? a.suffl : 0);
ret.suffr = b.suffr + (b.suffr == b.sz ? a.suffr : 0);
ret.preflr =
a.preflr + (a.preflr == a.sz ? a.prefl == a.sz ? b.preflr : b.prefr : 0);
ret.prefrl =
a.prefrl + (a.prefrl == a.sz ? a.prefr == a.sz ? b.prefrl : b.prefl : 0);
ret.sufflr =
b.sufflr + (b.sufflr == b.sz ? b.suffr == b.sz ? a.sufflr : a.suffl : 0);
ret.suffrl =
b.suffrl + (b.suffrl == b.sz ? b.suffl == b.sz ? a.suffrl : a.suffr : 0);
ret.insidelr = max(max(a.insidelr, b.insidelr),
max(a.sufflr + b.prefr, a.suffl + b.preflr));
ret.insiderl = max(max(a.insiderl, b.insiderl),
max(a.suffrl + b.prefl, a.suffr + b.prefrl));
return ret;
}
void sinvert(Val& a) {
swap(a.prefl, a.prefr);
swap(a.suffl, a.suffr);
swap(a.preflr, a.prefrl);
swap(a.sufflr, a.suffrl);
swap(a.insidelr, a.insiderl);
}
bool slazy[MAXS];
Val sval[MAXS];
void sapply(int x) {
sinvert(sval[x]);
slazy[x] = !slazy[x];
}
void spush(int x) {
if (slazy[x]) sapply(2 * x + 1), sapply(2 * x + 2), slazy[x] = false;
}
void spull(int x) { sval[x] = smerge(sval[2 * x + 1], sval[2 * x + 2]); }
void sinit(int x, int l, int r) {
slazy[x] = false;
if (l == r) {
sval[x] = smake(s[l]);
} else {
int m = l + (r - l) / 2;
sinit(2 * x + 1, l, m);
sinit(2 * x + 2, m + 1, r);
spull(x);
}
}
void stoggle(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) {
sapply(x);
} else {
int m = l + (r - l) / 2;
spush(x);
if (L <= m) stoggle(2 * x + 1, l, m, L, R);
if (m + 1 <= R) stoggle(2 * x + 2, m + 1, r, L, R);
spull(x);
}
}
Val sget(int x, int l, int r, int L, int R) {
if (L <= l && r <= R) {
return sval[x];
} else {
int m = l + (r - l) / 2;
spush(x);
if (L > m) return sget(2 * x + 2, m + 1, r, L, R);
if (m + 1 > R) return sget(2 * x + 1, l, m, L, R);
return smerge(sget(2 * x + 1, l, m, L, R), sget(2 * x + 2, m + 1, r, L, R));
}
}
void solve() {
sinit(0, 0, n - 1);
for (int i = (0); i < (nq); ++i) {
int l = ql[i], r = qr[i];
stoggle(0, 0, n - 1, l, r);
Val val = sget(0, 0, n - 1, l, r);
qans[i] = val.insiderl;
}
}
void run() {
scanf("%d%d", &n, &nq);
scanf("%s", s);
assert(strlen(s) == n);
for (int i = (0); i < (nq); ++i)
scanf("%d%d", &ql[i], &qr[i]), --ql[i], --qr[i];
solve();
for (int i = (0); i < (nq); ++i) printf("%d\n", qans[i]);
}
int main() {
run();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char O[100010];
string s, t;
int n, m;
int dp[40][100010];
const int MAX = 300010;
string txt;
int iSA[MAX], SA[MAX];
int cnt[MAX], hehe[MAX];
bool bh[MAX], b2h[MAX];
bool smaller_first_char(int a, int b) { return txt[a] < txt[b]; }
void suffixSort(int n) {
for (int i = 0; i < n; ++i) {
SA[i] = i;
}
sort(SA, SA + n, smaller_first_char);
for (int i = 0; i < n; ++i) {
bh[i] = i == 0 || txt[SA[i]] != txt[SA[i - 1]];
b2h[i] = false;
}
for (int h = 1; h < n; h <<= 1) {
int buckets = 0;
for (int i = 0, j; i < n; i = j) {
j = i + 1;
while (j < n && !bh[j]) j++;
hehe[i] = j;
buckets++;
}
if (buckets == n) break;
for (int i = 0; i < n; i = hehe[i]) {
cnt[i] = 0;
for (int j = i; j < hehe[i]; ++j) {
iSA[SA[j]] = i;
}
}
cnt[iSA[n - h]]++;
b2h[iSA[n - h]] = true;
for (int i = 0; i < n; i = hehe[i]) {
for (int j = i; j < hehe[i]; ++j) {
int s = SA[j] - h;
if (s >= 0) {
int head = iSA[s];
iSA[s] = head + cnt[head]++;
b2h[iSA[s]] = true;
}
}
for (int j = i; j < hehe[i]; ++j) {
int s = SA[j] - h;
if (s >= 0 && b2h[iSA[s]]) {
for (int k = iSA[s] + 1; !bh[k] && b2h[k]; k++) b2h[k] = false;
}
}
}
for (int i = 0; i < n; ++i) {
SA[iSA[i]] = i;
bh[i] |= b2h[i];
}
}
for (int i = 0; i < n; ++i) {
iSA[SA[i]] = i;
}
}
int lcp[MAX];
void getlcp(int n) {
for (int i = 0; i < n; ++i) iSA[SA[i]] = i;
lcp[0] = 0;
for (int i = 0, h = 0; i < n; ++i) {
if (iSA[i] > 0) {
int j = SA[iSA[i] - 1];
while (i + h < n && j + h < n && txt[i + h] == txt[j + h]) h++;
lcp[iSA[i]] = h;
if (h > 0) h--;
}
}
}
int pos[200010];
int rmq[20][200010];
int logx[200010];
const int logn = 19;
int minValue(int x, int y) {
int size = y - x + 1;
int bk = logx[size];
return min(rmq[bk][x], rmq[bk][y - (1 << bk) + 1]);
}
int getPrefix(int p, int q) {
if (p >= n) return 0;
if (q >= m) return 0;
int P = pos[p];
int Q = pos[q + n + 1];
if (P > Q) swap(P, Q);
return minValue(P + 1, Q);
}
int main() {
scanf("%d", &n);
scanf("%s", O);
s = O;
scanf("%d", &m);
scanf("%s", O);
t = O;
txt = s + "#" + t;
int size = txt.size();
suffixSort(size);
getlcp(size);
for (int i = 0; i < size; i++) {
pos[SA[i]] = i;
}
for (int i = 0; i < size; i++) {
rmq[0][i] = lcp[i];
}
for (int i = 1; i <= logn; i++) {
for (int j = 0; j < size; j++) {
if (j + (1 << (i - 1)) < size)
rmq[i][j] = min(rmq[i - 1][j], rmq[i - 1][j + (1 << (i - 1))]);
}
}
logx[1] = 0;
for (int i = 2; i <= size; i++) {
logx[i] = logx[i >> 1] + 1;
}
int X;
scanf("%d", &X);
for (int i = 0; i < X; i++) {
for (int j = 1; j <= n; j++) {
dp[i][j] = max(dp[i][j], dp[i][j - 1]);
}
for (int j = 0; j <= n; j++) {
int cp = getPrefix(j, dp[i][j]);
dp[i + 1][j + cp] = max(dp[i + 1][j + cp], dp[i][j] + cp);
}
}
bool good = false;
for (int i = 0; i <= n; i++) {
if (dp[X][i] >= m) {
good = true;
break;
}
}
if (good)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 99999;
int d[maxn], s[maxn];
int n;
int m;
queue<int> q;
vector<pair<int, int> > p;
bool inq[maxn];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%d %d", &d[i], &s[i]), m += d[i];
if (d[i] == 1) q.push(i);
}
m /= 2;
while (!q.empty()) {
int x = q.front();
q.pop();
if (d[x] <= 0) continue;
int y = s[x];
p.push_back(make_pair(x, y));
s[y] ^= x;
d[y]--;
if (d[y] == 1) q.push(s[x]);
}
printf("%d\n", p.size());
for (int i = 0; i < p.size(); i++) printf("%d %d\n", p[i].first, p[i].second);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int N;
long long int pt[100005][2];
long long int CP(long long int x1, long long int y1, long long int x2,
long long int y2) {
return x1 * y2 - y1 * x2;
}
bool dir(long long int x1, long long int y1, long long int x2,
long long int y2) {
long long int cp = CP(x1, y1, x2, y2);
return cp >= 0;
}
int main() {
cin >> N;
for (int i = 0; i < N; ++i) {
cin >> pt[i][0] >> pt[i][1];
}
int t;
cin >> t;
long long int px, py;
while (t--) {
cin >> px >> py;
bool valid = 1;
for (int i = 0; i < N; ++i) {
int start = i;
int end = (i + 1) % N;
if (dir(px - pt[start][0], py - pt[start][1], pt[end][0] - pt[start][0],
pt[end][1] - pt[start][1]) == 0) {
valid = 0;
break;
}
}
if (valid == 0) {
cout << "0\n";
continue;
}
long long int ans = (long long int)N * (N - 1) * (N - 2) / 6;
int start = 0, end = 1;
int sc = 0, ec = 1;
while (1) {
while (dir(px - pt[start][0], py - pt[start][1],
pt[end][0] - pt[start][0], pt[end][1] - pt[start][1])) {
end = (end + 1) % N;
ec++;
}
if (end == 0)
end = N - 1;
else
end--;
ec--;
long long int term = (long long int)(ec - sc - 1) * (ec - sc) / 2;
ans -= term;
start = (start + 1) % N;
;
sc++;
if (start == 0) break;
}
cout << ans << endl;
}
return 0;
}
| 5 |
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=100010;
int n,tot,Next[N<<1],head[N],tree[N<<1],In[N],color[N],Q[N],sum,Max,a[N],f[N],g[N];
char s[N];
bool vis[N];
void add(int x,int y)
{
tot++;
Next[tot]=head[x];
head[x]=tot;
tree[tot]=y;
}
int calc(int id,int x) { return (!color[id])^(x&1);}
void dfs(int u,int fa)
{
bool flag=0;
int Max1=0,Max2=0;
for (int i=head[u];i;i=Next[i])
{
int v=tree[i];
if (v==fa||vis[v]) continue;
flag=1;
dfs(v,u);
Max=max(Max,max(Max1+g[v]+a[u],Max2+f[v]+a[u]));
Max1=max(Max1,f[v]);
Max2=max(Max2,g[v]);
}
f[u]=Max1+a[u];
if (!flag) g[u]=-(1<<29);
else g[u]=Max2+a[u];
}
void pre()
{
int t=0,w=0;
for (int i=1;i<=n;i++)
if (In[i]==1&&color[i]) Q[++w]=i;
while (t<w)
{
int u=Q[++t];
vis[u]=1;
for (int i=head[u];i;i=Next[i])
{
int v=tree[i];
In[v]--;
if (In[v]==1&&color[v]) Q[++w]=v;
}
}
}
int main()
{
scanf("%d",&n);
for (int i=1;i<n;i++)
{
int x,y;
scanf("%d%d",&x,&y);
add(x,y);add(y,x);
In[x]++;In[y]++;
}
scanf("%s",s+1);
for (int i=1;i<=n;i++) color[i]=(s[i]=='B');
pre();
int root=0;
sum=Max=0;
for (int i=1;i<=n;i++)
if (!vis[i])
{
if (!root) root=i;
if (calc(i,In[i])) sum++,a[i]=2;
sum+=In[i];
}
if (!root) { puts("0");return 0;}
dfs(root,0);
printf("%d\n",sum-Max);
return 0;
}
| 0 |
#include <bits/stdc++.h>
typedef long long ll;
const ll M = 1000000007;
int n, m, k;
ll f[1000010], fi[1000010], thr[1000010], ans;
ll pw(ll x, ll k){
if(k == 1) return x;
return (k % 2 ? x : 1) * pw(x * x % M, k / 2) % M;
}
ll cm(int n, int r){
return f[n] * fi[r] % M * fi[n - r] % M;
}
ll cal(int x, int b){
ll ret = 0, s = 1;
for(int i = 0; i <= x; i++){
ret = (ret + thr[m + k - i - b] * cm(n - 1 + i + b, n - 1) % M * s) % M;
s = (2 * s - cm(i + b, i) + cm(i + b + 1, i + 1) + M) % M;
}
return ret;
}
int main(){
scanf("%d%d%d", &n, &m, &k);
f[0] = fi[0] = thr[0] = 1;
for(int i = 1; i <= 1000005; i++){
f[i] = f[i - 1] * i % M;
fi[i] = pw(f[i], M - 2);
thr[i] = thr[i - 1] * 3 % M;
}
printf("%lld\n", (cal(m + k, 0) - cal(m - 1, k + 1) - cal(k - 1, m + 1) + 2 * M) % M);
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
using namespace std;
const int N = 100005;
const int inf = 1000 * 1000 * 1000;
const int mod = 1000 * 1000 * 1000 + 7;
int n, m;
vector<int> g[N];
int p[N], t[N];
int sz[N];
void dfs(int v) {
sz[v] = 1;
for (int i = 0; i < (int)g[v].size(); i++) {
int to = g[v][i];
dfs(to);
sz[v] += sz[to];
if (sz[to] > sz[g[v][0]]) swap(g[v][0], g[v][i]);
}
}
int tin[N], tout[N], timer;
int id[N], nxt[N];
void hld(int v) {
tin[v] = ++timer;
id[timer] = v;
for (int i = 0; i < (int)g[v].size(); i++) {
int to = g[v][i];
if (i == 0) nxt[to] = nxt[v];
hld(to);
}
tout[v] = timer;
}
int answ = 0;
bool used[N];
int mas[N];
void upd1(int l, int r) {
for (int i = l; i <= r; i++) {
mas[i]--;
answ += (mas[i] == -1);
}
}
void upd2(int l, int r) {
for (int i = l; i <= r; i++) {
mas[i]++;
answ -= (mas[i] == 0);
}
}
void update1(int v) {
if (mas[tin[v]] < 0) --answ;
mas[tin[v]] += inf;
used[tin[v]] = true;
while (nxt[v] != 1) {
upd1(tin[nxt[v]], tin[v]);
v = p[nxt[v]];
}
upd1(tin[1], tin[v]);
}
void update2(int v) {
mas[tin[v]] -= inf;
if (mas[tin[v]] < 0) ++answ;
used[tin[v]] = false;
while (nxt[v] != 1) {
upd2(tin[nxt[v]], tin[v]);
v = p[nxt[v]];
}
upd2(tin[1], tin[v]);
}
int main() {
mt19937 myrand(chrono::steady_clock::now().time_since_epoch().count());
scanf("%d%d", &n, &m);
for (int i = 2; i <= n; i++) {
scanf("%d", &p[i]);
g[p[i]].push_back(i);
}
for (int i = 1; i <= n; i++) {
scanf("%d", &t[i]);
}
dfs(1);
iota(nxt + 1, nxt + n + 1, 1);
hld(1);
for (int i = 1; i <= n; i++) {
mas[tin[i]] = t[i];
}
while (m--) {
int v;
scanf("%d", &v);
if (v > 0)
update1(v);
else
update2(-v);
printf("%d ", answ);
}
cout << endl;
return 0;
}
| 5 |
#include<iostream>
using namespace std;
typedef long long ll;
int main(){
ll n,t,sum=0;
cin>>n;
for(int i=0;i<n;i++){
cin>>t;
sum+=t;
}
cout<<sum/n<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n, m;
cin >> n >> m;
vector<int> used(n * 3, 0);
vector<int> matching;
for (int j = 0; j < m; j++) {
int u, v;
cin >> u >> v;
u--;
v--;
if (used[u] == 0 && used[v] == 0) {
matching.push_back(j + 1);
used[u]++;
used[v]++;
}
}
if ((int)matching.size() >= n) {
cout << "Matching" << endl;
for (int j = 0; j < n; j++) {
cout << matching[j] << " ";
}
cout << endl;
continue;
} else {
cout << "IndSet" << endl;
vector<int> indset;
for (int j = 0; j < 3 * n; j++) {
if (used[j] == 0) {
indset.push_back(j + 1);
}
}
for (int j = 0; j < min(n, (int)indset.size()); j++) {
cout << indset[j] << " ";
}
cout << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
const int mod = 1000000007;
inline int fastpow(int a, int n)
{
int ans = 1;
while(n)
{
if(n & 1)
ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
inline int inv(int x)
{
return fastpow(x, mod - 2);
}
int inv2 = inv(2);
int n;
struct Edge
{
int to, nxt;
}e[401];
int head[201], ecnt = 0;
inline void addedge(int from, int to)
{
e[ecnt].to = to;
e[ecnt].nxt = head[from];
head[from] = ecnt++;
}
int fa[201], dep[201], sz[201];
void InitTree(int u)
{
sz[u] = 1;
for(int i = head[u]; i != -1; i = e[i].nxt)
{
int v = e[i].to;
if(v == fa[u])
continue;
fa[v] = u;
dep[v] = dep[u] + 1;
InitTree(v);
sz[u] += sz[v];
}
}
int logn;
int st[201][10];
inline void Initst()
{
logn = ceil(log2(n));
for(int i = 1; i <= n; i++)
st[i][0] = i;
for(int i = 1; i <= logn; i++)
for(int j = 1; j <= n; j++)
st[j][i] = st[fa[st[j][i - 1]]][i - 1];
}
inline void up(int &u, int &v)
{
if(dep[u] > dep[v])
swap(u, v);
int d = dep[v] - dep[u];
for(int i = logn; i >= 0; i--)
if(d >= (1 << i))
v = fa[st[v][i]], d -= (1 << i);
}
inline int LCA(int u, int v)
{
up(u, v);
for(int i = logn; i >= 0; i--)
if(st[u][i] != st[v][i])
u = fa[st[u][i]], v = fa[st[v][i]];
return u;
}
int pro[201][201];
inline void InitProb()
{
for(int i = 1; i <= n; i++)
pro[i][0] = 0, pro[0][i] = 1;
for(int i = 1; i <= n; i++)
for(int j = 1; j <= n; j++)
pro[i][j] = (pro[i - 1][j] + pro[i][j - 1]) * inv2 % mod;
}
signed main()
{
memset(head, -1, sizeof(head));
scanf("%lld", &n);
for(int i = 1; i < n; i++)
{
int u, v;
scanf("%lld %lld", &u, &v);
addedge(u, v);
addedge(v, u);
}
fa[1] = 1, dep[1] = 0;
InitTree(1);
Initst();
InitProb();
int ans = 0;
for(int i = 1; i <= n; i++)
for(int j = i + 1; j <= n; j++)
{
int tot = 0;
int lca = LCA(i, j);
if(lca == i)
{
tot = sz[j];
int len = dep[j] - dep[i], pre, u, cnt;
for(pre = j, u = fa[j], cnt = 1; u != i; pre = u, u = fa[u], cnt++)
tot = (tot + pro[cnt][len - cnt] * (sz[u] - sz[pre])) % mod;
}
else if(lca == j)
{
int len = dep[i] - dep[j], pre, u, cnt;
for(pre = i, u = fa[i], cnt = 1; u != j; pre = u, u = fa[u], cnt++)
tot = (tot + pro[len - cnt][cnt] * (sz[u] - sz[pre])) % mod;
tot = (tot + n - sz[pre]) % mod;
}
else
{
tot = sz[j];
int leni = dep[i] - dep[lca], lenj = dep[j] - dep[lca];
int pre, u, cnt;
for(pre = i, u = fa[i], cnt = 1; u != lca; pre = u, u = fa[u], cnt++)
tot = (tot + pro[leni - cnt + lenj][cnt] * (sz[u] - sz[pre])) % mod;
int soni = pre;
for(pre = j, u = fa[j], cnt = 1; u != lca; pre = u, u = fa[u], cnt++)
tot = (tot + pro[cnt][lenj - cnt + leni] * (sz[u] - sz[pre])) % mod;
int sonj = pre;
tot = (tot + pro[lenj][leni] * (n - sz[soni] - sz[sonj])) % mod;
}
ans = (ans + tot) % mod;
}
ans = ans * inv(n) % mod;
printf("%lld\n", ans);
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
void init() {
cin.tie(0);
cin.sync_with_stdio(0);
cout.tie(0);
}
struct point {
double x, y;
point() { x = y = 0.0; }
point(double _x, double _y) : x(_x), y(_y) {}
bool operator<(point other) const {
if ((fabs(x - other.x) > 1e-9)) return x < other.x;
return y < other.y;
}
bool operator==(point other) const {
return fabs(x - other.x) < 1e-9 && fabs(y - other.y) < 1e-9;
}
point operator+(const point& p) const { return point(x + p.x, y + p.y); }
point operator-(const point& p) const { return point(x - p.x, y - p.y); }
};
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
double dist(point p1, point p2) { return hypot(p1.x - p2.x, p1.y - p2.y); }
int dcmp(double a, double b) {
if (fabs(a - b) <= 1e-9) return 0;
return 1;
}
const int N = 1e6;
bool g[10000];
bool ok;
int cnt, ans;
bool b[N];
int main() {
init();
double x1, x2, x3, y1, y2, y3;
cin >> x1 >> y1;
point a(x1, y1);
cin >> x2 >> y2;
point b(x2, y2);
cin >> x3 >> y3;
point c(x3, y3);
cout << '3' << '\n';
point z = c + b - a;
cout << z.x << " " << z.y << '\n';
z = c + a - b;
cout << z.x << " " << z.y << '\n';
z = a + b - c;
cout << z.x << " " << z.y;
}
| 2 |
#include <bits/stdc++.h>
long long T, n, m;
int main() {
scanf("%lld", &T);
while (T--) {
scanf("%lld%lld", &n, &m);
if (n == 1)
printf("%lld\n", n - 1);
else if (n == 2)
printf("%lld\n", m);
else
printf("%lld\n", 2 * m + 1 - 1);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1510;
int n, q, tim, f[maxn], c[maxn][maxn], vis[maxn * maxn];
vector<pair<int, int>> S[maxn][maxn];
int main() {
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
scanf("%d", &c[i][j]);
}
}
for (int i = n; i; i--) {
for (int j = n; j; j--) {
vector<pair<int, int>> V = {{0, c[i][j]}};
auto upd = [&](vector<pair<int, int>> &S) {
vector<pair<int, int>> T(V.size() + S.size());
merge(V.begin(), V.end(), S.begin(), S.end(), T.begin()), V = T;
};
upd(S[i][j + 1]), upd(S[i + 1][j]);
upd(S[i + 1][j + 1]), tim++;
for (auto p : V) if (vis[p.second] ^ tim) {
vis[p.second] = tim;
S[i][j].emplace_back(p.first + 1, p.second);
if (S[i][j].size() > q) break;
}
int t = S[i][j].size() > q ? S[i][j][q].first : INT_MAX;
f[1]++, f[min({n - i + 2, n - j + 2, t})]--;
}
}
for (int i = 1; i <= n; i++) {
printf("%d\n", f[i] += f[i - 1]);
}
return 0;
} | 4 |
#include<cstdio>
#include<cmath>
int n,m,a[100][100],ans,sum,t;
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
scanf("%d",&a[i][j]);
for(int j=1;j<i;j++)
{
sum=0;
for(int k=1;k<=m;k++)
sum+=(a[i][k]-a[j][k])*(a[i][k]-a[j][k]);
t=sqrt(sum);
if(t*t==sum)ans++;
}
}
printf("%d",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int A[1000000];
int S[1000000];
int T[1000000];
int P[1000000];
long long N, K, L;
long long LN;
long long R = 0;
int TL = 0;
long long mul(long long a, long long b) { return (a * b) % 1000000007; }
long long add(long long a, long long b) { return (a + b) % 1000000007; }
void addsol(long long x) { R = (R + x) % 1000000007; }
void addsol(long long x, int k) {
long long t = LN - k + 1;
if (t > 0) addsol(mul(x, t % 1000000007));
}
int main() {
scanf("%I64d%I64d%I64d", &N, &L, &K);
LN = L / N;
K = min(K, LN + 3);
for (int i = 0; i < N; i++) {
scanf("%d", &A[i]);
S[i] = A[i];
}
sort(S, S + N);
TL = 0;
T[0] = 1;
for (int i = 1; i < N; i++) {
if (S[i] == S[i - 1]) {
T[TL]++;
} else {
P[TL] += T[TL];
TL++;
P[TL] = P[TL - 1];
T[TL]++;
}
}
P[TL] += T[TL];
TL++;
long long D[TL][K];
long long PD[TL][K];
PD[0][0] = 0;
for (int i = 0; i < TL; i++) {
D[i][0] = T[i];
if (i != 0)
PD[i][0] = add(D[i][0], PD[i - 1][0]);
else
PD[i][0] = D[i][0];
addsol(D[i][0], 1);
}
for (int j = 1; j < K; j++) {
for (int i = 0; i < TL; i++) {
D[i][j] = mul(PD[i][j - 1], T[i]);
if (i != 0) {
PD[i][j] = add(PD[i - 1][j], D[i][j]);
} else
PD[0][j] = D[i][j];
addsol(D[i][j], j + 1);
}
}
long long rem = L % N;
addsol(rem);
for (int i = 0; i < rem; i++) {
int si = (lower_bound(S, S + N, A[i]) - S);
int di = (upper_bound(P, P + TL, si) - P);
for (int j = 1; j < min(K, LN + 1); j++) {
addsol(PD[di][j - 1]);
}
}
cout << R << endl;
}
| 2 |
#include<bits/stdc++.h>
#define N 400005
using namespace std;
int n,fa[N],rd[N],fl[N],a[N];
vector<int>s[N];
void OK()
{
puts("POSSIBLE");
exit(0);
}
void dfs(int x)
{
//cout<<x<<endl;
rd[x]=-1;
for (int i=0;i<s[x].size();i++)
fl[a[s[x][i]]]=x;
for (;fl[a[x]]==x;a[x]++);
rd[fa[x]]--;
s[fa[x]].push_back(x);
if (!rd[fa[x]]) dfs(fa[x]);
}
int main()
{
scanf("%d",&n);
for (int i=1;i<=n;i++)
{
scanf("%d",&fa[i]);
rd[fa[i]]++;
}
for (int i=1;i<=n;i++)
if (rd[i]==0) dfs(i);
//puts("ok");
for (int i=1;i<=n;i++)
if (rd[i]>0)
{
for (int j=0;j<s[i].size();j++)
fl[a[s[i][j]]]=i;
for (;fl[a[i]]==i;a[i]++);
//cout<<a[i]<<endl;
int t=fa[i],lst=i;
while(t!=i)
{
for (int j=0;j<s[t].size();j++)
fl[a[s[t][j]]]=t;
fl[a[lst]]=t;
for (;fl[a[t]]==t;a[t]++);
lst=t;t=fa[t];
}
if (a[lst]!=a[i])OK();
a[i]=a[i]+1;
t=fa[i],lst=i;
while(t!=i)
{
for (int j=0;j<s[t].size();j++)
fl[a[s[t][j]]]=t+n;
fl[a[lst]]=t+n;
for (a[t]=0;fl[a[t]]==t+n;a[t]++);
lst=t;t=fa[t];
}
if (a[lst]==a[i]-1)OK();
puts("IMPOSSIBLE");return 0;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long const M = 2e5 + 10, M2 = 1e7 + 10, mod = 1e9 + 7, inf = 1e9 + 10;
long double seg[M * 4], lazy[M * 4], p[M * 4];
long long tmp;
void shift(long long id1, long long id2, long long len) {
p[id2] *= p[id1];
seg[id2] = (p[id1]) * seg[id2] + lazy[id1] * (long double)len;
lazy[id2] = p[id1] * lazy[id2] + lazy[id1];
}
void upd(long long l, long long r, long long st, long long en, long double inc,
long long node) {
if (st <= l && r <= en) {
seg[node] = ((long double)1 / (long double)(tmp)) * inc * (r - l) +
((long double)(tmp - 1) / (long double)(tmp)) * seg[node];
p[node] *= (long double)(tmp - 1) / (long double)(tmp);
lazy[node] = ((long double)1 / (long double)(tmp)) * inc +
((long double)(tmp - 1) / (long double)(tmp)) * lazy[node];
return;
}
if (st >= r || l >= en) return;
long long mid = (l + r) >> 1;
shift(node, node * 2, mid - l);
shift(node, node * 2 + 1, r - mid);
p[node] = 1, lazy[node] = 0;
upd(l, mid, st, en, inc, node * 2);
upd(mid, r, st, en, inc, node * 2 + 1);
seg[node] = seg[node * 2] + seg[node * 2 + 1];
}
long double get(long long l, long long r, long long st, long long en,
long long node) {
if (st <= l && r <= en) {
return seg[node];
}
if (st >= r || l >= en) return (long double)0;
long long mid = (l + r) >> 1;
shift(node, node * 2, mid - l);
shift(node, node * 2 + 1, r - mid);
p[node] = 1, lazy[node] = 0;
return get(l, mid, st, en, node * 2) + get(mid, r, st, en, node * 2 + 1);
}
int32_t main() {
long long n, q;
cin >> n >> q;
long long tmpp;
tmp = 1;
for (long long i = 1; i <= n; i++)
cin >> tmpp, upd(1, n + 1, i, i + 1, (long double)tmpp, 1);
while (q--) {
long long ty, l, r;
cin >> ty;
if (ty == 1) {
long long l1, l2, r1, r2;
cin >> l1 >> r1 >> l2 >> r2;
long double inc1 =
get(1, n + 1, l1, r1 + 1, 1) / (long double)(r1 - l1 + 1);
long double inc2 =
get(1, n + 1, l2, r2 + 1, 1) / (long double)(r2 - l2 + 1);
tmp = r1 - l1 + 1;
upd(1, n + 1, l1, r1 + 1, inc2, 1);
tmp = r2 - l2 + 1;
upd(1, n + 1, l2, r2 + 1, inc1, 1);
} else {
cin >> l >> r;
cout << fixed << setprecision(10) << get(1, n + 1, l, r + 1, 1) << endl;
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T> bool chmax(T &u, const T z) { if (u < z) {u = z; return true;} else return false; }
template <typename T> bool chmin(T &u, const T z) { if (u > z) {u = z; return true;} else return false; }
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ll long long
int a[3005][3005];
long long dp[3005][3005][4];
//解説写し
int main() {
int R,C,K;
cin>>R>>C>>K;
rep(i,K){
int r,c,v;
cin>>r>>c>>v;
a[r-1][c-1]=v;
}
rep(i,R)rep(j,C){
for(int k=2;k>=0;k--){
chmax(dp[i][j][k+1],dp[i][j][k]+a[i][j]);
}
rep(k,4){
chmax(dp[i+1][j][0],dp[i][j][k]);//次の行に行ったら、リセットしてk=0とする
chmax(dp[i][j+1][k],dp[i][j][k]);
}
}
ll ans=0;
rep(k,4)chmax(ans,dp[R-1][C-1][k]);
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(NULL);
long long T;
cin >> T;
while (T--) {
long long n;
cin >> n;
long long A[n];
for (int i = 0; i < n; i++) cin >> A[i];
int l = 0;
while (l < n) {
if (A[l] == 0)
l++;
else
break;
}
int r = n - 1;
while (r >= 0) {
if (A[r] == 0)
r--;
else
break;
}
int sum = 0;
for (int i = l; i <= r; i++)
if (A[i] == 0) sum++;
cout << sum << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int l, r;
mutable int v;
node(int L, int R = -1, int V = 0) : l(L), r(R), v(V) {}
bool operator<(const node &o) const { return l < o.l; }
};
int n, m, k, las, f[15][15];
char s[200005];
set<node> st;
set<node>::iterator split(int pos) {
set<node>::iterator it = st.lower_bound(node(pos));
if (it != st.end() && (*it).l == pos) return it;
it--;
int L = (*it).l, R = (*it).r, V = (*it).v;
st.erase(it);
st.insert(node(L, pos - 1, V));
return st.insert(node(pos, R, V)).first;
}
void change(int l, int r, int id) {
set<node>::iterator it2 = split(r + 1), it1 = split(l);
for (set<node>::iterator now_it = it1; now_it != it2; now_it++) {
set<node>::iterator it = now_it;
if (it == st.begin()) continue;
it--;
if ((*it).v != (*now_it).v) f[(*it).v][(*now_it).v]--;
}
set<node>::iterator it = it2;
if (it != st.begin()) {
it--;
if ((*it).v != (*it2).v) f[(*it).v][(*it2).v]--;
}
st.erase(it1, it2);
st.insert(node(l, r, id));
set<node>::iterator nw = st.lower_bound(node(l, r, id));
if (nw != st.begin()) {
nw--;
if ((*nw).v != id) f[(*nw).v][id]++;
nw++;
}
nw++;
if ((*nw).v != id && (*nw).l <= n) f[id][(*nw).v]++;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
las = 0;
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
if (las) f[las][s[i] - 'a' + 1]++;
las = s[i] - 'a' + 1;
st.insert(node(i, i, s[i] - 'a' + 1));
}
st.insert(node(n + 1, n + 1, 0));
for (int i = 1; i <= m; i++) {
int op;
scanf("%d", &op);
if (op == 1) {
int l, r;
char s1[10];
scanf("%d%d", &l, &r);
scanf("%s", s1 + 1);
change(l, r, s1[1] - 'a' + 1);
} else {
char s1[20];
scanf("%s", s1 + 1);
int ans = n;
for (int t = 1; t <= k; t++) {
for (int j = t + 1; j <= k; j++) {
ans -= f[s1[t] - 'a' + 1][s1[j] - 'a' + 1];
}
}
printf("%d\n", ans);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1001001001001001001ll;
int size;
vector<long long> val;
vector<long long> lazy;
void lazy_propagate(int p) {
if (lazy[p] != -1) {
val[p] = lazy[p];
if (p < size-1) {
lazy[p*2+1] = lazy[p];
lazy[p*2+2] = lazy[p];
}
lazy[p] = -1;
}
}
void update(int wishl, int wishr, int watchl, int watchr, int k, int x) {
if (wishr <= watchl || watchr <= wishl) {
lazy_propagate(k);
return;
}
if (wishl <= watchl && watchr <= wishr) {
lazy[k] = x;
lazy_propagate(k);
return;
}
int mid = (watchl+watchr)/2;
lazy_propagate(k);
update(wishl, wishr, watchl, mid, k*2+1, x);
update(wishl, wishr, mid, watchr, k*2+2, x);
val[k] = min(val[k*2+1], val[k*2+2]);
}
void update(int wishl, int wishr, int x) {
update(wishl, wishr, 0, size, 0, x);
}
long long getmin(int wishl, int wishr, int watchl, int watchr, int k) {
if (wishr <= watchl || watchr <= wishl) {
return INF;
}
if (wishl <= watchl && watchr <= wishr) {
lazy_propagate(k);
return val[k];
}
int mid = (watchl+watchr)/2;
lazy_propagate(k);
long long ml = getmin(wishl, wishr, watchl, mid, k*2+1);
long long mr = getmin(wishl, wishr, mid, watchr, k*2+2);
return min(ml, mr);
}
long long getmin(int wishl, int wishr) {
return getmin(wishl, wishr, 0, size, 0);
}
signed main() {
int n, q;
cin >> n >> q;
size = 1;
while (size < n) size <<= 1;
val = vector<long long>(size*2, (1ll<<31)-1);
lazy = vector<long long>(size*2, -1);
while (q--) {
int type, l, r;
cin >> type >> l >> r;
if(type == 0) {
int x;
cin >> x;
update(l, r+1, x);
} else {
cout << getmin(l, r+1) << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll gcd(ll a, ll b) {return b == 0 ? a : gcd(b, a % b);}
ll ans[510][510];
int n;
int prime[20010], cnt;
int np[20010];
int main() {
scanf("%d", &n);
if (n == 2) return puts("4 7\n23 10"), 0;
for (int i = 0; i <= n + 1; i++) ans[0][i] = ans[i][0] = ans[n + 1][i] = ans[i][n + 1] = 1;
for (int i = 2; i <= 20000; i++) {
if (!np[i]) prime[++cnt] = i;
for (int j = 1; prime[j] * i <= 20000; j++) {
np[i * prime[j]] = 1;
if (i % prime[j] == 0) break;
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if ((i + j) % 2 == 0) ans[i][j] = prime[(i + j) / 2] * prime[(i - j) / 2 + n + n];
}
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
if ((i + j) % 2 == 1) {
ans[i][j] = 1;
ans[i][j] *= ans[i - 1][j] / gcd(ans[i - 1][j], ans[i][j]);
ans[i][j] *= ans[i + 1][j] / gcd(ans[i + 1][j], ans[i][j]);
ans[i][j] *= ans[i][j - 1] / gcd(ans[i][j - 1], ans[i][j]);
ans[i][j] *= ans[i][j + 1] / gcd(ans[i][j + 1], ans[i][j]);
ans[i][j]++;
}
for (int i = 1; i <= n; i++, puts(""))
for (int j = 1; j <= n; j++) printf("%lld ", ans[i][j]);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int sum[210], b[210];
int bj[210], maxp[20], minp[20];
int n, k;
int main() {
scanf("%d%d", &n, &k);
sum[0] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
sum[i] = sum[i - 1] + b[i];
}
int ans = -10000;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
memset(bj, 0, sizeof(bj));
int maxt = 0, mint = 0;
for (int u = 1; u <= k; u++) {
int maxpp = -10000, minpp = 10000, lp = 0, sp = 0;
for (int l = 1; l <= n; l++) {
if (l >= i && l <= j) {
if (!bj[l] && minpp > b[l]) {
sp = l;
minpp = b[l];
}
} else {
if (!bj[l] && maxpp < b[l]) {
lp = l;
maxpp = b[l];
}
}
}
if (lp) {
bj[lp] = 1;
maxp[++maxt] = b[lp];
}
if (sp) {
bj[sp] = 1;
minp[++mint] = b[sp];
}
}
int summ = sum[j] - sum[i - 1];
for (int u = 1; u <= min(maxt, mint); u++) {
if (maxp[u] > minp[u]) summ = summ - minp[u] + maxp[u];
}
ans = max(ans, summ);
}
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int oo = 2e5 + 7;
int n, a[oo];
int left[oo], right[oo];
bool solve() {
int x = 0, y = n - 1;
bool alice = true;
int maxx = -1;
while (x < y) {
bool levi = a[x] >= a[y];
if (std::max(a[x], a[y]) <= maxx) return !alice;
if (levi) {
int kraj = left[x + 1];
if ((kraj - x) % 2) return alice;
} else {
int kraj = right[y - 1];
if ((y - kraj) % 2) return alice;
}
if (std::min(a[x], a[y]) <= maxx) return !alice;
if (!levi)
maxx = std::max(maxx, a[x++]);
else
maxx = std::max(maxx, a[y--]);
alice ^= 1;
}
if ((x == 0 || a[x] > a[x - 1]) && (x == n - 1 || a[x] > a[x + 1]))
return alice;
return !alice;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
int last = -1;
for (int i = 0; i < n - 1; i++) {
if (a[i] <= a[i + 1]) last = i;
right[i] = last;
}
last = n;
for (int i = n - 1; i > 0; i--) {
if (a[i] <= a[i - 1]) last = i;
left[i] = last;
}
printf("%s\n", (solve() ? "Alice" : "Bob"));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mol = 1e9 + 9;
long long solve(long long a, long long y) {
long long ans = 1;
while (y) {
if (y & 1) ans = (ans * a + mol) % mol;
a = (a * a + mol) % mol;
y >>= 1;
}
return ans;
}
int main() {
long long n, m, k, cnt, sum = 0, pp;
scanf("%I64d %I64d %I64d", &n, &m, &k);
long long ps = (n - m) * k;
if (ps <= n)
pp = n - ps;
else {
printf("%I64d\n", m);
return 0;
}
sum = (sum + (n - m) * (k - 1) + mol) % mol;
cnt = pp / k;
if (cnt > 0) {
long long sum1 = ((solve(2, cnt + 1) - 2) * k + mol) % mol;
sum = (sum + sum1 + mol) % mol;
}
sum = (sum + (pp - cnt * k) + mol) % mol;
printf("%I64d\n", sum);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> v(n);
vector<int> cnt(n + 1, 0);
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> v[i];
sum += v[i];
cnt[i] += sum;
}
int k;
int num = 0;
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
if (i > 0) {
k = j - i + 1 - (cnt[j] - cnt[i - 1]);
num = max(k + cnt[i - 1] + cnt[n - 1] - cnt[j], num);
} else if (i == 0) {
k = j + 1 - cnt[j];
num = max(k + cnt[n - 1] - cnt[j], num);
}
}
cout << num;
}
| 1 |
#include <iostream>
using namespace std;
int main()
{
int a, b;
cin >> a >> b;
cout << (((a*b)%2)?"Odd":"Even") << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
typedef unsigned int UI;
typedef long int LI;
typedef unsigned long int ULI;
typedef long long int LL;
typedef unsigned long long int ULL;
LL mod = 1e9 + 7;
inline int scanInt() {
int n = 0;
char ch = getchar();
int sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
n = (n << 1) + (n << 3) + (int)(ch - '0');
ch = getchar();
}
return n * sign;
}
inline LL scanLong() {
LL n = 0;
char ch = getchar();
LL sign = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') sign = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
n = (n << 1) + (n << 3) + (LL)(ch - '0');
ch = getchar();
}
return n * sign;
}
int main() {
LL n = scanLong();
;
LL k = scanLong();
;
LL arr[n];
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
arr[i] = scanLong();
LL maxi = LL(max_element(arr, arr + n) - arr);
LL mini = LL(min_element(arr, arr + n) - arr);
if (k == 1)
printf("%lld ", arr[mini]);
else if (k == 2) {
printf("%lld ", max(arr[0], arr[n - 1]));
} else if (k >= 3)
printf("%lld ", arr[maxi]);
printf("\n");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
long long d[2020][2020];
int level[2020];
long long oo = 1e15;
vector<vector<int> > adj(2020);
priority_queue<pair<long long, pair<int, int> > > pq;
long long dist[2020];
bool vis[2020];
vector<int> id, lvl;
int indx[4040];
void dfs(int i, int l, long long c, int p) {
dist[i] = c;
id.push_back(i);
lvl.push_back(l);
indx[i] = id.size() - 1;
for (auto v : adj[i]) {
if (v != p) {
dfs(v, l + 1, c + d[v][i], i);
id.push_back(i);
lvl.push_back(l);
}
}
}
pair<int, int> sp[4010][13];
void buildSparse() {
int len = lvl.size();
int lg = log2(len);
for (int i = 0; i < len; ++i) sp[i][0] = {lvl[i], id[i]};
for (int j = 1; j <= lg; ++j) {
for (int i = 0; i < len; ++i) {
int e = 1 << (j - 1);
auto p1 = sp[i][j - 1];
auto p2 = sp[i + e][j - 1];
sp[i][j] = p2.first < p1.first ? p2 : p1;
}
}
}
long long rmq(int s, int e) {
int len = e - s + 1;
int lg = log2(len);
auto p1 = sp[s][lg];
auto p2 = sp[s + len - (1 << lg)][lg];
int parent = p1.first < p2.first ? p1.second : p2.second;
return dist[id[s]] + dist[id[e]] - 2 * dist[parent];
}
void look(int v) {
for (int i = 0; i < n; ++i) {
if (d[v][i] != 0 && !vis[i]) {
pq.push({-d[i][v], {i, v}});
}
}
}
int main() {
memset(indx, -1, sizeof(indx));
scanf("%d", &n);
bool ok = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
scanf("%I64d", &d[i][j]);
if (i == j && d[i][j] || i != j && !d[i][j]) ok = 0;
if (j < i && d[i][j] != d[j][i]) ok = 0;
}
}
if (!ok) {
cout << "NO\n";
return 0;
}
for (int k = 1; k < n; ++k) pq.push({-d[0][k], {0, k}});
while (!pq.empty()) {
auto pp = pq.top();
int v = pp.second.first, u = pp.second.second;
pq.pop();
if (vis[v] && vis[u]) continue;
adj[v].push_back(u);
adj[u].push_back(v);
if (!vis[v]) look(v);
if (!vis[u]) look(u);
vis[u] = vis[v] = 1;
}
dfs(0, 0, 0, -1);
buildSparse();
for (int l = 0; l < n; ++l) {
for (int i = l + 1; i < n; ++i) {
int s = indx[l], e = indx[i];
if (s == -1 || e == -1 || rmq(min(s, e), max(s, e)) != d[l][i]) {
cout << "NO\n";
return 0;
}
}
}
cout << "YES\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
if (n == 0 && m != 0) {
cout << "Impossible" << endl;
} else if (n != 0 && m != 0) {
if (n > m) {
cout << n << " ";
cout << (n - 1) + m << endl;
} else if (n < m) {
cout << (m) << " ";
cout << m + n - 1 << endl;
} else if (n == m) {
cout << n << " ";
cout << m + n - 1 << endl;
}
} else if (n == 0 && m == 0) {
cout << 0 << " " << 0 << endl;
} else if (n != 0 && m == 0) {
cout << n << " " << n << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int get() {
int f = 0, v = 0;
char ch;
while (!isdigit(ch = getchar()))
if (ch == '-') break;
if (ch == '-')
f = 1;
else
v = ch - '0';
while (isdigit(ch = getchar())) v = v * 10 + ch - '0';
if (f)
return -v;
else
return v;
}
const int maxn = 103, inf = 1000000000;
int d[maxn][maxn], n, f[maxn], g[maxn], vis[maxn], cnt[maxn][maxn], T[maxn], m,
A, B, tot = 1;
bool p[maxn][maxn];
int dfs(int x, int aim) {
if (x == aim) return f[x];
if (vis[x] == tot) return g[x];
g[x] = 0;
vis[x] = tot;
for (int i = 1; i <= n; i++)
if (d[x][i] == 1 && 1 + d[i][aim] == d[x][aim])
g[x] = max(g[x], dfs(i, aim));
return g[x] = min(g[x], f[x]);
}
int main() {
n = get(), m = get(), A = get(), B = get();
for (int i = 1; i <= n; d[i][i] = 0, f[i] = inf, i++)
for (int j = 1; j <= n; j++) d[i][j] = inf;
f[B] = 0;
for (int i = 1, x; i <= m; i++) x = get(), d[x][get()] = 1;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
m = get();
for (int i = 1; i <= m; i++) {
int x = get(), y = get();
T[i] = y;
if (d[x][y] == inf) continue;
for (int j = 1; j <= n; j++)
if (d[x][j] + d[j][y] == d[x][y]) cnt[i][d[x][j]]++;
for (int j = 1; j <= n; j++)
if (d[x][j] + d[j][y] == d[x][y] && cnt[i][d[x][j]] == 1) p[i][j] = 1;
}
for (int _ = 1; _ <= n; _++) {
bool flag = 0;
for (int i = 1; i <= m; i++, tot++)
for (int j = 1; j <= n; j++) {
if (!p[i][j]) continue;
int tp = dfs(j, T[i]) + 1;
if (tp < f[j]) f[j] = tp, flag = 1;
}
}
printf("%d\n", f[A] == inf ? -1 : f[A]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int t;
int p;
};
stack<int> ans;
node order[200010];
node stk[200010];
int num[200010];
int n, m, top, pos;
int cmp1(int u, int v) { return u < v; }
int cmp2(int u, int v) { return u > v; }
void init() {
int i, j, maxx;
stk[0].t = 0, stk[0].p = 0;
maxx = 0, top = 0;
for (i = m; i >= 1; i--) {
if (order[i].t == stk[top].t) {
if (order[i].p > stk[top].p) {
stk[top] = order[i];
}
} else {
if (order[i].p > stk[top].p) {
top++;
stk[top] = order[i];
}
}
}
return;
}
void calculate() {
int i, t, l, r;
while (!ans.empty()) ans.pop();
l = 1, r = n;
while (r > stk[top].p) {
ans.push(num[r]);
r--;
}
if (stk[top].t == 1)
sort(num + l, num + r + 1, cmp1);
else
sort(num + l, num + r + 1, cmp2);
top--;
while (top >= 1) {
if (l <= r) {
while (r > l + stk[top].p - 1) {
ans.push(num[r]);
r--;
}
t = l, l = r, r = t;
} else {
while (r < l - stk[top].p + 1) {
ans.push(num[r]);
r++;
}
t = l, l = r, r = t;
}
top--;
}
if (l <= r) {
while (l <= r) {
ans.push(num[r]);
r--;
}
} else {
while (r <= l) {
ans.push(num[r]);
r++;
}
}
while (!ans.empty()) {
printf("%d ", ans.top());
ans.pop();
}
printf("\n");
return;
}
int main() {
int i, j, maxx, l, r;
while (scanf("%d%d", &n, &m) != EOF) {
for (i = 1; i <= n; i++) {
scanf("%d", &num[i]);
}
for (i = 1; i <= m; i++) {
scanf("%d%d", &order[i].t, &order[i].p);
}
init();
calculate();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int sz = 1e3, sz2 = 1e5 + 10, mod = 1e9 + 7;
int nex[sz][32], sm[sz][sz];
unsigned int nmask[sz][32];
unsigned int f(unsigned int mask, int x) {
unsigned int re = mask | (1 << x);
for (int i = 0; i < 32; i++) {
if (mask & (1 << i)) re |= (1 << (i ^ x));
}
return re;
}
vector<pair<int, int> > sv[sz2];
int h[sz2], s, near[sz2], dp[sz], dp2[sz];
void dfs(int v, int pr) {
for (int a = 0; a < sv[v].size(); a++) {
int ne = sv[v][a].first, w = sv[v][a].second;
if (ne and near[ne] == -1) {
if (h[ne] == -1)
h[ne] = h[v] ^ w, dfs(ne, v);
else if (v < ne and ne != pr) {
s = nex[s][h[v] ^ h[ne] ^ w];
}
}
}
}
int SUM(int x, int y) { return (x + y < mod) ? x + y : x + y - mod; }
int main() {
map<unsigned int, int> ma;
ma[0] = 0;
queue<int> qu;
qu.push(0);
while (qu.size()) {
unsigned int v = qu.front();
for (int i = 0; i < 32; i++) {
unsigned int ne = f(v, i);
if (ma.find(ne) == ma.end()) {
ma[ne] = 0;
qu.push(ne);
}
}
qu.pop();
}
int q = 0;
unsigned int mask[ma.size()];
for (auto it = ma.begin(); it != ma.end(); it++)
mask[q] = (*it).first, (*it).second = q++;
for (int a = 0; a < q; a++) {
for (int i = 0; i < 32; i++) {
nmask[a][i] = f(mask[a], i);
nex[a][i] = ma[nmask[a][i]];
}
}
for (int a = 0; a < q; a++) {
for (int b = 0; b < q; b++) {
unsigned int re = mask[a];
for (int i = 0; i < 32; i++) {
if (mask[b] & (1 << i)) re = re | nmask[a][i];
}
sm[a][b] = ma[re];
}
}
int n, m;
cin >> n >> m;
for (int a = 0; a < m; a++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
u--, v--;
sv[u].push_back({v, w});
sv[v].push_back({u, w});
}
for (int a = 0; a < n; a++) h[a] = -1, near[a] = -1;
for (int a = 0; a < sv[0].size(); a++) {
near[sv[0][a].first] = sv[0][a].second;
}
dp[0] = 1;
for (int a = 0; a < n; a++) {
if (near[a] != -1) {
s = 0;
int a2 = -1, add;
for (int b = 0; b < sv[a].size(); b++) {
int ne = sv[a][b].first, w = sv[a][b].second;
if (near[ne] != -1) a2 = ne, add = near[a] ^ near[ne] ^ w;
}
near[a] = -1, h[a] = 0, dfs(a, a);
if (a2 != -1) near[a2] = -1, h[a2] = 0, dfs(a2, a2);
for (int b = 0; b < q; b++) {
dp2[b] = SUM(dp2[b], dp[b]);
int to = sm[b][s];
dp2[to] = SUM(dp2[to], dp[b]);
if (a2 != -1) {
dp2[to] = SUM(dp2[to], dp[b]);
to = nex[to][add];
dp2[to] = SUM(dp2[to], dp[b]);
}
}
for (int b = 0; b < q; b++) dp[b] = dp2[b], dp2[b] = 0;
}
}
int an = 0;
for (int a = 0; a < q; a++)
if ((mask[a] & 1) == 0) an = SUM(an, dp[a]);
cout << an;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, sum = 0;
cin >> n >> m;
vector<int> vec;
for (int i = 0; i < n; ++i) {
int a;
cin >> a;
vec.push_back(a);
}
sort(vec.begin(), vec.end());
for (int i = 0; i < m; ++i) {
if (vec[i] <= 0) sum = sum + vec[i];
}
cout << abs(sum) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define MAX_N 3000
using namespace std;
typedef long long lnt;
template <class T> inline void read(T &x) {
x = 0; int c = getchar(), f = 1;
for (; !isdigit(c); c = getchar()) if (c == 45) f = -1;
for (; isdigit(c); c = getchar()) (x *= 10) += f*(c-48);
}
int n; lnt P, C[MAX_N+5][MAX_N+5];
lnt f[MAX_N+5], g[MAX_N+5][MAX_N+5];
lnt Pow(lnt x, lnt k, lnt P) {
lnt ret = 1;
for (; k; k >>= 1, x = x*x%P)
if (k&1) ret = ret*x%P;
return ret;
}
int main() {
read(n), read(P);
for (int i = 0; i <= n; i++) C[i][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++)
C[i][j] = (C[i-1][j-1]+C[i-1][j])%P;
for (int i = 0; i <= n; i++) g[i][0] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= i; j++)
g[i][j] = (g[i-1][j-1]+g[i-1][j]*(j+1)%P)%P;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= i; j++)
(f[i] += g[i][j]*Pow(2, (n-i)*j, P)%P) %= P;
for (int i = 0; i <= n; i++)
(f[i] *= Pow(2, Pow(2, n-i, P-1), P)) %= P;
lnt tot = 0;
for (int i = 0; i <= n; i++)
(tot += Pow(-1, i, P)*C[n][i]*f[i]%P) %= P;
return printf("%lld\n", (tot+P)%P), 0;
}
| 0 |
#include<iostream>
using namespace std;
int main(){
int a,b;cin>>a>>b;
int c=(a+b)%24;
cout<<c<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a[10005], i, j, k, m, p, ans;
while (cin >> k) {
m = 0;
ans = 0;
for (i = 0; i < k; i++) {
cin >> a[i];
}
for (i = 0; i < k; i++) {
for (j = i; j < k; j++) {
for (p = i; p <= j; p++) m = m ^ a[p];
ans = max(ans, m);
m = 0;
}
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long N, A[100];
int main(void) {
cin >> N;
for (long long i = ((long long)0); i < ((long long)N); i++) cin >> A[i];
bool ans = true;
long long p1 = 1, p2 = 2, s = 3;
for (long long i = ((long long)0); i < ((long long)N); i++) {
if (A[i] == p1) {
swap(p2, s);
} else if (A[i] == p2) {
swap(p1, s);
} else {
ans = false;
break;
}
}
cout << (ans ? "YES" : "NO") << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, m, i, j, x = 1, cn = 0;
cin >> n >> m;
int a[m];
for (i = 0; i < m; i++) cin >> a[i];
for (i = 0; i < m; i++) {
if (a[i] > x) {
cn += a[i] - x;
x = a[i];
}
if (a[i] < x) {
cn += n - x + a[i];
x = a[i];
}
}
cout << cn << endl;
}
| 2 |
#include<cstdio>
int main(){
int N,Ans=0;
scanf("%d",&N);
for(int i=1;i<=N;i+=2){
int cnt=0;
for(int j=1;j<=i;j++)
cnt+=i%j==0;
Ans+=cnt==8;
}
printf("%d",Ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn];
int dp[110][110];
int main() {
int n, ans = 0;
cin >> n;
while (n--) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
for (int i = y1; i <= y2; i++) {
for (int j = x1; j <= x2; j++) {
dp[i][j]++;
}
}
}
for (int i = 0; i <= 100; i++) {
for (int j = 0; j <= 100; j++) {
ans += dp[i][j];
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dp[1 << 24];
int n, a[30];
int dfs(int state, int p) {
int v;
if (dp[state]) return dp[state];
v = __builtin_popcount(state);
int ret = 1e9;
for (int i = 0; i < p; i++) {
for (int j = 0; j <= i; j++) {
if (a[i] + a[j] != a[p]) continue;
int tmp =
dfs(state ^ (1 << p) | (1 << (p - 1)) | (1 << i) | (1 << j), p - 1);
ret = min(ret, max(v, tmp));
}
}
return dp[state] = ret;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
dp[1] = 1;
int ans = dfs(1 << (n - 1), n - 1);
if (ans == 1e9) ans = -1;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n, head[1001], nxt[2001], b[2001], k, size[1001], mx[1001], root;
void push(int s, int t) {
nxt[++k] = head[s];
head[s] = k;
b[k] = t;
}
void getroot(int x, int f) {
size[x] = 1, mx[x] = 0;
for (int i = head[x]; i; i = nxt[i])
if (b[i] != f) {
getroot(b[i], x);
size[x] += size[b[i]];
mx[x] = std::max(mx[x], size[b[i]]);
}
mx[x] = std::max(mx[x], n - size[x]);
if (mx[x] < mx[root]) root = x;
}
void get(int x, int f) {
size[x] = 1;
for (int i = head[x]; i; i = nxt[i])
if (b[i] != f) {
get(b[i], x);
size[x] += size[b[i]];
}
}
int A, B;
std::vector<int> t1, t2;
void dfs(int x, int f, int mul) {
int tem = 1;
for (int i = head[x]; i; i = nxt[i])
if (b[i] != f) {
printf("%d %d %d\n", b[i], x, tem * mul);
dfs(b[i], x, mul);
tem += size[b[i]];
}
}
int main() {
scanf("%d", &n);
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
push(u, v);
push(v, u);
}
mx[root = 0] = n;
getroot(1, 0);
get(root, 0);
for (int i = head[root]; i; i = nxt[i])
if (A < B)
A += size[b[i]], t1.push_back(b[i]);
else
B += size[b[i]], t2.push_back(b[i]);
int tem = 1;
for (int i = 0; i < t1.size(); i++)
printf("%d %d %d\n", root, t1[i], tem), dfs(t1[i], root, 1),
tem += size[t1[i]];
tem = 1;
for (int i = 0; i < t2.size(); i++)
printf("%d %d %d\n", root, t2[i], tem * (A + 1)), dfs(t2[i], root, A + 1),
tem += size[t2[i]];
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string str;
int ar[100010];
int main() {
ios::sync_with_stdio(false);
int i, j, x, y, n, m = 0, k, a, b, c, d, e, f, wa;
cin >> n >> k;
cin >> str;
for (int i = 0; i <= n - 1; i++) {
if (str[i] == '0') ar[m] = i + 1, m++;
}
wa = n;
for (int i = 0; i <= m - k - 1; i++) {
a = ar[i];
b = ar[i + k];
c = (a + b) / 2;
d = lower_bound(ar, ar + m, c) - ar;
e = max(d--, 0);
f = min(m - 1, d++);
x = max(abs(ar[d] - ar[i]), abs(ar[i + k] - ar[d]));
wa = min(wa, x);
d = f;
x = max(abs(ar[d] - ar[i]), abs(ar[i + k] - ar[d]));
wa = min(wa, x);
}
cout << wa << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int C[1000100];
long long sum;
long long avgfloor, avgceil;
long long f1(long long cut) {
long long ret = 0;
for (int i = n - 1; i >= 0; i--) {
if (C[i] <= cut) break;
ret += C[i] - cut;
}
return ret;
}
long long bs1() {
long long l = avgceil, r = C[n - 1], m;
while (l < r) {
m = (l + r) / 2;
if (f1(m) > k) {
l = m + 1;
} else {
r = m;
}
}
return l;
}
long long f2(long long cut) {
long long ret = 0;
for (int i = 0; i < n; i++) {
if (C[i] >= cut) break;
ret += cut - C[i];
}
return ret;
}
long long bs2() {
long long l = 0, r = avgfloor, m;
while (l < r) {
m = (l + r + 1) / 2;
if (f2(m) <= k) {
l = m;
} else {
r = m - 1;
}
}
return l;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &C[i]);
sum += C[i];
}
sort(C, C + n);
avgfloor = sum / n;
avgceil = (sum + n - 1) / n;
long long high = bs1();
long long low = bs2();
cout << high - low << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, x;
int t[2200], h[2200], m[2200], vis[2200];
int main() {
while (~scanf("%d%d", &n, &x)) {
for (int i = 0; i < n; i++) {
scanf("%d%d%d", &t[i], &h[i], &m[i]);
}
int heigh = x;
memset(vis, 0, sizeof(vis));
bool flag = 1;
int tag = 0;
int ans = 0;
int p;
while (flag) {
p = -1;
for (int i = 0; i < n; i++) {
if (vis[i] == 0 && h[i] <= x) {
vis[i] = 1;
}
if (vis[i] == 1)
if (t[i] == tag && (p == -1 || m[p] < m[i])) p = i;
}
if (p == -1) break;
ans++;
tag = 1 - tag;
x += m[p];
vis[p] = 2;
}
int res = ans;
memset(vis, 0, sizeof(vis));
x = heigh;
tag = 1;
ans = 0;
p;
while (flag) {
p = -1;
for (int i = 0; i < n; i++) {
if (vis[i] == 0 && h[i] <= x) {
vis[i] = 1;
}
if (vis[i] == 1)
if (t[i] == tag && (p == -1 || m[p] < m[i])) p = i;
}
if (p == -1) break;
ans++;
tag = 1 - tag;
x += m[p];
vis[p] = 2;
}
res = max(res, ans);
cout << res << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
int n;
int m;
int ans[10][10][10][2][8];
int was[10][10][10][2][8];
pair<pair<int, int>, pair<int, int> > prev239[10][10][10][2][8];
int pflag[10][10][10][2][8];
int ppa[10][10][10][2][8], ppb[10][10][10][2][8], ppc[10][10][10][2][8];
int len1, len2, len3;
int mas1[10], mas2[10], mas3[10];
int parse(int x, int *mas) {
int n = 0;
if (!x) {
mas[0] = 0;
return 1;
}
while (x) {
mas[n++] = x % 10;
x /= 10;
}
return n;
}
long long aa, bb, cc;
void out(int cp1, int cp2, int cp3, int cf, int cflag) {
if (!cp1 && !cp2 && !cp3 && !cf && cflag == 7) return;
pair<pair<int, int>, pair<int, int> > o = prev239[cp1][cp2][cp3][cf][cflag];
int p1 = o.first.first;
int p2 = o.first.second;
int p3 = o.second.first;
int f = o.second.second;
int flag = pflag[cp1][cp2][cp3][cf][cflag];
int a = ppa[cp1][cp2][cp3][cf][cflag];
int b = ppb[cp1][cp2][cp3][cf][cflag];
int c = ppc[cp1][cp2][cp3][cf][cflag];
aa = aa * 10 + a;
bb = bb * 10 + b;
cc = cc * 10 + c;
out(p1, p2, p3, f, flag);
}
void go(int p1, int p2, int p3, int f, int flag) {
was[p1][p2][p3][f][flag] = 1;
if (p1 >= len1 && p2 >= len2 && p3 >= len3 && f == 0 && flag == 0) return;
int d = ans[p1][p2][p3][f][flag];
int o1 = flag & 1;
int o2 = (flag >> 1) & 1;
int o3 = (flag >> 2) & 1;
for (int a = 0; a < (10); a++)
for (int b = 0; b < (10); b++) {
int c = (a + b + f) % 10;
int nf = (a + b + f) / 10;
if (a && !o1 || b && !o2 || c && !o3) continue;
int np1 = p1, np2 = p2, np3 = p3;
if (p1 < len1 && a == mas1[p1]) np1++;
if (p2 < len2 && b == mas2[p2]) np2++;
if (p3 < len3 && c == mas3[p3]) np3++;
int len = o1 + o2 + o3;
for (int nflag = 0; nflag < (8); nflag++) {
if ((nflag & flag) != nflag) continue;
int no1 = nflag & 1;
int no2 = (nflag >> 1) & 1;
int no3 = (nflag >> 2) & 1;
if (!no1 && np1 < len1 || !no2 && np2 < len2 || !no3 && np3 < len3)
continue;
if (ans[np1][np2][np3][nf][nflag] == -1 ||
ans[np1][np2][np3][nf][nflag] > d + len) {
ans[np1][np2][np3][nf][nflag] = d + len;
prev239[np1][np2][np3][nf][nflag] =
make_pair(make_pair(p1, p2), make_pair(p3, f));
pflag[np1][np2][np3][nf][nflag] = flag;
ppa[np1][np2][np3][nf][nflag] = a;
ppb[np1][np2][np3][nf][nflag] = b;
ppc[np1][np2][np3][nf][nflag] = c;
}
}
}
}
void hate() {
while (1) {
int ff = 0;
int ba, bb, bc, bf, bflag;
int bd = 1000000000;
for (int a = 0; a < (len1 + 1); a++)
for (int b = 0; b < (len2 + 1); b++)
for (int c = 0; c < (len3 + 1); c++)
for (int f = 0; f < (2); f++)
for (int flag = 0; flag < (8); flag++) {
if (ans[a][b][c][f][flag] != -1 && ans[a][b][c][f][flag] < bd &&
!was[a][b][c][f][flag]) {
bd = ans[a][b][c][f][flag];
ba = a;
bb = b;
bc = c;
bf = f;
bflag = flag;
ff = 1;
}
}
if (ff)
go(ba, bb, bc, bf, bflag);
else
break;
}
}
int main() {
string s;
cin >> s;
replace((s).begin(), (s).end(), '+', ' ');
replace((s).begin(), (s).end(), '=', ' ');
istringstream sin(s);
int a, b, c;
sin >> a >> b >> c;
len1 = parse(a, mas1);
len2 = parse(b, mas2);
len3 = parse(c, mas3);
memset(ans, -1, sizeof(ans));
ans[0][0][0][0][7] = 0;
hate();
int d = ans[len1][len2][len3][0][0];
out(len1, len2, len3, 0, 0);
cout << aa << "+" << bb << "=" << cc << endl;
return 0;
}
| 5 |
#include<iostream>
#include<sstream>
using namespace std;
typedef long long ll;
ll pw(ll b,ll e){
ll i,r=1;
for(i=0;i<e;i++)r*=b;
return r;
}
int main(){
ll n,k;
while(cin>>n>>k,n){
ll m,s,r;
for(m=1;n>9*m*pw(10,m-1);m++)n-=9*m*pw(10,m-1);
for(r=0;n>m;r++)n-=m;
s=pw(10,m-1)+r;
stringstream ans;
while(ans.str().size()<=k+n)ans<<s++;
cout<<ans.str().substr(n-1,k)<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[100004], b[100004], d[100004];
vector<int> c;
int search(int x, int l, int r) {
if (r - l <= 1) {
if (c[r] <= x)
return r;
else if (c[l] > x)
return -1;
else
return l;
}
int m = (l + r) / 2;
if (c[m] == x)
return m;
else if (c[m] < x)
return search(x, m, r);
else
return search(x, l, m - 1);
}
int main() {
int n, m, i, k = 0;
scanf("%d", &n);
scanf("%d", &m);
a[0] = -1;
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] != a[i - 1]) d[++k] = a[i];
b[i] = k;
}
for (i = 2; i < k; i++)
if (d[i] < d[i - 1] && d[i] < d[i + 1]) c.push_back(i);
for (i = 1; i <= m; i++) {
int l, r;
scanf("%d", &l);
scanf("%d", &r);
l = b[l];
r = b[r];
if (l == r || c.size() == 0) {
cout << "Yes" << endl;
continue;
}
int x = search(l, 0, c.size() - 1);
int y = search(r - 1, 0, c.size() - 1);
if (x == y)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int data[N];
int temp[N];
int n;
bool check(int nn, int mm, int x, int y) {
memset(temp, 0, sizeof(temp));
for (int i = 1; i <= nn; i++) {
for (int j = 1; j <= mm; j++) {
int a = abs(i - x) + abs(j - y);
temp[a]++;
}
}
for (int i = 0; i < n; i++) {
if (temp[i] != data[i]) return false;
}
return true;
}
int dis(int i, int j, int r, int c) { return abs(i - r) + abs(j - c); }
int fac[N];
int main() {
scanf("%d", &n);
int maxx = 0;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
maxx = max(maxx, a);
data[a]++;
}
if (n == 1) {
printf("1 1\n1 1\n");
return 0;
}
int m;
for (int i = 1; i < n; i++) {
if (data[i] != 4 * i) {
m = i;
break;
}
}
m--;
int cnt = 0;
for (int i = 1; i * i <= n; i++) {
if (n % i == 0) fac[cnt++] = i;
}
for (int i = 0; i < cnt; i++) {
int r = fac[i];
int c = n / fac[i];
if (r + c - 2 < maxx) continue;
for (int j = 1; j <= r; j++) {
int k = maxx - j + 2;
if (k >= 1 && k <= c) {
int minn = min(min(j - 1, r - j), min(k - 1, c - k));
if (minn == m) {
if (check(r, c, j, k)) {
printf("%d %d\n%d %d\n", r, c, j, k);
return 0;
}
}
}
}
}
printf("-1\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const pair<int, int> DD[] = {{1, 0}, {1, 1}, {0, 1}, {-1, 1},
{-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
template <class T>
T smin(T &a, T b) {
if (a > b) a = b;
return a;
}
template <class T>
T smax(T &a, T b) {
if (a < b) a = b;
return a;
}
int32_t main(void) {
srand(time(0));
cout << fixed << setprecision(7);
cerr << fixed << setprecision(7);
static vector<long long> g[1 << 20];
vector<long long> a, b;
ios_base ::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
static long long v[1 << 20];
for (long long i = 1; i <= n; ++i) cin >> v[i];
for (long long i = 2; i <= n; ++i) {
long long par;
cin >> par;
g[par].push_back(i);
}
function<long long(long long)> dfs = [&](long long node) {
long long wh = -1;
if (g[node].empty()) wh = 1;
for (auto it : g[node]) wh = 1 - dfs(it);
if (wh)
a.push_back(v[node]);
else
b.push_back(v[node]);
return wh;
};
dfs(1);
long long Xor = 0;
for (auto it : a) Xor ^= it;
long long ans = 0;
long long sz = a.size();
if (!Xor) ans += sz * (sz - 1) / 2;
sz = b.size();
if (!Xor) ans += sz * (sz - 1) / 2;
static map<long long, long long> M;
for (auto it : b) ++M[it];
for (auto it : a) ans += M[it ^ Xor];
cout << ans << '\n';
cerr << "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms"
<< '\n';
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
#define dbg(x...) do { cout << "\033[32;1m" << #x <<" -> "; err(x); } while (0)
void err() { cout << "\033[39;0m" << endl; }
template<class T, class... Ts> void err(const T& arg,const Ts&... args) { cout << arg << " "; err(args...); }
typedef long double db;
const db eps = 1e-8;
const db pi = acosl(-1.0);
int sgn(db x){if(fabs(x) < eps) return 0; return x < 0 ? -1 : 1;}
struct Point{
db x, y;
Point(){}
Point(db x, db y):x(x), y(y){}
void input(){cin >> x >> y;}
Point operator - (const Point &b) const{
return Point(x - b.x, y - b.y);
}
Point operator + (const Point &b) const{
return Point(x + b.x, y + b.y);
}
db operator ^ (const Point&b)const{
return x * b.y - y * b.x;
}
db operator * (const Point &b) const{
return x * b.x + y * b.y;
}
db len2(){
return x * x + y * y;
}
db len(){
return sqrtl(len2());
}
};
struct Line{
Point s, e;
Line(){};
Line(Point s, Point e) :s(s), e(e){}
void input(){ s.input(); e.input(); }
int getPointPos(Point p) {
return sgn((e - s) ^ (p - s));
}
bool isPointOnSeg(Point p) {
return getPointPos(p) == 0 && sgn((p - s) * (p - e)) <= 0;
}
int getCrossTypeofSeg(Line v) {
int d1 = getPointPos(v.s);
int d2 = getPointPos(v.e);
int d3 = v.getPointPos(s);
int d4 = v.getPointPos(e);
if((d1 ^ d2) == -2 && (d3 ^ d4) == -2) return 2;
return isPointOnSeg(v.s) || isPointOnSeg(v.e) || v.isPointOnSeg(s) || v.isPointOnSeg(e);
}
}l1, l2;
int main(){
#ifndef ONLINE_JUDGE
// freopen("i.in","r",stdin);
// freopen("o.out","w",stdout);
#endif
int T;scanf("%d", &T);
while(T--){
l1.input(); l2.input();
cout << (l1.getCrossTypeofSeg(l2) > 0 ? 1 : 0) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int sum[maxn], num[maxn], n, k, q;
int main() {
cin >> n >> k >> q;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
num[a]++, num[b + 1]--;
}
for (int i = 1; i < maxn; i++) {
num[i] += num[i - 1];
sum[i] = sum[i - 1] + (num[i] >= k);
}
for (int i = 0; i < q; i++) {
int a, b;
cin >> a >> b;
cout << sum[b] - sum[a - 1] << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
long long int x;
cin >> x;
if (x % 3 == 0) {
cout << x / 3 << " " << x / 3 << '\n';
} else {
long long temp = x / 3 + 1;
long long temp2 = x / 3;
if (temp + 2 * temp2 == x) {
cout << temp << " " << temp2 << '\n';
} else
cout << temp2 << " " << temp << '\n';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long ans = 0;
for (long long i = 30; i >= 1; i--) {
long long max_sum = 0;
for (long long j = 0; j < n; j++) {
if (a[j] > i) {
max_sum = 0;
continue;
}
max_sum += a[j];
max_sum = max(max_sum, 0ll);
ans = max(ans, max_sum - i);
}
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100005];
int test(int x, int y) {
swap(a[x], a[y]);
int da = 0, xi = 0;
for (int i = 2; i <= n; i++) {
if (a[i] > a[i - 1])
da = 1;
else if (a[i] < a[i - 1])
xi = 1;
}
swap(a[x], a[y]);
return da + xi;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
if (n <= 2)
cout << -1 << endl;
else {
int p = 0;
for (int i = 2; i < n; i++)
if (a[i] != a[1] || a[i] != a[n]) {
p = i;
break;
}
if (p) {
int i;
for (i = 1; i <= n; i++) {
if (a[p] != a[i] && test(i, p) == 2) {
cout << i << " " << p << endl;
break;
}
}
if (i > n) cout << -1 << endl;
} else
cout << -1 << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
string s[n];
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
for (int j = 0; j < m; j++) s[i] += '#';
} else {
for (int j = 0; j < m - 1; j++) s[i] += '.';
s[i] += '#';
}
}
for (int i = 3; i < n; i += 4) {
reverse(s[i].begin(), s[i].end());
}
for (int i = 0; i < n; i++) {
cout << s[i] << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long factorial(long long n) {
if (n == 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}
long long gcd(long long a, long long b) { return factorial(min(a, b)); }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long a, b;
cin >> a;
cin >> b;
cout << gcd(a, b) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
int dr[] = {2, 2, -2, -2, 1, -1, 1, -1};
int dc[] = {1, -1, 1, -1, 2, 2, -2, -2};
int dr1[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dc1[] = {1, -1, 1, 0, -1, 0, 1, -1};
int dr2[] = {0, 0, 1, -1};
int dc2[] = {1, -1, 0, 0};
using namespace std;
long long b[12][12], n;
string t;
struct data {
int a[11][11], l, r, laz;
};
data tr[200005 * 3];
void build(long long n, long long b, long long e) {
long long i, j;
if (b == e) {
tr[n].l = t[b] - 'a' + 1;
tr[n].r = t[b] - 'a' + 1;
return;
}
long long mid = (b + e) >> 1, l = n * 2, r = l + 1;
build(l, b, mid);
build(r, mid + 1, e);
for (i = 1; i <= 10; i++) {
for (j = 1; j <= 10; j++) {
tr[n].a[i][j] = tr[l].a[i][j] + tr[r].a[i][j];
}
}
tr[n].a[tr[l].r][tr[r].l]++;
tr[n].l = tr[l].l;
tr[n].r = tr[r].r;
}
void make(long long n, long long b, long long e, long long c) {
if (c == 0) return;
memset(tr[n].a, 0, sizeof(tr[n].a));
tr[n].laz = c;
tr[n].a[c][c] = (e - b);
tr[n].l = tr[n].r = c;
}
void update(long long n, long long b, long long e, long long x, long long y,
long long c) {
long long i, j;
if (b > y || e < x) return;
if (b >= x && e <= y) {
make(n, b, e, c);
return;
}
long long mid = (b + e) >> 1, l = n * 2, r = l + 1;
make(l, b, mid, tr[n].laz);
make(r, mid + 1, e, tr[n].laz);
tr[n].laz = 0;
update(l, b, mid, x, y, c);
update(r, mid + 1, e, x, y, c);
for (i = 1; i <= 10; i++) {
for (j = 1; j <= 10; j++) {
tr[n].a[i][j] = tr[l].a[i][j] + tr[r].a[i][j];
}
}
tr[n].a[tr[l].r][tr[r].l]++;
tr[n].l = tr[l].l;
tr[n].r = tr[r].r;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long i, j, u, v, tc, m, k, q;
while (cin >> n >> q >> k) {
cin >> t;
build(1, 0, n - 1);
while (q--) {
cin >> m;
if (m == 1) {
long long l, r, c;
char ch;
cin >> l >> r >> ch;
c = ch - 'a' + 1;
update(1, 0, n - 1, l - 1, r - 1, c);
} else {
string t1;
cin >> t1;
memset(b, 0, sizeof(b));
for (i = 0; i < t1.size(); i++) {
for (j = i + 1; j < t1.size(); j++) {
b[t1[i] - 'a' + 1][t1[j] - 'a' + 1]++;
}
}
long long ans = 1;
for (i = 1; i <= k; i++) {
for (j = 1; j <= k; j++) {
if (b[i][j] == 0) ans += tr[1].a[i][j];
}
}
cout << ans << endl;
}
}
}
return 0;
}
| 5 |
#include<iostream>
using namespace std;
void solve(char* s, int n){
char prev=s[0];
char curr=s[0];
bool arr[26]={0};
arr[curr-65]=1;
for(int i=0; i<n ;i++){
curr=s[i];
if(curr==prev){
continue;
}
if(arr[curr-65]!=0){
cout<<"NO"<<endl;
return;
}
arr[curr-65]=1;
prev=curr;
}
cout<<"YES"<<endl;
return;
}
int main(){
int t;
cin>>t;
while(t>0){
t--;
int n;
cin>>n;
char *s= new char[n];
for(int i=0; i<n; i++){
cin>>s[i];
}
solve(s, n);
}
} | 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
const T& max(const T& a, const T& b, const T& c) {
return max(a, max(b, c));
}
template <class T>
const T& min(const T& a, const T& b, const T& c) {
return min(a, min(b, c));
}
long long stoi(string& str) {
istringstream second(str);
long long i;
second >> i;
return i;
}
string itos(long long i) {
stringstream second;
second << i;
return second.str();
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long poww(long long a, long long b) {
if (b == 0) return 1;
long long tmp = poww(a, b / 2);
return (b & 1 ? a * tmp * tmp : tmp * tmp);
}
long long sumOfDigs(string s) {
long long sum = 0;
for (int i = 0; i < s.length(); i++) sum += s[i] - '0';
return sum;
}
long long sumOfDigs(long long n) {
return (n < 10 ? n : n % 10 + sumOfDigs(n / 10));
}
long long mod = poww(10, 6) + 3;
int months[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
using namespace std;
void t() { freopen("test.txt", "r", stdin); }
int main() {
int a, b, c, d, e, f;
cin >> a >> b >> c >> d >> e >> f;
vector<pair<pair<int, int>, char> > v = {
make_pair(make_pair(max(a, b), min(a, b)), 'A'),
make_pair(make_pair(max(c, d), min(c, d)), 'B'),
make_pair(make_pair(max(e, f), min(e, f)), 'C')};
sort(v.begin(), v.end(), greater<pair<pair<int, int>, char> >());
int n = v[0].first.first;
if (max(a, b) == max(c, d) && max(a, b) == max(e, f) && max(a, b) == n) {
if (min(a, b) + min(c, d) + min(e, f) != n) {
return cout << -1 << endl, 0;
}
cout << n << endl;
for (int i = 1; i <= min(a, b); i++) {
for (int j = 1; j <= n; j++) cout << "A";
cout << endl;
}
for (int i = 1; i <= min(c, d); i++) {
for (int j = 1; j <= n; j++) cout << "B";
cout << endl;
}
for (int i = 1; i <= min(e, f); i++) {
for (int j = 1; j <= n; j++) cout << "C";
cout << endl;
}
return 0;
}
if (v[0].first.first != n) {
return cout << -1 << endl, 0;
} else {
int x = n - v[0].first.second;
if (v[1].first.first != x && v[1].first.second != x) {
return cout << -1 << endl, 0;
}
if (v[1].first.first == x) swap(v[1].first.second, v[1].first.first);
if (v[2].first.first != x && v[2].first.second != x) {
return cout << -1 << endl, 0;
}
if (v[2].first.first == x) {
swap(v[2].first.second, v[2].first.first);
}
if (v[1].first.first + v[2].first.first != n) {
return cout << -1 << endl, 0;
}
cout << n << endl;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= v[0].first.second; j++) cout << v[0].second;
char ch = (i > v[1].first.first ? v[2].second : v[1].second);
for (int j = 1; j <= x; j++) cout << ch;
cout << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
constexpr int const maxn = 5120;
int d[maxn], fa[maxn], f[maxn], g[maxn], id[maxn];
vector<pair<int, int>> adj[maxn];
void dfs(int u, int p, int i) {
d[u] = d[p] + 1;
fa[u] = p;
id[u] = i;
for (auto const& e : adj[u])
if (e.first != p) dfs(e.first, u, e.second);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 1; i != n; ++i) {
int u, v;
cin >> u >> v;
adj[u].emplace_back(v, i);
adj[v].emplace_back(u, i);
f[i + 1] = 1000000;
}
dfs(1, 0, 0);
int m;
cin >> m;
vector<pair<int, pair<int, int>>> line(m);
for (int i = 0; i != m; ++i) {
int u, v, w;
cin >> u >> v >> w;
if (d[u] < d[v]) swap(u, v);
line[i] = make_pair(w, make_pair(u, v));
}
sort(line.begin(), line.end());
for (int i = 0; i != m; ++i) {
int u = line[i].second.first, v = line[i].second.second, w = line[i].first;
while (d[u] > d[v]) {
f[u] = w;
u = fa[u];
}
while (u != v) {
f[u] = w;
u = fa[u];
f[v] = w;
v = fa[v];
}
}
for (int i = 0; i != m; ++i) {
int u = line[i].second.first, v = line[i].second.second, w = 1000000;
while (d[u] > d[v]) {
w = min(w, f[u]);
u = fa[u];
}
while (u != v) {
w = min(w, f[u]);
u = fa[u];
w = min(w, f[v]);
v = fa[v];
}
if (w != line[i].first) {
cout << "-1" << endl;
return 0;
}
}
for (int i = 2; i <= n; ++i) g[id[i]] = f[i];
for (int i = 1; i != n; ++i) cout << g[i] << " \n"[i == n - 1];
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, k, m, c;
void solve() {
cin >> n;
vector<pair<long long, long long> > a;
for (i = 0; i < n; i++) {
cin >> j;
a.push_back({j, i});
}
string b;
cin >> b;
long long int ans[b.size()];
sort(a.begin(), a.end());
priority_queue<pair<long long, long long> > q;
j = 0;
long long int person[n];
for (i = 0; i < n; i++) person[i] = 0;
for (i = 0; i < b.size(); i++) {
if (b[i] == '0') {
ans[i] = a[j].second;
person[a[j].second]++;
{ q.push(a[j]); }
j++;
} else {
pair<long long, long long> p = q.top();
ans[i] = p.second;
person[p.second]++;
{ q.pop(); }
}
}
for (i = 0; i < b.size(); i++) {
cout << ans[i] + 1 << " ";
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int T = 1;
long long h = T;
while (T--) {
solve();
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, x, n;
void input() {
cin >> a >> b >> n >> x;
return;
}
long long powmod(long long a, long long b) {
if (b == 1) return a;
if (b < 1) return 1;
long long t = powmod(a, b / 2) % 1000000007;
t = (t * t) % 1000000007;
if (b % 2 == 1) {
t = (t * a) % 1000000007;
}
return t;
}
void solve() {
if (a == 1) {
cout << (b * (n % 1000000007) + x) % 1000000007;
return;
}
long long tmp = powmod(a, n);
long long ans = ((tmp - 1) * powmod(a - 1, 1000000007 - 2)) % 1000000007;
tmp = (tmp * x) % 1000000007;
ans = (ans * b) % 1000000007;
cout << (tmp + ans) % 1000000007;
return;
}
void output() { return; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
{
input();
solve();
output();
}
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int r;
cin>>r;
cout<<(3*r*r);
return 0;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.