solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int Nx = 200005;
int ct[Nx], MMsize, A, B, tree[Nx * 4];
map<int, int> MM;
vector<int> pos[Nx];
int query(int a, int b, int key) {
if (A <= a && b <= B) return tree[key];
if (B < a || b < A) return 0;
int m = (a + b) / 2;
return query(a, m, key * 2) + query(m + 1, b, key * 2 + 1);
}
void insert(int a, int b, int key) {
if (A < a || A > b) return;
tree[key]++;
if (a == b) return;
int m = (a + b) / 2;
insert(a, m, key * 2);
insert(m + 1, b, key * 2 + 1);
}
int main() {
int N;
scanf("%d", &N);
for (int i = 1, v, p; i <= N; i++) {
scanf("%d", &v);
if ((p = MM[v]) == 0) p = MM[v] = ++MMsize;
pos[p].push_back(i);
}
for (map<int, int>::iterator i = MM.begin(); i != MM.end(); i++) {
int p = i->second;
for (vector<int>::iterator j = pos[p].begin(); j != pos[p].end(); j++) {
int v = *j;
for (int k = 1; k < N; k++) {
if ((k * (v - 1) + 2) > N) break;
A = k * (v - 1) + 2;
B = min(N, k * v + 1);
ct[k] += query(1, N, 1);
}
}
for (vector<int>::iterator j = pos[p].begin(); j != pos[p].end(); j++) {
A = *j;
insert(1, N, 1);
}
}
for (int i = 1; i < N; i++) {
printf("%d", ct[i]);
if (i == (N - 1))
putchar('\n');
else
putchar(32);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 61;
int n;
int x[15][15];
int main() {
memset(x, 0, sizeof(x));
for (int i = 1; i <= 10; i++) x[i][1] = x[1][i] = 1;
for (int i = 2; i <= 10; i++) {
for (int j = 2; j <= 10; j++) {
x[i][j] = x[i - 1][j] + x[i][j - 1];
}
}
scanf("%d", &n);
printf("%d\n", x[n][n]);
}
| 1 |
#include <iostream>
using namespace std;
int main() {
string x;
cin >> x;
for (int i = 0 ; i < int(x.size()); i++){
cout << "x";
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int buffer_size = 1 << 20;
int rd_char() {
static char buf[buffer_size];
static int l = buffer_size, r = buffer_size;
if (l == r && r == buffer_size) {
r = fread(buf, sizeof(char), 1 << 20, stdin);
l = 0;
}
if (l == r) return EOF;
return buf[l++];
}
unsigned int rd_uint() {
int c;
unsigned int x = 0;
while ('0' <= (c = rd_char())) x = x * 10 + c - '0';
return x;
}
int rd_int() {
bool neg = false;
int c = rd_char();
long long x = 0;
if (c == '-')
neg = true;
else
x = c - '0';
while ('0' <= (c = rd_char())) x = x * 10 + c - '0';
return neg ? -x : x;
}
unsigned long long rd_ull() {
int c;
unsigned long long x = 0;
while ('0' <= (c = rd_char())) x = x * 10 + c - '0';
return x;
}
long long rd_ll() {
bool neg = false;
int c = rd_char();
long long x = 0;
if (c == '-')
neg = true;
else
x = c - '0';
while ('0' <= (c = rd_char())) x = x * 10 + c - '0';
return neg ? -x : x;
}
string rd_str() {
string ret;
int c;
while ((c = rd_char()) != '\n' && c != ' ' && c != EOF) ret += c;
return ret;
}
struct writer_struct {
char buf[buffer_size];
int l = 0;
~writer_struct() { fwrite(buf, sizeof(char), l, stdout); }
} writer;
void flush() {
fwrite(writer.buf, sizeof(char), writer.l, stdout);
fflush(stdout);
writer.l = 0;
}
void wt(char c) {
if (writer.l == buffer_size) {
fwrite(writer.buf, sizeof(char), buffer_size, stdout);
writer.l = 0;
}
writer.buf[writer.l++] = c;
}
void wt(unsigned int x) {
if (x == 0)
wt('0');
else {
char f[10];
int sz = 0;
while (x) {
f[sz++] = x % 10 + '0';
x /= 10;
}
while (sz) wt(f[--sz]);
}
}
void wt(int x) {
if (x < 0) wt('-'), x = -x;
wt((unsigned int)x);
}
void wt(unsigned long long x) {
if (x == 0)
wt('0');
else {
char f[20];
int sz = 0;
while (x) {
f[sz++] = x % 10 + '0';
x /= 10;
}
while (sz) wt(f[--sz]);
}
}
void wt(long long x) {
if (x < 0) wt('-'), x = -x;
wt((unsigned long long)x);
}
void wt(const char* s) {
while (*s != '\0') wt(*s++);
}
void wt(const string& s) {
for (char c : s) wt(c);
}
const int LIM = 3e6;
int N, C[LIM + 1];
long long cnt[LIM + 1];
int main() {
N = rd_uint();
for (int i = 0; i < N; i++) C[rd_uint()]++;
for (int i = 1; i <= LIM; i++) {
if ((long long)i * i <= LIM)
cnt[i * i] += (long long)C[i] * (C[i] - 1);
else
cnt[LIM] += (long long)C[i] * (C[i] - 1);
int rest = N - C[i];
for (int j = 1; (long long)i * j <= LIM; j++) {
if (i != j) cnt[i * j] += (long long)C[i] * C[j], rest -= C[j];
}
cnt[LIM] += (long long)C[i] * rest;
}
for (int i = LIM; i >= 1; i--) cnt[i - 1] += cnt[i];
int M = rd_uint();
for (; M--;) {
int p = rd_uint();
wt(cnt[p]);
wt('\n');
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int size = 120004;
const long long inf = 1e18;
const long long modulo = 1000000007;
int main() {
int n, k;
cin >> n >> k;
vector<size_t> net(n);
for (int i = 0; i < n; i++) {
size_t a, b, c, d;
scanf("%d.%d.%d.%d", &a, &b, &c, &d);
net[i] = (a << 24) + (b << 16) + (c << 8) + d;
}
size_t subnetwork = (1 << 31);
set<size_t> nets;
for (int i = 30; i >= 0; i--) {
nets.clear();
for (int j = 0; j < n; j++) nets.insert(net[j] & subnetwork);
if (nets.size() == k) {
printf("%d.%d.%d.%d\n", subnetwork >> 24, (subnetwork >> 16) & 0xFF,
(subnetwork >> 8) & 0xFF, subnetwork & 0xFF);
return 0;
}
subnetwork += (1 << i);
}
cout << -1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
char s[100001];
int main() {
scanf("%s", s);
int len = strlen(s);
int las = 0;
int i, j;
for (i = 25; i >= 0; i--) {
for (j = las; j < len; j++) {
if (s[j] == 'a' + i) {
las = j + 1;
printf("%c", s[j]);
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
while (cin >> s) {
map<string, int> a;
for (int i = 0; i < 10; i++) {
string buf;
cin >> buf;
a[buf] = i;
}
for (int i = 0; i < 8; i++) {
cout << a[s.substr(10 * i, 10)];
}
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
const long long N = 110;
const long long mod = 1e9 + 7;
using namespace std;
int a[N][N];
int raw[N], arrange[N];
int main() {
int n, m, i, j;
scanf("%d%d", &n, &m);
for (i = 1; i <= n; i++) raw[i] = 1;
for (i = 1; i <= m; i++) arrange[i] = 1;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
if (a[i][j] == 0) {
raw[i] = arrange[j] = 0;
}
}
int t = 0;
for (i = 1; i <= n; i++) {
if (raw[i] == 0) t++;
}
if (t == n) {
for (i = 1; i <= m; i++) arrange[i] = 0;
}
t = 0;
for (i = 1; i <= m; i++) {
if (arrange[i] == 0) t++;
}
if (t == m) {
for (i = 1; i <= n; i++) raw[i] = 0;
}
int flag = 1;
for (i = 1; i <= n && flag; i++)
for (j = 1; j <= m && flag; j++) {
if (a[i][j]) {
if (!raw[i] && !arrange[j]) {
flag = 0;
break;
}
}
}
if (flag) {
printf("YES\n");
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
printf("%d", (raw[i] && arrange[j]) != 0 ? 1 : 0);
if (j == m)
printf("\n");
else
printf(" ");
}
}
} else
printf("NO\n");
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int n,d;
int main()
{
while(cin>>n>>d)
cout<<ceil(1.0*n/(2*d+1))<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
using ll=long long;
int main(){
int n; cin>>n;
ll sum=0;
vector<ll> num(n);
for(int i=0;i<n;i++){
ll a,b; cin>>a>>b;
num[i]=a+b;
sum+=b;
}
sort(num.rbegin(),num.rend());
ll ans=0;
for(int i=0;i<n;i+=2){
ans+=num[i];
}
cout<<ans-sum<<endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
const int S=(1<<20)+5;
char buf[S],*H,*T;
inline char Get()
{
if(H==T) T=(H=buf)+fread(buf,1,S,stdin);
if(H==T) return -1;return *H++;
}
inline int read()
{
int x=0;char c=Get();
while(!isdigit(c)) c=Get();
while(isdigit(c)) x=x*10+c-'0',c=Get();
return x;
}
const int N=200010;
struct Type
{
int l,r;
friend bool operator < (const Type &a,const Type &b){return a.l<b.l||a.l==b.l&&a.r>b.r;}
} a[N];
int n,m;
int c[N];
int main()
{
n=read();m=read();
for(int i=1;i<=n;i++) a[i].l=read(),a[i].r=read();
sort(a+1,a+1+n);
int L=0,R=m+1,cnt=0;
for(int i=1;i<=n;i++)
if(a[i].l>L&&L<m) L++;
else c[++cnt]=a[i].r;
sort(c+1,c+1+cnt);
for(int i=cnt;i>=1;i--)
{
if(R-L==1) break;
if(c[i]<R) R--;
}
printf("%d\n",n-(L+m-R+1));
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
const int N=605;
int n,m;
vector<int> g[N];
double dp[N];
double calc(int id){
for(int u=n-1;u>=1;--u){
double sum=0,Max=0;
int cnt=0;
for(int i=0;i<(int)g[u].size();++i){
int v=g[u][i];
sum+=dp[v]+1;
Max=max(Max,dp[v]+1);
++cnt;
}
if(cnt>=2 && id==u){
--cnt;
sum-=Max;
}
dp[u]=sum/cnt;
}
return dp[1];
}
int main(){
scanf("%d%d",&n,&m);
for(int i=0;i<m;++i){
int u,v;
scanf("%d%d",&u,&v);
g[u].push_back(v);
}
double ans=2e9;
for(int i=0;i<=n-1;++i) ans=min(ans,calc(i));
printf("%.10lf\n",ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
const int mod = 1e9 + 7;
using namespace std;
int n, m, mini, rev;
int ans[1 << 20], cnt[1 << 20], val[1 << 20], num[1 << 20];
char ch[21][100010];
inline int get_val(int x) {
int sum = 0;
for (int j = 1; j <= n; j++)
if (x & (1 << (j - 1))) sum++;
return min(sum, n - sum);
}
inline void prework() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%s", ch[i] + 1);
for (int i = 1; i <= m; i++) {
int x = 0;
for (int j = 1; j <= n; j++)
if (ch[j][i] == '1') x |= (1 << (j - 1));
num[x]++;
}
int len = 1 << 20;
for (int i = 1; i < len; i++) {
cnt[i] = cnt[i >> 1] + (i & 1);
val[i] = min(cnt[i], n - cnt[i]);
}
}
void fwt(int a[], int n) {
for (int d = 1; d < n; d <<= 1)
for (int m = d << 1, i = 0; i < n; i += m)
for (int j = 0; j < d; j++) {
int x = a[i + j], y = a[i + j + d];
a[i + j] = (x + y) % mod, a[i + j + d] = (x - y + mod) % mod;
}
}
void ufwt(int a[], int n) {
for (int d = 1; d < n; d <<= 1)
for (int m = d << 1, i = 0; i < n; i += m)
for (int j = 0; j < d; j++) {
int x = a[i + j], y = a[i + j + d];
a[i + j] = (1LL * (x + y) * rev) % mod,
a[i + j + d] = (1LL * ((x - y + mod) % mod) * rev) % mod;
}
}
void solve(int a[], int b[], int len) {
fwt(a, len);
fwt(b, len);
for (int i = 0; i < len; i++) a[i] = 1LL * a[i] * b[i] % mod;
ufwt(a, len);
}
inline void mainwork() {
int len = 1 << n;
solve(num, val, len);
mini = n * m;
for (int i = 0; i < len; i++) mini = min(mini, num[i]);
}
inline void print() { printf("%d", mini); }
inline int qp(long long a, long long b) {
long long ans = 1, cnt = a;
while (b) {
if (b & 1) ans = (ans * cnt) % mod;
cnt = (cnt * cnt) % mod;
b >>= 1;
}
return ans;
}
int main() {
rev = qp(2, mod - 2);
prework();
mainwork();
print();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000005;
const int dx[4] = {0, 0, -1, 1};
const int dy[4] = {-1, 1, 0, 0};
int n, m, V, tt;
vector<int> adj[maxn];
int p[maxn];
int mark[1005][1005], idx[1005][1005];
bool vis[1005][1005];
int mat[1005][1005];
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
bool valid(int i, int j) {
return i >= 1 && i <= n && j >= 1 && j <= m && mat[i][j] == 1;
}
int getid(int i, int j) {
if (mark[i][j] == tt) return idx[i][j];
mark[i][j] = tt;
idx[i][j] = V++;
adj[V - 1].clear();
return idx[i][j];
}
void addEdge(int a, int b) {
adj[a].push_back(b);
adj[b].push_back(a);
}
int find(int x) { return p[x] == x ? x : p[x] = find(p[x]); }
bool euler() {
int odd = 0;
for (int i = 0; i < V; i++) {
odd += (adj[i].size() & 1);
}
if (odd != 2 && odd != 0) return false;
for (int i = 0; i < V; i++) p[i] = i;
for (int i = 0; i < V; i++)
for (int j = 0; j < adj[i].size(); j++) p[find(i)] = find(adj[i][j]);
for (int i = 0; i < V; i++)
if (find(i) != find(0)) return false;
return true;
}
void dfs(int i, int j) {
vis[i][j] = true;
for (int k = 0; k < 4; k++) {
if (valid(i + dx[k], j + dy[k]) && !vis[i + dx[k]][j + dy[k]]) {
dfs(i + dx[k], j + dy[k]);
}
}
}
bool isconnected() {
bool flag = true;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (mat[i][j] == 1 && !vis[i][j]) {
if (!flag) return false;
dfs(i, j);
flag = false;
}
}
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%d", &mat[i][j]);
}
}
int g = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m;) {
for (; j <= m && mat[i][j] == 0; j++)
;
if (j == m + 1) break;
int L = 1;
for (; j + L <= m && mat[i][j + L] == 1; L++)
;
g = gcd(g, L - 1);
j += L;
}
}
for (int j = 1; j <= m; j++) {
for (int i = 1; i <= n;) {
for (; i <= n && mat[i][j] == 0; i++)
;
if (i == n + 1) break;
int L = 1;
for (; i + L <= n && mat[i + L][j] == 1; L++)
;
g = gcd(g, L - 1);
i += L;
}
}
if (!isconnected()) {
puts("-1");
return 0;
}
vector<int> ans;
tt = 0;
for (int k = 2; k <= g; k++)
if (g % k == 0) {
V = 0;
tt++;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
for (; j <= m && mat[i][j] == 0; j++)
;
if (j == m + 1) break;
while (j + 1 <= m && mat[i][j + 1] == 1) {
addEdge(getid(i, j), getid(i, j + k));
j += k;
}
}
}
for (int j = 1; j <= m; j++) {
for (int i = 1; i <= n; i++) {
for (; i <= n && mat[i][j] == 0; i++)
;
if (i == n + 1) break;
while (i + 1 <= n && mat[i + 1][j] == 1) {
addEdge(getid(i, j), getid(i + k, j));
i += k;
}
i++;
}
}
if (euler()) ans.push_back(k);
}
if (ans.size() == 0)
puts("-1");
else {
for (int i = 0; i < ans.size(); i++)
printf("%d%c", ans[i], i == ans.size() - 1 ? '\n' : ' ');
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e18;
const long long int mod = 1e9 + 7;
const long long int MOD = 998244353;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c *x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug &operator<<(const c &) {
return *this;
}
};
vector<char *> tokenizer(const char *args) {
char *token = new char[111];
strcpy(token, args);
token = strtok(token, ", ");
vector<char *> v({token});
while ((token = strtok(NULL, ", "))) v.push_back(token);
return reverse(v.begin(), v.end()), v;
}
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
void debugg(vector<char *> args) { cerr << "\b\b "; }
#pragma clang diagnostic pop
template <typename Head, typename... Tail>
void debugg(vector<char *> args, Head H, Tail... T) {
debug() << " [" << args.back() << ": " << H << "] ";
args.pop_back();
debugg(args, T...);
}
template <typename T>
T power(T a, T b) {
if (b == 0) return 1;
if (b == 1)
return a;
else {
T res = (power(a, b / 2));
if (b % 2) {
return (res * res * a);
} else {
return res * res;
}
}
}
template <typename T>
T power(T a, T b, T modulo) {
if (b == 0) return 1;
if (b == 1)
return a;
else {
T res = (power(a, b / 2, modulo) % modulo);
if (b % 2) {
return ((((res % modulo) * (res % modulo)) % modulo) * (a % modulo)) %
modulo;
} else {
return ((res % modulo) * (res % modulo)) % modulo;
}
}
}
template <typename T>
T gcd(T a, T b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
template <typename T>
T gcd_extended(T a, T b, T &x, T &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
T x1, y1;
T d = gcd_extended(b, a % b, x1, y1);
x = y1;
y = x1 - y1 * (a / b);
return d;
}
bool find_solution(long long int a, long long int b, long long int c,
long long int &x, long long int &y) {
long long int g = gcd_extended<long long int>(a, b, x, y);
if (c % g) {
return false;
}
x = x * (c / g);
y = y * (c / g);
if (a < 0) x *= (-1);
if (b < 0) y *= (-1);
return true;
}
void factorial(vector<long long int> &fact, long long int n) {
fact.resize(n + 1, 1);
fact[0] = 1;
fact[1] = 1;
for (int i = 2; i <= n; ++i) {
fact[i] = ((fact[i - 1] % mod) * (i % mod)) % mod;
}
}
long long int mod_inv(long long int a) {
return (power<long long int>(a, mod - 2, mod)) % mod;
}
long long int ncr(long long int n, long long int r,
vector<long long int> &fact) {
if (r > n or n < 0 or r < 0) return 0LL;
return (((fact[n] % mod) * (mod_inv(fact[n - r]) % mod)) % mod *
(mod_inv(fact[r]) % mod)) %
mod;
}
long long int sum(vector<long long int> &v, long long int l, long long int k) {
long long int a = 1;
for (auto &i : v) {
if (abs(l - i) <= k) {
continue;
}
a = 0;
break;
}
return a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int test;
cin >> test;
while (test--) {
long long int n;
cin >> n;
long long int k;
cin >> k;
vector<long long int> v(n - 1 + 1);
for (auto i = 0; i <= n - 1; i++) {
cin >> v[i];
};
sort((v).begin(), (v).end());
long long int ans = v[0] + k;
{};
for (auto &i : v) {
if (abs(i - ans) > k) {
ans = -1;
break;
}
}
cout << ((ans)) << "\n";
;
}
return 0;
}
| 2 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <functional>
#define rep(i, n) for(i = 0; i < n; i++)
using namespace std;
void chmax(int &a, int b) { a = max(a, b); }
int n;
int r[1000], w[1000];
bool dp[1001][1001];
void toSort() {
typedef pair<int, int> P;
vector<P> vec;
for (int i = 0; i < n; i++) vec.push_back(P(r[i], w[i]));
sort(vec.begin(), vec.end(), greater<P>());
for (int i = 0; i < n; i++) {
r[i] = vec[i].first;
w[i] = vec[i].second;
}
}
int main() {
int i, j;
while (cin >> n) {
if (!n) break;
rep(i, n) cin >> r[i] >> w[i]; toSort();
int sum_r = 0;
rep(i, n) sum_r += r[i];
int blank = max(0, 2 * r[0] - sum_r);
rep(i, n+1) rep(j, blank+1) dp[i][j] = false;
dp[0][0] = true;
rep(i, n) {
rep(j, blank + 1) {
dp[i + 1][j] |= dp[i][j];
if (i > 0 && j + w[i] <= blank) dp[i + 1][j + w[i]] |= dp[i][j];
}
}
int max_wb = 0;
rep(j, blank + 1) {
if (dp[n][j]) chmax(max_wb, j);
}
int gokei = 0;
rep(i, n) gokei += r[i] + w[i];
cout << gokei + blank - max_wb << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
class compare {
public:
bool operator()(pair<long long, long long> a, pair<long long, long long> b) {
if (a.first > b.first) return true;
return false;
}
};
bool comp(long long a, long long b) { return a > b; }
long long power(long long a, long long b) {
long long res = 1;
a = a % 1000000007;
while (b) {
if (b & 1) {
res = (res * a) % 1000000007;
}
b /= 2;
a = (a * a) % 1000000007;
}
return res;
}
bool primes[100005];
vector<long long> prime;
void sieve(long long n) {
primes[2] = false;
for (long long i = 2; i * i <= 100000; i++) {
if (primes[i] == false) {
for (long long p = i * i; p <= 100000; p += i) {
primes[p] = true;
}
}
}
for (long long i = 2; i <= 100000; i++) {
if (primes[i] == false) prime.push_back(i);
}
}
string check(string a) {
long long n = a.length();
if (n % 2 == 1) return a;
string s1 = check(a.substr(0, n / 2));
string s2 = check(a.substr(n / 2, n));
if (s1 < s2)
return s1 + s2;
else {
return s2 + s1;
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string a, b;
cin >> a >> b;
if (check(a) == check(b))
cout << "YES" << endl;
else {
cout << "NO" << endl;
}
}
| 2 |
#include<iostream>
#include<vector>
#include<cmath>
#include<iomanip>
using namespace std;
struct Point{
double x;
double y;
};
int main()
{
Point p1,p2;
cin>>p1.x>>p1.y>>p2.x>>p2.y;
int q;
cin>>q;
vector<Point> pp(q);
for(int i=0; i<q; i++){
cin>>pp[i].x>>pp[i].y;
}
double rc1,rc2,b1;
rc1=(p1.y-p2.y)/(p1.x-p2.x);
if(p1.x-p2.x==0){
b1=p1.y;
rc2=0;
}else{
b1=p1.y-rc1*p1.x;
rc2=(-1)/rc1;
}
vector<double> bb(q);
vector<Point> ans(q);
for(int i=0; i<pp.size(); i++){
if(rc1==0){
ans[i].x=pp[i].x;
}else{
bb[i]=pp[i].y-rc2*pp[i].x;
if(p1.x-p2.x==0){
ans[i].x=0;
}else if(rc2-rc1==0){
ans[i].x=0;
}else{
ans[i].x=(b1-bb[i])/(rc2-rc1);
}
}
if(p1.x-p2.x==0){
ans[i].y=bb[i];
}else{
ans[i].y=rc1*ans[i].x+b1;
}
Point ans2[q];
ans2[i].x=pp[i].x+2*(ans[i].x-pp[i].x);
if(p1.y-p2.y==0){
ans2[i].y=-pp[i].y;
}else{
ans2[i].y=rc2*ans2[i].x+bb[i];
}
cout<<fixed;
cout<<setprecision(10)<<ans2[i].x<<" "<<ans2[i].y<<endl;;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int sol(int a, int b, int p, string s) {
int cost = s[s.size() - 2] == 'A' ? a : b;
if (cost > p) return s.size();
for (int i = s.size() - 2; i > 0; i--) {
if (s[i - 1] != s[i]) {
cost += s[i - 1] == 'A' ? a : b;
if (cost > p) return i + 1;
}
}
return 1;
}
int main(int argn, char** argc) {
string line;
getline(cin, line);
int n = stoi(line);
while (n--) {
getline(cin, line);
istringstream ss(line);
int a, b, p;
ss >> a;
ss >> b;
ss >> p;
getline(cin, line);
cout << sol(a, b, p, line) << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005], f[100005];
int main()
{
scanf("%d", &n);
for(int i = 1; i <= n ; ++i)
scanf("%d", &a[i]), ++f[a[i]];
int Max = 0;
for(int i = 1; i <= 100000 ; ++i)
Max = max(Max, f[i] + f[i - 1] + f[i + 1]);
printf("%d", Max);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
long long n, x, ans = 0;
cin >> n;
map<long long,long long> freq;
for(int i=0; i<n; i++)
{
cin >> x;
ans += freq[i-x];
freq[i+x]++;
}
cout << ans << "\n";
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
vector<int>A;
long long int n,ai,sum=0;
cin>>n;
for(int i=0;i<n;i++){
cin>>ai;
A.push_back(ai);
sum+=ai;
}
int x=sum/n;
int y=ceil(sum*1.000/n);
long long int c=0,d=0;
for(int i=0;i<n;i++){
c+=pow(A[i]-x,2);
d+=pow(A[i]-y,2);
}
cout<<min(c,d)<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N(1e5 + 21);
struct hh {
int v, nxt;
} edges[N * 2];
int n, en, point[N], sz[N];
double pu[N], pv[N], au, av, su[N], sv[N], ans;
inline void addedge(int u, int v) {
edges[++en] = (hh){v, point[u]};
point[u] = en;
}
inline void dfs(int x, int fa) {
sz[x] = 1;
su[x] = pu[x];
sv[x] = pv[x];
for (int i(point[x]), v; i; i = edges[i].nxt)
if ((v = edges[i].v) != fa) {
dfs(v, x);
sz[x] += sz[v];
su[x] += su[v];
sv[x] += sv[v];
}
for (int i(point[x]), v; i; i = edges[i].nxt)
if ((v = edges[i].v) != fa) ans += pv[x] * sz[v] * su[v];
ans += pv[x] * (n - sz[x]) * (1.0 - su[x]);
}
int main() {
scanf("%d", &n);
for (int i(1), u, v; i < n; i++) {
scanf("%d%d", &u, &v);
addedge(u, v);
addedge(v, u);
}
for (int i(1); i <= n; i++) {
scanf("%lf%lf", pu + i, pv + i);
au += pu[i], av += pv[i];
}
for (int i(1); i <= n; i++) pu[i] /= au, pv[i] /= av;
dfs(1, 0);
printf("%.15lf\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int t, n, i, j;
scanf("%d", &t);
for (i = 0; i < t; i++) {
scanf("%d", &n);
for (j = 2; j <= n + 1; j++) printf("%d ", j);
printf("\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v(0);
int main() {
int n, l, x, y;
cin >> n >> l >> x >> y;
for (int i = (0); i < (n); i++) {
int tmp;
cin >> tmp;
v.push_back(tmp);
}
bool isx = false, isy = false, isxpy = false, isxmy = false;
int xpyp = -1, xmyp = -1;
int fxmyp = -1;
int xpy = x + y, xmy = abs(x - y);
for (int i = (0); i < (n - 1); i++) {
if (binary_search(v.begin() + i, v.end(), v[i] + x)) isx = true;
if (binary_search(v.begin() + i, v.end(), v[i] + y)) isy = true;
if (binary_search(v.begin() + i, v.end(), v[i] + xpy)) {
isxpy = true;
xpyp = i;
}
if (binary_search(v.begin() + i, v.end(), v[i] + xmy)) {
isxmy = true;
xmyp = i;
if (fxmyp == -1) fxmyp = i;
}
}
if (isx && isy) {
cout << 0;
return 0;
}
if (isx || isy) {
if (isx) {
cout << 1 << ' ' << y;
return 0;
} else {
cout << 1 << ' ' << x;
return 0;
}
}
if (!isxpy && !isxmy) {
cout << 2 << ' ' << x << ' ' << y;
return 0;
}
if (isxpy) {
cout << 1 << ' ' << v[xpyp] + x;
return 0;
}
if (isxmy) {
int a = max(x, y);
if (v[xmyp] + a < l) {
cout << 1 << ' ' << v[xmyp] + a;
return 0;
} else if (v[xmyp] - a + xmy > 0) {
cout << 1 << ' ' << v[xmyp] - a + xmy;
return 0;
}
if (v[fxmyp] + a < l) {
cout << 1 << ' ' << v[fxmyp] + a;
return 0;
} else if (v[fxmyp] - a + xmy > 0) {
cout << 1 << ' ' << v[fxmyp] - a + xmy;
return 0;
} else {
cout << 2 << ' ' << x << ' ' << y;
return 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> jumps[3];
int dp[3][7010], cont[3][7010];
bool vis[3][7010];
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
int n, k1, k2;
cin >> n;
cin >> k1;
for (int i = 0; i < k1; i++) {
int val;
cin >> val;
jumps[0].push_back(val);
}
cin >> k2;
for (int i = 0; i < k2; i++) {
int val;
cin >> val;
jumps[1].push_back(val);
}
memset(dp, -1, sizeof dp);
dp[1][1] = dp[0][1] = 0;
queue<pair<int, int> > q;
q.push({0, 1});
q.push({1, 1});
vis[0][1] = vis[1][1] = 1;
while (!q.empty()) {
pair<bool, int> f = q.front();
q.pop();
for (int i = 0; i < jumps[!f.first].size(); i++) {
int nxt = f.second - jumps[!f.first][i];
if (nxt <= 0) nxt += n;
if (vis[!f.first][nxt]) continue;
if (dp[f.first][f.second] == 0) {
dp[!f.first][nxt] = 1;
vis[!f.first][nxt] = 1;
q.push({!f.first, nxt});
} else if (dp[!f.first][nxt] != 1) {
cont[!f.first][nxt]++;
if (cont[!f.first][nxt] == jumps[!f.first].size()) {
dp[!f.first][nxt] = 0;
vis[!f.first][nxt] = 1;
q.push({!f.first, nxt});
}
}
}
}
for (int i = 0; i <= 1; i++) {
for (int j = 2; j <= n; j++) {
if (dp[i][j] == 0) {
cout << "Lose ";
} else if (dp[i][j] == 1) {
cout << "Win ";
} else
cout << "Loop ";
}
cout << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string x, z;
vector<int> y;
int f = -1;
vector<int> v(1200, 0);
while (cin >> z) x += z;
for (int i = 0; i < (int)x.size(); i++) {
if (x[i] == '<') {
string s = "";
i++;
while (x[i] != '>') {
s += x[i];
i++;
}
if (s == "table") {
f++;
y.push_back(f);
} else if (s == "td")
v[y[(int)y.size() - 1]]++;
else if (s == "/table")
y.erase(y.begin() + (int)y.size() - 1, y.begin() + (int)y.size());
}
}
v.erase(v.begin() + f + 1, v.end());
sort((v).begin(), (v).end());
for (int i = 0; i <= f; i++) cout << v[i] << " ";
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main() {
int h, w;
cin >> h >> w;
vector<string> a(h);
for (auto& e : a) cin >> e;
cout << string(w+2, '#') << endl;
for (auto& e : a) cout << '#' << e << '#' << endl;
cout << string(w+2, '#') << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long sum = n * (n + 1) / 2;
if (sum % 2 == 0)
cout << "0";
else
cout << "1";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxs = 1000005;
int a[maxs], y[maxs], used[maxs], appear[maxs];
int n, tot, cnt = 1;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
appear[a[i]] = true;
}
for (int i = 1; i <= n; i++) {
if (!appear[1000001 - a[i]]) {
y[tot++] = 1000001 - a[i];
} else if (!used[a[i]]) {
while (appear[cnt] || appear[1000001 - cnt]) cnt++;
y[tot++] = cnt;
y[tot++] = 1000001 - cnt;
used[1000001 - a[i]] = 1;
cnt++;
}
}
printf("%d\n", tot);
for (int i = 0; i < tot; i++) printf("%d ", y[i]);
printf("\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
int main() {
cin >> s1;
cin >> s2;
int idx = 0;
for (int i = 0; i < s1.length(); ++i) {
if (s1[i] == '|') {
idx = i;
break;
}
}
string l = s1.substr(0, idx);
string r = s1.substr(idx + 1, s1.length() - idx);
while (s2.length()) {
if (l.size() < r.size())
l += s2.back();
else
r += s2.back();
s2.pop_back();
}
if (l.size() == r.size()) {
cout << l + '|' + r;
return 0;
}
cout << "Impossible";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
cin >> T;
while (T--) {
int n;
cin >> n;
int sum1 = 0, sum2 = 0;
sum1 = pow(2, n);
sum2 = pow(2, n - 1);
for (int a = 1, b = n - 2; a < b; a++, b--) {
if (sum1 < sum2) {
sum1 += pow(2, b);
sum2 += pow(2, a);
} else {
sum1 += pow(2, a);
sum2 += pow(2, b);
}
}
int ans = abs(sum1 - sum2);
cout << ans << endl;
}
}
| 1 |
#include <iostream>
using namespace std;
int main(){
int a, b;
cin >> a >> b;
int x = b*10;
for(int i=x;i<x+10;i++){
if(a==i*2/25){
cout << i << endl;
return 0;
}
}
cout << -1 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, p;
long long d[100005], a[100005], s[100005], q[100005], f[100005], g[100005];
double inter(int i, int j) {
return ((double)f[i] + s[i] - f[j] - s[j]) / (i - j);
}
int main() {
cin >> n >> m >> p;
for (int i = 2; i <= n; i++) cin >> d[i], d[i] += d[i - 1];
for (int i = 1; i <= m; i++) {
int h, t;
cin >> h >> t;
a[i] = t - d[h];
}
sort(a + 1, a + m + 1);
for (int i = 1; i < m + 1; i++) s[i] = s[i - 1] + a[i];
for (int i = 1; i < m + 1; i++) f[i] = i * a[i] - s[i];
while (--p) {
int head = 0, tail = 0;
q[0] = 0;
for (int i = 1; i < m + 1; i++) {
while (head < tail and
f[q[head]] + s[q[head]] - q[head] * a[i] >=
f[q[head + 1]] + s[q[head + 1]] - q[head + 1] * a[i])
head++;
g[i] = i * a[i] - s[i] + f[q[head]] + s[q[head]] - q[head] * a[i];
while (head < tail and inter(i, q[tail]) <= inter(q[tail], q[tail - 1]))
tail--;
q[++tail] = i;
}
for (int i = 1; i < m + 1; i++) f[i] = g[i];
}
cout << f[m] << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
template <typename T>
T sqr(T x) {
return x * x;
}
template <typename T>
bool exmax(T &a, T b) {
return (b > a) ? (a = b) || 1 : 0;
}
template <typename T>
bool exmin(T &a, T b) {
return (b < a) ? (a = b) || 1 : 0;
}
using namespace std;
int main(void) {
int N, M;
scanf("%d%d", &N, &M);
int C;
scanf("%d", &C);
long long lu = -(1LL << 40), ru = -(1LL << 40), ld = -(1LL << 40),
rd = -(1LL << 40);
for (__typeof(C) i = 0; i < (C); i++) {
long long x, y;
scanf("%I64d%I64d", &x, &y);
lu = max(lu, -x + y);
ru = max(ru, x + y);
ld = max(ld, -x - y);
rd = max(rd, x - y);
}
int ind;
long long km = 1LL << 40;
int H;
scanf("%d", &H);
for (__typeof(H) i = 0; i < (H); i++) {
long long x, y;
scanf("%I64d%I64d", &x, &y);
long long tmp;
tmp = max(max(x - y + lu, -x - y + ru), max(x + y + ld, -x + y + rd));
if (tmp < km) {
km = tmp;
ind = i + 1;
}
}
printf("%I64d\n%d\n", km, ind);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
int times;
cin >> n >> m >> k;
int y = 0;
queue<pair<int, string> > Q;
pair<int, string> z;
if (k > 4 * m * n - 2 * n - 2 * m)
cout << "NO";
else {
cout << "YES" << endl;
while (k > 0) {
if (y == n - 1) break;
times = 0;
if (k >= 3 && m > 1) {
times = min(m - 1, k / 3);
Q.push(make_pair(times, "RDU"));
k -= times * 3;
}
if (k == 1 && times < m - 1) {
Q.push(make_pair(1, "R"));
k -= 1;
}
if (k == 2 && times < m - 1) {
Q.push(make_pair(1, "RD"));
k -= 2;
}
if (times == m - 1 && k >= m - 1) {
if (m > 1) Q.push(make_pair(m - 1, "L"));
k -= m - 1;
} else {
if (k != 0) Q.push(make_pair(k, "L"));
k = 0;
}
if (k >= 1) {
Q.push(make_pair(1, "D"));
y++;
k -= 1;
}
}
if (k > 0) {
times = min(k, m - 1);
if (m > 1) Q.push(make_pair(times, "R"));
k -= times;
}
if (k > 0) {
times = min(k, m - 1);
if (m > 1) Q.push(make_pair(times, "L"));
k -= times;
}
if (k > 0) {
times = min(k, n - 1);
Q.push(make_pair(times, "U"));
k -= times;
}
cout << Q.size() << endl;
while (!Q.empty()) {
z = Q.front();
cout << z.first << " " << z.second;
cout << endl;
Q.pop();
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int X, Y;
double x, y;
point() { X = Y = x = y = .0; }
point(double a, double b) { x = a, y = b; }
inline void init(int a, int b) {
X = a, Y = b;
x = 1.0 / X;
y = 1.0 / Y;
}
inline double operator*(point p) { return x * p.y - y * p.x; }
inline point operator-(point p) { return point(x - p.x, y - p.y); }
inline double dis(point p) {
return ((x - p.x) * (x - p.x)) + ((y - p.y) * (y - p.y));
}
inline pair<int, int> PII() { return pair<int, int>(X, Y); }
};
point o;
point l;
inline bool ocmp(const point &a, const point &b) {
return make_pair(a.y, a.x) < make_pair(b.y, b.x);
}
inline bool lcmp(const point &a, const point &b) {
return make_pair(a.x, a.y) < make_pair(b.x, b.y);
}
inline bool scmp(const point &a, const point &b) {
double cross = ((point)a - o) * ((point)b - o);
if (fabs(cross) <= 1e-18) return o.dis(a) < o.dis(b);
return cross < 1e-18;
}
vector<point> v;
vector<point> hull;
map<pair<int, int>, vector<int>> indx;
void CH() {
o = *min_element(v.begin(), v.end(), ocmp);
l = *min_element(v.begin(), v.end(), lcmp);
if (o.PII() == l.PII()) {
for (int p : indx[o.PII()]) {
cout << p << " ";
}
cout << endl;
return;
}
sort(v.begin(), v.end(), scmp);
if ((int)v.size() == 1) {
hull.push_back(v.front());
return;
}
for (int i = 0; i < 2; i++) hull.push_back(v[i]);
int po = 2;
while (po < (int)v.size() && hull.back().PII() != l.PII()) {
while (hull.size() > 1 && (hull[hull.size() - 1] - hull[hull.size() - 2]) *
(v[po] - hull[hull.size() - 2]) >
1e-18)
hull.pop_back();
hull.push_back(v[po++]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
indx[make_pair(x, y)].push_back(i + 1);
}
if ((int)indx.size() == 1) {
for (auto p : indx) {
for (int x : p.second) cout << x << " ";
cout << endl;
}
return 0;
}
for (auto p : indx) {
int x = p.first.first;
int y = p.first.second;
point P;
P.init(x, y);
v.push_back(P);
}
CH();
vector<int> ans;
for (point p : hull) {
for (int x : indx[p.PII()]) {
ans.push_back(x);
}
}
sort(ans.begin(), ans.end());
for (int x : ans) cout << x << " ";
cout << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int m, k;
cin >> m >> k;
vector<long long> sum(k, 0LL), sum2(k, 0LL);
int pos;
for(int i=0;i<k;++i){
for(int j=0;j<m;++j){
cin >> pos;
sum[i] += 1LL*pos;
sum2[i] += 1LL*pos*pos;
}
}
long long r1 = sum[1] - sum[0], r2 = sum[k-1] - sum[k-2], r3 = sum[3] - sum[2];
long long r;
if(r1 == r2 || r1 == r3) r = r1;
else r = r2;
int y;
for(int i=1;i<k-1;++i){
if(sum[i] - sum[i-1] != r){
y = i;
break;
}
}
int t;
if(y == k-2 || y == k-3) t = y-3;
else t = y+1;
long long vct = sum2[t+2] + sum2[t] - 2*sum2[t+1];
long long inc = ((sum[y+1] + sum[y-1])/2) - sum[y];
long long mod = ((sum2[y+1] + sum2[y-1] - vct)/2 - sum2[y] - inc*inc)/(2*inc);
cout << y << " " << mod+inc << endl;
return 0;
} | 6 |
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <math.h>
using namespace std;
int main(){
cin.tie(NULL);
ios::sync_with_stdio(false);
int n;
int p[1005][1005];
int tf=0;
int tt=0;
int ans=0;
cin>>n;
for(int i=0;i<n;i++){
for(int j=0;j<3;j++){
cin>>p[i][j];
}
sort(p[i],p[i]+3);
for(int k=0;k<i;k++){
for(int j=0;j<3;j++){
if(p[i][j]==p[k][j]){
tt++;
}
}
if(tt==3){
tf++;
}
tt=0;
}
if(tf>0){
ans++;
}
tf=0;
}
cout<<ans<<"\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
int f[1010][1010];
int n, k;
int a[1010];
int solve(int x) {
f[0][0] = 1;
int lst = 0;
for (int i = 1; i <= n; i++) {
while (a[i] - a[lst + 1] >= x) lst++;
for (int j = 0; j <= k; j++) {
f[i][j] = f[i - 1][j];
if (j) f[i][j] = (f[i][j] + f[lst][j - 1]) % 998244353;
}
}
return f[n][k];
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
std::sort(a + 1, a + n + 1);
int ans = 0;
for (int i = 1; i <= 100000 / (k - 1); i++)
ans = (ans + solve(i)) % 998244353;
printf("%d\n", ans);
}
| 3 |
#include <iostream>
using namespace std;
const int MAX_N = 1e+7;
bool is_p[MAX_N+1] = {false,false};
void sieve(){
for(int i = 2 ; i <= MAX_N ; i++ )
is_p[i] = true;
for(int i = 2 ; i*i <= MAX_N ; i++ ){
if( is_p[i] ){
for(int j = i+i ; j <= MAX_N ; j += i ){
is_p[j] = false;
}
}
}
}
int main(){
sieve();
int k;
while( cin >> k , k ){
int a, b;
for(int i=k ; 2 <= i ; i-- ){
if( is_p[i] ){
a = i;
break;
}
}
for(int i=k ; true ; i++ ){
if( is_p[i] ){
b = i;
break;
}
}
cout << b - a << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool f(vector<vector<int>> arr, int n) {
int curr = arr[0][0], i = 1;
for (i = 1; i < n; i++) {
if (curr >= arr[i][0] && curr >= arr[i][1]) {
curr = max(arr[i][0], arr[i][1]);
} else if (curr >= arr[i][0] && curr < arr[i][1]) {
curr = arr[i][0];
} else if (curr < arr[i][0] && curr >= arr[i][1]) {
curr = arr[i][1];
} else
break;
}
if (i >= n) return true;
curr = arr[0][1];
i = 1;
for (i = 1; i < n; i++) {
if (curr >= arr[i][0] && curr >= arr[i][1]) {
curr = max(arr[i][0], arr[i][1]);
} else if (curr >= arr[i][0] && curr < arr[i][1]) {
curr = arr[i][0];
} else if (curr < arr[i][0] && curr >= arr[i][1]) {
curr = arr[i][1];
} else
break;
}
if (i >= n)
return true;
else
return false;
}
int main() {
int n;
cin >> n;
vector<vector<int>> arr(n, vector<int>(2));
for (int i = 0; i < n; i++) {
cin >> arr[i][0] >> arr[i][1];
}
if (f(arr, n))
cout << "YES" << endl;
else
cout << "NO" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int scan() {
int t = 0;
char c;
c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
t = (t << 3) + (t << 1) + c - '0';
c = getchar();
}
return (t);
}
int a[26][100001], ind[26] = {0};
char str[100002];
int main() {
scanf("%s", str);
for (int i = 0; str[i] != '\0'; i++) a[str[i] - 'a'][ind[str[i] - 'a']++] = i;
int lind = -1;
for (int i = 25; i >= 0; i--) {
for (int j = 0; j < ind[i]; j++) {
if (a[i][j] > lind) {
printf("%c", i + 'a');
lind = a[i][j];
}
}
}
return (0);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
vector<vector<int> > adj(N);
int h[N];
struct centroidDecomp {
vector<vector<int> > cd;
vector<int> d;
vector<bool> vis;
vector<int> sz;
vector<int> par;
int n;
centroidDecomp(int root = 1) {
n = adj.size();
d.resize(n, 1000000000);
par.resize(n, -1);
cd.resize(n);
vis.resize(n, false);
sz.resize(n, 0);
init_centroid(root);
constructTree();
}
void constructTree() {
for (int i = 0; i < n; i++) {
if (par[i] == -1) continue;
cd[i].push_back(par[i]);
cd[par[i]].push_back(i);
}
}
int fillSize(int v, int p = -1) {
if (vis[v]) return 0;
sz[v] = 1;
for (auto i : adj[v]) {
if (!vis[i] && i != p) sz[v] += fillSize(i, v);
}
return sz[v];
}
int find_centroid(int u, int p, int n) {
for (int x : adj[u]) {
if (!vis[x] && x != p && sz[x] > n / 2) return find_centroid(x, u, n);
}
return u;
}
void init_centroid(int u, int p = -1) {
fillSize(u, p);
int c = find_centroid(u, p, sz[u]);
par[c] = p;
vis[c] = true;
for (auto x : adj[c]) {
if (!vis[x]) init_centroid(x, c);
}
}
void printTree() {
for (int i = 0; i < n; i++) {
if (cd[i].size()) {
cout << i << ": ";
for (auto j : cd[i]) cout << j << " ";
cout << "\n";
}
}
}
};
void dfs(vector<vector<int> > &adj, int u, int p = -1) {
for (auto x : adj[u]) {
if (x != p) {
h[x] = h[u] + 1;
dfs(adj, x, u);
}
}
}
int32_t main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int i, j;
int n;
cin >> n;
for (i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
}
centroidDecomp cdecomp;
int rt;
for (i = 1; i < n + 1; i++)
if (cdecomp.par[i] == -1) rt = i;
dfs(cdecomp.cd, rt);
for (i = 1; i < n + 1; i++) cout << (char)(h[i] + 'A') << " ";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int fst[400020], nxt[200020], vv[200020], cost[200020], e;
void init() {
memset(fst, -1, sizeof fst);
e = 0;
}
void add(int u, int v, int c) {
vv[e] = v, cost[e] = c, nxt[e] = fst[u], fst[u] = e++;
}
int n, w[400020], sz[400020];
int val[400020];
vector<int> son[400020];
double ans;
void dfs(int u, int p) {
sz[u] = 1;
w[u] = 0;
for (int i = fst[u]; ~i; i = nxt[i]) {
int v = vv[i];
int c = cost[i];
if (v == p) continue;
dfs(v, u);
son[u].push_back(v);
sz[u] += sz[v];
val[v] = c;
w[v] += c;
w[u] += w[v];
}
}
bool cmp(int i, int j) { return 1LL * w[i] * sz[j] < 1LL * w[j] * sz[i]; }
void dfs2(int u, int p) {
int cnt = 0;
for (int i = 0; i < son[u].size(); ++i) {
int v = son[u][i];
cnt += sz[v];
ans += sz[v] * val[v];
ans += 1LL * (sz[u] - cnt - 1) * w[v] * 2;
dfs2(v, u);
}
}
int main() {
scanf("%d", &n);
init();
for (int i = 1; i < n; ++i) {
int u, v, c;
scanf("%d%d%d", &u, &v, &c);
add(u, v, c);
add(v, u, c);
}
dfs(1, -1);
for (int i = 1; i <= n; ++i) {
sort(son[i].begin(), son[i].end(), cmp);
}
dfs2(1, -1);
printf("%.12lf\n", ans / (n - 1));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<int, vector<int>> e;
int n, m, k, q;
bool safe[200005];
int sl[200005], sr[200005];
const long long inf = 1e18;
struct stanje {
int x, y;
long long cost;
};
long long mn(vector<stanje> vs) {
long long z = inf;
for (auto s : vs) z = min(z, s.cost);
return z;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n >> m >> k >> q;
for (int i = 0; i < k; i++) {
int x, y;
cin >> x >> y;
e[x].push_back(y);
}
for (int i = 0; i < q; i++) {
int x;
cin >> x;
safe[x] = true;
}
memset(sl, 255, sizeof(sl));
memset(sr, 255, sizeof(sr));
for (int i = 1; i <= m; i++) {
sl[i] = sl[i - 1];
if (safe[i]) sl[i] = i;
}
for (int i = m; i >= 1; i--) {
sr[i] = sr[i + 1];
if (safe[i]) sr[i] = i;
}
vector<stanje> st;
if (e.count(1)) {
int y = *max_element(e[1].begin(), e[1].end());
st.push_back({1, y, y - 1});
e.erase(1);
} else {
st.push_back({1, 1, 0});
}
for (auto [x, vy] : e) {
int yl = *min_element(vy.begin(), vy.end());
int yr = *max_element(vy.begin(), vy.end());
stanje tl = {x, yl, inf}, tr = {x, yr, inf};
for (auto [xx, yy, vv] : st) {
if (sl[yy] != -1) {
long long cost = vv + yy - sl[yy];
cost += x - xx;
cost += yr - yl;
tl.cost = min(tl.cost, cost + abs(sl[yy] - yr));
tr.cost = min(tr.cost, cost + abs(sl[yy] - yl));
}
if (sr[yy] != -1) {
long long cost = vv + sr[yy] - yy;
cost += x - xx;
cost += yr - yl;
tl.cost = min(tl.cost, cost + abs(sr[yy] - yr));
tr.cost = min(tr.cost, cost + abs(sr[yy] - yl));
}
}
st = {tl, tr};
}
cout << mn(st) << '\n';
}
| 4 |
#include <iostream>
int main() {
int a, b, x; std::cin >> a >> b >> x;
std::cout << ((a <= x && x <= (a+b))?"YES":"NO") << std::endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
long long max(long long a, long long b) {
if (a > b) {
return a;
} else {
return b;
}
}
long long min(long long a, long long b) {
if (a < b) {
return a;
} else {
return b;
}
}
long long power(long long b, long long e) {
if (e == 0) return 1;
if (e % 2)
return ((b * power((b) * (b), (e - 1) / 2)));
else
return power((b) * (b), e / 2);
}
long long modpower(long long b, long long e, long long q) {
long long MOD = q;
if (e == 0) return 1;
if (e % 2)
return ((b % MOD) * modpower((b % MOD) * (b % MOD), (e - 1) / 2, q)) % MOD;
else
return modpower((b % MOD) * (b % MOD), e / 2, q) % MOD;
}
void dpv(vector<long long> v) {
for (long long i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << endl;
}
void dpv(vector<pair<long long, long long> > v) {
for (long long i = 0; i < v.size(); i++) {
cout << v[i].first << " " << v[i].second << endl;
}
}
void dpv(set<long long> v) {
for (auto i : v) {
cout << i << " ";
}
cout << endl;
}
void oblivious() {
long long n;
cin >> n;
if (n == 1) {
cout << "! 1" << endl;
fflush(stdout);
return;
} else {
long long a[n];
long long l = 0, r = n - 1;
long long ans = 0;
long long cnt = n * (n + 1) / 2;
while (l < r) {
long long x1, x2;
cout << "? " << l + 1 << " " << r + 1 << endl;
fflush(stdout);
cin >> x1;
cout << "? " << r + 1 << " " << l + 1 << endl;
fflush(stdout);
cin >> x2;
if (x2 > x1) {
a[r] = x2;
ans += x2;
r--;
} else {
a[l] = x1;
ans += x1;
l++;
}
}
a[l] = cnt - ans;
cout << "!";
for (long long i = 0; i < n; i++) {
cout << " " << a[i];
}
cout << endl;
fflush(stdout);
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
oblivious();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#define pb push_back
#define sz(a) a.size()
#define re return
#define all(a) a.begin(),a.end()
using namespace std;
long long a[55],b[55];
vector<long long>v[55];
long long dfs(long long k,long long a,long long b,long long u[]){
u[k]=1;
long long ans=1;
for (long long i : v[k]){
if ( (k==a && i==b) || (k==b && i==a) ) continue;
if (u[i]==0) ans+=dfs(i,a,b,u);
}
re ans;
}
signed main()
{
long long n,m,ans=0;
cin>>n>>m;
for (long long i=0;i<m;i++){
cin>>a[i]>>b[i];
v[a[i]].pb(b[i]);
v[b[i]].pb(a[i]);
}
for (long long i=0;i<m;i++){
long long u[55]={};
if (dfs(1,a[i],b[i],u)<n) ans++;
}
cout<<ans;
re 0;
} | 0 |
#include <bits/stdc++.h>
const double eps = (1e-10);
using namespace std;
int dcmp(long double a, long double b) {
return fabsl(a - b) <= eps ? 0 : (a > b) ? 1 : -1;
}
int getBit(int num, int idx) { return ((num >> idx) & 1) == 1; }
int setBit1(int num, int idx) { return num | (1 << idx); }
long long setBit0(long long num, int idx) { return num & ~(1ll << idx); }
long long flipBit(long long num, int idx) { return num ^ (1ll << idx); }
void M() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int countNumBit1(int mask) {
int ret = 0;
while (mask) {
mask &= (mask - 1);
++ret;
}
return ret;
}
int k, m, n, q, arr[109][109];
map<string, int> mb;
vector<pair<int, string> > ans[109];
vector<pair<string, int> > ans2[109];
map<string, vector<pair<string, string> > > v;
vector<string> comp, bc;
int main() {
cin >> k >> n >> m >> q;
string st;
for (int i = 0; i < n; i++) {
cin >> st;
bc.push_back(st);
mb[st] = i + 1;
}
string line, sst;
cin.ignore();
for (int i = 0; i < m; i++) {
getline(cin, line);
stringstream ss(line);
string art;
ss >> art;
art.erase(art.end() - 1);
string st, no;
while (ss >> st >> no) {
if (no[((int)(no).size()) - 1] == ',') no.erase(no.end() - 1);
v[art].push_back(make_pair(st, no));
}
comp.push_back(art);
}
int num;
while (q--) {
cin >> num >> st;
if (mb[st] == 0) continue;
arr[num][mb[st]]++;
}
for (int i = 1; i <= k; i++) {
for (int j = 0; j < m; j++) {
string com = comp[j];
int mi = INT_MAX;
for (int l = 0; l < ((int)(v[com]).size()); l++) {
string basic = v[com][l].first;
int num = atoi(v[com][l].second.c_str());
mi = min(mi, arr[i][mb[basic]] / num);
}
if (mi != 0) ans[i].push_back(make_pair(mi, com));
}
}
for (int i = 1; i <= k; i++) {
sort(((ans[i]).rbegin()), ((ans[i]).rend()));
for (int j = 0; j < ((int)(ans[i]).size()); j++) {
string com = ans[i][j].second;
int mi = INT_MAX;
for (int l = 0; l < ((int)(v[com]).size()); l++) {
string basic = v[com][l].first;
int num = atoi(v[com][l].second.c_str());
mi = min(mi, arr[i][mb[basic]] / num);
}
for (int l = 0; l < ((int)(v[com]).size()); l++) {
string basic = v[com][l].first;
int num = atoi(v[com][l].second.c_str());
arr[i][mb[basic]] -= mi * num;
}
if (mi != 0) ans2[i].push_back(make_pair(com, mi));
}
}
for (int i = 1; i <= k; i++) {
for (int j = 0; j < n; j++) {
if (arr[i][mb[bc[j]]] > 0)
ans2[i].push_back(make_pair(bc[j], arr[i][mb[bc[j]]]));
}
}
for (int i = 1; i <= k; i++) sort(((ans2[i]).begin()), ((ans2[i]).end()));
for (int i = 1; i <= k; i++) {
cout << ((int)(ans2[i]).size()) << endl;
for (int j = 0; j < ((int)(ans2[i]).size()); j++) {
cout << ans2[i][j].first << " " << ans2[i][j].second << endl;
}
}
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define MAX 200002
int n;
int m;
vector<int> v[MAX];
int star[MAX];
int linkk[MAX];
int ord;
bool vis[MAX];
int cnt[MAX];
int belong[MAX];
inline int root(int b){
if(belong[b]==-1)return b;
return belong[b]=root(belong[b]);
}
inline void merge(int a,int b){
a=root(a);
b=root(b);
if(a==b)return;
cnt[b]+=cnt[a];
belong[a]=b;
}
inline void dfs(int b,int pr=-1){
vis[b]=true;
linkk[b]=star[b]=ord;
ord++;
for(int go:v[b]){
if(vis[go]){
if(go==pr)continue;
linkk[b]=min(linkk[b],star[go]);
//cout<<"f "<<b<<" "<<go<<endl;
merge(b,go);
continue;
}
dfs(go,b);
linkk[b]=min(linkk[b],linkk[go]);
if(linkk[go]<=star[b]){
merge(b,go);
}
}
}
vector<int> r;
vector<pair<int,int> > ed;
vector<int> g[MAX];
int dp[MAX][2];
inline void dfs2(int b,int pr=-1){
vis[b]=true;
dp[b][1]+=cnt[b];
for(int go:g[b]){
if(go==pr)continue;
dfs2(go,b);
dp[b][0]+=max(dp[go][1],dp[go][0]);
dp[b][1]+=dp[go][0];
}
}
int main(){
memset(belong,-1,sizeof(belong));
cin>>n>>m;
for(int i=0;i<n;i++)cnt[i]=1;
for(int j=0;j<m;j++){
int s,t;
scanf("%d%d",&s,&t);
v[s].push_back(t);
v[t].push_back(s);
ed.push_back(make_pair(s,t));
}
for(int i=0;i<n;i++){
if(vis[i]==false){
dfs(i);
}
}
for(int i=0;i<n;i++){
r.push_back(root(i));
//cout<<root(i)<<" ";
}
// cout<<endl;
sort(r.begin(),r.end());
r.erase(unique(r.begin(),r.end()),r.end());
for(int i=0;i<ed.size();i++){
int a=ed[i].first;
int b=ed[i].second;
a=root(a);
b=root(b);
if(a!=b){
g[a].push_back(b);
g[b].push_back(a);
}
}
memset(vis,false,sizeof(vis));
int ans=0;
for(int i=0;i<r.size();i++){
if(vis[r[i]]==false){
dfs2(r[i]);
ans+=max(dp[r[i]][0],dp[r[i]][1]);
}
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
if (n == 1) {
cout << "? 1 1" << endl;
string ans;
cin >> ans;
cout << "! " << ans << endl;
return 0;
}
map<string, int> prefix;
int cnt = n * (n + 1) / 2;
cout << "? 1 " << n << endl;
for (int i = 0; i < cnt; i++) {
string s;
cin >> s;
sort(begin(s), end(s));
prefix[s]++;
}
cnt = (n - 1) * (n) / 2;
cout << "? 2 " << n << endl;
for (int i = 0; i < cnt; i++) {
string s;
cin >> s;
sort(begin(s), end(s));
prefix[s]--;
}
vector<string> prefixes;
for (auto &i : prefix) {
if (i.second > 0) {
prefixes.emplace_back(i.first);
}
}
string ans;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (prefixes[j].size() == i + 1) {
int alp[26] = {};
for (int k = 0; k < prefixes[j].size(); k++) {
alp[prefixes[j][k] - 'a']++;
}
for (int k = 0; k < ans.size(); k++) {
alp[ans[k] - 'a']--;
}
for (int k = 0; k < 26; k++) {
if (alp[k] == 1) {
ans.push_back(k + 'a');
break;
}
}
}
}
}
cout << "! " << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
#define abs(a) max((a),-(a))
#define rep(i,n) for(int i=0;i<(int)(n);i++)
#define repe(i,n) rep(i,(n)+1)
#define per(i,n) for(int i=(int)(n)-1;i>=0;i--)
#define pere(i,n) rep(i,(n)+1)
#define all(x) (x).begin(),(x).end()
#define SP <<" "<<
#define RET return 0
#define MOD 1000000007
#define INF 1000000000000000000
typedef long long LL;
typedef long double LD;
int main(){
while(1){
int w,h;
cin >> w >> h;
if(w==0) return 0;
vector<string> f(h);
for(int i=0;i<h;i++){
cin >> f[i];
}
vector<vector<string>> dp(h+1,vector<string>(w+1,""));
string s="";
for(int i=1;i<=h;i++){
for(int j=1;j<=w;j++){
if('0'<=f[i-1][j-1]&&f[i-1][j-1]<='9'){
if(dp[i-1][j].length()>dp[i][j-1].length()){
dp[i][j]=dp[i-1][j]+string(1,f[i-1][j-1]);
}else if(dp[i-1][j].length()<dp[i][j-1].length()){
dp[i][j]=dp[i][j-1]+string(1,f[i-1][j-1]);
}else{
if(f[i-1][j-1]=='0'&&dp[i-1][j]=="") continue;
if(dp[i-1][j]>dp[i][j-1]){
dp[i][j]=dp[i-1][j]+string(1,f[i-1][j-1]);
}else{
dp[i][j]=dp[i][j-1]+string(1,f[i-1][j-1]);
}
}
}
if(dp[i][j].length()>s.length()||(dp[i][j].length()==s.length()&&dp[i][j]>s)){
s=dp[i][j];
}
}
}
cout << s << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int s[110][110];
struct poin {
int x1;
int y1;
int x2;
int y2;
};
vector<struct poin> v;
int main() {
int a, b, c, d, e, f, n, x1, y1, x2, y2;
while (cin >> n) {
v.clear();
memset(s, 0, sizeof(s));
for (c = 0; c < n; c++) {
cin >> x1 >> y1 >> x2 >> y2;
struct poin A;
A.x1 = x1;
A.y1 = y1;
A.x2 = x2;
A.y2 = y2;
v.push_back(A);
}
for (c = 0; c < v.size(); c++) {
for (d = v[c].x1; d <= v[c].x2; d++) {
for (e = v[c].y1; e <= v[c].y2; e++) {
s[d][e]++;
}
}
}
int ans = 0;
for (c = 0; c < 101; c++) {
for (d = 0; d < 101; d++) {
ans += s[c][d];
}
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int C = 26;
void add(int &x, int y) {
x += y;
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
}
int fix(int x) {
while (x >= MOD) x -= MOD;
while (x < 0) x += MOD;
return x;
}
int pw(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = 1ll * ret * a % MOD;
b >>= 1;
a = 1ll * a * a % MOD;
}
return ret;
}
const int MAXN = 1e5 + 10;
const int L = 10;
struct Node {
int cnt[L][L] = {};
} st[MAXN << 2];
struct OP {
int to[L];
OP() { iota(to, to + L, 0); }
} lz[MAXN << 2];
OP fuck(const OP &a, const OP &b) {
OP ret;
for (int i = 0; i < L; i++) {
ret.to[i] = b.to[a.to[i]];
}
return ret;
}
Node fuck(const Node &a, const OP &op) {
Node ret;
for (int d = 0; d < L; d++) {
for (int i = 0; i < L; i++) {
ret.cnt[op.to[d]][i] += a.cnt[d][i];
}
}
return ret;
}
Node merge(const Node &a, const Node &b) {
Node ret;
for (int i = 0; i < L; i++) {
for (int j = 0; j < L; j++) {
ret.cnt[i][j] = a.cnt[i][j] + b.cnt[i][j];
}
}
return ret;
}
void weed(int i) {
for (int j : {i << 1, i << 1 ^ 1}) {
st[j] = fuck(st[j], lz[i]);
lz[j] = fuck(lz[j], lz[i]);
}
lz[i] = OP();
}
void water(int i, int b, int e, int l, int r, const OP &op) {
if (l >= r) return;
if (l == b && r == e) {
st[i] = fuck(st[i], op);
lz[i] = fuck(lz[i], op);
return;
}
int m = (b + e) >> 1;
weed(i);
water(i << 1, b, m, l, min(r, m), op);
water(i << 1 ^ 1, m, e, max(m, l), r, op);
st[i] = merge(st[i << 1], st[i << 1 ^ 1]);
}
Node smoke(int i, int b, int e, int l, int r) {
if (l >= r) return Node();
if (l == b && r == e) {
return st[i];
}
int m = (b + e) >> 1;
weed(i);
return merge(smoke(i << 1, b, m, l, min(r, m)),
smoke(i << 1 ^ 1, m, e, max(l, m), r));
}
int a[MAXN];
void plant(int i, int b, int e) {
if (e - b == 1) {
string s = to_string(a[b]);
int m = s.size();
for (int j = 0; j < m; j++) {
++st[i].cnt[s[j] - '0'][m - 1 - j];
}
return;
}
int m = (b + e) >> 1;
plant(i << 1, b, m);
plant(i << 1 ^ 1, m, e);
st[i] = merge(st[i << 1], st[i << 1 ^ 1]);
}
void solve() {
int n, q;
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
plant(1, 0, n);
while (q--) {
int t;
cin >> t;
if (t == 1) {
int l, r, x, y;
cin >> l >> r >> x >> y;
--l;
OP op;
op.to[x] = y;
water(1, 0, n, l, r, op);
} else {
int l, r;
cin >> l >> r;
--l;
Node ret = smoke(1, 0, n, l, r);
long long ans = 0;
for (int d = 0; d < L; d++) {
long long power = 1;
for (int i = 0; i < L; i++) {
ans += power * ret.cnt[d][i] * d;
power *= 10;
}
}
cout << ans << "\n";
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int te = 1;
for (int w = 1; w <= te; w++) {
solve();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
ll t;
cin >> t;
while (t--) {
double x, ans = 0, y;
ll n;
cin >> n;
n *= 2;
x = 1 / (2.0 * sin((3.14159265) / n));
x = x * cos((3.14159265) / n);
ans = 2 * x;
cout << fixed << setprecision(10) << ans << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool is_prime(int num) {
for (int i = 2; i * i <= num; i++)
if (num % i == 0) return false;
return true;
}
int t;
void read() { cin >> t; }
const long long inf = 1e18;
long long ask(long long q) {
cout << "? " << q << endl;
long long res;
cin >> res;
return res;
}
void solve() {
vector<int> primes;
for (int i = 2; i <= 800; i++)
if (is_prime(i)) primes.push_back(i);
vector<long long> to_check;
for (int i = 0; i < (int)primes.size(); i++) {
int j;
long long pr = 1;
for (j = i; j < (int)primes.size(); j++) {
if ((double)inf / primes[j] < pr) break;
pr *= primes[j];
}
to_check.push_back(pr);
i = j;
}
while (t--) {
vector<long long> curr_pr;
for (auto i : to_check) {
auto curr = ask(i);
for (auto j : primes)
if (curr % j == 0) curr_pr.push_back(j);
}
long long d = 1;
for (int i = 0; i < (int)curr_pr.size(); i += 2) {
long long num = 1;
for (;;) {
num *= curr_pr[i];
if (num > 1000000000) break;
}
num /= curr_pr[i];
long long num1 = 1;
if (i != (int)curr_pr.size() - 1) {
for (;;) {
num1 *= curr_pr[i + 1];
if (num1 > 1000000000) break;
}
num1 /= curr_pr[i + 1];
}
num *= num1;
auto curr = ask(num);
int cnt1 = 0;
while (curr % curr_pr[i] == 0) cnt1++, curr /= curr_pr[i];
d *= (cnt1 + 1);
if (i != (int)curr_pr.size() - 1) {
cnt1 = 0;
while (curr % curr_pr[i + 1] == 0) cnt1++, curr /= curr_pr[i + 1];
d *= (cnt1 + 1);
}
}
cout << "! " << d * 2 << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
read();
solve();
}
| 6 |
#pragma GCC optimize("O3")
#include<bits/stdc++.h>
using namespace std;
#define SET0(a) memset(a,0,sizeof(a))
#define FOR(i,a,b) for(int i=(a);i<=(b);i++)
#define DWN(i,a,b) for(int i=(a);i>=(b);i--)
#define INF 0x3f3f3f3f
typedef long long ll;
int main(){
int T; cin>>T;
while(T--){
int x,y,n; cin>>x>>y>>n;
int l,r;
l=1; r=1;
while(!(x&1)){
x>>=1;
l<<=1;
}
while(!(y&1)){
y>>=1;
r<<=1;
}
if(l*r>=n) cout<<"YES"<<endl;
else cout<<"NO"<<endl;
}
return 0;
} | 1 |
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cassert>
#include <functional>
typedef long long ll;
using namespace std;
#ifndef LOCAL
#define debug(...) ;
#else
#define debug(...) cerr << __LINE__ << " : " << #__VA_ARGS__ << " = " << _tostr(__VA_ARGS__) << endl;
template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v);
template<typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template<typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
out << '{';
for (const T &item : v) out << item << ", ";
out << "\b\b}";
return out;
}
void _tostr_rec(ostringstream &oss) {
oss << "\b\b \b";
}
template<typename Head, typename... Tail>
void _tostr_rec(ostringstream &oss, Head &&head, Tail &&... tail) {
oss << head << ", ";
_tostr_rec(oss, forward<Tail>(tail)...);
}
template<typename... T>
string _tostr(T &&... args) {
ostringstream oss;
int size = sizeof...(args);
if (size > 1) oss << "{";
_tostr_rec(oss, forward<T>(args)...);
if (size > 1) oss << "}";
return oss.str();
}
#endif
#define mod 1000000007 //1e9+7(prime number)
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define SIZE 200010
template<typename T>
struct SlideMin: deque<T> {
void push(const T &v) {
while (this->size() && this->back() >= v) {
this->pop_back();
}
this->push_back(v);
}
void pop() { this->pop_front(); }
};
ll dp[SIZE];
int main() {
int N, M, K, A[SIZE];
scanf("%d%d%d", &N, &M, &K);
for (int i = 0; i < N; i++) {
scanf("%d", A + i);
}
for (int i = 0; i < K; i++) {
SlideMin<pair<ll, int>> dq;
if (i == 0) dq.push({0, INF});
for (int j = 0; j < N; j++) {
ll tmp = dp[j];
while (dq.size() && j - dq.front().second > M) {
dq.pop();
}
if (dq.size()) {
dp[j] = dq.front().first - (ll)(i + 1) * A[j];
} else {
dp[j] = LLINF;
}
if (tmp <= 0) dq.push({tmp, j});
}
}
ll ans = 0;
for (int i = 0; i < N; i++) {
ans = max(ans, -dp[i]);
}
printf("%lld\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
map<long long, vector<int> > mp;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
mp.clear();
vector<pair<int, long long> > v;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
mp[x].push_back(i);
}
for (auto e : mp) {
long long x = e.first;
vector<int> foo = e.second;
sort(foo.begin(), foo.end());
for (int i = 1; i < ((int)(foo.size())); i += 2)
mp[x * 2LL].push_back(foo[i]);
if (((int)(foo.size())) & 1) v.push_back({foo.back(), x});
}
sort(v.begin(), v.end());
cout << ((int)(v.size())) << '\n';
for (auto e : v) cout << e.second << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int num, a, b, c;
scanf("%d%d%d%d", &num, &a, &b, &c);
int ans = 0;
for (int i = 0; i <= c; i++) {
if (i * 2 > num) break;
for (int j = 0; j <= b; j++) {
int sum = i * 2 + j * 1;
int rest = num - sum;
if (rest >= 0 && rest * 2 <= a) ans++;
}
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void op() {
int n;
cin >> n;
vector<pair<long long int, long long int>> v(n);
for (int i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
v[i] = {a, b};
}
sort(v.begin(), v.end());
long long int mi = v[0].second, mx = v[n - 1].first;
for (int i = 0; i < n; i++) {
mi = min(mi, v[i].second);
}
int p = 0;
for (int i = 0; i < n; i++) {
if (mx < v[i].first || mx > v[i].second) break;
p++;
}
if (p == n)
cout << 0;
else
cout << abs(mx - mi);
}
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
op();
cout << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, ans, x, y, m;
while (~scanf("%lld%lld%lld", &x, &y, &m)) {
long long js = 0;
if (x > y) swap(x, y);
if (y >= m)
puts("0");
else {
if (y <= 0)
puts("-1");
else {
if (x < 0) {
js += (-x) / y;
x += js * y;
}
while (y < m) {
x += y;
if (x > y) swap(x, y);
js++;
}
printf("%lld\n", js);
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long pwr(long long a, long long b, long long mod) {
a %= mod;
if (a < 0) a += mod;
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % mod;
a = (a * a) % mod;
b /= 2;
}
return ans;
}
long long pwr(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans *= a;
a *= a;
b /= 2;
}
return ans;
}
long long gcd(long long a, long long b) {
while (b) {
long long temp = a;
a = b;
b = temp % b;
}
return a;
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long modularInverse(long long a, long long m) {
assert(false);
return pwr(a, m - 2, m);
}
const int mod = 1000000007;
template <class T>
class Hash {
private:
long long X[2], MOD[2];
vector<vector<int> > xpwr;
protected:
long long pwr(long long a, long long b, long long MOD) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % MOD;
a = (a * a) % MOD;
b >>= 1;
}
return ans;
}
public:
int hash(const T& s, long long X, long long MOD) {
long long ans = 0;
long long mul = 1;
for (int i = 0; i < s.size(); ++i) {
mul *= X;
mul %= MOD;
ans += s[i] * mul;
ans %= MOD;
}
if (ans < 0) ans += MOD;
return (int)ans;
}
pair<int, int> hash(const T& s) {
pair<int, int> ans;
ans.first = hash(s, X[0], MOD[0]);
ans.second = hash(s, X[1], MOD[1]);
return ans;
}
Hash() {
MOD[0] = 999999937;
MOD[1] = 999999929;
X[0] = 37;
X[1] = 31;
xpwr.resize(1 + max(X[0], X[1]));
xpwr[X[0]].resize(1000006);
xpwr[X[1]].resize(1000006);
xpwr[X[0]][0] = 1;
xpwr[X[1]][0] = 1;
for (int i = 1; i <= 1000000; ++i) {
xpwr[X[0]][i] = ((long long)xpwr[X[0]][i - 1] * X[0]) % MOD[0];
xpwr[X[1]][i] = ((long long)xpwr[X[1]][i - 1] * X[1]) % MOD[1];
}
}
private:
int replaceOneChar(int oldHash, int index, int oldVal, int newVal, int X,
int MOD) {
long long mul = xpwr[X][index + 1];
long long ans = oldHash + (newVal - oldVal) * mul;
if (ans >= MOD || ans <= -MOD) ans %= MOD;
if (ans < 0) ans += MOD;
return (int)ans;
}
int pushBackCharacter(int oldHash, int index, int newVal, int X, int MOD) {
long long mul = xpwr[X][index + 1];
long long ans = oldHash + newVal * mul;
if (ans >= MOD || ans <= -MOD) ans %= MOD;
if (ans < 0) ans += MOD;
return (int)ans;
}
int pushFrontCharacter(int oldHash, int newVal, int X, int MOD) {
long long ans = ((long long)oldHash + newVal) * X;
if (ans >= MOD || ans <= -MOD) ans %= MOD;
if (ans < 0) ans += MOD;
return (int)ans;
}
int mergeHash(int pre, int post, int prelen, int X, int MOD) {
long long mul = xpwr[X][prelen];
long long ans = pre + post * mul;
if (ans >= MOD || ans <= -MOD) ans %= MOD;
if (ans < 0) ans += MOD;
return ans;
}
public:
pair<int, int> replaceOneChar(const pair<int, int>& oldHash, int index,
int oldVal, int newVal) {
pair<int, int> ans;
ans.first =
replaceOneChar(oldHash.first, index, oldVal, newVal, X[0], MOD[0]);
ans.second =
replaceOneChar(oldHash.second, index, oldVal, newVal, X[1], MOD[1]);
return ans;
}
pair<int, int> pushBackCharacter(const pair<int, int>& oldHash, int index,
int newVal) {
pair<int, int> ans;
ans.first = pushBackCharacter(oldHash.first, index, newVal, X[0], MOD[0]);
ans.second = pushBackCharacter(oldHash.second, index, newVal, X[1], MOD[1]);
return ans;
}
pair<int, int> pushFrontCharacter(const pair<int, int>& oldHash, int newVal) {
pair<int, int> ans;
ans.first = pushFrontCharacter(oldHash.first, newVal, X[0], MOD[0]);
ans.second = pushFrontCharacter(oldHash.second, newVal, X[1], MOD[1]);
return ans;
}
pair<int, int> mergeHash(const pair<int, int>& pre,
const pair<int, int>& post, int prelen) {
pair<int, int> ans;
ans.first = mergeHash(pre.first, post.first, prelen, X[0], MOD[0]);
ans.second = mergeHash(pre.second, post.second, prelen, X[1], MOD[1]);
return ans;
}
};
template <class T>
class DynamicHash : public Hash<T> {
private:
set<pair<int, int> > table;
public:
int size() { return table.size(); }
bool insert(const T& s) { return table.insert(this->hash(s)).second; }
bool find(const pair<int, int> p) { return table.find(p) != table.end(); }
bool find(const T& s) { return find(this->hash(s)); }
};
template <class T>
class StaticHash : public Hash<T> {
private:
vector<pair<int, int> > table;
bool isReady;
public:
StaticHash() : Hash<T>() { isReady = false; }
int size() { return table.size(); }
void insert(const T& s) {
if (isReady == true) {
assert(0);
}
table.push_back(this->hash(s));
}
bool find(const pair<int, int> p) {
if (isReady == false) {
sort(table.begin(), table.end());
table.erase(unique(table.begin(), table.end()), table.end());
isReady = true;
}
return binary_search(table.begin(), table.end(), p);
}
bool find(const T& s) { return find(this->hash(s)); }
};
pair<int, int> suffixHash[3000000];
pair<int, int> prefixHash[3000000];
char str[3000001];
long long p26[3000000];
int main() {
p26[0] = 1;
for (int i = 1; i <= 1000001; ++i) p26[i] = (p26[i - 1] * 26) % mod;
int n, m;
scanf("%d%d", &n, &m);
scanf("%s", str);
string p(str);
Hash<string> hashTable;
for (int i = 0; i < p.size(); ++i)
prefixHash[i + 1] = hashTable.pushBackCharacter(prefixHash[i], i, p[i]);
for (int i = 0; i < p.size(); ++i)
suffixHash[i + 1] =
hashTable.pushFrontCharacter(suffixHash[i], p[p.size() - 1 - i]);
if (m == 0) {
cout << pwr(26, n, mod);
return 0;
}
int yp;
scanf("%d", &yp);
long long ans = p26[yp - 1];
--yp;
for (int i = 1; i < m; ++i) {
int y;
scanf("%d", &y);
--y;
int st = y;
int en = yp + p.size() - 1;
int overLap = en - st + 1;
if (overLap > 0) {
if (prefixHash[overLap] != suffixHash[overLap]) {
cout << "0";
return 0;
}
} else {
overLap *= -1;
ans *= p26[overLap];
ans %= mod;
}
yp = y;
}
int firstUnassigned = yp + p.size();
int total = (n - 1) - firstUnassigned + 1;
if (total >= 0) ans *= p26[total];
ans %= mod;
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const bool DEBUG = 0;
const int Q = 1 << 22;
mt19937 gen(chrono::high_resolution_clock::now().time_since_epoch().count());
char dp[100001][4];
char p[100001][4];
int a[100000];
int b[100000];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin.sync_with_stdio(0);
cout.tie(0);
cout.sync_with_stdio(0);
int n;
cin >> n;
--n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i <= 3; i++)
for (int j = 0; j <= 3; j++)
if ((i | j) == a[0] && (i & j) == b[0]) {
dp[1][j] = 1;
p[1][j] = i;
}
for (int len = 2; len <= n; len++) {
for (int cur = 0; cur <= 3; cur++) {
for (int prev = 0; prev <= 3; prev++) {
if (!dp[len - 1][prev]) continue;
if ((cur | prev) == a[len - 1] && (cur & prev) == b[len - 1]) {
dp[len][cur] = 1;
p[len][cur] = prev;
}
}
}
}
int st = -1;
for (int i = 0; i <= 3; i++)
if (dp[n][i]) st = i;
if (st == -1) {
cout << "NO";
return 0;
}
cout << "YES\n";
vector<int> res;
for (int len = n; len >= 0; st = p[len][st], len--) res.push_back(st);
reverse(res.begin(), res.end());
for (int& x : res) cout << x << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
int n, s;
std::cin >> n >> s;
int max = INT_MIN;
for (int(i) = (0); (i) < (n); ++(i)) {
int x, y;
std::cin >> x >> y;
if (x > s || (x == s && y > 0))
continue;
else {
if (y == 0 && max < 0)
max = 0;
else if ((100 - y) > max && y != 0)
max = 100 - y;
}
}
if (max < 0)
std::cout << -1 << std::endl;
else
std::cout << max << std::endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, s;
cin >> n >> s;
if (s - n + 1 > (s + 1) / 2) {
cout << "YES\n";
for (int i = 1; i < n; i++) cout << 1 << " ";
cout << s - n + 1 << endl;
cout << (s + 1) / 2;
} else
cout << "NO";
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vc = vector<T>;
template <class T>
using vvc = vc<vc<T>>;
template <class T>
void mkuni(vector<T>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
long long rand_int(long long l, long long r) {
static mt19937_64 gen(chrono::steady_clock::now().time_since_epoch().count());
return uniform_int_distribution<long long>(l, r)(gen);
}
template <class T>
void print(T x, int suc = 1) {
cout << x;
if (suc == 1)
cout << '\n';
else
cout << ' ';
}
template <class T>
void print(const vector<T>& v, int suc = 1) {
for (int i = 0; i < v.size(); i++)
print(v[i], i == (int)(v.size()) - 1 ? suc : 2);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
while (T--) {
int n, a, b, c, d;
cin >> n >> a >> b >> c >> d;
int low = n * (a - b), up = n * (a + b);
if (up >= c - d && low <= c + d)
cout << "Yes\n";
else
cout << "No\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
using vi = vector<long long>;
using mi = map<long long, long long>;
using pi = pair<long long, long long>;
const long long N = 2005;
const long long MOD = 1e9 + 7;
const long long inf = 1e18 + 1;
vi v[N];
void solve() {
long long n, ans = 0, t;
cin >> n >> t;
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
v[t - x].push_back(y);
}
for (long long i = 0; i < t + 1; i++) {
v[i].push_back(0);
sort((v[i]).begin(), (v[i]).end(), greater<long long>());
long long t = 0;
long long m = v[i].size();
for (long long j = 0; j < m; j++) {
long long x = v[i][j];
v[i][j] = t;
t += x;
}
}
long long dp[t + 1][N];
for (long long i = 0; i < t + 1; i++)
for (long long j = 0; j < N; j++) dp[i][j] = -inf;
long long m = v[t - 1].size();
for (long long i = 0; i < N; i++) {
if (i < m)
dp[t - 1][i] = v[t - 1][i];
else
dp[t - 1][i] = dp[t - 1][i - 1];
}
for (long long i = t - 2; i >= 0; i--) {
m = v[i].size();
for (long long j = 0; j <= n; j++) {
for (long long k = 0; k <= min(j, m - 1); k++) {
dp[i][j] = max(dp[i][j], v[i][k] + dp[i + 1][min(n, 2 * (j - k))]);
}
}
}
ans = max(ans, dp[0][1]);
cout << ans << '\n';
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n,last_r=114514;
cin>>n;
vector <int> a(n),b;
for(int i=0;i<n;i++) cin>>a[i];
for(int i=0;i<=3;i++){
b=a;
int r=i;
b[0]-=i;
if(b[0]<0) b[0]=0;
for(int j=0;j<n-1;j++){
r+=b[j]*2;
b[j+1]-=b[j];
if(b[j+1]<0) b[j+1]=0;
}
last_r=min(last_r,r+b[n-1]);
}
cout<<last_r<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
static long parsenum(long j, long l) {
string k = "";
long cur = 0;
for (int i = (int)j; i <= l; ++i) {
cur *= 10;
cur += k[i] - '0';
}
return cur;
}
static long gcd(long a, long b) {
if (b == 0) {
return a;
} else {
return gcd(b, a % b);
}
}
static bool pri(int k) {
if (k == 1) return false;
for (int i = 2; i * i <= k; i++) {
if (k % i == 0) return false;
}
return true;
}
using namespace std;
using ll = long long;
constexpr int N = 100005;
vector<int> adj[N];
int val[N];
int xor_sum[2];
int cnt[2];
map<int, int> has[2];
int dfs(int v, int p, int even) {
xor_sum[even] ^= val[v];
cnt[even]++;
has[even][val[v]]++;
int res = even;
for (int u : adj[v]) {
if (u != p) {
res = dfs(u, v, even ^ 1);
}
}
return res;
}
int main(void) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> val[i];
}
for (int i = 2; i <= n; i++) {
int u;
cin >> u;
adj[i].push_back(u);
adj[u].push_back(i);
}
int res = dfs(1, -1, 0);
ll ans = 0;
if (xor_sum[res] == 0) {
ans += cnt[res] * 1LL * (cnt[res] - 1) / 2;
ans += cnt[res ^ 1] * 1LL * (cnt[res ^ 1] - 1) / 2;
}
for (int i = 0; i < 1 << 24 + 1; i++) {
if (has[res].find(i) != has[res].end()) {
int needed = xor_sum[res] ^ i;
if (has[res ^ 1].find(needed) != has[res ^ 1].end()) {
ans += has[res][i] * 1LL * has[res ^ 1][needed];
}
}
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double fRand(double fMin, double fMax) {
double f = (double)rand() / RAND_MAX;
return fMin + f * (fMax - fMin);
}
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
const double PI = acos(-1.0);
const double EPS = 1e-9;
struct p2 {
double x, y;
p2 operator+(p2 p) { return {x + p.x, y + p.y}; }
p2 operator-(p2 p) { return {x - p.x, y - p.y}; }
p2 operator*(double k) { return {x * k, y * k}; }
p2 operator/(double k) { return {x / k, y / k}; }
double operator*(p2 p) { return x * p.y - y * p.x; }
double operator|(p2 p) { return x * p.x + y * p.y; }
friend istream& operator>>(istream& is, p2& p) {
is >> p.x >> p.y;
return is;
}
friend ostream& operator<<(ostream& os, p2& p) {
os << "(" << p.x << ", " << p.y << ")";
return os;
}
};
p2 perp(p2 v) { return {-v.y, v.x}; }
struct p3 {
double x, y, z;
p3 operator+(p3 p) { return {x + p.x, y + p.y, z + p.z}; }
p3 operator-(p3 p) { return {x - p.x, y - p.y, z - p.z}; }
p3 operator*(double k) { return {x * k, y * k, z * k}; }
p3 operator/(double k) { return {x / k, y / k, z / k}; }
p3 operator*(p3 p) {
return {y * p.z - z * p.y, z * p.x - x * p.z, x * p.y - y * p.x};
}
double operator|(p3 p) { return x * p.x + y * p.y + z * p.z; }
friend istream& operator>>(istream& is, p3& p) {
is >> p.x >> p.y >> p.z;
return is;
}
friend ostream& operator<<(ostream& os, p3& p) {
os << "(" << p.x << ", " << p.y << ", " << p.z << ")";
return os;
}
};
template <class T>
double sq(T p) {
return p | p;
}
template <class T>
double mag(T p) {
return sqrt(sq(p));
}
template <class T>
T unit(T v) {
return v / mag(v);
}
struct coords {
p3 o, dx, dy, dz;
coords(p3 p, p3 q, p3 r) : o(p) {
dx = unit(q - p);
dz = unit(dx * (r - p));
dy = dz * dx;
}
p2 pos2d(p3 p) { return {(p - o) | dx, (p - o) | dy}; }
};
struct circle {
p2 o;
double r;
circle(p2 o, double r) : o(o), r(r) {}
bool contain(p2 p) { return mag(o - p) <= r + EPS; }
};
circle circumCircle(p2 a, p2 b, p2 c) {
b = b - a;
c = c - a;
p2 o = a + perp(b * sq(c) - c * sq(b)) / (b * c) / 2;
return circle(o, mag(a - o));
}
const int MAXN = 905;
int n, m;
p3 cen[MAXN];
int main() {
cin >> n >> m;
for (int i = (0); i <= (n - 1); ++i) cin >> cen[i];
for (int j = (0); j <= (m - 1); ++j) {
int a, b, c;
cin >> a >> b >> c;
vector<p3> inPlane;
inPlane.push_back({0, 0, 0});
if (a != 0) {
inPlane.push_back({-1.0 * b / a, 1, 0});
inPlane.push_back({-1.0 * c / a, 0, 1});
} else if (b != 0) {
inPlane.push_back({1, -1.0 * a / b, 0});
inPlane.push_back({0, -1.0 * c / b, 1});
} else if (c != 0) {
inPlane.push_back({1, 0, -1.0 * a / c});
inPlane.push_back({0, 1, -1.0 * b / c});
}
coords C(inPlane[0], inPlane[1], inPlane[2]);
vector<p2> p(n);
for (int i = (0); i <= (n - 1); ++i) p[i] = C.pos2d(cen[i]);
random_shuffle(p.begin(), p.end());
circle ans(p[0], 0);
for (int i = (1); i <= (n - 1); ++i) {
if (ans.contain(p[i])) continue;
ans = circle(p[i], 0);
for (int j = (0); j <= (i - 1); ++j) {
if (ans.contain(p[j])) continue;
ans = circle((p[i] + p[j]) / 2, mag(p[i] - p[j]) / 2);
for (int k = (0); k <= (j - 1); ++k) {
if (ans.contain(p[k])) continue;
ans = circumCircle(p[i], p[j], p[k]);
}
}
}
cout << setprecision(50) << ans.r << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
long long x = (1 << 26) - 1;
int ans = 0;
while (--n) {
char c;
cin >> c;
string s;
cin >> s;
long long y = 0;
for (int i = 0; s[i]; ++i) {
y |= 1 << (s[i] - 'a');
}
if (c == '!') {
ans += (__builtin_popcount(x) == 1);
x &= y;
} else if (c == '.') {
x &= y ^ ((1 << 26) - 1);
} else {
ans += (__builtin_popcount(x) == 1);
x &= ~(1 << (s[0] - 'a'));
}
}
cout << ans;
}
| 1 |
#include <iostream>
using namespace std;
int main(){
int N, T;
while(cin >> N >> T){
int m = 0, M = 0, d = 0;
int r = 0;
cin >> m; M = m;
for(int i=1;i<N;i++){
int A; cin >> A;
if(A < m) m = M = A;
if(A > M){
if(A-m >= d){
if(A-m > d) r = 1;
else if(A-m == d) ++r;
d = A-m;
}
M = A;
}
}
cout << r << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[100005];
vector<int> ps[100005 * 10];
vector<pair<int, int>> edges[100005 * 10];
int fp[100005 * 10];
int dis[100005 * 10];
int bfs(int u) {
queue<pair<int, int>> q;
dis[u] = 0;
for (auto v : edges[u]) {
q.push(v);
if (v.first == u) return 1;
dis[v.first] = 1;
}
int res = -1;
while (!q.empty()) {
auto cur = q.front();
q.pop();
int v = cur.first;
int p = cur.second;
for (auto v2 : edges[v]) {
if (v2.second == p) continue;
if (dis[v2.first] < 0 && v2.first != u) {
dis[v2.first] = dis[v] + 1;
q.push(v2);
} else {
res = (res < 0 ? dis[v2.first] + dis[v] + 1
: min(res, dis[v2.first] + dis[v] + 1));
}
}
}
return res;
}
int main() {
vector<int> prs;
prs.clear();
prs.push_back(1);
for (int i = 2; i <= 1000000; ++i) {
if (!fp[i]) {
prs.push_back(i);
for (int j = i; j <= 1000000; j += i) {
fp[j] = i;
}
}
ps[i] = ps[i / fp[i]];
auto itr = find(ps[i].begin(), ps[i].end(), fp[i]);
if (itr == ps[i].end()) {
ps[i].push_back(fp[i]);
} else {
ps[i].erase(itr);
}
}
scanf("%d", &n);
int maxv = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
maxv = max(maxv, a[i]);
}
for (int i = 1; i <= n; ++i) {
if (ps[a[i]].size() < 2) {
ps[a[i]].push_back(1);
}
if (ps[a[i]].size() < 2) {
ps[a[i]].push_back(1);
}
int p1 = ps[a[i]][0];
int p2 = ps[a[i]][1];
edges[p1].push_back(make_pair(p2, i));
edges[p2].push_back(make_pair(p1, i));
}
int ans = -1;
for (int v : prs) {
if (v * v > maxv) {
break;
}
for (int v2 : prs) {
dis[v2] = -1;
}
int res = bfs(v);
if (res >= 0) {
ans = (ans < 0 ? res : min(ans, res));
}
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
const int s = 1e6;
const int MAXS = 1e6 + 123;
int n;
scanf("%d", &n);
static int bio[MAXS];
memset(bio, 0, sizeof bio);
for (int i = 0; i < (n); ++i) {
int x;
scanf("%d", &x);
bio[x] = true;
}
vector<int> output;
vector<int> praznih;
int parova = 0;
for (int i = 1; i <= s; ++i) {
if (bio[i] && !bio[s - i + 1]) output.push_back(s - i + 1);
if (bio[i] && bio[s - i + 1] && i < s - i + 1) {
++parova;
}
if (!bio[i] && !bio[s - i + 1] && i < s - i + 1) praznih.push_back(i);
}
assert((int)praznih.size() >= parova);
for (int i = 0; i < (parova); ++i) {
int top = praznih.back();
praznih.pop_back();
output.push_back(top);
output.push_back(s - top + 1);
}
int sz = output.size();
sort(output.begin(), output.end());
printf("%d\n", sz);
for (int i = 0; i < (sz); ++i)
printf("%d%c", output[i], i + 1 == sz ? '\n' : ' ');
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
int main() {
fast();
long long n, m, l = 0, d = 0;
cin >> n >> m;
vector<pair<long long, long long>> a, front, back;
a.push_back(make_pair(0, 1));
int c = 0;
for (int i = 1; i <= n; ++i) {
long long temp;
cin >> temp;
a.push_back(make_pair(temp, c));
c = !c;
}
a.push_back(make_pair(m, 0));
front.push_back(make_pair(0, 0));
for (int i = 1; i < a.size(); ++i) {
int temp = a[i].first - a[i - 1].first;
if (n % 2 && i == a.size() - 1) {
d += temp;
front.push_back(make_pair(l, d));
continue;
}
if (a[i].second == 0)
l += temp;
else
d += temp;
front.push_back(make_pair(l, d));
}
back.push_back(make_pair(0, 0));
for (int i = 1; i < a.size(); ++i)
back.push_back(make_pair(d - front[i].second, l - front[i].first));
long long f_ans = l;
for (int i = 1; i < a.size(); ++i) {
long long temp = a[i].first - a[i - 1].first,
ans = front[i].first - 1 + back[i].first;
if (!i % 2) ans += temp;
f_ans = max(f_ans, ans);
}
cout << f_ans << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template< typename T >
struct edge
{
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
operator int() const { return to; }
};
template< typename T >
using Edges = vector< edge< T > >;
template< typename T >
using WeightedGraph = vector< Edges< T > >;
using UnWeightedGraph = vector< vector< int > >;
template< typename T >
using Matrix = vector< vector< T > >;
template< typename T >
pair< int, int > dfs(const WeightedGraph< T > &g, int idx, int par)
{
pair< T, int > ret(0, idx);
for(auto &e : g[idx]) {
if(e.to == par) continue;
auto cost = dfs(g, e.to, idx);
cost.first += e.cost;
ret = max(ret, cost);
}
return ret;
}
template< typename T >
T tree_diameter(const WeightedGraph< T > &g)
{
auto p = dfs(g, 0, -1);
auto q = dfs(g, p.second, -1);
return (q.first);
}
int main()
{
int V;
scanf("%d", &V);
WeightedGraph< int > g(V);
for(int i = 0; i < V - 1; i++) {
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
g[x].emplace_back(y, z);
g[y].emplace_back(x, z);
}
cout << tree_diameter(g) << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
vector<pair<int, bool>> balls, b;
int main() {
int i, j, n, k, x, z;
scanf("%d%d%d", &n, &k, &x);
for (int i = 0; i < int(n); ++i) {
scanf("%d", &z);
balls.push_back({z, 0});
}
int res = 0;
for (int m = int(0); m <= int(n); ++m) {
int tmp = -1;
b = balls;
b.insert(b.begin() + m, {x, 1});
bool change = true;
while (change) {
change = false;
for (i = 0; i < b.size(); ++i) {
for (j = i + 1; j < b.size() && b[j].first == b[i].first; ++j)
;
if (j - i >= 3) {
change = true;
tmp += j - i;
b.erase(b.begin() + i, b.begin() + j);
}
i = j - 1;
}
}
for (int i = 0; i < int(b.size()); ++i)
if (b[i].second) ++tmp;
res = max(res, tmp);
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ld = double;
namespace fft {
const ld PI = acos(-1);
struct num {
ld x, y;
num(ld x = 0, ld y = 0) : x(x), y(y) {}
num operator+(const num& o) const { return num(x + o.x, y + o.y); }
num operator-(const num& o) const { return num(x - o.x, y - o.y); }
num operator*(const num& o) const {
return num(x * o.x - y * o.y, x * o.y + y * o.x);
}
};
num conj(num a) { return num(a.x, -a.y); }
vector<num> fa, fb, roots = {num(0, 0), num(1, 0)};
vector<int> rev = {0, 1};
int base = 1;
void ensure_base(int nbase) {
if (nbase <= base) {
return;
}
rev.resize(1 << nbase);
for (int i = 0; i < (1 << nbase); ++i) {
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (nbase - 1));
}
roots.resize(1 << nbase);
while (base < nbase) {
ld angle = 2 * PI / (1 << (base + 1));
for (int i = 1 << (base - 1); i < (1 << base); ++i) {
roots[i << 1] = roots[i];
ld ang = angle * ((i << 1) + 1 - (1 << base));
roots[i << 1 | 1] = num(cos(ang), sin(ang));
}
++base;
}
}
void dft(vector<num>& a, int n) {
int zeros = __builtin_ctz(n);
ensure_base(zeros);
int shift = base - zeros;
for (int i = 0; i < n; ++i) {
if (i < (rev[i] >> shift)) {
swap(a[i], a[rev[i] >> shift]);
}
}
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j += i << 1) {
for (int k = 0; k < i; ++k) {
num x = a[j + k], y = a[j + k + i] * roots[i + k];
a[j + k] = x + y;
a[j + k + i] = x - y;
}
}
}
}
vector<ld> multiply(const vector<ld>& a, const vector<ld>& b) {
int need = a.size() + b.size() - 1, nbase = 0;
while (1 << nbase < need) {
++nbase;
}
ensure_base(nbase);
bool equal = a == b;
int sz = 1 << nbase;
if (sz > (int)fa.size()) {
fa.resize(sz);
}
if (sz > (int)fb.size()) {
fb.resize(sz);
}
for (int i = 0; i < (int)a.size(); i++) {
fa[i] = num(a[i], 0);
}
for (int i = a.size(); i < sz; ++i) {
fa[i] = num(0, 0);
}
dft(fa, sz);
if (equal) {
for (int i = 0; i < sz; ++i) {
fb[i] = fa[i];
}
} else {
for (int i = 0; i < (int)b.size(); ++i) {
fb[i] = num(b[i], 0);
}
for (int i = (int)b.size(); i < sz; ++i) {
fb[i] = num(0, 0);
}
dft(fb, sz);
}
num ratio(1.0 / sz, 0);
for (int i = 0; i < sz; ++i) {
fa[i] = fa[i] * fb[i] * ratio;
}
reverse(fa.begin() + 1, fa.begin() + sz);
dft(fa, sz);
vector<ld> c(need);
for (int i = 0; i < need; ++i) {
c[i] = fa[i].x;
}
return c;
}
} // namespace fft
using fft::multiply;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, t, c;
cin >> n >> m >> t >> c;
vector<int> from(m), to(m), cost(m);
vector<vector<ld>> p(m, vector<ld>(t));
vector<vector<ld>> sum(m, vector<ld>(t + 1));
for (int i = 0; i < m; ++i) {
cin >> from[i] >> to[i] >> cost[i];
--from[i];
--to[i];
for (int j = 0; j < t; ++j) {
int x;
cin >> x;
p[i][j] = x / 1e5;
}
for (int j = t - 1; ~j; --j) {
sum[i][j] = p[i][j] + sum[i][j + 1];
}
}
vector<ld> dist(n, 1e9);
dist[n - 1] = c;
for (int tt = 0; tt < n; ++tt) {
for (int i = 0; i < m; ++i) {
dist[from[i]] = min(dist[from[i]], dist[to[i]] + cost[i]);
}
}
vector<vector<ld>> dp(n, vector<ld>(t + 1));
vector<vector<ld>> ad(m, vector<ld>(t + 1));
function<void(int, int)> solve = [&](int l, int r) {
if (l == r) {
for (int i = 0; i < n - 1; ++i) {
dp[i][l] = 1e9;
}
for (int i = 0; i < m; ++i) {
dp[from[i]][l] = min(dp[from[i]][l],
ad[i][l] + cost[i] + dist[to[i]] * sum[i][t - l]);
}
} else {
int mid = (l + r) >> 1;
solve(mid + 1, r);
for (int i = 0; i < m; ++i) {
vector<ld> foo(r - mid);
for (int j = 0; j < r - mid; ++j) {
foo[j] = dp[to[i]][j + mid + 1];
}
vector<ld> bar(r - l);
for (int j = 0; j < r - l; ++j) {
bar[j] = p[i][r - l - j - 1];
}
vector<ld> baz = multiply(foo, bar);
for (int j = 0; j <= mid - l; ++j) {
ad[i][j + l] += baz[j + r - mid - 1];
}
}
solve(l, mid);
}
};
solve(0, t);
cout << fixed << setprecision(9) << dp[0][0] << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long l[5010];
int tot;
long long ans, n, k;
void prepare() {
tot = 2;
l[0] = 4, l[1] = 7;
for (int i = 0; i < tot; i++)
if (l[i] > 2e9)
break;
else
l[tot++] = l[i] * 10 + 4, l[tot++] = l[i] * 10 + 7;
}
bool inside(long long t) {
for (int i = 0; i < tot; i++)
if (l[i] == t) return 1;
return 0;
}
long long deal(int b, int n) {
long long ret = 0, temp = 1;
for (int i = 1; i <= n; i++) temp *= i;
bool v[20];
memset(v, 0, sizeof v);
if (temp < k) return -0x7ffffff;
k--;
for (int i = n; i >= 1; i--) {
temp /= i;
int t = k / temp + 1, j;
k -= (t - 1) * temp;
for (j = 1; j <= n; j++) {
if (!v[j]) t--;
if (!t) break;
}
v[j] = 1;
if (inside(b + j) && inside(b + n - i + 1)) ret++;
}
return ret;
}
int main() {
prepare();
cin >> n >> k;
if (n <= 15)
ans = deal(0, n);
else {
for (int i = 0; l[i] <= n - 15; i++) ans++;
ans += deal(n - 15, 15);
}
if (ans < 0)
puts("-1");
else
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, a, b, ans = 0;
cin >> n >> m >> a >> b;
int ans1 = ((n + m - 1) / m) * b;
int ans2 = (n / m) * b + (n % m) * a;
int ans3 = n * a;
cout << min(ans1, min(ans2, ans3)) << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string a[10010];
bool vis[10010];
string p;
bool cmp(string x, string y) { return x + p + y < y + p + x; }
int main() {
int n;
cin >> n;
int l = 0;
for (int i = 0; i < n; i++) cin >> a[i], l += a[i].length();
cin >> p;
sort(a, a + n, cmp);
l = l / (n / 2);
for (int i = 0; i < n; i++) {
if (!vis[i]) {
for (int j = i + 1; j < n; j++) {
if (!vis[j] && a[i].length() + a[j].length() == l) {
cout << a[i] << p << a[j] << endl;
vis[j] = 1;
break;
}
}
}
}
return 0;
}
| 4 |
#include <cstdio>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
using namespace std;
#define reep(i,f,n) for(int i=f; i<int(n); ++i)
#define rep(i,n) reep(i,0,n)
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
map<string, int> price;
map<string, vector<string> > resipi;
map<string, int> memo;
int solve(string str)
{
if(memo.count(str))
return memo[str];
memo[str] = -1;
if(!resipi.count(str))
return memo[str] = price[str];
int cost = 0;
rep(i, resipi[str].size()){
int a = solve(resipi[str][i]);
if(a == -1)
return memo[str] = price[str];
cost += a;
}
return memo[str] = min(price[str], cost);
}
int main()
{
int n;
while(scanf("%d", &n), n){
price.clear();
resipi.clear();
memo.clear();
rep(i, n){
char name[128];
int p;
scanf("%s%d", name, &p);
price[string(name)] = p;
}
int m;
scanf("%d", &m);
rep(i, m){
char name[128];
int k;
scanf("%s%d", name, &k);
rep(j, k){
char factor[128];
scanf("%s", factor);
resipi[string(name)].push_back(string(factor));
}
}
char name[128];
scanf("%s", name);
printf("%d\n", solve(string(name)));
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long int n;
cin >> n;
long long int x = n / 2;
if (n % 2 == 0) {
while (x--) cout << 1;
} else {
cout << 7;
x--;
while (x--) cout << 1;
}
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) solve();
cerr << '\n'
<< "Time elapsed :" << clock() * 1000.0 / CLOCKS_PER_SEC << " ms\n";
}
| 3 |
#include<bits/stdc++.h>
#define LL long long
#define cbn(u,y) ((LL)fac[u]*inv[y]%mod*inv[(u)-(y)]%mod)
const int mod=1e9+7;
struct Combin{
#define N 400005
int fac[N],rv[N],facrv[N];
Combin(){
fac[0]=rv[1]=facrv[0]=1;
for(int i=2;i<N;i++) rv[i]=((-(LL)(mod/i)*rv[mod%i]%mod)+mod)%mod;
for(int i=1;i<N;i++) fac[i]=(LL)fac[i-1]*i%mod;
for(int i=1;i<N;i++) facrv[i]=(LL)facrv[i-1]*rv[i]%mod;
}
int C(int r1,int n1){
if(r1>n1) return 0;
return fac[n1]*(LL)facrv[r1]%mod*facrv[n1-r1]%mod;
}
#undef N
}C;
#define N 200005
using namespace std;
struct edge{
int d,t,next;//d=x+y
}e[N*2];int ecnt,head[N];
void addedge(int dp,int t,int d){
e[++ecnt]=(edge){d,t,head[dp]};head[dp]=ecnt;
e[++ecnt]=(edge){d,dp,head[t]};head[t]=ecnt;
}
int medge,sta[N],top,vis[N],vise[N];
void dfsc(int u,int fr_edge){//染色
vis[u]=1;sta[++top]=u;
for(int i=head[u],y;i;i=e[i].next)
if((i^1)!=fr_edge){
if (vise[i>>1]==0) vise[i>>1]=1,medge++;
if (vis[e[i].t]==0) dfsc(e[i].t,i);
}
}
int fre[N],mxp;//mxp 连通块中最右上角的点
void dfsp(int u,int fr_edge){//找到环上权值最大的边
vis[u]=2;
for(int i=head[u];i;i=e[i].next)
if((i^1)!=fr_edge){
if (vis[e[i].t]!=2){
fre[e[i].t]=i;
dfsp(e[i].t,i);
}else if(mxp==0){//找到环了
mxp=i;
for (int t=u;t!=e[i].t;t=e[fre[t]^1].t)
if (e[fre[t]].d>e[mxp].d) mxp=fre[t];
}
}
}
int n,m,ans;
int dp[N],sz[N];
void calc(int u,int fr_edge){
sz[u]=dp[u]=1;
for(int i=head[u];i;i=e[i].next)
if(((i^1)!=fr_edge)&&(i>>1)!=(mxp>>1)){
calc(e[i].t,i);
if(e[i].d>e[fr_edge].d){
ans=(LL)ans*dp[e[i].t]%mod*C.facrv[sz[e[i].t]]%mod;
}else{
sz[u]+=sz[e[i].t];
dp[u]=(LL)dp[u]*dp[e[i].t]%mod*C.C(sz[e[i].t],sz[u]-1)%mod;
}
}
}
int main(){
scanf("%d",&n);ecnt=1;
for(int i=1,x,y;i<=n*2;i++){
scanf("%d%d",&x,&y);
addedge(x,y+n,x+y);
}
int sum=C.fac[n*2],tot;
for(int i=1,v;i<=n*2;i++)
if(vis[i]==0){
mxp=medge=top=tot=0;
dfsc(i,0);
if(medge!=top) return puts("0"),0;
dfsp(i,0);
v=e[mxp].t,ans=1,calc(v,mxp);
ans=(LL)ans*dp[v]%mod*C.facrv[sz[v]]%mod;
tot+=ans;
v=e[mxp^1].t,ans=1,calc(v,mxp);
ans=(LL)ans*dp[v]%mod*C.facrv[sz[v]]%mod;
tot+=ans;
sum=(LL)sum*tot%mod;
}
printf("%d\n",sum);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
int n, m, spi[N], dis[N];
vector<int> gra[N];
int f(int v) {
int &res = dis[v];
if (res) return res;
res = 1;
for (auto &(to) : (gra[v])) {
(res) = max((res), (f(to) + 1));
}
return res;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
scanf("%d%d", &n, &m);
for (int i = 0; i < (int)m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
spi[u]++;
spi[v]++;
if (u < v) swap(u, v);
gra[u].push_back(v);
}
long long ans = 0;
for (int i = 0; i < (int)n; ++i) {
(ans) = max((ans), (1ll * f(i) * spi[i]));
}
printf("%I64d\n", ans);
}
| 2 |
#pragma GCC optimize("O3")
#include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
// gp_hash_table<int, int> mapka;
using namespace std;
#define PB push_back
#define MP make_pair
#define LL long long
#define int LL
#define FOR(i,a,b) for(int i = (a); i <= (b); i++)
#define RE(i,n) FOR(i,1,n)
#define REP(i,n) FOR(i,0,(int)(n)-1)
#define R(i,n) REP(i,n)
#define VI vector<int>
#define PII pair<int,int>
#define LD long double
#define FI first
#define SE second
#define st FI
#define nd SE
#define ALL(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
template<class C> void mini(C &a4, C b4) { a4 = min(a4, b4); }
template<class C> void maxi(C &a4, C b4) { a4 = max(a4, b4); }
template<class TH> void _dbg(const char *sdbg, TH h){ cerr<<sdbg<<'='<<h<<endl; }
template<class TH, class... TA> void _dbg(const char *sdbg, TH h, TA... a) {
while(*sdbg!=',')cerr<<*sdbg++;
cerr<<'='<<h<<','; _dbg(sdbg+1, a...);
}
template<class T> ostream &operator<<(ostream& os, vector<T> V) {
os << "["; for (auto vv : V) os << vv << ","; return os << "]";
}
template<class L, class R> ostream &operator<<(ostream &os, pair<L,R> P) {
return os << "(" << P.st << "," << P.nd << ")";
}
#ifdef LOCAL
#define debug(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
#else
#define debug(...) (__VA_ARGS__)
#define cerr if(0)cout
#endif
const int P = 1e9 + 7;
const int MAX = 1e5 + 10;
int sil[MAX];
int odw[MAX];
void add(int &a, int b){
a += b;
if(a >= P)
a -= P;
}
int mul(int a,int b){
return a * b % P;
}
int pot(int a,int w){
int r = 1;
while(w){
if(w & 1){
r = r * a % P;
}
w/=2;
a = a * a % P;
}
return r;
}
int dwu(int a,int b){
if(a < b || b < 0)return 0;
return sil[a] * odw[b] % P * odw[a - b] % P;
}
int odwdwu(int a,int b){
if(a < b || b < 0)return 0;
return odw[a] * sil[b] % P * sil[a - b] % P;
}
struct Sol{
int n,k;
void run(){
cin >> n >> k;
int res = 1;
for(int i = 1; i < n; i++){
int us = (k - 1) * (i - 1);
debug(n,us,i);
add(res, mul(dwu(n - us, i), odwdwu(n, i)));
}
cout << res << "\n";
}
};
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout << fixed << setprecision(11);
cerr << fixed << setprecision(6);
sil[0] = 1;
R(i,MAX-1){
sil[i + 1] = mul(sil[i], i + 1);
}
R(i,MAX){
odw[i] = pot(sil[i], P - 2);
}
int t;
cin >> t;
while(t--){
Sol sol;
sol.run();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<string, string> mp1;
map<string, string> mp2;
string word;
string s1, s2;
int i;
cin >> i;
int j;
while (i--) {
cin >> s1;
cin >> s2;
if (mp2.count(s1) == 0) {
mp1[s1] = s2;
mp2[s2] = s1;
} else {
mp2[s2] = mp2[s1];
mp1[mp2[s1]] = s2;
mp2.erase(s1);
}
}
int l = 0;
for (map<string, string>::iterator i = mp1.begin(); i != mp1.end(); i++) {
l++;
}
cout << l << endl;
for (map<string, string>::iterator i = mp1.begin(); i != mp1.end(); i++) {
cout << i->first << " ";
cout << i->second << endl;
}
}
| 2 |
#include <cstdio>
#include <vector>
using namespace std;
vector<int> p;
void Prime(){
bool prime[100000];
prime[0] = false;
prime[1] = false;
for(int i = 2; i < 100000; i++) prime[i] = true;
for(int i = 2; i < 1000; i++){
if(!prime[i]) continue;
for(int j = i*2; j < 100000; j += i) prime[j] = false;
}
for(int i = 0; i < 100000; i++) if(prime[i]) p.push_back(i);
}
int main(){
Prime();
int m, a, b;
while(scanf("%d%d%d", &m, &a, &b),m||a||b){
int aa, bb;
int ans = 0;
for(int i = 0; i < p.size(); i++){
if(p[i] > 1000) break;
for(int j = i; j < p.size(); j++){
if(p[i]*p[j] > m || a*p[j] > b*p[i]) break;
if(p[i]*p[j] > ans){
ans = p[i]*p[j];
aa = p[i]; bb = p[j];
}
}
}
printf("%d %d\n", aa, bb);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int monthes[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int main() {
pair<int, pair<int, int>> d1;
pair<int, pair<int, int>> d2;
scanf("%d:%d:%d", &d1.first, &d1.second.first, &d1.second.second);
scanf("%d:%d:%d", &d2.first, &d2.second.first, &d2.second.second);
if (d1 > d2) swap(d1, d2);
int ans = 0;
for (int i = d1.first; i < d2.first; i++) {
if (i % 4 == 0 && (i % 100 != 0 || i % 400 == 0))
ans += 366;
else
ans += 365;
}
for (int i = 1; i < d1.second.first; i++) ans -= monthes[i];
if (d1.second.first > 2 &&
(d1.first % 4 == 0 && (d1.first % 100 != 0 || d1.first % 400 == 0)))
ans--;
ans -= d1.second.second;
for (int i = 1; i < d2.second.first; i++) ans += monthes[i];
if (d2.second.first > 2 &&
(d2.first % 4 == 0 && (d2.first % 100 != 0 || d2.first % 400 == 0)))
ans++;
ans += d2.second.second;
cout << ans;
return 0;
}
| 2 |
#include<cstdio>
#include<cstring>
char s[10];
int main(){
scanf("%s",s);
int len=strlen(s);
for(int i=1;i<len;i++){
if(s[i]=='C'&&s[i-1]=='A') {
puts("Yes");
return 0;
}
}
puts("No");
return 0;
} | 0 |
#include <bits/stdc++.h>
long long dx[4] = {0, -1, 0, 1};
long long dy[4] = {1, 0, -1, 0};
using namespace std;
class pa3 {
public:
long long x, y, z;
pa3(long long x = 0, long long y = 0, long long z = 0) : x(x), y(y), z(z) {}
bool operator<(const pa3 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
return z < p.z;
}
bool operator>(const pa3 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
return z > p.z;
}
bool operator==(const pa3 &p) const {
return x == p.x && y == p.y && z == p.z;
}
bool operator!=(const pa3 &p) const {
return !(x == p.x && y == p.y && z == p.z);
}
};
class pa4 {
public:
double x;
long long y, z, w;
pa4(double x = 0, long long y = 0, long long z = 0, long long w = 0)
: x(x), y(y), z(z), w(w) {}
bool operator<(const pa4 &p) const {
if (x != p.x) return x < p.x;
if (y != p.y) return y < p.y;
if (z != p.z) return z < p.z;
return w < p.w;
}
bool operator>(const pa4 &p) const {
if (x != p.x) return x > p.x;
if (y != p.y) return y > p.y;
if (z != p.z) return z > p.z;
return w > p.w;
}
bool operator==(const pa4 &p) const {
return x == p.x && y == p.y && z == p.z && w == p.w;
}
};
class pa2 {
public:
long long x, y;
pa2(long long x = 0, long long y = 0) : x(x), y(y) {}
pa2 operator+(pa2 p) { return pa2(x + p.x, y + p.y); }
pa2 operator-(pa2 p) { return pa2(x - p.x, y - p.y); }
bool operator<(const pa2 &p) const { return y != p.y ? y < p.y : x < p.x; }
bool operator>(const pa2 &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const pa2 &p) const {
return abs(x - p.x) == 0 && abs(y - p.y) == 0;
}
bool operator!=(const pa2 &p) const {
return !(abs(x - p.x) == 0 && abs(y - p.y) == 0);
}
};
class Point {
public:
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(x * a, y * a); }
Point operator/(double a) { return Point(x / a, y / a); }
double absv() { return sqrt(norm()); }
double norm() { return x * x + y * y; }
bool operator<(const Point &p) const { return x != p.x ? x < p.x : y < p.y; }
bool operator==(const Point &p) const {
return fabs(x - p.x) < (1e-10) && fabs(y - p.y) < (1e-10);
}
};
struct Segment {
Point p1, p2;
};
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
bool parareru(Point a, Point b, Point c, Point d) {
return abs(cross(a - b, d - c)) < (1e-10);
}
double distance_ls_p(Point a, Point b, Point c) {
if (dot(b - a, c - a) < (1e-10)) return (c - a).absv();
if (dot(a - b, c - b) < (1e-10)) return (c - b).absv();
return abs(cross(b - a, c - a)) / (b - a).absv();
}
bool is_intersected_ls(Segment a, Segment b) {
if (a.p1 == b.p1 || a.p2 == b.p1 || a.p1 == b.p2 || a.p2 == b.p2)
return false;
if (parareru((a.p2), (a.p1), (a.p1), (b.p2)) &&
parareru((a.p2), (a.p1), (a.p1), (b.p1))) {
if (dot(a.p1 - b.p1, a.p1 - b.p2) < (1e-10)) return true;
if (dot(a.p2 - b.p1, a.p2 - b.p2) < (1e-10)) return true;
if (dot(a.p1 - b.p1, a.p2 - b.p1) < (1e-10)) return true;
if (dot(a.p1 - b.p2, a.p2 - b.p2) < (1e-10)) return true;
return false;
} else
return (cross(a.p2 - a.p1, b.p1 - a.p1) * cross(a.p2 - a.p1, b.p2 - a.p1) <
(1e-10)) &&
(cross(b.p2 - b.p1, a.p1 - b.p1) * cross(b.p2 - b.p1, a.p2 - b.p1) <
(1e-10));
}
double segment_dis(Segment a, Segment b) {
if (is_intersected_ls(a, b)) return 0;
double r = distance_ls_p(a.p1, a.p2, b.p1);
r = min(r, distance_ls_p(a.p1, a.p2, b.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p2));
r = min(r, distance_ls_p(b.p1, b.p2, a.p1));
return r;
}
Point intersection_ls(Segment a, Segment b) {
Point ba = b.p2 - b.p1;
double d1 = abs(cross(ba, a.p1 - b.p1));
double d2 = abs(cross(ba, a.p2 - b.p1));
double t = d1 / (d1 + d2);
return a.p1 + (a.p2 - a.p1) * t;
}
string itos(long long i) {
ostringstream s;
s << i;
return s.str();
}
long long gcd(long long v, long long b) {
if (v > b) return gcd(b, v);
if (v == b) return b;
if (b % v == 0) return v;
return gcd(v, b % v);
}
double distans(double x1, double y1, double x2, double y2) {
double rr = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2);
return sqrt(rr);
}
long long mod;
long long ch(long long n, long long y) {
if (n == 1) {
return 1;
}
if (n == 2) {
return y;
}
if (n == 3) {
if (y == 1) return 1;
if (y == 2) return 3;
if (y == 3) return 2;
}
if (n % 2 == 0) {
if (y % 2) {
return y / 2 + 1;
}
return n / 2 + ch(n / 2, y / 2);
} else {
if (y % 2) {
return y / 2 + 1;
}
long long g = (y) / 2 + 1;
return n / 2 + ch((n + 1) / 2, g);
}
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long n, q;
cin >> n >> q;
for (long long i = 0; i < q; i++) {
long long y;
cin >> y;
cout << ch(n, y) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[3][1000];
int n[3];
long long sum[3][1000];
long long d[3][1000][1000];
int t, st, dist = 0;
void dfs(int v, int par) {
d[t][st][v] = dist;
sum[t][st] += dist;
for (int to : g[t][v])
if (to != par) {
++dist;
dfs(to, v);
--dist;
}
}
int main() {
ios_base::sync_with_stdio(false);
for (int i = 0; i < (int)(3); ++i) cin >> n[i];
for (int i = 0; i < (int)(3); ++i)
for (int j = 0; j < (int)(n[i] - 1); ++j) {
int from, to;
cin >> from >> to, --from, --to;
g[i][from].push_back(to);
g[i][to].push_back(from);
}
for (t = 0; t < 3; ++t)
for (st = 0; st < n[t]; ++st) dfs(st, -1);
long long tot = 0;
for (int t = 0; t < (int)(3); ++t)
for (int i = 0; i < (int)(n[t]); ++i) tot += sum[t][i];
tot /= 2;
long long ans = tot;
for (int mid = 0; mid < (int)(3); ++mid) {
int l = 0, r = 2;
if (mid == 0) l = 1;
if (mid == 2) r = 1;
long long bestL = 0;
for (int i = 0; i < (int)(n[l]); ++i) bestL = max(bestL, sum[l][i]);
long long bestR = 0;
for (int i = 0; i < (int)(n[r]); ++i) bestR = max(bestR, sum[r][i]);
long long cur = (bestL + n[l]) * (n[mid] + n[r]);
cur += (bestR + n[r]) * (n[mid] + n[l]);
long long bestMid = 0;
for (int i = 0; i < (int)(n[mid]); ++i)
for (int j = 0; j < (int)(n[mid]); ++j)
bestMid = max(bestMid, d[mid][i][j] * (n[l] * n[r]) +
sum[mid][i] * n[l] + sum[mid][j] * n[r]);
cur += bestMid;
ans = max(ans, tot + cur);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma warning(disable : 4786)
#pragma warning(disable : 4996)
using namespace std;
const int N = 1e5 + 5;
vector<pair<int, int> > e;
int main() {
int n, d, h;
cin >> n >> d >> h;
if (d == h) {
if (d == 1 && n > 2) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= h; i++) {
printf("%d %d\n", i, i + 1);
}
int node = h + 2;
for (int i = node; i <= n; i++) printf("%d %d\n", 2, i);
} else if (d > h && d <= 2 * h && d < n) {
for (int i = 1; i <= h; i++) {
e.push_back(make_pair(i, i + 1));
}
int node = h + 2;
e.push_back(make_pair(1, node));
bool flag = 1;
for (int i = 1; i <= d - h - 1; i++) {
e.push_back(make_pair(node, node + 1));
node++;
}
node++;
for (; node <= n && e.size() < n - 1; node++) {
e.push_back(make_pair(1, node));
}
for (auto a : e) printf("%d %d\n", a.first, a.second);
} else {
printf("-1");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, f[105][200005], q[200005], he, ta;
int main() {
scanf("%d%d", &n, &m);
memset(f, 0x3f, sizeof f);
f[0][0] = 0;
for (int i = 1, len, t; i <= m; i++) {
scanf("%d%d", &len, &t);
len = t - len;
for (int j = 0; j <= t; j++) f[i][j] = f[i - 1][j];
he = 1, ta = 0;
for (int j = t; ~j; j--) {
while (he <= ta && q[he] < t - j - len) he++;
while (he <= ta && f[i - 1][q[ta]] > f[i - 1][t - j]) ta--;
q[++ta] = t - j;
f[i][j] = min(f[i][j], f[i - 1][q[he]] + 1);
}
if (len) {
he = 1, ta = 0;
for (int j = 0; j <= t; j++) {
while (he <= ta && q[he] < j - len) he++;
while (he <= ta && f[i - 1][q[ta]] > f[i - 1][j]) ta--;
q[++ta] = j;
f[i][j] = min(f[i][j], f[i - 1][q[he]] + 2);
}
}
}
if (f[m][n] >= f[0][1])
puts("Hungry");
else {
puts("Full");
printf("%d\n", f[m][n]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll M = 1e9 + 7;
ll mpw(ll a, ll b) {
return (b == 0LL ? 1LL
: (mpw(a * a % M, b / 2LL) * ((b & 1LL) ? a : 1LL) % M));
}
int main() {
ll n, m;
cin >> n >> m;
if (m == 1)
cout << n + 1 << endl;
else
cout << (mpw(m, n) + m * mpw(m - 1, M - 2) % M *
(mpw(2LL * m - 1LL, n) - mpw(m, n) + M)) %
M
<< endl;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
const long long P = 998244353;
using namespace std;
inline void ckmax(long long &a, long long b) { a = max(a, b); }
inline void ckmin(long long &a, long long b) { a = min(a, b); }
inline void mul(long long &a, long long b) { a = 1ll * a * b % P; }
inline void addmod(long long &a, long long b) {
long long t = a + b;
a = (t >= P ? t - P : t);
}
inline long long ksm(long long a, long long b) {
long long ans = 1;
for (; b; b >>= 1) {
if (b & 1) ans = 1ll * ans * a % P;
a = 1ll * a * a % P;
}
return ans;
}
inline long long inv(long long a) { return ksm(a, P - 2); }
inline void printarray(long long *a, long long n) {
for (register long long i = (1); i <= (n); i++) fprintf(stderr, "%d ", a[i]);
fprintf(stderr, "\n");
}
namespace FastIO {
const long long SIZE = 1 << 16;
char buf[SIZE], obuf[SIZE], str[64];
long long bi = SIZE, bn = SIZE, opt;
long long read(char *s) {
while (bn) {
for (; bi < bn && buf[bi] <= ' '; bi++)
;
if (bi < bn) break;
bn = fread(buf, 1, SIZE, stdin), bi = 0;
}
long long sn = 0;
while (bn) {
for (; bi < bn && buf[bi] > ' '; bi++) s[sn++] = buf[bi];
if (bi < bn) break;
bn = fread(buf, 1, SIZE, stdin), bi = 0;
}
s[sn] = 0;
return sn;
}
bool read(long long &x) {
if (x) x = 0;
long long bf = 0, n = read(str);
if (!n) return 0;
long long i = 0;
if (str[i] == '-') bf = 1, i = 1;
for (x = 0; i < n; i++) x = x * 10 + str[i] - '0';
if (bf) x = -x;
return 1;
}
void write(long long x) {
if (!x)
obuf[opt++] = '0';
else {
if (x < 0) obuf[opt++] = '-', x = -x;
long long sn = 0;
while (x) str[sn++] = x % 10 + '0', x /= 10;
for (long long i = sn - 1; i >= 0; i--) obuf[opt++] = str[i];
}
if (opt >= (SIZE >> 1)) {
fwrite(obuf, 1, opt, stdout);
opt = 0;
}
}
void write(char x) {
obuf[opt++] = x;
if (opt >= (SIZE >> 1)) {
fwrite(obuf, 1, opt, stdout);
opt = 0;
}
}
void Fflush() {
if (opt) fwrite(obuf, 1, opt, stdout);
opt = 0;
}
}; // namespace FastIO
const long long MAXN = 2e5 + 5;
long long n, m, h, a[MAXN], b[MAXN];
struct Segment_tree {
static const long long N = MAXN << 2;
long long mn[N], tag[N];
void build(long long k, long long l, long long r) {
if (l == r) return mn[k] = -l, tag[k] = 0, void();
build((k << 1), l, ((l + r) >> 1)),
build((k << 1 | 1), ((l + r) >> 1) + 1, r);
mn[k] = min(mn[(k << 1)], mn[(k << 1 | 1)]);
}
inline void pushr(long long k, long long v) { mn[k] += v, tag[k] += v; }
void update(long long k, long long l, long long r, long long ql, long long qr,
long long v) {
if (l == ql && r == qr) return pushr(k, v), void();
if (tag[k])
pushr((k << 1), tag[k]), pushr((k << 1 | 1), tag[k]), tag[k] = 0;
if (qr <= ((l + r) >> 1))
update((k << 1), l, ((l + r) >> 1), ql, qr, v);
else if (((l + r) >> 1) < ql)
update((k << 1 | 1), ((l + r) >> 1) + 1, r, ql, qr, v);
else
update((k << 1), l, ((l + r) >> 1), ql, ((l + r) >> 1), v),
update((k << 1 | 1), ((l + r) >> 1) + 1, r, ((l + r) >> 1) + 1, qr,
v);
mn[k] = min(mn[(k << 1)], mn[(k << 1 | 1)]);
}
} tr;
void modify(long long p, long long v) {
if (p <= m) tr.update(1, 1, m, p, m, v);
}
signed main() {
FastIO::read(n);
FastIO::read(m);
FastIO::read(h);
for (register long long i = (1); i <= (m); i++) FastIO::read(b[i]);
sort(b + 1, b + 1 + m);
tr.build(1, 1, m);
for (register long long i = (1); i <= (n); i++)
FastIO::read(a[i]), a[i] = lower_bound(b + 1, b + 1 + m, h - a[i]) - b;
for (register long long i = (1); i <= (m - 1); i++) modify(a[i], 1);
long long ans = 0;
for (register long long i = (m); i <= (n); i++) {
modify(a[i], 1);
ans += (tr.mn[1] >= 0);
modify(a[i - m + 1], -1);
}
cout << ans << endl;
return FastIO::Fflush(), 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n;
cin >> i;
cin >> n;
if (n == i) {
cout << 0 << endl;
return 0;
}
int moves = 0;
while (n % (i * 3) == 0 && n > i) {
i *= 3;
moves++;
}
while (n % (i * 2) == 0 && n > i) {
i *= 2;
moves++;
}
if (i == n)
cout << moves << endl;
else
cout << -1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
long long max(long long a, long long b) { return a > b ? a : b; }
bool r(long long p1, long long p2) { return (p2 < p1); }
long long min(long long a, long long b) { return a < b ? a : b; }
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
const int N = 9;
long long power(long long a, long long b) {
long long ans = 1;
while (b > 0) {
if (b & 1) {
ans = (ans * a);
}
a = (a * a);
b >>= 1;
}
return ans;
}
void solve() {
int n;
cin >> n;
int a[n], b[n], c[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
for (int i = 0; i < n; i++) cin >> c[i];
int p[n];
p[0] = a[0];
for (int i = 1; i < n; i++) {
p[i] = a[i];
if (p[i] == p[i - 1]) p[i] = b[i];
}
if (p[n - 1] == p[0]) p[n - 1] = c[n - 1];
if (p[n - 1] == p[n - 2]) p[n - 1] = b[n - 1];
for (int i = 0; i < n; i++) cout << p[i] << " ";
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.