solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
void swap(int *xp, int *yp) {
int temp = *xp;
*xp = *yp;
*yp = temp;
}
void selectionSort(int arr[], int n) {
int i, j, min_idx;
for (i = 0; i < n - 1; i++) {
min_idx = i;
for (j = i + 1; j < n; j++)
if (arr[j] < arr[min_idx]) min_idx = j;
swap(&arr[min_idx], &arr[i]);
}
}
int main() {
int n, m;
int B[2], z = 0;
while (z < 2) {
cin >> B[z];
z += 1;
}
n = B[0], m = B[1];
int A[n];
memset(A, 0, sizeof(A));
for (int i = 0; i < n; i++) cin >> A[i];
int ss = (sizeof(A) / sizeof(A[0]));
selectionSort(A, ss);
int cost = 0;
int k = 0;
while (k < m) {
if (A[k] > 0) break;
cost += A[k];
k++;
}
cout << abs(cost);
return 0;
}
| 2 |
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<cassert>
#include<set>
#include<map>
using namespace std;
#define pb push_back
#define mp make_pair
#define rep(i,n) for(int i=1;i<=n;i++)
typedef long long LL;
const int MOD=(int)1e9+7;
const int N=110;
int f[N][N*N],ssb[N],sc[N],b[N],c[N],n,q,ans[N];
void work(int&ans,int x)
{
memset(f,0,sizeof(f));
rep(i,n)
{
if(i==1)for(int j=max(0,x);j<=c[1];j++)f[1][j]=1;
else
{
rep(j,sc[i])(f[i-1][j]+=f[i-1][j-1])%=MOD;
for(int j=max(0,i*x+ssb[i]);j<=sc[i];j++)f[i][j]=(f[i-1][j]-(j-c[i]-1>=0?f[i-1][j-c[i]-1]:0)+MOD)%MOD;
}
}
ans=0;
for(int i=0;i<=sc[n];i++)(ans+=f[n][i])%=MOD;
}
int main()
{
scanf("%d",&n);
rep(i,n)scanf("%d",&c[i]),sc[i]=sc[i-1]+c[i];
rep(i,n-1)scanf("%d",&b[i+1]),ssb[i+1]=ssb[i]+b[i+1];
rep(i,n)ssb[i]+=ssb[i-1];
int L=(-ssb[n])/n,R=(sc[n]-ssb[n])/n;
rep(i,n-1)L=min(L,(-ssb[i])/i),R=min(R,(sc[i]-ssb[i])/i);
L=max(L,-(int)1e5);R=min(R,(int)1e5);
for(int i=L;i<=R;i++)work(ans[i-L+1],i);
scanf("%d",&q);
int pw2=1;
rep(i,n)pw2=1ll*pw2*(c[i]+1)%MOD;
rep(Q,q)
{
int x;scanf("%d",&x);
if(Q==217)
{
int ans=0;
work(ans,x);
printf("%d\n",ans);
continue;
}
if(x>R)puts("0");
else if(x<L)printf("%d\n",pw2);
else printf("%d\n",ans[x-L+1]);
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
const int N=3010,MOD=1e9+7;
int n,m,ans;
int f[N][N][2];
int plu(int u,int v){
return (u+v)%MOD;
}
int main(){
scanf("%d%d",&n,&m);
f[0][0][1]=1;
for(int i=1;i<=n;i++){
f[0][i][0]=1;
}
for(int i=0;i<m;i++){
for(int j=0;j<=n;j++){
for(int k=0;k<2;k++){
if(j){
f[i+1][j-1][k|(j==1)]=plu(f[i+1][j-1][k|(j==1)],f[i][j][k]);
f[i+1][j][k|(j==1)]=plu(f[i+1][j][k|(j==1)],f[i][j][k]);
}
if(j!=n){
f[i+1][j+1][k]=plu(f[i+1][j+1][k],f[i][j][k]);
f[i+1][j][k]=plu(f[i+1][j][k],f[i][j][k]);
}
}
}
}
for(int i=0;i<=n;i++){
ans=plu(ans,f[m][i][1]);
}
printf("%d\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
struct Fenwich {
int n;
int tr[N];
Fenwich() { memset(tr, 0, sizeof(tr)); }
void add(int pos, int delta) {
while (pos <= n) {
tr[pos] += delta;
pos += pos & -pos;
}
}
int ask(int pos) {
int ret = 0;
while (pos) {
ret += tr[pos];
pos -= pos & -pos;
}
return ret;
}
};
Fenwich pre, suf;
int n, k, a, b;
int capb[N], capa[N];
int main() {
int q;
scanf("%d%d%d%d%d", &n, &k, &a, &b, &q);
pre.n = n;
suf.n = n;
while (q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int di, ai;
scanf("%d%d", &di, &ai);
int df = min(capb[di - 1] + ai, b) - capb[di - 1];
if (df) {
capb[di - 1] += df;
pre.add(di, df);
}
df = min(capa[n - di] + ai, a) - capa[n - di];
if (df) {
capa[n - di] += df;
suf.add(n - di + 1, df);
}
} else {
int pi;
scanf("%d", &pi);
int ans = pre.ask(pi - 1);
if (pi + k <= n) {
ans += suf.ask(n - (pi + k) + 1);
}
printf("%d\n", ans);
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dx[]{1, -1, 0, 0, 1, 1, -1, -1};
int dy[]{0, 0, 1, -1, 1, -1, 1, -1};
void K_K() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
K_K();
int n;
cin >> n;
vector<int> arr(n);
int sum = 0;
for (auto &it : arr) cin >> it, sum += it;
int cnt = 0;
for (int i = 0; i < n; i++) {
cnt += (!((sum - arr[i]) & 1));
}
cout << cnt;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, l, r, j;
while (cin >> n >> m) {
char s[n], c1, c2;
for (i = 1; i <= n; i++) {
cin >> s[i];
}
for (i = 1; i <= m; i++) {
cin >> l >> r >> c1 >> c2;
for (j = l; j <= r; j++) {
if (s[j] == c1) s[j] = c2;
}
}
for (i = 1; i <= n; i++) cout << s[i];
cout << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(std::chrono::system_clock::now().time_since_epoch().count());
const int N = 2e5 + 1;
int n,k,p[N],bit[N],ans;
void add(int at,int val){
for(int cur = at;cur < N;cur+=cur&(-cur))bit[cur]+=val;
}
int get(int at){
int ret = 0;
for(int cur = at;cur;cur-=cur&(-cur))ret+=bit[cur];
return ret;
}
bool did;
int main(){
//freopen("input.txt","r",stdin);
scanf("%d%d",&n,&k);
for(int i = 0;i < n;i++)scanf("%d",p + i),p[i]++;
bool lastf = 0;
long long inv = 0;
for(int i = 0;i < k;i++){
inv+=-get(p[i]) + i;
add(p[i],1);
}
if(get(p[0]) - 1)lastf = 1;
ans+=!!inv;
did|=!inv;
for(int i = k;i < n;i++){
add(p[i - k],-1);
inv-=get(p[i - k]);
inv+=k - 1 - get(p[i]);
add(p[i],1);
bool curf = get(p[i - k + 1]) - 1;
bool cure = k - get(p[i]);
if(lastf || cure)ans+=!!inv;
lastf = curf;
did|=!inv;
}
printf("%d\n",ans + did);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline void go(const vector<pair<int, int> > &v) {
int n = int(v.size());
for (int i = 0; i < n; ++i) {
if (i > 0) putchar(' ');
printf("%d", v[i].second);
}
putchar('\n');
}
int main() {
int n, x;
scanf("%d", &n);
vector<pair<int, int> > v, sw;
for (int i = 0; i < n; ++i) {
scanf("%d", &x);
v.push_back(make_pair(x, i + 1));
}
sort(v.begin(), v.end());
for (int i = 1; i < n; ++i) {
if (v[i - 1].first == v[i].first) {
sw.push_back(make_pair(i - 1, i));
if (int(sw.size()) == 2) break;
}
}
if (int(sw.size()) < 2) {
puts("NO");
} else {
puts("YES");
go(v);
swap(v[sw[0].first], v[sw[0].second]);
go(v);
swap(v[sw[1].first], v[sw[1].second]);
go(v);
}
return 0;
}
| 2 |
#include<string>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
const int L_MAX=1030;
int rad[2*L_MAX];
void Manacher(const char *s){
int m=2*strlen(s);
for(int i=0,j=0;i<m;){
while(0<=i-j && i+j+1<m && s[(i-j)/2]==s[(i+j+1)/2]) j++;
rad[i]=j;
int k;
for(k=1;i-k>=0 && rad[i-k]<rad[i]-k;k++) rad[i+k]=rad[i-k];
i+=k;
j=(j>k?j-k:0);
}
}
bool is_subpalindrome(const string &s,const string &t){
int m=s.length(),n=t.length();
return m<=n && m%2==n%2 && s==t.substr(n/2-m/2,m);
}
int main(){
for(string s;getline(cin,s);){
string t;
rep(i,s.length()) if(isalpha(s[i])) t+=toupper(s[i]);
Manacher(t.c_str());
vector<string> ans;
rep(i,2*t.length()) if(rad[i]>=3) ans.push_back(t.substr((i+1)/2-rad[i]/2,rad[i]));
sort(ans.begin(),ans.end());
ans.erase(unique(ans.begin(),ans.end()),ans.end());
bool b=false;
rep(i,ans.size()){
bool ok=true;
rep(j,ans.size()) if(i!=j) if(is_subpalindrome(ans[i],ans[j])) { ok=false; break; }
if(ok) cout<<(b?" ":"")<<ans[i], b=true;
}
cout<<endl;
}
return 0;
}
| 0 |
#include<iostream>
#include<cstdio>
using namespace std;
int main(void)
{
int a=0;
int b=0;
scanf("%d %d",&a,&b);
printf("%d\n",(a+b)/2);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 100005;
int n, nn, a[N][2], lst[N], sz[N], len;
int ans[N][2], idx, num[N], d[N], ptr;
bool vis[N];
inline void add_edge(int x, int y) {
a[++len][0] = y;
a[len][1] = lst[x];
lst[x] = len;
}
void add(int x, int y) {
ans[++idx][0] = x;
ans[idx][1] = y;
}
int dfs1(int pos, int fa) {
int ret = 1;
for (int i = lst[pos]; i > 0; i = a[i][1])
if (a[i][0] != fa && !vis[a[i][0]]) ret += dfs1(a[i][0], pos);
return ret;
}
void dfs2(int pos, int fa, int v) {
sz[pos] = 1;
num[pos] = v;
for (int i = lst[pos]; i > 0; i = a[i][1])
if (a[i][0] != fa && !vis[a[i][0]]) {
dfs2(a[i][0], pos, v);
sz[pos] += sz[a[i][0]];
}
if (sz[pos] >= nn) d[++ptr] = pos, sz[pos] = 0;
}
void dfs3(int pos, int fa, int st) {
if (!vis[pos]) add(st, pos);
for (int i = lst[pos]; i > 0; i = a[i][1])
if (a[i][0] != fa && !vis[a[i][0]]) dfs3(a[i][0], pos, st);
}
void solve(int pos, int v, int l) {
int ss = dfs1(pos, 0);
nn = sqrt(ss);
dfs2(pos, 0, v);
int r = ptr;
for (int i = l; i < r; i++)
for (int j = i + 1; j <= r; j++) add(d[i], d[j]);
for (int i = l; i <= r; i++) vis[d[i]] = 1;
for (int i = l; i <= r; i++) dfs3(d[i], 0, d[i]);
for (int i = l; i <= r; i++) {
for (int j = lst[d[i]]; j > 0; j = a[j][1])
if (!vis[a[j][0]] && num[a[j][0]] != v + 1)
solve(a[j][0], v + 1, ptr + 1);
}
}
int main() {
ios::sync_with_stdio(false);
int kk, t1, t2;
cin >> n >> kk;
for (int i = 1; i < n; i++)
cin >> t1 >> t2, add_edge(t1, t2), add_edge(t2, t1);
solve(1, 1, 1);
cout << idx << endl;
for (int i = 1; i <= idx; i++) cout << ans[i][0] << ' ' << ans[i][1] << endl;
return 0;
}
| 3 |
#include "bits/stdc++.h"
#define int long long
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(obj) begin(obj), end(obj)
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
#define LOWER_BOUND(A, key) distance(A.begin(), lower_bound(ALL(A), key))
#define UPPER_BOUND(A, key) distance(A.begin(), upper_bound(ALL(A), key))
using namespace std;
using ll = long long;
const int MOD = (int)(1e9 + 7);
const int INF = (int)(1e13 + 7);
int ceil_(int a, int b) { return (a >= 0 ? (a + (b - 1)) / b : (a - (b - 1)) / b); }
int mod(int a, int b) { return a >= 0 ? a % b : a - (b * ceil_(a, b)); }
int bpm(int x, unsigned int y) {
if (x == 0) return 0;
if (y == 0) return 1;
int ans = 1;
int digit = (int)((log((double)y) / log((double)2) / 1 + 1));
x %= MOD;
for (unsigned int i = 0; i < digit; i++) {
if (((y >> i) & 1u) == 1) ans = ans * x % MOD;
x = x * x % MOD;
}
return ans;
}
template <class T>
void cumulative_sum(T &container) {
for (int i = 0; i < container.size() - 1; i++) container[i + 1] += container[i];
}
#define MAX_N 500000
int bit_[MAX_N + 1];
int n_; //assign length of sequence
int sum(int i) {
int s = 0;
while (i > 0) {
s += bit_[i];
i -= i & -i;
}
return s;
}
void add(int i, int x) {
while (i <= n_) {
bit_[i] += x;
i += i & -i;
}
}
signed main() {
int N;
cin >> N;
while (N != 0) {
fill(ALL(bit_), 0LL);
int R;
cin >> R;
map<int, int> dict;
rep(i, N) dict[i + 1] = i + 1;
rep(i, R) {
int s, t;
cin >> s >> t;
int temp = dict[s];
dict[s] = dict[t];
dict[t] = temp;
}
n_ = N;
rep(i, N) add(i + 1, 1);
vector<int> fact_list = {1};
rep(i, N) {
fact_list.emplace_back(fact_list[i] * (i + 2) % MOD);
}
int ans = 0;
rep(i, N - 1) {
ans = (ans + (sum(dict[i + 1]) - 1) * fact_list[N - (i + 2)]) % MOD;
add(dict[i + 1], -1);
}
cout << ans << endl;
cin >> N;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define Rep(i, N) for(int i = 0; i < N; i++)
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define alluniq(x) (x).erase(unique((x).begin(), (x).end()), (x).end())
signed main()
{
vector<int> x, y, d;
int N, K;
int X1[55], Y1[55], D1[55], X2[55], Y2[55], D2[55];
int ans = 0;
cin >> N >> K;
Rep(i, N) {
cin >> X1[i] >> Y1[i] >> D1[i] >> X2[i] >> Y2[i] >> D2[i];
x.pb(X1[i]); x.pb(X2[i]);
y.pb(Y1[i]); y.pb(Y2[i]);
d.pb(D1[i]); d.pb(D2[i]);
}
sort(all(x)); sort(all(y)); sort(all(d));
alluniq(x); alluniq(y); alluniq(d);
Rep(i, x.size() - 1) {
Rep(j, y.size() - 1) {
Rep(k, d.size() - 1) {
int cnt = 0;
Rep(l, N) {
if(X1[l] <= x[i] && x[i + 1] <= X2[l] && Y1[l] <= y[j] && y[j + 1] <= Y2[l] && D1[l] <= d[k] && d[k + 1] <= D2[l]) cnt++;
}
if(cnt >= K) ans += (x[i + 1] - x[i]) * (y[j + 1] - y[j]) * (d[k + 1] - d[k]);
}
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 5005, N = 60;
double f[N][M], p[N];
int a[N], b[N];
int n, r;
inline int ck(double mid) {
for (int i = n - 1; i >= 0; i--) {
for (int j = r + 1; j < M; j++) f[i + 1][j] = mid;
for (int j = 0; j <= r; j++) {
f[i][j] =
min(mid, p[i] / 100.0 * (f[i + 1][j + a[i]] + a[i]) +
(1.0 - p[i] / 100.0) * (f[i + 1][j + b[i]] + b[i]));
}
}
return f[0][0] < mid;
}
int main() {
scanf("%d%d", &n, &r);
for (int i = 0; i < n; i++) {
scanf("%d%d%lf", &a[i], &b[i], &p[i]);
}
double l = 0, r = 1e9, mid = 0;
while (r - l > 1e-10) {
mid = 0.5 * (l + r);
if (ck(mid))
r = mid;
else
l = mid;
}
printf("%.9lf", mid);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = (int)1e9 + 7, inf = 0x7fffffff, dxy[] = {-1, 0, 1, 0, -1};
const long long INF = 1ll << 60;
const double pi = acos(-1), eps = 1e-6;
template <class T>
void rd(T &x) {
x = 0;
char c;
while (c = getchar(), c < 48)
;
do x = (x << 3) + (x << 1) + (c ^ 48);
while (c = getchar(), c > 47);
}
template <class T>
void rec_pt(T x) {
if (!x) return;
rec_pt(x / 10);
putchar(x % 10 ^ 48);
}
template <class T>
void pt(T x) {
if (!x)
putchar('0');
else
rec_pt(x);
}
template <class T>
inline void ptn(T x) {
pt(x), putchar('\n');
}
template <class T>
inline void Max(T &a, T b) {
if (b > a) a = b;
}
template <class T>
inline void Min(T &a, T b) {
if (b < a) a = b;
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
inline void mod_add(int &a, int b, int m = mod) {
if ((a += b) >= m) a -= m;
}
inline void mod_minus(int &a, int b, int m = mod) {
if ((a -= b) < 0) a += m;
}
int fast_mod_pow(int a, int b, int m = mod) {
int res = 1;
for (; b; b >>= 1, a = (long long)a * a % m)
if (b & 1) res = (long long)res * a % m;
return res;
}
inline int calc_inv(int x, int m = mod) { return fast_mod_pow(x, m - 2); }
const int N = (int)2e5 + 5;
int tot_edge, head[N], dep[N], ans = 1, extra, par[N];
bool vis[N];
pair<int, int> edge[N << 1];
void add_edge(int u, int v) {
edge[tot_edge] = pair<int, int>(v, head[u]);
head[u] = tot_edge++;
}
int consider(int u, int v) {
int res = 1;
for (; u != v; u = par[u]) {
if (dep[u] < dep[v]) swap(u, v);
++res;
}
return res;
}
void dfs(int cur, int pre = -1) {
vis[cur] = true;
for (int i = head[cur]; ~i; i = edge[i].second) {
if ((i ^ 1) == pre) continue;
int to = edge[i].first;
if (vis[to]) {
if (dep[to] < dep[cur]) {
int cnt = consider(cur, to);
extra -= cnt;
ans = (long long)ans * (fast_mod_pow(2, cnt) - 2) % mod;
}
} else {
par[to] = cur;
dep[to] = dep[cur] + 1;
dfs(to, i);
}
}
}
int main() {
int n;
rd(n);
memset(head, -1, n + 1 << 2);
for (register int i = (1), _t = (n + 1); i < _t; ++i) {
int to;
rd(to);
add_edge(i, to);
add_edge(to, i);
}
extra = n;
for (register int i = (1), _t = (n + 1); i < _t; ++i)
if (!vis[i]) dfs(i);
ans = (long long)ans * fast_mod_pow(2, extra) % mod;
if (ans < 0) ans += mod;
ptn(ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long ans;
int n;
char s[1000005];
void cal(int l, int k, int r) {
long long L = 0, R = 0;
int i, j;
for (i = k - 1; i >= l; --i) {
if (s[i] == '.') break;
if (isalpha(s[i])) ++L;
}
++k, j = 0;
while (isalnum(s[k])) ++k, ++j;
if (s[k] == '.' && j) {
for (i = k + 1; i <= r; ++i) {
if (!isalpha(s[i])) break;
++R;
}
}
ans += L * R;
}
void work() {
int i;
vector<int> A;
scanf("%s", s + 1);
n = strlen(s + 1);
A.push_back(0);
for (i = 1; i <= n; ++i)
if (s[i] == '@') A.push_back(i);
A.push_back(n + 1);
for (i = 1; i + 1 < A.size(); ++i) cal(A[i - 1] + 1, A[i], A[i + 1] - 1);
cout << ans << endl;
}
int main() {
work();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T a) {
return a < 0 ? (-a) : a;
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
const int MAXN = 55;
const long long MOD = 1000000007;
long long dpc[MAXN][MAXN][2];
int dp[MAXN][MAXN][2];
long long cnk[MAXN][MAXN];
int s1 = 0, s2 = 0;
int W;
queue<pair<pair<int, int>, int> > q, sq;
void Process(int c1, int c2, int side, int step) {
if (dp[c1][c2][side] != -1) return;
dp[c1][c2][side] = step;
int rc1 = c1;
int rc2 = c2;
if (side) {
rc1 = s1 - c1;
rc2 = s2 - c2;
}
int nc1, nc2;
for (int p1 = 0; p1 < (rc1 + 1); ++p1) {
for (int p2 = 0; p2 < (rc2 + 1); ++p2) {
if (p1 + p2 == 0 || p1 * 1 + p2 * 2 > W) continue;
if (!side) {
nc1 = c1 - p1;
nc2 = c2 - p2;
} else {
nc1 = c1 + p1;
nc2 = c2 + p2;
}
if (dp[nc1][nc2][!side] == -1) {
q.push(make_pair(make_pair(nc1, nc2), !side));
} else if (dp[nc1][nc2][!side] == step - 1) {
dpc[c1][c2][side] +=
dpc[nc1][nc2][!side] * ((cnk[rc1][p1] * cnk[rc2][p2]) % MOD) % MOD;
dpc[c1][c2][side] %= MOD;
}
}
}
}
int main() {
int n;
cin >> n;
cin >> W;
W /= 50;
for (int i = 0; i < (n); ++i) {
int a;
cin >> a;
if (a == 50)
++s1;
else
++s2;
}
cnk[0][0] = 1;
for (int i = 1; i < MAXN; ++i) {
cnk[i][0] = 1;
for (int j = 1; j < MAXN; ++j) {
cnk[i][j] = (cnk[i - 1][j - 1] + cnk[i - 1][j]) % MOD;
}
}
fill(&dp[0][0][0], &dp[0][0][0] + MAXN * MAXN * 2, -1);
memset((dpc), 0, sizeof(dpc));
q.push(make_pair(make_pair(0, 0), 1));
dpc[0][0][1] = 1;
int step = 0;
while (!q.empty()) {
swap(q, sq);
while (!sq.empty()) {
int c1 = sq.front().first.first;
int c2 = sq.front().first.second;
int side = sq.front().second;
sq.pop();
Process(c1, c2, side, step);
}
++step;
}
cout << dp[s1][s2][0] << endl;
cout << dpc[s1][s2][0] << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
int n, K;
int mx[3 * N];
int zro[3 * N];
int tab[N];
long long int res = 0LL;
void construct() {
K = 1;
while (K < n) K *= 2;
for (int i = 1; i <= n; ++i) mx[K + i - 1] = tab[i], zro[K + i - 1] = i;
for (int i = K - 1; i >= 1; --i)
mx[i] = max(mx[2 * i], mx[2 * i + 1]),
zro[i] = mx[2 * i] > mx[2 * i + 1] ? zro[2 * i] : zro[2 * i + 1];
}
int ask(int p, int k) {
p += K - 1;
k += K - 1;
int ret = p;
while (p < k) {
if ((p & 1) && mx[p] > mx[ret]) ret = p;
if (!(k & 1) && mx[k] > mx[ret]) ret = k;
p = (p + 1) >> 1;
k = (k - 1) >> 1;
}
if (p == k && mx[p] > mx[ret]) ret = k;
return zro[ret];
}
void solve(int p, int k) {
if (p > k) return;
int now = ask(p, k);
res += 1LL * tab[now] * (k - now + 1) * (now - p + 1);
solve(p, now - 1);
solve(now + 1, k);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &tab[i]);
construct();
solve(1, n);
for (int i = 1; i <= n; ++i) tab[i] *= -1;
construct();
solve(1, n);
printf("%lld\n", res);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
bool mstu[2048];
int mstc[2048];
tuple<int,int,int> edges[2048];
int P[2048],R[2048];
int findS(int u){
if(P[u] != u) P[u] = findS(P[u]);
return P[u];
}
bool mergeS(int x,int y){
x = findS(x);y = findS(y);
if(x == y) return false;
if(R[x] > R[y]) P[y] = x;
else P[x] = y;
if(R[y] == R[x]) R[y] += 1;
return true;
}
int main(){
int N,M;cin>>N>>M;
for(int i=0;i<N;i++) P[i] = i;
long long X;cin>>X;
for(int i=0;i<M;i++){
int u,v,w;cin>>u>>v>>w;
u--;v--;
edges[i] = make_tuple(w,u,v);
}
sort(edges,edges+M);
int idx = 0;
long long total = 0;
while(idx < M){
int currw = get<0>(edges[idx]);
vector<int> to_merge;
while(idx < M && get<0>(edges[idx]) == currw){
int u = get<1>(edges[idx]),v = get<2>(edges[idx]);
to_merge.push_back(idx);
if(findS(u) != findS(v)) mstu[idx] = true;
idx += 1;
}
for(auto x: to_merge){
int u = get<1>(edges[x]), v = get<2>(edges[x]);
if(mergeS(u,v)) total += get<0>(edges[x]);
}
}
if(total == X){
long long ans = 1;
for(int i=0;i<M;i++) ans = ans * 2 % MOD;
long long rem = 2;
for(int i=0;i<M;i++) if(mstu[i] == false) rem = rem * 2 % MOD;
ans = (ans + MOD - rem)%MOD;
cout<<ans<<endl;
}else{
for(int i=0;i<M;i++) if(mstu[i] == false){
for(int j=0;j<N;j++){
P[j] = j;
R[j] = 1;
}
long long ctot = get<0>(edges[i]);
mergeS(get<1>(edges[i]),get<2>(edges[i]));
for(int j=0;j<M;j++){
int u = get<1>(edges[j]),v = get<2>(edges[j]),w = get<0>(edges[j]);
if(mergeS(u,v)) ctot += w;
}
if(ctot == X) mstc[i] = 1;
else if(ctot > X) mstc[i] = 2;
}
long long ans = 2;
for(int i=0;i<M;i++) if(mstc[i] != 0) ans = ans * 2 % MOD;
long long rem = 2;
for(int i=0;i<M;i++) if(mstc[i] == 2) rem = rem * 2 % MOD;
ans = (ans - rem + MOD)%MOD;
cout<<ans<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long x(long long n, long long m) {
string z;
long long ans = n;
while (n) {
z += n % 10 + '0';
n /= 10;
}
for (long long i = 0; i < z.size(); i++) {
ans = ans * 10 + z[i] - '0';
}
ans %= m;
return ans;
}
int main() {
long long n, m, ans = 0;
cin >> n >> m;
for (long long i = 1; i <= n; i++) {
ans += x(i, m);
ans %= m;
}
cout << ans << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int n , a;
int main(){
scanf("%d" , &n);
for(int i = 1; i <= n; i++){
scanf("%d" , &a);
if(a & 1) continue;
if(a % 3 && a % 5){ puts("DENIED"); return 0; }
}
puts("APPROVED");
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(3, "Ofast")
using namespace std;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
return s * w;
}
const int inf = 2e9 + 7;
const long long INF = INT64_MAX;
double eps = 1e-6;
const int mod = 1e9 + 7;
const int N = 1e3 + 10;
const double pi = acos(-1.0);
int s[N][N];
int main() {
int _;
scanf("%d", &_);
while (_--) {
int n, m, res = 0;
scanf("%d", &n);
scanf("%d", &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) scanf("%d", &s[i][j]);
}
if ((n + m) % 2) {
int d = (n + m) / 2;
int now = 1;
int yi, ling;
vector<pair<int, int> > g;
g.clear();
for (int i = 1; i <= m; i++) {
yi = ling = 0;
int x = 1, y = i;
for (int k = 0; k <= 1e9; k++) {
int X = x + k, Y = y - k;
if (X >= 1 && X <= n && Y >= 1 && Y <= m) {
if (s[X][Y] == 1)
yi++;
else
ling++;
} else
break;
}
if (now <= d)
g.push_back({yi, ling});
else
g[d - 1 - (now - d - 1)].first += yi,
g[d - 1 - (now - d - 1)].second += ling;
now++;
}
for (int j = 2; j <= n; j++) {
yi = ling = 0;
int x = j, y = m;
for (int k = 0; k <= 1e9; k++) {
int X = x + k, Y = y - k;
if (X >= 1 && X <= n && Y >= 1 && Y <= m) {
if (s[X][Y] == 1)
yi++;
else
ling++;
} else
break;
}
if (now <= d)
g.push_back({yi, ling});
else
g[d - 1 - (now - d - 1)].first += yi,
g[d - 1 - (now - d - 1)].second += ling;
now++;
}
for (int i = 0; i <= d - 1; i++) res += min(g[i].first, g[i].second);
} else {
int d = (n + m) / 2;
int now = 1;
int yi, ling;
vector<pair<int, int> > g;
g.clear();
for (int i = 1; i <= m; i++) {
yi = ling = 0;
int x = 1, y = i;
for (int k = 0; k <= 1e9; k++) {
int X = x + k, Y = y - k;
if (X >= 1 && X <= n && Y >= 1 && Y <= m) {
if (s[X][Y] == 1)
yi++;
else
ling++;
} else
break;
}
if (now <= d)
g.push_back({yi, ling});
else
g[d - 1 - (now - d)].first += yi, g[d - 1 - (now - d)].second += ling;
now++;
}
for (int j = 2; j <= n; j++) {
yi = ling = 0;
int x = j, y = m;
for (int k = 0; k <= 1e9; k++) {
int X = x + k, Y = y - k;
if (X >= 1 && X <= n && Y >= 1 && Y <= m) {
if (s[X][Y] == 1)
yi++;
else
ling++;
} else
break;
}
if (now <= d)
g.push_back({yi, ling});
else
g[d - 1 - (now - d)].first += yi, g[d - 1 - (now - d)].second += ling;
now++;
}
for (int i = 0; i <= d - 2; i++) res += min(g[i].first, g[i].second);
}
cout << res << '\n';
}
}
| 3 |
#include <bits/stdc++.h>
typedef struct {
int x;
int y;
int i;
} node;
typedef struct {
int l;
int r;
long long s;
int n;
} range;
int a[100000][2][2], f[100000];
range b[100000], v[100000];
int p, q, r;
int s[200000], t[100000];
long long rmq[200000][2];
int cmp(const void *a, const void *b) {
if (((node *)a)->x != ((node *)b)->x) {
return ((node *)a)->x - ((node *)b)->x;
} else {
return ((node *)a)->y - ((node *)b)->y;
}
}
int cmp2(const void *a, const void *b) { return *((int *)a) - *((int *)b); }
int binary_search(int x) {
int l = -1, r = q, m = (l + r) / 2;
while (r - l > 1) {
if (v[m].l <= x) {
l = m;
m = (l + r) / 2;
} else {
r = m;
m = (l + r) / 2;
}
}
return l;
}
int binary_search2(int x) {
int l = -1, r = q, m = (l + r) / 2;
while (r - l > 1) {
if (v[m].r >= x) {
r = m;
m = (l + r) / 2;
} else {
l = m;
m = (l + r) / 2;
}
}
return r;
}
int minimum(int a, int b) {
if (a < b) {
return a;
} else {
return b;
}
}
int maximum(int a, int b) {
if (a > b) {
return a;
} else {
return b;
}
}
void make(int x, int l1, int r1, int l2, int r2, int key) {
if (f[a[x][0][1]] == 0) {
b[p].l = key;
b[p].r = r1;
b[p++].s = a[x][0][0];
s[r++] = key;
s[r++] = r1;
;
if (l1 > minimum(key, l2)) {
b[p].l = minimum(key, l2);
b[p].r = l1;
b[p++].s = a[x][0][0];
s[r++] = minimum(key, l2);
s[r++] = l1;
}
} else {
make(a[x][0][1], l1, key, minimum(key, l2), r1, a[x][0][0]);
}
if (f[a[x][1][1]] == 0) {
b[p].l = l1;
b[p].r = key;
b[p++].s = a[x][1][0];
s[r++] = l1;
s[r++] = key;
if (r1 < maximum(key, r2)) {
b[p].l = r1;
b[p].r = maximum(key, r2);
b[p++].s = a[x][1][0];
s[r++] = r1;
s[r++] = maximum(key, r2);
}
} else {
make(a[x][1][1], key, r1, l1, maximum(key, r2), a[x][1][0]);
}
}
void add(int a, int b, int k, int x, int l, int r) {
if (r <= a || b <= l) return;
if (a <= l && b >= r) {
rmq[k][0] += x;
rmq[k][1]++;
} else {
add(a, b, k * 2 + 1, x, l, (l + r) / 2);
add(a, b, k * 2 + 2, x, (l + r) / 2, r);
}
}
int main() {
int n, k, i, j;
node c[100000];
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d %d", &c[i].x, &c[i].y);
c[i].i = i + 1;
}
qsort(c, n, sizeof(node), cmp);
for (i = 1; i < n; i += 2) {
f[c[i].x] = 1;
a[c[i].x][0][0] = c[i].y;
a[c[i].x][0][1] = c[i].i;
a[c[i].x][1][0] = c[i + 1].y;
a[c[i].x][1][1] = c[i + 1].i;
}
make(c[0].i, 0, 1e9, 1e9, 0, c[0].y);
s[r++] = 0;
s[r++] = 1e9;
qsort(s, r, sizeof(int), cmp2);
for (i = 0; i < r; i++) {
t[q++] = s[i];
for (j = i + 1; j < r; j++) {
if (s[i] != s[j]) break;
}
i = j - 1;
}
for (i = 0; i < q - 1; i++) {
v[i].l = t[i];
v[i].r = t[i + 1];
v[i].s = v[i].n = 0;
}
q--;
n = 1;
while (n < q) n *= 2;
for (i = 0; i < p; i++) {
int l = binary_search(b[i].l);
int r = binary_search2(b[i].r);
add(l, r + 1, 0, b[i].s, 0, n);
}
for (i = 0; i < q; i++) {
j = i + n - 1;
while (j > 0) {
v[i].s += rmq[j][0];
v[i].n += rmq[j][1];
j = (j - 1) / 2;
}
}
scanf("%d", &k);
for (i = 0; i < k; i++) {
int x, y;
scanf("%d", &x);
y = binary_search2(x);
printf("%.9lf\n", (double)v[y].s / v[y].n);
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n;
cin>>n;
string s;
int a=0,b=0,c=0,d=0;
while(n--){
cin>>s;
if(s=="AC") a++;
else if(s=="WA") b++;
else if(s=="TLE") c++;
else d++;
}
cout<<"AC x "<<a<<endl;
cout<<"WA x "<<b<<endl;
cout<<"TLE x "<<c<<endl;
cout<<"RE x "<<d;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
int cnt;
char s[110];
cin >> a >> s;
int len = strlen(s);
for (int i = len - 1; i >= len - 4; i--) {
if (s[i] == 'e') {
cnt = len - 1 - i;
if (cnt == 3) {
b = (s[i + 1] - '0') * 100 + (s[i + 2] - '0') * 10 +
(s[i + 3] - '0') * 1;
break;
} else if (cnt == 2) {
b = (s[i + 1] - '0') * 10 + (s[i + 2] - '0');
break;
} else {
b = s[i + 1] - '0';
break;
}
}
}
int n;
if (b == len - cnt - 2) {
cout << a;
n = 0;
for (int i = len - cnt - 2;; i--) {
if (s[i] == '0' || s[i] == '.')
n++;
else
break;
}
for (int i = 1; i < len - cnt - 1 - n; i++) cout << s[i];
cout << endl;
} else if (b > len - cnt - 2) {
int oo = b + 1 - (len - 1 - cnt);
cout << a;
for (int i = 1; i < len - cnt - 1; i++) cout << s[i];
for (int i = 0; i < oo; i++) cout << 0;
cout << endl;
} else {
for (int i = 0; i < b; i++) {
s[i] = s[i + 1];
}
s[b] = '.';
cout << a;
n = 0;
for (int i = len - cnt - 2;; i--) {
if (s[i] == '0' || s[i] == '.')
n++;
else
break;
}
for (int i = 0; i < len - cnt - 1 - n; i++) cout << s[i];
cout << endl;
}
return 0;
}
| 2 |
#include<iostream>
#include<cstring>
using namespace std;
int main()
{
int n,m,i,x,y;
int a[110];
cin>>n>>m;
memset(a,0,sizeof(a));
for(i=0;i<m;i++)
{
cin>>x>>y;
a[x]++;
a[y]++;
}
for(i=1;i<=n;i++)
cout<<a[i]<<endl;
return 0;
}
| 0 |
#include <iostream>
#include <algorithm>
using namespace std;
int n;
char sq[1000][1000];
int dp[1000][1000];
int solve(){
int ans = 0;
for(int i = 0;i < n;i++){
dp[0][i] = (sq[0][i] == '*' ? 0 : 1);
dp[i][0] = (sq[i][0] == '*' ? 0 : 1);
}
for(int y = 1;y < n;y++){
for(int x = 1;x < n;x++){
if(sq[y][x] == '*') dp[y][x] = 0;
else {
dp[y][x] = min({ dp[y-1][x], dp[y][x-1], dp[y-1][x-1] }) + 1;
ans = max(ans, dp[y][x]);
}
}
}
return ans;
}
int main(){
while(cin >> n, n != 0){
for(int i = 0;i < n;i++){
for(int j = 0;j < n;j++){
cin >> sq[i][j];
}
}
cout << solve() << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long k, p, n = 2, ans;
vector<long long> zcy;
int main() {
cin >> k >> p;
for (int i = 1; i <= 9; i++) {
zcy.push_back(i * 10 + i);
}
for (int i = 1; i <= 9; i++) {
for (int j = 0; j <= 9; j++) {
zcy.push_back(i * 1000 + i + j * 100 + j * 10);
}
}
for (int i = 1; i <= 9; i++) {
for (int j = 0; j <= 9; j++) {
for (int h = 0; h <= 9; h++) {
zcy.push_back(i * 100000 + i + j * 10000 + j * 10 + h * 1000 + h * 100);
}
}
}
for (int i = 1; i <= 9; i++) {
for (int j = 0; j <= 9; j++) {
for (int h = 0; h <= 9; h++) {
for (int l = 0; l <= 9; l++) {
zcy.push_back(i * 10000000 + i + j * 1000000 + j * 10 + h * 100000 +
h * 100 + l * 10000 + l * 1000);
}
}
}
}
for (int i = 1; i <= 9; i++) {
for (int j = 0; j <= 9; j++) {
for (int h = 0; h <= 9; h++) {
for (int l = 0; l <= 9; l++) {
for (int m = 0; m <= 9; m++) {
zcy.push_back(i * 1000000000 + i + j * 100000000 + j * 10 +
h * 10000000 + h * 100 + l * 1000000 + l * 1000 +
m * 100000 + m * 10000);
}
}
}
}
}
for (int i = 1; i <= 9; i++) {
for (int j = 0; j <= 9; j++) {
for (int h = 0; h <= 9; h++) {
for (int l = 0; l <= 9; l++) {
for (int m = 0; m <= 9; m++) {
for (int q = 0; q <= 9; q++) {
zcy.push_back(i * 100000000000 + i + j * 10000000000 + j * 10 +
h * 1000000000 + h * 100 + l * 100000000 +
l * 1000 + m * 10000000 + m * 10000 + q * 1000000 +
q * 100000);
}
}
}
}
}
}
for (int i = 0; i < k; i++) ans += zcy[i];
cout << ans % p;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 10;
bool b(long long a, long long b, long long c) {
return c <= min(a, b) || c >= max(a, b);
}
int main() {
long long x1, y1, x2, y2, x3, y3;
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
if ((x1 == x2 && x2 == x3) || (y1 == y2 && y2 == y3))
printf("1");
else if ((x1 == x2 && b(y1, y2, y3)) || (x1 == x3 && b(y1, y3, y2)) ||
(x3 == x2 && b(y3, y2, y1)) || (y1 == y2 && b(x1, x2, x3)) ||
(y1 == y3 && b(x1, x3, x2)) || (y3 == y2 && b(x3, x2, x1)))
printf("2");
else
printf("3");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct recta {
int x1, x2;
int y1, y2;
} a[6];
int n;
int main() {
scanf("%d", &n);
for (int p = (0); p <= (n - 1); p += (1))
scanf("%d%d%d%d", &a[p].x1, &a[p].y1, &a[p].x2, &a[p].y2);
int lwx = 1e6, lwy = 1e6;
int gtx = -1, gty = -1, s = 0;
for (int p = (0); p <= (n - 1); p += (1)) {
s += (a[p].x2 - a[p].x1) * (a[p].y2 - a[p].y1);
if (a[p].x1 < lwx) lwx = a[p].x1;
if (a[p].x2 > gtx) gtx = a[p].x2;
if (a[p].y1 < lwy) lwy = a[p].y1;
if (a[p].y2 > gty) gty = a[p].y2;
}
if ((gtx - lwx) == (gty - lwy) && s == (gtx - lwx) * (gty - lwy)) {
printf("YES");
return 0;
}
printf("NO");
return 0;
}
| 1 |
#include<iostream>
using namespace std;
int dp[5001];
int item[] = {200, 300, 500, 1000, 1200, 1500};
int price[] = {380, 550, 850, 1520, 1870, 2244};
int main()
{
for(int i = 0; i < 5001; i++)
dp[i] = 10000000;
dp[0] = 0;
for(int j = 0; j < 6; j++)
{
for(int i = 0; i < 5001; i += 100)
{
if(i + item[j] > 5000)
continue;
dp[i + item[j]] = min(dp[i + item[j]], dp[i] + price[j]);
}
}
while(true)
{
int n;
cin >> n;
if(!n)
break;
cout << dp[n] << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char a[] = {'v', '<', '^', '>'};
int main() {
char t1, t2;
scanf("%c %c", &t1, &t2);
int pos, n;
scanf("%d", &n);
for (int i = 0; i < 4; i++) {
if (a[i] == t1) {
pos = i;
break;
}
}
int tt = n % 4;
int a1 = (tt + pos) % 4, a2 = (pos - tt + 4) % 4;
if (a[a1] == t2 && a1 != a2)
puts("cw");
else if (a[a2] == t2 && a1 != a2)
puts("ccw");
else
puts("undefined");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int mod, k, a, b;
struct matrix {
long long int a, b, c, d;
matrix(long long int x, long long int y, long long int z, long long int w)
: a(x), b(y), c(z), d(w) {}
matrix operator*(const matrix &m) const {
return matrix(((a * m.a) % mod + (b * m.c) % mod) % mod,
((a * m.b) % mod + (b * m.d) % mod) % mod,
((c * m.a) % mod + (d * m.c) % mod) % mod,
((c * m.b) % mod + (d * m.d) % mod) % mod);
}
};
inline long long int F(long long int n) {
matrix fib(1, 1, 1, 0), id(1, 0, 0, 1);
while (n) {
if (n & 1ll) id = id * fib;
fib = fib * fib;
n >>= 1;
}
return id.b;
}
inline long long int nm(long long int d) {
if (d == 0) return 0;
long long int ans = b / d - (a - 1) / d;
return ans;
}
int main() {
cin >> mod >> a >> b >> k;
long long int greatest_i = 1, nm_i, nm_bi;
for (long long int i = ceil(sqrt((long double)b)) + 1; i > 0; --i) {
if (nm(i) - k >= 0 && i > greatest_i)
greatest_i = i;
else if (nm(b / i) - k >= 0 && b / i > greatest_i)
greatest_i = b / i;
}
cout << F(greatest_i) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
string s;
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
p;
bool vis[200010];
int dis[200010];
int dec(int x) {
if (x == 0)
return n - 1;
else
return --x;
}
int inc(int x) {
if (x == n - 1)
return 0;
else
return ++x;
}
int inc1(int x, int u) { return (x + u) % n; }
int dec1(int x, int u) { return (n + x - u) % n; }
void bfs(int x) {
int u = inc(x);
if (!vis[u]) {
dis[u] = dis[x] + 1;
vis[u] = 1;
p.push({dis[u], u});
}
int v = dec(x);
if (!vis[v]) {
dis[v] = dis[x] + 1;
vis[v] = 1;
p.push({dis[v], v});
}
}
int main() {
cin >> n >> k >> s;
for (int i = 0; i < n; i++) {
int u = inc(i), v = dec(i);
if (s[i] == s[u] || s[i] == s[v]) {
vis[i] = 1;
p.push({0, i});
}
}
while (p.size()) {
auto x = p.top();
p.pop();
bfs(x.second);
}
for (int i = 0; i < n; i++) {
if (dis[i] <= k) {
int v = inc1(i, dis[i]);
if (dis[v] == 0)
cout << s[v];
else {
v = dec1(i, dis[i]);
cout << s[v];
}
} else {
if (k & 1) {
if (s[i] == 'W') {
cout << "B";
} else
cout << 'W';
} else
cout << s[i];
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.14159265358979323846;
const long long MODUL = 1000000007;
const long long MAXINT = 2e9 + 2;
const long long MAXLL = 2e18 + 2;
const double eps = 1e-11;
const int MAXN = 5e5 + 10;
struct ver {
int h, com;
vector<int> edges;
};
ver mas[1000], mas1[1000];
int main() {
ios_base::sync_with_stdio(0);
int ans(-1), n, m, a, b, wave[1000], wsi(1), ma, csi(0), loc(0), n1;
bool f;
cin >> n >> m;
for (int i(0); i < m; ++i) {
cin >> a >> b;
--a, --b;
mas1[a].edges.push_back(b);
mas1[b].edges.push_back(a);
}
for (int i(0); i < n; ++i) mas1[i].com = -1;
for (int t(0); t < n; ++t)
if (mas1[t].com == -1) {
mas1[t].com = csi;
wave[0] = t;
wsi = 1;
for (int i(0); i < wsi; ++i) {
int fw = wave[i], to;
for (int j(0); j < mas1[fw].edges.size(); ++j) {
to = mas1[fw].edges[j];
if (mas1[to].com == -1) mas1[to].com = csi, wave[wsi++] = to;
}
}
++csi;
}
n1 = n;
for (int k(0); k < csi; ++k) {
ans = -1;
for (int i(0); i < n1; ++i)
if (mas1[i].com == k)
mas[i] = mas1[i];
else
mas[i].com = -1;
for (int t(0); t < n; ++t) {
if (mas[t].com == -1) continue;
ma = f = 0;
for (int i(0); i < n; ++i) mas[i].h = -1;
mas[t].h = 0;
wave[0] = t;
wsi = 1;
for (int i(0); i < wsi && !f; ++i) {
int fw = wave[i], to;
for (int j(0); j < mas[fw].edges.size(); ++j) {
to = mas[fw].edges[j];
if (mas[to].h == mas[fw].h) {
f = 1;
break;
}
if (mas[to].h == -1) {
mas[to].h = mas[fw].h + 1;
wave[wsi++] = to;
ma = max(ma, mas[to].h);
}
}
}
if (!f) ans = max(ans, ma);
}
if (ans == -1) {
cout << -1;
return 0;
}
loc += ans;
}
cout << loc;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using std::function;
void decouple() { ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0); }
void solve() {
int c, r;
cin >> c >> r;
int first[2] = {-1}, t = 0;
vector<vector<char>> f(c, vector<char>(r));
for (int i = 0; i < c; i++) {
for (int j = 0; j < r; j++) {
cin >> f[i][j];
if (f[i][j] == 'B') t += 1;
if (f[i][j] == 'B' and first[0] == -1) first[0] = i, first[1] = j;
}
}
cout << (int)(first[0] + sqrt(t) / 2 + 1);
cout << " " << (int)(first[1] + sqrt(t) / 2 + 1) << '\n';
}
int main() {
decouple();
solve();
return 0;
}
| 1 |
#include <iostream>
#include <vector>
#include <map>
#include <queue>
#include <algorithm>
using namespace std;
typedef pair<int,int> P;
struct edge{
int to, d, c;
edge(int to_, int d_, int c_){
to = to_; d = d_; c = c_;
}
edge(){}
};
const int INF = 1e+8;
const int MAX_N = 10001;
int N, M;
vector<edge> G[MAX_N];
vector<int> from[MAX_N];
map<P,int> es;
int d[MAX_N];
void add_edge(int u, int v, int d, int c){
G[u].push_back( edge(v, d, c) );
G[v].push_back( edge(u, d, c) );
es[P(u,v)] = es[P(v,u)] = c;
}
void dijkstra(){
fill(d, d+MAX_N, INF);
priority_queue<P, vector<P>, greater<P> > q;
q.push( P(0, 0) );
d[0] = 0;
while( !q.empty() ){
int dist = q.top().first;
int v = q.top().second;
q.pop();
if( d[v] < dist ) continue;
for(int i=0 ; i < G[v].size() ; i++ ){
int to = G[v][i].to;
int next_dist = G[v][i].d + dist;
if( next_dist < d[to] ){
from[to].clear();
from[to].push_back( v );
d[to] = next_dist;
q.push( P(next_dist, to) );
}else if( next_dist == d[to] ){
from[to].push_back( v );
q.push( P(next_dist, to) );
}
}
}
}
int solve(){
int res = 0;
for(int v=0 ; v < N ; v++ ){
int cost = INF;
for(int i=0 ; i < from[v].size() ; i++ ){
cost = min(cost, es[P(from[v][i], v)] );
}
if( cost != INF ){
res += cost;
}
}
return res;
}
int main(){
while( cin >> N >> M , N || M ){
// テ・ツ按敕ヲツ慊淌・ツ個?
es.clear();
for(int i=0 ; i < MAX_N ; i++ ){
G[i].clear();
from[i].clear();
}
for(int i=0 ; i < M ; i++ ){
int u, v, d, c;
cin >> u >> v >> d >> c;
u--, v--;
add_edge(u, v, d, c);
}
dijkstra();
cout << solve() << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int k;
struct node {
int mn[12], mx[12];
bool operator<(const node &b) const {
int i;
for (i = 1; i <= k; i++)
if (mx[i] > b.mn[i]) return false;
return true;
}
int c;
} a[50010];
set<node> s;
set<node>::iterator it1, it2, itm;
int main() {
int n, i, j;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++) {
for (j = 1; j <= k; j++) {
scanf("%d", &a[i].mn[j]);
a[i].mx[j] = a[i].mn[j];
}
a[i].c = 1;
}
for (i = 1; i <= n; i++) {
it1 = s.lower_bound(a[i]);
it2 = s.upper_bound(a[i]);
node t = a[i];
for (; it1 != it2;) {
for (j = 1; j <= k; j++) {
t.mn[j] = min(t.mn[j], it1->mn[j]);
t.mx[j] = max(t.mx[j], it1->mx[j]);
}
t.c += it1->c;
itm = it1;
it1++;
s.erase(itm);
}
s.insert(t);
printf("%d\n", (--s.end())->c);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
long long a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long ans = 0;
for (long long i = 1; i < n; i++) {
if (a[i] < a[i - 1]) {
ans += a[i - 1] - a[i];
}
}
cout << ans;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<long long, int> st;
int main() {
long long n, i, j, k, l;
scanf("%lld", &n);
if (n <= 11) {
st.clear();
long long ans;
for (i = 0; i <= n; i++) {
for (j = 0; j <= n - i; j++) {
for (k = 0; k <= n - j - i; k++) {
l = n - j - i - k;
if (l < 0) {
break;
}
ans = 50 * i + 10 * j + 5 * k + l;
st[ans]++;
}
}
}
printf("%d", st.size());
} else {
printf("%lld", 292 + (n - 11) * (long long)(49));
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int trie[505][10];
char str[5000];
int cnt[5000];
int Cur = 1;
void insert(int m) {
int n = strlen(str);
int cur = 0;
for (int i = 0; i < n; i++) {
int d = str[i] - '0';
if (trie[cur][d] == 0) trie[cur][d] = Cur++;
cur = trie[cur][d];
}
cnt[cur] += m;
}
int dp[505][501][11][10];
int rec(int node, int len, int roise, int pos) {
if (roise < 0) return 1000000007;
if (pos > 9) return cnt[node] * len;
int &ans = dp[node][len][roise][pos];
if (ans != -1) return ans;
ans = rec(node, 0, roise - 1, 0);
int f = 0;
int f2 = 0;
for (int i = 0; i < 10; i++)
if (trie[node][i]) f2 = 1;
if (!f2) return ans = roise ? 0 : cnt[node] * len;
for (int i = 0; i <= roise; i++) {
if (trie[node][pos]) {
ans = min(ans, rec(trie[node][pos], len + 1, i, 0) +
rec(node, len, roise - i, pos + 1));
f = 1;
}
}
if (!f) ans = min(ans, rec(node, len, roise, pos + 1));
f = 0;
return ans;
}
int main() {
int k;
int n;
memset(dp, -1, sizeof dp);
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) {
int m;
scanf("%s %d", str, &m);
insert(m);
}
printf("%d\n", rec(0, 0, k, 0));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
bool prime[1000001];
long long spf[10000001];
long long f[300005];
long long pow1(long long x, long long y) {
long long res = 1;
x = x % mod;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
long long divide(long long n) { return pow1(n, mod - 2); }
long long ncr(long long n, long long r) {
if (n < r) return 0;
return (f[n] * ((divide(f[r]) * divide(f[n - r])) % mod)) % mod;
}
void sieve() {
memset(prime, true, sizeof(prime));
for (long long i = 2; i * i <= 1000000; i++)
if (prime[i])
for (long long j = i * i; j <= 1000000; j += i) prime[j] = false;
prime[0] = prime[1] = false;
}
void fastsieve() {
spf[1] = 1;
for (int i = 2; i <= 1e7; i++) spf[i] = i;
for (int i = 4; i <= 1e7; i += 2) spf[i] = 2;
for (int i = 3; i * i <= 1e7; i++) {
if (spf[i] == i) {
for (int j = i * i; j <= 1e7; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
vector<long long> factorize(long long n) {
long long count = 0;
vector<long long> fac;
while (!(n % 2)) {
n >>= 1;
count++;
}
if (count % 2) fac.push_back(2ll);
for (long long i = 3; i <= sqrt(n); i += 2) {
count = 0;
while (n % i == 0) {
count++;
n = n / i;
}
if (count % 2) fac.push_back(i);
}
if (n > 2) fac.push_back(n);
return fac;
}
vector<long long> fastfactorize(long long n) {
vector<long long> v;
long long prev = 0, cnt = 0;
while (n != 1) {
if (prev == spf[n])
cnt++;
else {
if (cnt % 2) v.push_back(prev);
cnt = 1;
prev = spf[n];
}
n /= spf[n];
if (n == 1) {
if (cnt % 2) v.push_back(prev);
cnt = 1;
prev = spf[n];
}
}
return v;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, m, i, j;
cin >> n >> m;
long long cnt[n + 1], val[n + 1];
memset(cnt, 0, sizeof(cnt));
for (i = 0; i <= n; i++) val[i] = 1e18;
for (i = 1; i <= m; i++) {
long long x, y;
cin >> x >> y;
cnt[x]++;
val[x] = min(val[x], (y - x + n) % n);
}
for (i = 1; i <= n; i++) {
long long ans = 0;
for (j = 1; j <= n; j++) {
if (!cnt[j]) continue;
ans = max(ans, (j - i + n) % n + n * (cnt[j] - 1) + val[j]);
}
cout << ans << " ";
}
return 0;
}
| 1 |
#include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
int main() {
int d, e;
while (cin >> d >> e && d + e) {
int x, y;
double ans = 1e5;
for (x = 0; x <= d; ++x) {
y = d - x;
ans = min(ans, abs(sqrt(x * x + y * y) - ( double) e));
}
printf("%.10f\n", ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 10, M = 1e3 + 10, K = 1e6 + 10;
priority_queue<long long> q;
int n, m, k, p;
int a[N][M];
long long l[K], r[K];
long long ans = -0x7f7f7f7f7f7f7f7f;
void inp() {
cin >> n >> m >> k >> p;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
}
void init() {
for (int i = 1; i <= n; i++) {
long long sum = 0;
for (int j = 1; j <= m; j++) sum += a[i][j];
q.push(sum);
}
for (int i = 1; i <= k; i++) {
long long t = q.top();
q.pop();
l[i] = l[i - 1] + t;
t -= p * m;
q.push(t);
}
while (!q.empty()) q.pop();
for (int i = 1; i <= m; i++) {
long long sum = 0;
for (int j = 1; j <= n; j++) sum += a[j][i];
q.push(sum);
}
for (int i = 1; i <= k; i++) {
int t = q.top();
q.pop();
r[i] = r[i - 1] + t;
t -= p * n;
q.push(t);
}
}
void solve() {
for (int i = 0; i <= k; i++)
ans = max(ans, (long long)r[i] + l[k - i] - (long long)i * p * (k - i));
}
void print() { cout << ans; }
int main() {
inp();
init();
solve();
print();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 998244353ll;
const long long int P = 1000000007ll;
const long long int N = 300005ll;
bool cmp(long long int x, long long int y) { return x > y; }
void solve() {
long long int n, x;
cin >> n >> x;
vector<long long int> a(n);
for (long long int i = (0); i <= (n - 1); ++i) cin >> a[i];
double ans = 0;
for (long long int i = (0); i <= (n - 2); ++i) {
long long int pos = upper_bound(a.begin(), a.end(), a[i] + x) - a.begin();
double t = 0;
if (pos > i + 2) t = (a[pos - 1] - a[i + 1]) / (double)(a[pos - 1] - a[i]);
ans = max(ans, t);
}
cout << setprecision(9) << fixed;
if (ans == 0)
cout << -1;
else
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1001;
int n, m, tmp;
int isPrime(int n) {
for (int i = 2; i < n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = n + 1; i <= m; i++) {
if (isPrime(i)) {
tmp = i;
break;
}
}
tmp == m ? puts("YES") : puts("NO");
return 0;
}
| 1 |
#include <iostream>
#include <complex>
#include <sstream>
#include <string>
#include <algorithm>
#include <deque>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <vector>
#include <set>
#include <limits>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <ctime>
using namespace std;
#define REP(i, j) for(int i = 0; i < (int)(j); ++i)
#define FOR(i, j, k) for(int i = (int)(j); i < (int)(k); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define REVERSE(v) reverse((v).begin(), (v).end())
typedef complex<double> P;
//typedef pair<double, double> P;
#define X real()
#define Y imag()
#define curr(P, i) P[i]
#define next(P, i) P[(i+1)%P.size()]
#define prev(P, i) P[(i+P.size()-1) % P.size()]
#define diff(P, i) (next(P, i) - curr(P, i))
const double EPS = 1e-8;
const double INF = 1e12;
namespace std {
bool operator < (const P& a, const P& b) {
return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
}
}
typedef vector<P> G;
double compare_x(const P &a, const P &b){
return a.X != b.X ? a.X < b.X : a.Y < b.Y;
}
double compare_y(const P &a, const P &b){
return a.Y != b.Y ? a.Y < b.Y : a.X < b.X;
}
double length_of_the_nearest_point_to(P a[100000], int n){
if(n<=1)return 999999999.9;
int m=n/2;
double x=a[m].X;
double d=min(length_of_the_nearest_point_to(a, m), length_of_the_nearest_point_to(a+m, n-m));
sort(a, a+n, compare_y);
vector<P> b;
for(int i=0; i<n; i++){
if(fabs(a[i].X-x)>=d)continue;
for(int j=0; j<b.size(); j++){
double dx=a[i].X-b[b.size()-j-1].X;
double dy=a[i].Y-b[b.size()-j-1].Y;
if(dy>=d)break;
d=min(d,sqrt(dx*dx+dy*dy));
}
b.push_back(a[i]);
}
return d;
}
int main() {
int N; cin >>N;
G g(N);
REP(i, N){
double x, y; cin >>x >>y;
g[i] = P(x, y);
}
sort(g.begin(), g.end(), compare_x);
printf("%.10lf\n", length_of_the_nearest_point_to(&g[0], N));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<long long>;
template <typename T>
std::istream &operator>>(std::istream &input, std::pair<T, T> &data) {
input >> data.first >> data.second;
return input;
}
template <typename T>
std::istream &operator>>(std::istream &input, std::vector<T> &data) {
for (T &first : data) input >> first;
return input;
}
template <typename T>
std::ostream &operator<<(std::ostream &output, const pair<T, T> &data) {
output << "(" << data.first << "," << data.second << ")";
return output;
}
template <typename T>
std::ostream &operator<<(std::ostream &output, const std::vector<T> &data) {
for (const T &first : data) output << first << " ";
return output;
}
std::ostream &operator<<(std::ostream &output, const __int128 &first) {
__int128 n = first;
if (n == 0) {
output << "0";
return output;
}
if (n < 0) {
n = -n;
output << "-";
}
string s;
while (n) {
s += '0' + (n % 10);
n /= 10;
}
reverse(s.begin(), s.end());
cout << s;
return output;
}
long long div_up(long long a, long long b) {
return a / b + ((a ^ b) > 0 && a % b);
}
long long div_down(long long a, long long b) {
return a / b - ((a ^ b) < 0 && a % b);
}
long long math_mod(long long a, long long b) { return a - b * div_down(a, b); }
template <class T>
using V = vector<T>;
template <class T>
bool ckmin(T &a, const T &b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
long long gcd(long long a, long long b) {
while (b) {
tie(a, b) = make_pair(b, a % b);
}
return a;
}
long long Bit(long long mask, long long bit) { return (mask >> bit) & 1; }
const long double PI = 4 * atan(1.);
const long double eps = 1e-10;
bool eq(long double first, long double second) {
return abs(first - second) < eps;
}
bool ls(long double first, long double second) {
return first < second && !eq(first, second);
}
bool lseq(long double first, long double second) {
return first < second || eq(first, second);
}
long long sgn(long double first) {
if (eq(first, 0)) return 0;
if (first > 0)
return 1;
else
return -1;
}
long double sqr(long double first) { return first * first; }
long double readLD() {
double first;
scanf("%lf", &first);
return first;
}
struct Point {
long double first, second;
Point() : first(), second() {}
Point(long double _x, long double _y) : first(_x), second(_y) {}
void scan() {
first = readLD();
second = readLD();
}
void print() { printf("%.13lf %.13lf\n", (double)first, (double)second); }
Point operator+(const Point &a) const {
return Point(first + a.first, second + a.second);
}
Point operator-(const Point &a) const {
return Point(first - a.first, second - a.second);
}
Point operator*(const long double &k) const {
return Point(first * k, second * k);
}
Point operator/(const long double &k) const {
return Point(first / k, second / k);
}
long double operator%(const Point &a) const {
return first * a.first + second * a.second;
}
long double operator*(const Point &a) const {
return first * a.second - second * a.first;
}
long double sqrLen() const { return *this % *this; }
long double len() const { return sqrtl(sqrLen()); }
Point norm() const { return *this / len(); }
Point ort() const { return Point(-second, first); }
Point rot(const long double &ca, const long double &sa) const {
return *this * ca + ort() * sa;
}
Point rot(const long double &ang) const { return rot(cosl(ang), sinl(ang)); }
bool operator==(const Point &a) const {
return eq(first, a.first) && eq(second, a.second);
}
bool operator<(const Point &a) const {
if (!eq(first, a.first)) return first < a.first;
return ls(second, a.second);
}
};
long double getAngle(Point v, Point u) { return atan2l(v * u, v % u); }
bool onLine(Point A, Point B, Point C) { return eq((A - B) * (A - C), 0); }
bool onSegm(Point A, Point B, Point C) { return lseq((A - B) % (C - B), 0); }
bool intersectLines(Point A, Point a, Point B, Point b, Point &I) {
if (eq(a * b, 0)) return false;
long double second = ((A - B) * a) / (b * a);
I = B + b * second;
return true;
}
Point getH(Point P, Point A, Point a) {
return A + a * (((P - A) % a) / a.sqrLen());
}
bool intersectLineCircle(Point A, Point a, Point O, long double R, Point &I1,
Point &I2) {
Point H = getH(O, A, a);
long double h = (O - H).len();
if (ls(R, h)) return false;
if (eq(R, h)) {
I1 = I2 = H;
return true;
}
long double first = sqrtl(sqr(R) - sqr(h));
a = a.norm();
I1 = H + a * first;
I2 = H - a * first;
return true;
}
bool intersectCircles(Point O1, long double R1, Point O2, long double R2,
Point &I1, Point &I2) {
if (R1 < R2) {
swap(R1, R2);
swap(O1, O2);
}
long double L = (O1 - O2).len();
if (ls(R1 + R2, L) || ls(L, R1 - R2) || eq(L, 0)) return false;
if (eq(R1 + R2, L) || eq(L, R1 - R2)) {
I1 = I2 = O1 + (O2 - O1).norm() * R1;
return true;
}
long double first = (sqr(L) + sqr(R1) - sqr(R2)) / (2 * L);
Point a = (O2 - O1).norm();
Point H = O1 + a * first;
a = a.ort() * sqrtl(sqr(R1) - sqr(first));
I1 = H + a;
I2 = H - a;
return true;
}
bool insidePolygon(Point P, const vector<Point> &a) {
for (long long i = 0; i < (long long)a.size() - 1; i++) {
if (onLine(a[i], P, a[i + 1]) && onSegm(a[i], P, a[i + 1])) {
return true;
}
}
long double ang = 0;
for (long long i = 0; i < (long long)a.size() - 1; i++)
ang += getAngle(a[i] - P, a[i + 1] - P);
return abs(ang) > 1;
}
long double polygonArea(const vector<Point> &a) {
long double S = 0;
for (long long i = 0; i < (long long)a.size() - 1; i++) S += a[i] * a[i + 1];
return abs(S) / 2;
}
bool cmp(const Point &v, const Point &u) {
long double first = v * u;
if (!eq(first, 0)) return first > 0;
return ls(v.sqrLen(), u.sqrLen());
}
vector<Point> graham(vector<Point> a) {
Point minP = a[0];
for (long long i = 0; i < (long long)a.size(); i++) {
minP = min(minP, a[i]);
}
for (long long i = 0; i < (long long)a.size(); i++) a[i] = a[i] - minP;
sort(a.begin(), a.end(), cmp);
for (long long i = 0; i < (long long)a.size(); i++) a[i] = a[i] + minP;
long long m = 0;
for (Point P : a) {
while (m > 2 && lseq(0, (P - a[m - 1]) * (P - a[m - 2]))) {
m--;
}
a[m++] = P;
}
a.resize(m);
return a;
}
bool tangentsFromPoint(Point P, Point O, long double R, Point &I1, Point &I2) {
long double L = (P - O).len();
if (lseq(L, R)) return false;
long double ang = acosl(R / L);
Point a = (P - O).norm() * R;
I1 = O + a.rot(ang);
I2 = O + a.rot(-ang);
return true;
}
long double distPointSegment(Point A, Point P, Point Q) {
Point H = getH(A, P, Q - P);
if (onSegm(P, H, Q))
return (A - H).len();
else
return min((A - P).len(), (A - Q).len());
}
bool onSameSide(Point P, Point Q, Point A, Point a) {
return sgn(a * (P - A)) * sgn(a * (Q - A)) == 1;
}
bool intersectSegments(Point A, Point B, Point C, Point D) {
if (eq(0, (A - B) * (C - D))) {
if (!onLine(A, B, C)) return false;
Point a = B - A;
if (a == Point()) a = D - C;
if (a == Point()) return A == C;
long double l1 = A % a, r1 = B % a, l2 = C % a, r2 = D % a;
if (l1 > r1) swap(l1, r1);
if (l2 > r2) swap(l2, r2);
return lseq(max(l1, l2), min(r1, r2));
}
return !onSameSide(A, B, C, D - C) && !onSameSide(C, D, A, B - A);
}
long double distSegments(Point A, Point B, Point C, Point D) {
if (intersectSegments(A, B, C, D)) return 0;
return min(min(distPointSegment(A, C, D), distPointSegment(B, C, D)),
min(distPointSegment(C, A, B), distPointSegment(D, A, B)));
}
const long double EPS = 1e-10;
const long long N = 2207;
pair<long double, long long> sc[N];
long double dist[N][N], ang[N][N];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long W, H, n;
cin >> W >> H >> n;
V<Point> a(n);
for (long long i = (0); i < (n); ++i) {
long long first, second;
cin >> first >> second;
a[i] = Point(first, second);
}
for (long long i = (0); i < (n); ++i) {
for (long long j = (0); j < (n); ++j) {
dist[i][j] = (a[j] - a[i]).len();
ang[i][j] = atan2(a[j].second - a[i].second, a[j].first - a[i].first);
}
}
auto check = [&](long long i, long double R) {
long long sz = 0;
long long cur = 0;
auto Arc = [&](long double l, long double r, long long first) {
if (r < l) {
swap(l, r);
cur += first;
first = -first;
}
sc[sz++] = make_pair(l, first);
sc[sz++] = make_pair(r + EPS, -first);
};
auto mod = [&](long double ang) {
while (ang < -PI) {
ang += 2 * PI;
}
while (ang > PI) {
ang -= 2 * PI;
}
return ang;
};
for (long long j = (0); j < (n); ++j) {
if (i == j) {
continue;
}
if (a[i] == a[j]) {
continue;
}
if (dist[i][j] < R * 2) {
long double sh = acos(dist[i][j] / (2 * R));
long double l = mod(ang[i][j] - sh);
long double r = mod(ang[i][j] + sh);
Arc(l, r, 1);
}
}
if (a[i].first < R) {
long double sh = acos(a[i].first / R);
Arc(mod(-PI - sh), mod(-PI + sh), 2);
}
if (W - a[i].first < R) {
long double sh = acos((W - a[i].first) / R);
Arc(mod(-sh), mod(+sh), 2);
}
if (a[i].second < R) {
long double sh = acos(a[i].second / R);
Arc(mod(-PI / 2 - sh), mod(-PI / 2 + sh), 2);
}
if (H - a[i].second < R) {
long double sh = acos((H - a[i].second) / R);
Arc(mod(PI / 2 - sh), mod(PI / 2 + sh), 2);
}
sort(sc, sc + sz);
if (cur < 2) {
return 1;
}
for (long long i = (0); i < (sz); ++i) {
cur += sc[i].second;
if (cur < 2) {
return 1;
}
}
return 0;
};
vi ord(n);
for (long long i = (0); i < (n); ++i) {
ord[i] = i;
}
mt19937 rnd(2007);
shuffle(ord.begin(), ord.end(), rnd);
long double ans = 0;
for (auto &i : ord) {
if (check(i, ans + EPS)) {
long double l = 0, r = W + H;
for (long long _ = (0); _ < (60); ++_) {
long double m = (l + r) / 2;
if (check(i, m)) {
l = m;
} else {
r = m;
}
}
ans = l;
}
}
cout.precision(20);
cout << fixed << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
vector<pair<int, int> > opt;
int n;
cin >> n;
map<pair<int, int>, int> stage;
pair<int, int> current = pair<int, int>(0, 0);
stage[current] = 0;
for (int i = 1; i <= n; i++) {
char c;
cin >> c;
if (c == 'L') {
current.first++;
} else if (c == 'R') {
current.first--;
} else if (c == 'U') {
current.second++;
} else {
current.second--;
}
if (stage.find(current) != stage.end())
opt.push_back({stage[current] + 1, i});
stage[current] = i;
}
long long _min = INT_MAX;
pair<int, int> ans;
for (pair<int, int> p : opt) {
int diff = abs(p.first - p.second);
if (diff < _min) {
_min = diff;
ans = p;
}
}
if (opt.size())
cout << min(ans.first, ans.second) << " " << max(ans.first, ans.second)
<< endl;
else
cout << -1 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long dp1[100000][2], dp2[100000][2], dp5[100000][2], dp3[100000][2],
dp4[100000][2];
long long a[100000];
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
dp1[0][0] = -30000;
dp1[0][1] = 30000;
dp2[1][0] = -300000;
for (int i = 1; i <= n; i++) {
dp1[i][0] = max(dp1[i - 1][0], a[i]);
dp1[i][1] = min(dp1[i - 1][1], a[i]);
}
for (int i = 2; i <= n; i++)
if (i == 2) {
dp2[i][0] = max(dp1[i - 1][0] * a[i], dp1[i - 1][1] * a[i]);
dp2[i][1] = min(dp1[i - 1][1] * a[i], dp1[i - 1][0] * a[i]);
} else {
dp2[i][0] =
max(max(dp1[i - 1][0] * a[i], dp1[i - 1][1] * a[i]), dp2[i - 1][0]);
dp2[i][1] =
min(min(dp1[i - 1][1] * a[i], dp1[i - 1][0] * a[i]), dp2[i - 1][1]);
}
for (int i = 3; i <= n; i++)
if (i == 3) {
dp3[i][0] = max(dp2[i - 1][0] * a[i], dp2[i - 1][1] * a[i]);
dp3[i][1] = min(dp2[i - 1][1] * a[i], dp2[i - 1][0] * a[i]);
} else {
dp3[i][0] =
max(max(dp2[i - 1][0] * a[i], dp2[i - 1][1] * a[i]), dp3[i - 1][0]);
dp3[i][1] =
min(min(dp2[i - 1][1] * a[i], dp2[i - 1][0] * a[i]), dp3[i - 1][1]);
}
for (int i = 4; i <= n; i++)
if (i == 4) {
dp4[i][0] = max(dp3[i - 1][0] * a[i], dp3[i - 1][1] * a[i]);
dp4[i][1] = min(dp3[i - 1][1] * a[i], dp3[i - 1][0] * a[i]);
} else {
dp4[i][0] =
max(max(dp3[i - 1][0] * a[i], dp3[i - 1][1] * a[i]), dp4[i - 1][0]);
dp4[i][1] =
min(min(dp3[i - 1][1] * a[i], dp3[i - 1][0] * a[i]), dp4[i - 1][1]);
}
for (int i = 5; i <= n; i++)
if (i == 5) {
dp5[i][0] = max(dp4[i - 1][0] * a[i], dp4[i - 1][1] * a[i]);
dp5[i][1] = min(dp4[i - 1][1] * a[i], dp4[i - 1][0] * a[i]);
} else {
dp5[i][0] =
max(max(dp4[i - 1][0] * a[i], dp4[i - 1][1] * a[i]), dp5[i - 1][0]);
dp5[i][1] =
min(min(dp4[i - 1][1] * a[i], dp4[i - 1][0] * a[i]), dp5[i - 1][1]);
}
cout << max(dp5[n][0], dp5[n][1]) << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline void mine(T1 &x, T2 y) {
if (x > y) x = y;
}
template <typename T1, typename T2>
inline void maxe(T1 &x, T2 y) {
if (x < y) x = y;
}
ostream &operator<<(ostream &a, const vector<int> &b) {
for (auto k : b) cout << k << ' ';
return a;
}
const int MOD = 1000000007;
const int INF = 1000000050;
const long long BIG = (long long)2e18 + 50;
const int MX = 200010;
const double EPS = 1e-9;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int x[MX];
int y[MX];
int c[MX];
set<int> g[MX];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i];
--x[i];
--y[i];
g[x[i]].insert(i);
g[y[i]].insert(i);
}
set<int> check;
set<int> man;
for (int i = 0; i < m; i++) man.insert(i);
for (int i = 0; i < n; i++)
if (g[i].size() <= c[i]) check.insert(i);
vector<int> ans;
while (!check.empty()) {
int s = *check.begin();
;
check.erase(check.begin());
for (auto &mn : g[s]) {
man.erase(mn);
ans.push_back(mn + 1);
int ss = (x[mn] == s ? y[mn] : x[mn]);
g[ss].erase(mn);
if (g[ss].size() <= c[ss]) check.insert(ss);
}
g[s].clear();
}
for (auto &mn : man) {
if (!c[mn] && !c[mn]) {
cout << "DEAD\n";
return 0;
}
if (c[x[mn]]) --c[y[mn]];
if (c[y[mn]]) --c[x[mn]];
ans.push_back(mn + 1);
}
reverse(ans.begin(), ans.end());
cout << "ALIVE\n" << ans << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << ": " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << ": " << arg1 << " |";
__f(comma + 1, args...);
}
const int INF = 1 << 29;
const int MOD = 1e9 + 7;
const int N = 5e3 + 10;
char s[N];
int main() {
scanf("%s", s);
int n = strlen(s);
int ret = 0;
for (int i = 0; i < n; ++i) {
int L = 0, R = 0;
for (int j = i; j < n && L <= R; ++j) {
if (s[j] == '(') {
++L;
++R;
} else if (s[j] == ')') {
--L;
--R;
} else {
--L;
++R;
}
if (L < 0) L += 2;
if (L == 0) {
++ret;
}
}
}
printf("%d\n", ret);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[501], b[501], n, m, d[501][501], px[501][501], py[501][501], Ans[501], fx,
fy, ans, k;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
cin >> m;
for (int j = 0; j < m; ++j) cin >> b[j];
px[0][0] = py[0][0] = -1;
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
if (a[i] == b[j]) {
d[i][j] = 1;
if (!ans) fx = i, fy = j, ans = 1;
for (int i1 = 0; i1 < i; ++i1)
for (int j1 = 0; j1 < j; ++j1)
if (a[i1] < a[i] && d[i][j] < d[i1][j1] + 1) {
d[i][j] = d[i1][j1] + 1;
px[i][j] = i1;
py[i][j] = j1;
if (ans < d[i][j]) ans = d[i][j], fx = i, fy = j;
}
}
cout << ans << endl;
while (ans--) {
int dx = px[fx][fy], dy = py[fx][fy];
Ans[k++] = a[fx];
fx = dx, fy = dy;
}
for (int i = 0; i < k; ++i) cout << Ans[k - i - 1] << " ";
}
| 4 |
#include <bits/stdc++.h>
#define rep(i,n) for (int (i) = 0; (i) < (n); (i)++)
using namespace std;
typedef long long ll;
int main() {
int a, b, c, ans = 0; cin >> a >> b >> c;
for (int i = 1; c > 0; i++) {
ans++;
c -= a;
if (i % 7 == 0) {
c -= b;
if (c <= 0) break;
}
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define for_(i,a,b) for(int i=(a);i<(b);++i)
int n, m, p[1010];
int main() {
while (cin >> n >> m, n) {
for_(i,0,n) cin >> p[i];
sort(p, p + n, greater< int >());
int ans = 0, cnt = 1;
for_(i,0,n) {
if (cnt == m) {
cnt = 1;
} else {
++cnt;
ans += p[i];
}
}
cout << ans << endl;
}
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, a[100];
double sum = 0;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
sum += a[i];
}
printf("%lf", (sum / (n * 100) * 100));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct rec {
long long x1, y1, x2, y2;
};
int main() {
int n;
cin >> n;
rec co[n];
long long x, y, p, q, x1min = INT_MAX, x2max = INT_MIN, y2max = INT_MIN,
y1min = INT_MAX;
vector<pair<long long, long long> > vx1, vx2, vy1, vy2;
for (int i = 0; i < n; i++) {
cin >> co[i].x1 >> co[i].y1 >> co[i].x2 >> co[i].y2;
vx1.push_back(make_pair(co[i].x1, i));
vy1.push_back(make_pair(co[i].y1, i));
vx2.push_back(make_pair(co[i].x2, i));
vy2.push_back(make_pair(co[i].y2, i));
}
sort(vx1.begin(), vx1.end());
sort(vy2.begin(), vy2.end());
sort(vx2.begin(), vx2.end());
sort(vy1.begin(), vy1.end());
int wt1 = -1, wt2 = -1;
if (vx2[0].first < vx1[n - 1].first) {
wt1 = vx2[0].second;
wt2 = vx1[n - 1].second;
}
if (vy2[0].first < vy1[n - 1].first) {
wt1 = vy2[0].second;
wt2 = vy1[n - 1].second;
}
long long cx1 = INT_MIN, cy1 = INT_MIN, cx2 = INT_MAX, cy2 = INT_MAX;
for (int i = 0; i < n; i++) {
if (i == wt1) continue;
cx1 = max(cx1, co[i].x1);
cx2 = min(cx2, co[i].x2);
cy1 = max(cy1, co[i].y1);
cy2 = min(cy2, co[i].y2);
}
if (cx1 <= cx2 and cy1 <= cy2) {
cout << cx1 << " " << cy1 << endl;
return 0;
}
cx1 = INT_MIN;
cy1 = INT_MIN;
cx2 = INT_MAX;
cy2 = INT_MAX;
for (int i = 0; i < n; i++) {
if (i == wt2) continue;
cx1 = max(cx1, co[i].x1);
cx2 = min(cx2, co[i].x2);
cy1 = max(cy1, co[i].y1);
cy2 = min(cy2, co[i].y2);
}
if (cx1 <= cx2 and cy1 <= cy2) {
cout << cx1 << " " << cy1 << endl;
return 0;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200010;
int p[N], x[N];
int rightMin[N];
int main() {
long long int d, n;
int m;
cin >> d >> n >> m;
vector<pair<int, int> > v;
for (int i = 1; i <= m; i++) {
int xx, yy;
scanf("%d%d", &xx, &yy);
v.push_back(pair<int, int>(xx, yy));
}
sort(v.begin(), v.end());
for (int i = 1; i <= m; i++) {
p[i] = v[i - 1].second;
x[i] = v[i - 1].first;
}
p[m + 1] = -10000010;
rightMin[m] = m + 1;
for (int i = m - 1; i > 0; i--) {
int j = i + 1;
while (p[j] >= p[i]) {
j = rightMin[j];
}
rightMin[i] = j;
}
if (n < x[1]) {
cout << -1 << endl;
return 0;
}
x[m + 1] = d;
long long int res = 0, presval = n - x[1];
for (int i = 1; i <= m; i++) {
if (presval < 0) {
cout << -1 << endl;
return 0;
}
long long int f = x[rightMin[i]] - x[i];
if (f <= presval) {
presval -= (x[i + 1] - x[i]);
continue;
}
long long int tot = min(n, f);
res += ((tot - presval) * p[i]);
presval = tot;
presval -= (x[i + 1] - x[i]);
}
if (presval < 0) {
cout << -1 << endl;
return 0;
}
cout << res << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[2 * 1111], b[2 * 1111], ans, n, x, y;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%lld%lld", &x, &y);
a[x + y]++, b[x - y + 1000]++;
}
for (int i = 0; i < 2 * 1111; i++) {
ans += a[i] * (a[i] - 1) / 2;
ans += b[i] * (b[i] - 1) / 2;
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1010;
const int MAXN = 1e4 + 10;
const int MOD = 1e9 + 7;
const int inf = 1e9;
const double pi = acos(-1.0);
const double eps = 1e-6;
int f[MAX];
vector<pair<int, int> > a;
int findSet(int u) { return f[u] = (u == f[u] ? f[u] : findSet(f[u])); }
int Union(int u, int v) {
u = findSet(u);
v = findSet(v);
if (u != v) {
f[v] = u;
return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
int n, u, v;
cin >> n;
for (int i = 1; i <= n; i++) f[i] = i;
for (int i = 1; i < n; i++) {
cin >> u >> v;
if (!Union(u, v)) a.push_back(make_pair(u, v));
}
cout << a.size() << endl;
u = 1;
while (u <= n && f[u] != u) u++;
v = u + 1;
for (int i = 0; i < a.size(); i++) {
while (v <= n && f[v] != v) v++;
cout << a[i].first << " " << a[i].second << " " << u << " " << v++ << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chkmax(T &a, T b) {
return (a < b) ? a = b, 1 : 0;
}
template <typename T>
bool chkmin(T &a, T b) {
return (a > b) ? a = b, 1 : 0;
}
inline int read() {
int x = 0, fh = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') fh = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ '0');
return x * fh;
}
int n, k;
int dep[1000005];
vector<int> dis[1000005];
vector<int> G[1000005];
int ans;
void dfs(int x, int fa) {
if (G[x].size() == 1) {
dep[x] = 1;
return;
}
for (int v : G[x]) {
if (v == fa) continue;
dfs(v, x);
dis[x].push_back(dep[v]);
}
sort(dis[x].begin(), dis[x].end());
int pre = dis[x][0], pos = 1;
for (; pos < dis[x].size() && pre + dis[x][pos] <= k;
pre = dis[x][pos], ++pos)
;
ans += dis[x].size() - pos, dep[x] = pre + 1;
}
int main() {
n = read();
k = read();
for (int i = (1), _end_ = (int)(n - 1); i <= _end_; ++i) {
int x = read(), y = read();
G[x].push_back(y);
G[y].push_back(x);
}
for (int i = (1), _end_ = (int)(n); i <= _end_; ++i) {
if (G[i].size() > 1) {
dfs(i, 0);
break;
}
}
printf("%d\n", ans + 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n, i, j = 1;
cin >> n;
int a[n];
for (i = 0; i < n; i++) {
if (j < 1000) {
a[i] = j;
j += 2;
} else
a[i] = a[i - 1];
}
for (i = 0; i < n; i++) cout << a[i] << " ";
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > pos;
vector<vector<int> > v;
int find_max(int l, int r) {
l++;
int ans = 0;
if (l >= r) return ans;
for (int i = 1; i <= 200; i++) {
ans = max(ans, v[i][r] - v[i][l]);
}
return ans;
}
int main() {
int t, n, x;
cin >> t;
while (t--) {
cin >> n;
int a[n];
pos.clear();
v.clear();
pos.resize(201);
v.resize(201);
for (int j = 1; j <= 200; j++) v[j].resize(n + 1, 0);
for (int i = 0; i < n; i++) {
cin >> x;
a[i] = x;
pos[x].push_back(i);
for (int j = 1; j <= 200; j++) {
v[j][i + 1] = v[j][i];
}
v[x][i + 1]++;
}
if (n == 1) {
cout << 1 << endl;
continue;
}
if (n == 2) {
if (a[0] == a[1])
cout << 2 << endl;
else
cout << 1 << endl;
continue;
}
int m = 200, ans = 0, i, j;
for (i = 1; i <= m; i++) {
ans = max(ans, int(pos[i].size()));
}
for (i = 1; i <= m; i++) {
if (pos[i].size() == 1) {
continue;
}
for (j = 0; j < pos[i].size() / 2; j++) {
ans = max(ans, 2 * (j + 1) +
find_max(pos[i][j], pos[i][pos[i].size() - j - 1]));
}
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
unsigned long long L, R, K, last, current;
cin >> L >> R >> K;
current = K;
last = 1;
bool found = false;
if (L == 1) {
cout << 1 << " ";
found = true;
}
while (current / K == last and current <= R) {
if (current >= L) {
cout << current << " ";
found = true;
}
last = current;
current *= K;
}
if (!found)
cout << "-1\n";
else
cout << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3;
const int score_max = 5e3;
int num[maxn + 10];
long long count_winscore[score_max + 10], A_score[score_max << 1 + 10];
int main() {
int n;
while (scanf("%d", &n) == 1 && n) {
memset(count_winscore, 0, sizeof(count_winscore));
memset(A_score, 0, sizeof(A_score));
for (int i = 0; i < n; i++) scanf("%d", &num[i]);
sort(num, num + n);
long long k = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < i; j++) {
count_winscore[num[i] - num[j]]++;
k++;
}
for (int i = 1; i <= 5000; i++) {
if (count_winscore[i]) {
for (int j = 1; j <= 5000; j++) {
if (count_winscore[j])
A_score[i + j] += count_winscore[i] * count_winscore[j];
}
}
}
long long ans = 0;
for (int i = 1; i <= 5000; i++) {
if (count_winscore[i]) {
for (int j = 1; j < i; j++) {
if (A_score[j]) ans += count_winscore[i] * A_score[j];
}
}
}
double possibility = (double)ans / k / k / k;
printf("%.10f\n", possibility);
}
return 0;
}
| 4 |
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <vector>
#include <queue>
#include <numeric>
#include <string>
#include <string.h>
#include <map>
#include <set>
#include <functional>
#include <complex>
#include <stack>
#include <tuple>
#include <array>
#include <ctype.h> // isdigit
#include <cassert>
using namespace std;
#define FOR(i,a,b) for (int i=(a);i<(b);i++)
#define RFOR(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define REP(i,n) for (int i=0;i<(n);i++)
#define RREP(i,n) for (int i=(n)-1;i>=0;i--)
#define ALL(u) begin(u),end(u)
#define PB push_back
#define LE(n,m) ((n) < (m) + EPS * (abs(n) + abs(m)))
#define GE(n,m) ((n) + EPS * (abs(n) + abs(m)) > (m))
#define LT(n,m) ((n) + EPS * (abs(n) + abs(m)) < (m))
#define GT(n,m) ((n) > (m) + EPS * (abs(n) + abs(m)))
#define EQ(n,m) (abs((n)-(m)) < EPS * (abs(n) + abs(m)))
typedef long long int ll;
const int INF = (1<<30) - 1;
const double EPS = 1e-9;
const int MOD = 1000000007;
//g++ -std=c++0x -msse4.2 -O3
//#include <bits/stdc++.h>
int main(){
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(16);
cout.setf(ios::fixed);
int N; cin >> N;
vector<int> ds(N);
for(auto &d: ds)
cin >> d;
vector<double> centers;
centers.push_back(ds[0]);
for(int i=1; i<N; i++){
double c = ds[i];
for(int j=0; j<i; j++)
c = max(c, centers[j] + sqrt((ds[j]+ds[i])*(ds[j]+ds[i]) - (ds[j]-ds[i])*(ds[j]-ds[i])));
centers.push_back(c);
}
double ans = 0;
for(int i=0; i<N; i++)
ans = max(ans, centers[i]+ds[i]);
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int sum = 0;
string s;
cin >> s;
for (int i = s.find('1'); i < s.find_last_of('1'); i++) {
if (s[i] == '0') sum++;
}
cout << sum << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long N = 2e5 + 11;
const long long NMAX = 200;
long long a[NMAX], n;
long long dp[NMAX][NMAX][NMAX][2];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie();
cerr.tie();
cout.tie();
cin >> n;
if (n == 1) return cout << 0, 0;
for (long long i = 1; i <= n; i++) cin >> a[i];
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0][0] = dp[0][0][0][1] = 0;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j <= i; j++) {
for (long long k = 0; k <= i; k++) {
if (j > 0)
dp[i][j][k][0] =
min(dp[i - 1][j - 1][k][1] + 1, dp[i - 1][j - 1][k][0]);
if (k > 0)
dp[i][j][k][1] =
min(dp[i - 1][j][k - 1][1], dp[i - 1][j][k - 1][0] + 1);
if (a[i]) {
if (a[i] % 2) {
dp[i][j][k][0] = 10000000;
} else {
dp[i][j][k][1] = 10000000;
}
}
}
}
}
return cout << min(dp[n][n / 2][(n + 1) / 2][0],
dp[n][n / 2][(n + 1) / 2][1]),
0;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long int counta = 0;
long long int countb = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == '-')
counta++;
else
countb++;
}
if (countb == 0) {
cout << "YES";
return 0;
}
if (counta % countb == 0)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a, s, d, f, g, h, j, k, l, i, n, m;
char c = 'a';
int main() {
cin >> n;
if (!n) {
cout << "a";
return 0;
}
while (n) {
for (i = 2; i <= 1000; i++) {
if (i * (i - 1) / 2 > n) {
i--;
break;
}
}
n -= i * (i - 1) / 2;
for (; i; i--) cout << c;
c++;
}
}
| 1 |
#include <bits/stdc++.h>
# define ll long long
# define ld double
# define fr first
# define sc second
# define pb push_back
# define pob pop_back
# define pf push_front
# define pof pop_front
const ll N = 1e6 + 10;
const ll INF = 1e18;
const ll inf = -1e18;
const ll MOD = 1e9 + 7;
const ll xesh = 31;
using namespace std;
ll n, i, a[1111], q, w, z, s;
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> n;
for(i = 1; i <= n; ++i)
{
cin >> s;
cout << s.size() << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
pair<int, int> operator+(const pair<int, int>& x, const pair<int, int>& y) {
return make_pair(x.first + y.first, x.second + y.second);
}
pair<int, int> operator-(const pair<int, int>& x, const pair<int, int>& y) {
return make_pair(x.first - y.first, x.second - y.second);
}
inline long long read() {
char ch = getchar();
long long x = 0, f = 0;
while (ch < '0' || ch > '9') f |= ch == '-', ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return f ? -x : x;
}
int T;
const int maxn = 3e7 + 7;
long long minn[maxn];
long long n, k;
void solve() {
cin >> n >> k;
if (n < k) {
cout << "NO\n";
return;
}
if (n >= minn[2 * k - 1] && ((n & 1) == (k & 1)))
cout << "YES\n";
else
cout << "NO\n";
return;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
T = 1;
minn[1] = 1ll;
for (int i = (0); i < (10000006); ++i) {
minn[2 * i + 1] = minn[2 * i - 1] + 2 * i + 1;
}
cin >> T;
while (T--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int const nmax = 100000;
int const domain = 1000000;
struct Person {
int x;
int v;
bool operator<(Person other) const { return x < other.x; }
};
bitset<domain> okl, okr;
Person pl[1 + nmax], pr[1 + nmax];
int nl, nr, vray;
double gettime(Person p, int distray) {
double s = vray;
int distp = p.x;
int vp = p.v;
double timep = 1.0L * distp / vp;
double timehit = 1.0L * (distray - distp) / (s - vp);
if (timep <= timehit)
return timep;
else {
double disthit = distp - timehit * vp;
return timehit + (disthit / (vp + s));
}
}
void solve(double target, Person *p, int np, bitset<domain> *ok) {
for (int i = 1; i <= np; i++) {
if (p[i].x <= p[i].v * target) {
for (int j = 1; j < domain; j++) (*ok)[j] = 1;
return;
}
}
int i = 1, j = 1;
while (j < domain) {
if (np < i || j < p[i].x) {
(*ok)[j] = false;
j++;
} else if (gettime(p[i], j) <= target) {
(*ok)[j] = true;
j++;
} else
i++;
}
}
int main() {
int n;
scanf("%d %d", &n, &vray);
for (int i = 1; i <= n; i++) {
int coord, v, dir;
scanf("%d %d %d", &coord, &v, &dir);
if (dir == 1) {
nl++;
pl[nl] = {coord, v};
} else {
nr++;
pr[nr] = {domain - coord, v};
}
}
sort(pl + 1, pl + nl + 1);
sort(pr + 1, pr + nr + 1);
double lim1 = 0, lim2 = domain, mid;
double precizie = 0.0000001 / 10;
while (lim1 + precizie < lim2) {
mid = (lim2 + lim1) / 2;
solve(mid, pl, nl, &okl);
solve(mid, pr, nr, &okr);
int flag = 0, i = 1;
while (flag == 0 && i < domain) {
if (okl[i] == 1 && okr[domain - i] == 1) {
flag = 1;
}
i++;
}
if (flag == 1)
lim2 = mid;
else
lim1 = mid;
}
printf("%.12lf", mid);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chmin(T &a, const T &b) {
return a > b ? a = b, true : false;
}
template <typename T>
bool chmax(T &a, const T &b) {
return a < b ? a = b, true : false;
}
const int maxN = 10000 + 5;
int n;
string s;
map<char, int> mp;
string name[] = {"Gryffindor", "Hufflepuff", "Ravenclaw", "Slytherin"};
set<basic_string<int> > S, T;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
string s;
cin >> s;
mp['G'] = 0;
mp['H'] = 1;
mp['R'] = 2;
mp['S'] = 3;
S.clear();
T.clear();
S.insert(basic_string<int>{0, 0, 0, 0});
for (char c : s) {
T.clear();
if (c != '?') {
for (auto x : S) {
x[mp[c]]++;
T.insert(x);
}
} else {
for (auto x : S) {
for (int i = 0; i < 4; ++i)
if (x[i] == *min_element(x.begin(), x.end())) {
x[i]++;
T.insert(x);
x[i]--;
}
}
}
T.swap(S);
}
set<int> A;
for (auto x : S) {
for (int i = 0; i < 4; ++i)
if (x[i] == *min_element(x.begin(), x.end())) {
A.insert(i);
}
}
for (int x : A) cout << name[x] << endl;
return 0;
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll t,n,a,b,c,d;
map<ll,ll> mp;
ll dfs(ll k)
{
if (k==0) return 0;
if (k==1) return d;
if (mp.count(k)) return mp[k];
ll res=1e18,tmp;
if (k<res/d) res=(ll)k*d;
tmp=k/2*2;
res=min(res,abs(k-tmp)*d+a+dfs(tmp/2));
tmp=(k+1)/2*2;
res=min(res,abs(k-tmp)*d+a+dfs(tmp/2));
tmp=k/3*3;
res=min(res,abs(k-tmp)*d+b+dfs(tmp/3));
tmp=(k+2)/3*3;
res=min(res,abs(k-tmp)*d+b+dfs(tmp/3));
tmp=k/5*5;
res=min(res,abs(k-tmp)*d+c+dfs(tmp/5));
tmp=(k+4)/5*5;
res=min(res,abs(k-tmp)*d+c+dfs(tmp/5));
mp[k]=res;
return res;
}
int main()
{
cin>>t;
while(t--)
{
cin>>n>>a>>b>>c>>d;
cout<<dfs(n)<<endl;
mp.clear();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
template <class T>
inline void checkmin(T& a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T& a, T b) {
if (b > a) a = b;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T lsb(T n) {
return (n & (-n));
}
template <class T>
inline int countbit(T n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
bool isequal(vector<int> a, vector<int> b) {
for (int i = 0; i < (a.size()); i++)
if (a[i] != b[i]) return false;
return true;
}
template <class T>
bool allequal(vector<T> a) {
sort(a.begin(), a.end());
return a[0] == a[a.size() - 1];
}
template <class T>
void printarray(vector<T> a) {
for (int i = 0; i < (a.size()); i++) cout << a[i] << " ";
cout << endl;
}
template <class T>
void printsubarray(vector<T> a, int start, int end) {
if (start < 0 or end > a.size() - 1) cout << "Out of bounds" << endl;
for (int i = start; i <= end; i++) cout << a[i] << " ";
cout << endl;
}
bool isprime(int n) {
if (n < 2) return false;
if (n == 2) return true;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
void split(const string& s, char c, vector<string>& result) {
stringstream ss(s);
string x;
while (getline(ss, x, c)) result.push_back(x);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\n';
err(++it, args...);
}
void readarray(vector<int>& a, int size) {
int tmp;
a.clear();
for (int i = 0; i < (size); i++) {
cin >> tmp;
a.push_back(tmp);
}
}
bool invalid(int n, int k) {
int nbits = countbit(n);
if (k < nbits or k > n) return true;
return false;
}
vector<int> res;
void split(int n, int k) {
if (k == 1) {
res.push_back(n);
} else {
int nbits = countbit(n);
if (nbits == 1) {
split(n >> 1, ((k >> 1) + k % 2));
split(n >> 1, (k >> 1));
} else {
int a, b;
int msb = (int)log2(n);
a = (1 << msb);
b = n ^ a;
int excess = k - nbits + 1;
int first = min(excess, a);
{
vector<string> _v;
split("a, b, excess, nbits, k, first", ',', _v);
err(_v.begin(), a, b, excess, nbits, k, first);
};
split(a, first);
split(b, k - first);
}
}
}
void solvecase() {
int n, k;
cin >> n >> k;
if (invalid(n, k)) {
cout << "NO" << endl;
return;
}
split(n, k);
cout << "YES" << endl;
printarray(res);
}
int main() {
int cases = 1;
while (cases--) {
solvecase();
}
return 0;
}
| 3 |
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--)
{
int n;
cin >> n;
string line;
cin >> line;
int t = 0, m = 0;
for (int i = 0; i < n; i++)
{
if (line[i] == 'T')t++;
else m++;
}
if (t == m * 2)
{
int count = 0, flag = 0;
for (int i = 0; i < n; i++)
{
if (line[i] == 'T')
count++;
else
count--;
if (count < 0)
{
flag = 1;
break;
}
}
if (flag)
{
cout << "NO\n";
}
else
{
reverse(line.begin(), line.end());
int count = 0, flag = 0;
for (int i = 0; i < n; i++)
{
if (line[i] == 'T')
count++;
else
count--;
if (count < 0)
{
flag = 1;
break;
}
}
if (flag)
{
cout << "NO\n";
}
else
cout << "YES\n";
}
}
else
{
cout << "NO\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define xx first
#define yy second
#define mp make_pair
#define pb push_back
#define mset(x, y) memset(x, y, sizeof x)
#define mcpy(x, y) memcpy(x, y, sizeof x)
using namespace std;
typedef long long LL;
typedef pair <int, int> pii;
inline int Read()
{
int x = 0, f = 1, c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-')
f = -1;
for (; isdigit(c); c = getchar())
x = x * 10 + c - '0';
return x * f;
}
const int MAXN = 524290;
const int mod = 1e9 + 7;
int f[2][MAXN], n, m, k, a[25][25], cur;
inline void Inc(int &x, int y) { x += y; if (x >= mod) x -= mod; }
inline int Lowbit(int x) { return x & -x; }
inline int Trans(int x, int y, int z)
{
if (x >> y & 1)
return !z ? -1 : x;
return !z ? x : ((x >> y) - Lowbit(x >> y) + 1) << y | (x & (1 << y) - 1);
}
int main()
{
#ifdef wxh010910
freopen("data.in", "r", stdin);
#endif
n = Read() - 1, m = Read(), k = Read();
mset(a, -1);
for (int i = 1, x, y; i <= k; i ++)
x = Read(), y = Read() - 1, a[x][y] = Read();
f[0][0] = cur = 1;
for (int i = 1; i <= m; i ++)
for (int j = 0; j < n; j ++, cur ^= 1)
{
mset(f[cur], 0);
for (int k = 0; k < (1 << n); k ++)
if (f[cur ^ 1][k])
{
if (a[i][j] != 1 && ~Trans(k, j, 0))
Inc(f[cur][Trans(k, j, 0)], f[cur ^ 1][k]);
if (a[i][j] != 0 && ~Trans(k, j, 1))
Inc(f[cur][Trans(k, j, 1)], f[cur ^ 1][k]);
}
}
int ans = 0;
for (int i = 0; i < (1 << n); i ++)
Inc(ans, f[cur ^ 1][i]);
return printf("%d\n", ans), 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
int n;
cin >> n;
ll a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
vector<int> sums(1e6, 0);
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
sums[a[i] + a[j]] += 1;
}
}
int maxnum = 0;
for (int i = 0; i < 1e6; i++) {
maxnum = max(maxnum, sums[i]);
}
cout << maxnum << endl;
}
| 2 |
#include<iostream>
using namespace std;
int main(){
int N,K,l,sum=0;
cin>>N>>K;
for(int i=0;i<N;i++){
cin>>l;
if(l>=K){sum++;}
}
cout<<sum<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout << setprecision(10);
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
if (x == 1) {
cout << "HARD\n";
return 0;
}
}
cout << "EASY\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
int n;
int a[10000];
int x[10000];
int y[10000];
while (~scanf("%d", &n)) {
int t = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (a[i] != 0) t++;
}
if (!t) {
printf("NO\n");
continue;
}
int len = 0;
for (int i = 1; i <= n; i++) {
x[len] = i;
while (a[i] == 0) i++;
t--;
if (!t) break;
y[len++] = i;
}
y[len++] = n;
printf("YES\n%d\n", len);
for (int i = 0; i < len; i++) printf("%d %d\n", x[i], y[i]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double a, b, c, d, x, y;
double pro(double p, double t) {
return max((3 * p) / 10, p - ((p / 250) * t));
}
int main() {
cin >> a >> b >> c >> d;
x = pro(a, c);
y = pro(b, d);
if (x == y)
cout << "Tie" << endl;
else if (x > y)
cout << "Misha" << endl;
else
cout << "Vasya" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 200005;
long long n, m, a, b;
std::vector<long long> v[MAXN];
bool vis[MAXN];
long long novis;
long long cnt1, cnt2;
void dfs(long long p, bool now) {
vis[p] = true;
if (now)
cnt1--;
else
cnt2--;
for (long long i = 0; i < v[p].size(); i++) {
long long u = v[p][i];
if (!vis[u] && u != novis) {
dfs(u, now);
}
}
}
signed main() {
ios::sync_with_stdio(false);
long long t;
cin >> t;
while (t--) {
cin >> n >> m >> a >> b;
cnt1 = cnt2 = n;
for (long long i = 1; i <= n; i++) {
v[i].clear();
vis[i] = false;
}
for (long long i = 1; i <= m; i++) {
long long x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
novis = a;
dfs(b, true);
for (long long i = 1; i <= n; i++) vis[i] = false;
novis = b;
dfs(a, false);
cnt1--;
cnt2--;
cout << cnt1 * cnt2 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
string NumberToString(T Number) {
ostringstream ss;
ss << Number;
return ss.str();
}
template <typename T>
T StringToNumber(const string &Text) {
istringstream ss(Text);
T result;
return ss >> result ? result : 0;
}
int v[100];
int main() {
int n;
cin >> n;
vector<int> x(n);
for (int i = 0; i < n; i++) cin >> x[i];
sort(x.begin(), x.end());
memset(v, 0, sizeof(v));
int z = -1, m = -1;
int f;
do {
z = -1;
f = -1;
for (int i = 0; i < n; i++) {
if (!v[i] && x[i] >= z && x[i] > f) {
f++;
z = x[i];
v[i] = 1;
}
}
m++;
} while (z != -1);
cout << m << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9+7;
int n;
vector<int>v[100002];
int dp[2][100002];
bool viz[100002];
void dfs(int x)
{
viz[x] = 1;
dp[0][x] = dp[1][x] = 1;
for(auto u: v[x]) {
if(viz[u]) continue;
dfs(u);
dp[1][x] = (long long)dp[1][x] * dp[0][u] % mod;;
dp[0][x] = (long long)dp[0][x] * ((dp[0][u] + dp[1][u]) % mod) % mod;
}
}
int main()
{
cin >> n;
for(int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
dfs(1);
cout<< (dp[0][1] + dp[1][1]) % mod;
return 0;
}
| 0 |
#include <iostream>
using namespace std;
int
main()
{
string s;
cin >> s;
s[13] = s[5] = ' ';
cout << s;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, k, m, team = 1, ans[N];
pair<int, int> a[N];
set<int> Set;
vector<set<int>::iterator> Vec;
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].first);
a[i].second = i;
Set.insert(i);
}
sort(a + 1, a + 1 + n, greater<pair<int, int> >());
for (int i = 1; i <= n; ++i)
if (ans[a[i].second] == 0) {
int pos = a[i].second;
m = k;
for (auto it = Set.lower_bound(pos); it != end(Set) && m >= 0; --m, --it)
Vec.push_back(it);
m = k;
for (auto it = Set.upper_bound(pos); it != end(Set) && m > 0; --m, ++it)
Vec.push_back(it);
for (auto it : Vec) ans[*it] = team, Set.erase(it);
Vec.clear();
team = 3 - team;
}
for (int i = 1; i <= n; ++i) printf("%d", ans[i]);
}
| 5 |
#include <iostream>
#include <map>
using namespace std;
int main(){
map<int, int>m;
for(int i=0; i<6; i++){
int a;
cin >> a;
m[a]++;
}
for(int i=1; i<=4; i++){
if(m[i]==3){
cout << "NO";
return 0;
}
}
cout << "YES";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long Set(long long N, long long pos) {
if (pos < 0) return N;
return N = N | (1ll << pos);
}
long long reset(long long N, long long pos) { return N = N & ~(1ll << pos); }
bool check(long long N, long long pos) {
if (pos < 0) return 0;
return (bool)(N & (1ll << pos));
}
void CI(long long &_x) { scanf("%d", &_x); }
void CO(long long &_x) { cout << _x; }
template <typename T>
void getarray(T a[], long long n) {
for (long long i = 0; i < n; i++) cin >> a[i];
}
template <typename T>
void prLLIarray(T a[], long long n) {
for (long long i = 0; i < n - 1; i++) cout << a[i] << " ";
cout << a[n - 1] << endl;
}
const double EPS = 1e-9;
const long long INF = 0x7f7f7f7f;
long long dr8[8] = {1, -1, 0, 0, 1, -1, -1, 1};
long long dc8[8] = {0, 0, -1, 1, 1, 1, -1, -1};
long long dr4[4] = {0, 0, 1, -1};
long long dc4[4] = {-1, 1, 0, 0};
long long kn8r[8] = {1, 2, 2, 1, -1, -2, -2, -1};
long long kn8c[8] = {2, 1, -1, -2, -2, -1, 1, 2};
vector<int> V, div_list;
void divisors(int num) {
div_list.clear();
int sq = sqrt(num);
for (int i = 1; i <= sq; i++)
if (num % i == 0) {
div_list.push_back(i);
if (i != (num / i)) div_list.push_back(num / i);
}
sort(div_list.begin(), div_list.end());
}
int kount[100005];
long long pow_(long long a, long long b) {
if (b == 0) return 1;
if (b % 2) {
return (a * pow_(a, b - 1)) % 1000000007;
} else {
long long temp = pow_(a, b / 2);
return (temp * temp) % 1000000007;
}
}
int lim;
long long fuck(long long len) {
if (len == 0) return 0;
int sz = div_list.size();
long long ans = 1;
for (int i = 0; i < len; i++) {
int a = div_list[i];
int b;
if (i + 1 < len)
b = div_list[i + 1] - 1;
else
b = lim;
ans *= pow_(i + 1, kount[b] - kount[a - 1]);
ans %= 1000000007;
}
return ans;
}
int main() {
int n, temp;
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> temp;
V.push_back(temp);
kount[temp]++;
}
sort(V.begin(), V.end());
lim = V[n - 1];
for (long long i = 1; i <= lim; i++) {
kount[i] += kount[i - 1];
}
long long res = 0;
for (int i = 1; i <= lim; i++) {
divisors(i);
res += fuck(div_list.size());
res %= 1000000007;
res -= fuck(div_list.size() - 1);
res += 1000000007;
res %= 1000000007;
}
cout << res << "\n";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e6 + 5;
vector<int> v[MAX];
int d[MAX], pa[MAX];
bool vis[MAX];
int find(int x) {
if (pa[x] == x) return x;
return pa[x] = find(pa[x]);
}
void ini() {
int i;
for (i = 1; i < MAX; i++) d[i] = 0, pa[i] = i, vis[i] = false;
}
int main() {
ini();
int n, m, i, loops = 0;
scanf("%d %d", &n, &m);
for (i = 0; i < m; i++) {
int x, y;
scanf("%d %d", &x, &y);
vis[x] = vis[y] = true;
if (x == y)
loops++;
else {
d[x]++, d[y]++;
pa[find(x)] = find(y);
}
}
int temp = 0;
for (i = 1; i <= n; i++) {
if (pa[i] == i && vis[i]) temp++;
}
if (temp >= 2)
printf("0\n");
else {
long long int ans = 0;
for (i = 1; i <= n; i++) ans += (d[i] * 1LL * (d[i] - 1) / 2);
ans += (loops * 1LL * (m - loops));
ans += (loops * 1LL * (loops - 1) / 2);
printf("%lld\n", ans);
}
return 0;
}
| 4 |
#include <iostream>
using namespace std;
typedef long long ll;
string s;
int n;
ll c;
int main() {
cin >> s;
n = s.size();
int a = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'A') {
a++;
} else if (i != n-1 && s[i] == 'B' && s[i+1] == 'C') {
c += a;
i++;
} else {
a = 0;
}
}
cout << c << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int N, ret[55];
long long K, dp[55];
int main() {
cin >> N >> K;
dp[0] = 1;
dp[1] = 1;
for (int i = 2; i <= N; ++i) {
dp[i] = dp[i - 1] + dp[i - 2];
}
for (int i = 0; i < N; ++i) {
ret[i] = i + 1;
}
int pos = 0;
while (pos != N) {
if (K > dp[N - (pos + 1)]) {
swap(ret[pos], ret[pos + 1]);
K -= dp[N - (pos + 1)];
pos += 2;
} else {
pos += 1;
}
}
for (int i = 0; i < N; ++i) {
if (i) cout << ' ';
cout << ret[i];
}
cout << '\n';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int recur_depth = 0;
const long long sz = 14, isz = 2e6 + 10, mod = 1e9 + 7;
long long p[sz], win[sz][sz], scc[(1 << sz)], n;
long long fastPow(long long x, long long n, long long MOD) {
long long ret = 1;
while (n) {
if (n & 1) ret = (ret * x) % MOD;
x = (x * x) % MOD;
n >>= 1;
}
return ret % MOD;
}
inline long long inv(long long x) { return fastPow(x, mod - 2, mod); }
long long prob(long long from, long long to) {
long long ret = 1;
for (long long i = 0; i < n; ++i) {
for (long long j = 0; j < n; ++j) {
if ((from >> i & 1) && (to >> j & 1)) ret = (ret * win[i][j]) % mod;
}
}
return ret;
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n;
for (long long i = 0; i < n; ++i) cin >> p[i];
for (long long i = 0; i < n; ++i)
for (long long j = 0; j < n; ++j)
win[i][j] = (p[i] * inv(p[i] + p[j])) % mod;
long long ans = 0, lim = (1 << n) - 1;
for (int mask = 0; mask <= lim; mask++) {
scc[mask] = 1;
for (int i = mask; i > 0; i = (i - 1) & mask) {
if (i == mask) continue;
scc[mask] -= (scc[i] * prob(i, mask ^ i)) % mod;
if (scc[mask] < 0) scc[mask] += mod;
}
long long win_prob = (scc[mask] * __builtin_popcount(mask)) % mod;
win_prob = (win_prob * prob(mask, lim ^ mask)) % mod;
ans += win_prob;
if (ans >= mod) ans -= mod;
}
cout << ans << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[1000001], ba, s[1000001], sa, L[1000001], R[1000001], qa, qb;
long long ans;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) a[i] = abs(a[i + 1] - a[i]);
--n, s[0] = n + 1;
for (int i = n; i >= 1; i--) {
while (sa != 0 && a[i] > a[s[sa]]) L[s[sa]] = i, --sa;
R[i] = s[sa];
++sa, s[sa] = i;
}
while (sa) L[s[sa]] = 0, --sa;
for (int i = 1; i <= m; i++) {
scanf("%d%d", &qa, &qb), qb--;
ans = 0;
for (int j = qa; j <= qb; j++)
ans +=
(long long)(a[j]) * (min(R[j], qb + 1) - j) * (j - max(L[j], qa - 1));
printf("%lld\n", ans);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
int n, p[maxn][20], level[maxn], v1 = 2, v2 = 3, diameter = 2;
int curV = 4;
void preprocess() {
for (int i = 1; i <= 1e6; i++) {
for (int j = 1; 1 << j < n; j++) {
p[i][j] = -1;
}
}
p[2][0] = p[3][0] = p[4][0] = level[2] = level[3] = level[4] = 1;
}
void add(int node, int cur) {
p[cur][0] = node;
level[cur] = level[node] + 1;
for (int j = 1; 1 << j < curV; j++) {
if (p[cur][j - 1] != -1) {
p[cur][j] = p[p[cur][j - 1]][j - 1];
}
}
}
int lca(int x, int y) {
if (level[x] < level[y]) swap(x, y);
int log;
for (log = 1; 1 << log <= level[x]; log++)
;
log--;
for (int i = log; i >= 0; i--) {
if (level[x] - (1 << i) >= level[y]) {
x = p[x][i];
}
}
if (x == y) return x;
for (int i = log; i >= 0; i--) {
if (p[x][i] != -1 && (p[x][i] != p[y][i])) {
x = p[x][i], y = p[y][i];
}
}
return p[x][0];
}
int dist(int a, int b) { return level[a] + level[b] - (2 * level[lca(a, b)]); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
preprocess();
while (n--) {
int v;
cin >> v;
add(v, ++curV);
add(v, ++curV);
int d1 = dist(curV, v1);
int d2 = dist(curV, v2);
if (d1 >= diameter && d1 >= d2) {
diameter = d1;
v2 = curV;
} else if (d2 >= diameter && d2 >= d1) {
diameter = d2;
v1 = curV;
}
printf("%d\n", diameter);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 30001;
long long a[30001], f[30001][700], n, d;
bool used[30001][501];
long long solve(long long x, long long y) {
if (x >= M) return 0;
if (used[x][y]) return f[x][y];
used[x][y] = true;
long long res;
if (y == 1) {
res = a[x] + max(solve(x + y, y), solve(x + y + 1, y + 1));
} else
res = a[x] + max(max(solve(x + y, y), solve(x + y + 1, y + 1)),
solve(x + y - 1, y - 1));
f[x][y] = res;
return res;
}
void input() {
cin >> n >> d;
long long fi = 0;
for (int i = 1; i <= n; ++i) {
long long x;
cin >> x;
++a[x];
}
cout << solve(d, d);
}
int main() {
ios_base::sync_with_stdio(false);
input();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > g(500005);
int a[1000005];
int main() {
int n, c, x, y;
scanf("%d%d", &n, &c);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
for (int j = 0; j < x; j++) {
scanf("%d", &y);
g[i].push_back(y);
}
}
for (int i = 0; i < n - 1; i++) {
int j = 0;
for (j = 0; j < min(g[i].size(), g[i + 1].size()); j++)
if (g[i][j] != g[i + 1][j]) break;
if (g[i].size() <= g[i + 1].size() && j == g[i].size()) {
a[0]++;
a[c]--;
} else if (g[i + 1].size() < g[i].size() && j == g[i + 1].size()) {
cout << "-1\n";
return 0;
} else if (g[i][j] < g[i + 1][j]) {
a[0]++;
a[c - g[i + 1][j] + 1]--;
a[c - g[i][j] + 1]++;
a[c]--;
} else {
a[c - g[i][j] + 1]++;
a[c - g[i + 1][j] + 1]--;
}
}
for (int i = 1; i <= c; i++) a[i] += a[i - 1];
for (int i = 0; i < c; i++)
if (a[i] == n - 1) {
cout << i << "\n";
return 0;
}
cout << "-1\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int IN() {
int c, f, x;
while (!isdigit(c = getchar()) && c != '-')
;
c == '-' ? (f = 1, x = 0) : (f = 0, x = c - '0');
while (isdigit(c = getchar())) x = (x << 1) + (x << 3) + c - '0';
return !f ? x : -x;
}
const int N = 3000 + 19;
char s[N][N];
int A[N], id[N];
int n, m, a, b, sum;
bool check() {
int sum = 0, top = 0;
for (int i = 1; i < n + 1; i++) {
sum += A[i];
top += 2 * (n - i);
if (sum > top) return 0;
}
if (sum != top) return 0;
for (int i = 1; i < n; i++)
if (A[i] < A[i + 1]) return 0;
return 1;
}
bool cmp(int a, int b) { return A[a] > A[b]; }
void Work(int x) {
if (x == n) return;
sort(id + x, id + n + 1, cmp);
if (A[id[x]] & 1) {
int k = (A[id[x]] - 1) / 2;
for (int i = n; i > x; i--) {
int a = k--;
if (a > 0) {
s[id[x]][id[i]] = 'W', s[id[i]][id[x]] = 'L';
} else if (a == 0) {
s[id[x]][id[i]] = s[id[i]][id[x]] = 'D';
A[id[i]]--;
} else {
s[id[x]][id[i]] = 'L', s[id[i]][id[x]] = 'W';
A[id[i]] -= 2;
}
}
} else {
int k = A[id[x]] / 2;
for (int i = n; i > x; i--)
if (k-- > 0) {
s[id[x]][id[i]] = 'W', s[id[i]][id[x]] = 'L';
} else {
s[id[x]][id[i]] = 'L', s[id[i]][id[x]] = 'W';
A[id[i]] -= 2;
}
}
Work(x + 1);
}
int main() {
n = IN(), m = IN();
for (int i = 1; i < m + 1; i++) {
A[i] = IN();
sum += A[i];
}
if (n > m) {
sum = n * (n - 1) - sum;
a = sum / (n - m);
b = sum % (n - m);
for (int i = m + 1; i < n + 1; i++)
if (b-- > 0)
A[i] = a + 1;
else
A[i] = a;
}
if (!check()) {
puts("no");
return 0;
}
puts("yes");
for (int i = 1; i < n + 1; i++) {
id[i] = i;
s[i][i] = 'X';
}
Work(1);
for (int i = 1; i < n + 1; i++) {
puts(s[i] + 1);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n >= 1) {
if (n % 2 == 0) {
cout << n / 2;
} else {
cout << (n / 2) + 1;
}
}
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.