更新
This commit is contained in:
Binary file not shown.
@@ -0,0 +1,34 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n; if (scanf("%d", &n) != 1) return 0;
|
||||
int a, b; if (scanf("%d %d", &a, &b) != 2) return 0;
|
||||
int *val = (int*)malloc((size_t)(n + 1) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) scanf("%d", &val[i]);
|
||||
ll *dp = (ll*)malloc((size_t)(n + 1) * sizeof(ll));
|
||||
for (int i = 0; i <= n; ++i) dp[i] = (ll)4e18;
|
||||
dp[0] = 0;
|
||||
for (int i = 1; i <= n; ++i){
|
||||
int mn = val[i], mx = val[i];
|
||||
for (int j = i; j >= 1; --j){
|
||||
if (val[j] < mn) mn = val[j];
|
||||
if (val[j] > mx) mx = val[j];
|
||||
ll cost = dp[j-1] + (ll)a + (ll)b * (ll)(mx - mn) * (ll)(mx - mn);
|
||||
if (cost < dp[i]) dp[i] = cost;
|
||||
}
|
||||
}
|
||||
printf("%lld\n", dp[n]);
|
||||
free(dp); free(val);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef unsigned long long ull;
|
||||
|
||||
typedef struct { ull l, r; } Interval;
|
||||
|
||||
static int cmpL(const void *a, const void *b){
|
||||
const Interval *x = (const Interval*)a;
|
||||
const Interval *y = (const Interval*)b;
|
||||
if (x->l < y->l) return -1;
|
||||
if (x->l > y->l) return 1;
|
||||
if (x->r < y->r) return -1;
|
||||
if (x->r > y->r) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
size_t cap = 1 << 16;
|
||||
size_t n = 0;
|
||||
Interval *arr = (Interval*)malloc(cap * sizeof(Interval));
|
||||
ull A, B;
|
||||
while (scanf("%llu %llu", &A, &B) == 2){
|
||||
if (n == cap){
|
||||
cap <<= 1;
|
||||
Interval *tmp = (Interval*)realloc(arr, cap * sizeof(Interval));
|
||||
if (!tmp){ free(arr); return 0; }
|
||||
arr = tmp;
|
||||
}
|
||||
ull l = A < B ? A : B;
|
||||
ull r = A > B ? A : B;
|
||||
arr[n].l = l;
|
||||
arr[n].r = r;
|
||||
++n;
|
||||
}
|
||||
if (n < 2){
|
||||
printf("0\n");
|
||||
free(arr);
|
||||
return 0;
|
||||
}
|
||||
qsort(arr, n, sizeof(Interval), cmpL);
|
||||
ull ans = 0ULL;
|
||||
ull max_r_prev = arr[0].r;
|
||||
for (size_t i = 1; i < n; ++i){
|
||||
ull l = arr[i].l;
|
||||
ull r = arr[i].r;
|
||||
ull M = r < max_r_prev ? r : max_r_prev;
|
||||
if (M >= l){
|
||||
ull len = M - l + 1ULL;
|
||||
if (len > ans) ans = len;
|
||||
}
|
||||
if (r > max_r_prev) max_r_prev = r;
|
||||
}
|
||||
printf("%llu\n", ans);
|
||||
free(arr);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef unsigned long long ull;
|
||||
|
||||
static char* dupstr(const char* s){ size_t len = strlen(s); char* p = (char*)malloc(len + 1); memcpy(p, s, len + 1); return p; }
|
||||
|
||||
typedef struct {
|
||||
char **keys;
|
||||
char **vals;
|
||||
unsigned char *used;
|
||||
size_t cap;
|
||||
} Map;
|
||||
|
||||
static ull fnv1a(const char *s){
|
||||
ull h = 1469598103934665603ULL;
|
||||
while (*s){ h ^= (unsigned char)(*s++); h *= 1099511628211ULL; }
|
||||
return h;
|
||||
}
|
||||
|
||||
static void map_init(Map *m, size_t n){ size_t c = 1; while (c < (n << 1)) c <<= 1; m->cap = c; m->keys = (char**)calloc(c, sizeof(char*)); m->vals = (char**)calloc(c, sizeof(char*)); m->used = (unsigned char*)calloc(c, 1); }
|
||||
|
||||
static void map_put(Map *m, const char *k, const char *v){ size_t mask = m->cap - 1; size_t i = (size_t)(fnv1a(k) & mask); for (;;){ if (!m->used[i]){ m->used[i] = 1; m->keys[i] = dupstr(k); m->vals[i] = dupstr(v); return; } if (strcmp(m->keys[i], k) == 0){ free(m->vals[i]); m->vals[i] = dupstr(v); return; } i = (i + 1) & mask; } }
|
||||
|
||||
static const char* map_get(Map *m, const char *k){ size_t mask = m->cap - 1; size_t i = (size_t)(fnv1a(k) & mask); for (;;){ if (!m->used[i]) return NULL; if (strcmp(m->keys[i], k) == 0) return m->vals[i]; i = (i + 1) & mask; } }
|
||||
|
||||
static void map_free(Map *m){ for (size_t i = 0; i < m->cap; ++i){ if (m->used[i]){ free(m->keys[i]); free(m->vals[i]); } } free(m->used); free(m->keys); free(m->vals); }
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int M; if (scanf("%d", &M) != 1) return 0;
|
||||
Map mp; map_init(&mp, (size_t)(M > 0 ? M : 1));
|
||||
char s1[4096], s2[4096];
|
||||
for (int i = 0; i < M; ++i){ if (scanf("%4095s %4095s", s1, s2) != 2) return 0; map_put(&mp, s1, s2); }
|
||||
int L; if (scanf("%d", &L) != 1){ map_free(&mp); return 0; }
|
||||
int ch; do { ch = getchar(); } while (ch != '\n' && ch != EOF);
|
||||
char *line = NULL; size_t bufcap = 0; ssize_t linelen;
|
||||
for (int li = 0; li < L; ++li){
|
||||
size_t len = 0; bufcap = 4096; line = (char*)malloc(bufcap);
|
||||
int c;
|
||||
while ((c = getchar()) != EOF && c != '\n'){
|
||||
if (len + 1 >= bufcap){ bufcap <<= 1; line = (char*)realloc(line, bufcap); }
|
||||
line[len++] = (char)c;
|
||||
}
|
||||
line[len] = '\0';
|
||||
char *out = (char*)malloc(len * 2 + 16);
|
||||
size_t outlen = 0;
|
||||
const char *p = line;
|
||||
while (*p){
|
||||
while (*p && (*p == ' ' || *p == '\t' || *p == '\r')) ++p;
|
||||
if (!*p) break;
|
||||
const char *q = p;
|
||||
while (*q && *q != ' ' && *q != '\t' && *q != '\r') ++q;
|
||||
size_t toklen = (size_t)(q - p);
|
||||
char *tok = (char*)malloc(toklen + 1);
|
||||
memcpy(tok, p, toklen); tok[toklen] = '\0';
|
||||
const char *rep = map_get(&mp, tok);
|
||||
const char *emit = rep ? rep : tok;
|
||||
size_t emitlen = strlen(emit);
|
||||
if (outlen) out[outlen++] = ' ';
|
||||
if (outlen + emitlen + 1 >= bufcap){ size_t need = outlen + emitlen + 1; size_t nc = bufcap; while (nc < need) nc <<= 1; out = (char*)realloc(out, nc); bufcap = nc; }
|
||||
memcpy(out + outlen, emit, emitlen); outlen += emitlen; out[outlen] = '\0';
|
||||
free(tok);
|
||||
p = q;
|
||||
}
|
||||
printf("%s\n", out);
|
||||
free(out);
|
||||
free(line);
|
||||
if (c == EOF) break;
|
||||
}
|
||||
map_free(&mp);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef unsigned long long ull;
|
||||
|
||||
static char* dupstr(const char* s){ size_t len = strlen(s); char* p = (char*)malloc(len + 1); memcpy(p, s, len + 1); return p; }
|
||||
|
||||
typedef struct {
|
||||
char **keys;
|
||||
int *cnt;
|
||||
unsigned char *used;
|
||||
size_t cap;
|
||||
} MapC;
|
||||
|
||||
static ull fnv1a(const char *s){ ull h = 1469598103934665603ULL; while (*s){ h ^= (unsigned char)(*s++); h *= 1099511628211ULL; } return h; }
|
||||
|
||||
static void map_init(MapC *m, size_t n){ size_t c = 1; while (c < (n << 1)) c <<= 1; m->cap = c; m->keys = (char**)calloc(c, sizeof(char*)); m->cnt = (int*)calloc(c, sizeof(int)); m->used = (unsigned char*)calloc(c, 1); }
|
||||
|
||||
static void map_inc(MapC *m, const char *k){ size_t mask = m->cap - 1; size_t i = (size_t)(fnv1a(k) & mask); for (;;){ if (!m->used[i]){ m->used[i] = 1; m->keys[i] = dupstr(k); m->cnt[i] = 1; return; } if (strcmp(m->keys[i], k) == 0){ ++m->cnt[i]; return; } i = (i + 1) & mask; } }
|
||||
|
||||
static int map_get_cnt(MapC *m, const char *k){ size_t mask = m->cap - 1; size_t i = (size_t)(fnv1a(k) & mask); for (;;){ if (!m->used[i]) return 0; if (strcmp(m->keys[i], k) == 0) return m->cnt[i]; i = (i + 1) & mask; } }
|
||||
|
||||
static void map_free(MapC *m){ for (size_t i = 0; i < m->cap; ++i){ if (m->used[i]) free(m->keys[i]); } free(m->used); free(m->cnt); free(m->keys); }
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int N; if (scanf("%d", &N) != 1) return 0;
|
||||
MapC mp; map_init(&mp, (size_t)(N > 0 ? N : 1));
|
||||
char **tks = (char**)malloc((size_t)N * sizeof(char*));
|
||||
char buf[4096];
|
||||
for (int i = 0; i < N; ++i){ if (scanf("%4095s", buf) != 1){ N = i; break; } tks[i] = dupstr(buf); map_inc(&mp, tks[i]); }
|
||||
int minc = 0x7fffffff; for (size_t i = 0; i < mp.cap; ++i){ if (mp.used[i]){ if (mp.cnt[i] < minc) minc = mp.cnt[i]; } }
|
||||
int first = 1;
|
||||
for (int i = 0; i < N; ++i){ int c = map_get_cnt(&mp, tks[i]); if (c != minc){ if (!first) putchar(' '); first = 0; fputs(tks[i], stdout); } }
|
||||
putchar('\n');
|
||||
for (int i = 0; i < N; ++i) free(tks[i]);
|
||||
free(tks);
|
||||
map_free(&mp);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
static int M;
|
||||
|
||||
static int imin(int a, int b){ return a < b ? a : b; }
|
||||
static int imax(int a, int b){ return a > b ? a : b; }
|
||||
|
||||
static int S;
|
||||
static int *col;
|
||||
static int *cnt;
|
||||
static int *memo;
|
||||
|
||||
static int idx(int l, int r, int k){ return ((l - 1) * S + (r - 1)) * M + k; }
|
||||
|
||||
static int F(int l, int r, int k){
|
||||
if (k >= M) k = M - 1;
|
||||
int id = idx(l, r, k);
|
||||
int v = memo[id];
|
||||
if (v != -1) return v;
|
||||
if (l == r){
|
||||
int L = cnt[r] + k;
|
||||
v = (L >= M) ? 0 : (M - L);
|
||||
memo[id] = v;
|
||||
return v;
|
||||
}
|
||||
int need = cnt[r] + k;
|
||||
int best = F(l, r - 1, 0) + ((need >= M) ? 0 : (M - need));
|
||||
for (int i = l; i <= r - 1; ++i){
|
||||
if (col[i] == col[r]){
|
||||
int nk = cnt[r] + k;
|
||||
if (nk >= M) nk = M - 1;
|
||||
int cand = F(l, i, nk) + F(i + 1, r - 1, 0);
|
||||
if (cand < best) best = cand;
|
||||
}
|
||||
}
|
||||
memo[id] = best;
|
||||
return best;
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
char s[256];
|
||||
while (scanf("%d", &M) == 1){
|
||||
if (scanf("%255s", s) != 1) break;
|
||||
int n = (int)strlen(s);
|
||||
col = (int*)malloc((size_t)(n + 1) * sizeof(int));
|
||||
cnt = (int*)malloc((size_t)(n + 1) * sizeof(int));
|
||||
S = 0;
|
||||
for (int i = 0; i < n;){
|
||||
int j = i;
|
||||
while (j < n && s[j] == s[i]) ++j;
|
||||
col[++S] = (int)s[i];
|
||||
cnt[S] = j - i;
|
||||
i = j;
|
||||
}
|
||||
memo = (int*)malloc((size_t)S * (size_t)S * (size_t)M * sizeof(int));
|
||||
for (int i = 0; i < S * S * M; ++i) memo[i] = -1;
|
||||
int ans = F(1, S, 0);
|
||||
printf("%d\n", ans);
|
||||
free(memo); free(cnt); free(col);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
typedef struct { ll x; ll a; } Item;
|
||||
|
||||
static int cmp_item(const void *p, const void *q){
|
||||
const Item *A = (const Item*)p;
|
||||
const Item *B = (const Item*)q;
|
||||
if (A->x < B->x) return -1;
|
||||
if (A->x > B->x) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int upper_less_ll(const ll *arr, int n, ll key){
|
||||
int l = 1, r = n, ans = 0;
|
||||
while (l <= r){
|
||||
int m = (l + r) >> 1;
|
||||
if (arr[m] < key){ ans = m; l = m + 1; }
|
||||
else r = m - 1;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
|
||||
typedef struct { int val; int idx; } Node;
|
||||
|
||||
static Node *seg;
|
||||
static int N;
|
||||
|
||||
static Node merge(Node a, Node b){
|
||||
if (a.val >= b.val) return a; else return b;
|
||||
}
|
||||
|
||||
static void build(int p, int l, int r, const int *R){
|
||||
if (l == r){ seg[p].val = R[l]; seg[p].idx = l; return; }
|
||||
int m = (l + r) >> 1;
|
||||
build(p<<1, l, m, R);
|
||||
build(p<<1|1, m+1, r, R);
|
||||
seg[p] = merge(seg[p<<1], seg[p<<1|1]);
|
||||
}
|
||||
|
||||
static Node query(int p, int l, int r, int ql, int qr){
|
||||
if (ql <= l && r <= qr) return seg[p];
|
||||
int m = (l + r) >> 1;
|
||||
if (qr <= m) return query(p<<1, l, m, ql, qr);
|
||||
if (ql > m) return query(p<<1|1, m+1, r, ql, qr);
|
||||
Node a = query(p<<1, l, m, ql, qr);
|
||||
Node b = query(p<<1|1, m+1, r, ql, qr);
|
||||
return merge(a, b);
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n; if (scanf("%d", &n) != 1) return 0;
|
||||
Item *arr = (Item*)malloc((size_t)(n + 1) * sizeof(Item));
|
||||
for (int i = 1; i <= n; ++i){ ll xi, ai; scanf("%lld %lld", &xi, &ai); arr[i].x = xi; arr[i].a = ai; }
|
||||
qsort(arr + 1, n, sizeof(Item), cmp_item);
|
||||
ll *xs = (ll*)malloc((size_t)(n + 1) * sizeof(ll));
|
||||
for (int i = 1; i <= n; ++i) xs[i] = arr[i].x;
|
||||
int *R = (int*)malloc((size_t)(n + 1) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i){ ll key = arr[i].x + arr[i].a; R[i] = upper_less_ll(xs, n, key); }
|
||||
N = n; seg = (Node*)malloc((size_t)(4 * N + 8) * sizeof(Node));
|
||||
build(1, 1, N, R);
|
||||
int *E = (int*)calloc((size_t)(n + 2), sizeof(int));
|
||||
for (int i = 1; i <= n; ++i){
|
||||
int t = i;
|
||||
int stsz = 0;
|
||||
int *stack = (int*)malloc((size_t)(n - i + 2) * sizeof(int));
|
||||
while (E[t] == 0){
|
||||
int rt = R[t];
|
||||
Node nd = query(1, 1, N, t, rt);
|
||||
if (nd.val == rt){ E[t] = rt + 1; break; }
|
||||
stack[stsz++] = t;
|
||||
t = nd.idx;
|
||||
}
|
||||
int res = E[t];
|
||||
while (stsz){ E[stack[--stsz]] = res; }
|
||||
free(stack);
|
||||
}
|
||||
const int MOD = 998244353;
|
||||
int *dp = (int*)calloc((size_t)(n + 2), sizeof(int));
|
||||
dp[n+1] = 1;
|
||||
for (int i = n; i >= 1; --i){
|
||||
int a1 = dp[i+1];
|
||||
int a2 = dp[E[i]];
|
||||
int s = a1 + a2; if (s >= MOD) s -= MOD;
|
||||
dp[i] = s;
|
||||
}
|
||||
printf("%d\n", dp[1]);
|
||||
free(dp); free(E); free(seg); free(R); free(xs); free(arr);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef struct { int to, next; } Edge;
|
||||
|
||||
static int *head;
|
||||
static Edge *edges;
|
||||
static int ecnt;
|
||||
|
||||
static void add_edge(int u, int v){ edges[ecnt].to = v; edges[ecnt].next = head[u]; head[u] = ecnt++; }
|
||||
|
||||
static int cmp_desc(const void *a, const void *b){ int x = *(const int*)a, y = *(const int*)b; return y - x; }
|
||||
|
||||
static int dfs(int u, int p){
|
||||
int cnt = 0;
|
||||
for (int e = head[u]; e != -1; e = edges[e].next){ int v = edges[e].to; if (v == p) continue; ++cnt; }
|
||||
if (cnt == 0) return 0;
|
||||
int *ts = (int*)malloc((size_t)cnt * sizeof(int));
|
||||
int k = 0;
|
||||
for (int e = head[u]; e != -1; e = edges[e].next){ int v = edges[e].to; if (v == p) continue; ts[k++] = dfs(v, u); }
|
||||
qsort(ts, (size_t)cnt, sizeof(int), cmp_desc);
|
||||
int best = 0;
|
||||
for (int i = 0; i < cnt; ++i){ int t = 1 + i + ts[i]; if (t > best) best = t; }
|
||||
free(ts);
|
||||
return best;
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int N; if (scanf("%d", &N) != 1) return 0;
|
||||
head = (int*)malloc(((size_t)N + 1) * sizeof(int));
|
||||
for (int i = 1; i <= N; ++i) head[i] = -1;
|
||||
edges = (Edge*)malloc((size_t)(2 * (N - 1)) * sizeof(Edge));
|
||||
ecnt = 0;
|
||||
for (int i = 2; i <= N; ++i){ int p; scanf("%d", &p); add_edge(i, p); add_edge(p, i); }
|
||||
int *times = (int*)malloc(((size_t)N + 1) * sizeof(int));
|
||||
int best = 1 << 30;
|
||||
for (int s = 1; s <= N; ++s){ int t = dfs(s, 0) + 1; times[s] = t; if (t < best) best = t; }
|
||||
printf("%d\n", best);
|
||||
int first = 1;
|
||||
for (int s = 1; s <= N; ++s){ if (times[s] == best){ if (!first) putchar(' '); first = 0; printf("%d", s); } }
|
||||
putchar('\n');
|
||||
free(times); free(edges); free(head);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef struct { int to, next; } Edge;
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n; if (scanf("%d", &n) != 1) return 0;
|
||||
int m = n - 1;
|
||||
int *head = (int*)malloc(((size_t)n + 1) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) head[i] = -1;
|
||||
Edge *edges = (Edge*)malloc((size_t)(2 * m) * sizeof(Edge));
|
||||
int ecnt = 0;
|
||||
for (int i = 0; i < m; ++i){ int x, y; scanf("%d %d", &x, &y); edges[ecnt] = (Edge){ y, head[x] }; head[x] = ecnt++; edges[ecnt] = (Edge){ x, head[y] }; head[y] = ecnt++; }
|
||||
int *parent = (int*)malloc(((size_t)n + 1) * sizeof(int));
|
||||
int *iter = (int*)malloc(((size_t)n + 1) * sizeof(int));
|
||||
char *vis = (char*)calloc((size_t)n + 1, 1);
|
||||
int *order = (int*)malloc((size_t)n * sizeof(int));
|
||||
int *stk = (int*)malloc((size_t)n * sizeof(int));
|
||||
int top = -1, ord = 0;
|
||||
parent[1] = 0; iter[1] = head[1]; vis[1] = 1; stk[++top] = 1;
|
||||
while (top >= 0){
|
||||
int u = stk[top];
|
||||
int e = iter[u];
|
||||
if (e != -1){
|
||||
iter[u] = edges[e].next;
|
||||
int v = edges[e].to;
|
||||
if (v == parent[u]) continue;
|
||||
if (!vis[v]){ vis[v] = 1; parent[v] = u; iter[v] = head[v]; stk[++top] = v; }
|
||||
} else {
|
||||
order[ord++] = u; --top;
|
||||
}
|
||||
}
|
||||
int *dp0 = (int*)calloc((size_t)n + 1, sizeof(int));
|
||||
int *dp1 = (int*)malloc(((size_t)n + 1) * sizeof(int));
|
||||
const int NEG = -1000000000;
|
||||
for (int i = 1; i <= n; ++i) dp1[i] = NEG;
|
||||
for (int t = 0; t < ord; ++t){
|
||||
int u = order[t];
|
||||
int base = 0;
|
||||
for (int e = head[u]; e != -1; e = edges[e].next){ int v = edges[e].to; if (v == parent[u]) continue; int mv = dp0[v] > dp1[v] ? dp0[v] : dp1[v]; base += mv; }
|
||||
dp0[u] = base;
|
||||
int best = NEG;
|
||||
for (int e = head[u]; e != -1; e = edges[e].next){ int v = edges[e].to; if (v == parent[u]) continue; int mv = dp0[v] > dp1[v] ? dp0[v] : dp1[v]; int cand = base - mv + dp0[v] + 1; if (cand > best) best = cand; }
|
||||
dp1[u] = best;
|
||||
}
|
||||
int ans = dp0[1] > dp1[1] ? dp0[1] : dp1[1];
|
||||
printf("%d\n", ans);
|
||||
free(dp1); free(dp0); free(stk); free(order); free(vis); free(iter); free(parent); free(edges); free(head);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n; if (scanf("%d", &n) != 1) return 0;
|
||||
for (int i = 0; i < n - 1; ++i){ int x, y; scanf("%d %d", &x, &y); }
|
||||
if ((n & 1) == 1) puts("YES"); else puts("NO");
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef struct { int to, next; } Edge;
|
||||
|
||||
static int *head;
|
||||
static Edge *edges;
|
||||
static int ecnt;
|
||||
|
||||
static void add_edge(int u, int v){ edges[ecnt].to = v; edges[ecnt].next = head[u]; head[u] = ecnt++; }
|
||||
|
||||
static int cmp_desc(const void *a, const void *b){ int x = *(const int*)a, y = *(const int*)b; return y - x; }
|
||||
|
||||
static int dfs(int u, int p){
|
||||
int cnt = 0;
|
||||
for (int e = head[u]; e != -1; e = edges[e].next){ int v = edges[e].to; if (v == p) continue; ++cnt; }
|
||||
if (cnt == 0) return 0;
|
||||
int *ts = (int*)malloc((size_t)cnt * sizeof(int));
|
||||
int k = 0;
|
||||
for (int e = head[u]; e != -1; e = edges[e].next){ int v = edges[e].to; if (v == p) continue; ts[k++] = dfs(v, u); }
|
||||
qsort(ts, (size_t)cnt, sizeof(int), cmp_desc);
|
||||
int best = 0;
|
||||
for (int i = 0; i < cnt; ++i){ int t = 1 + i + ts[i]; if (t > best) best = t; }
|
||||
free(ts);
|
||||
return best;
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int N; if (scanf("%d", &N) != 1) return 0;
|
||||
head = (int*)malloc(((size_t)N + 1) * sizeof(int));
|
||||
for (int i = 1; i <= N; ++i) head[i] = -1;
|
||||
edges = (Edge*)malloc((size_t)(2 * (N - 1)) * sizeof(Edge));
|
||||
ecnt = 0;
|
||||
for (int i = 2; i <= N; ++i){ int p; scanf("%d", &p); add_edge(i, p); add_edge(p, i); }
|
||||
int *times = (int*)malloc(((size_t)N + 1) * sizeof(int));
|
||||
int best = 1 << 30;
|
||||
for (int s = 1; s <= N; ++s){ int t = dfs(s, 0) + 1; times[s] = t; if (t < best) best = t; }
|
||||
printf("%d\n", best);
|
||||
int first = 1;
|
||||
for (int s = 1; s <= N; ++s){ if (times[s] == best){ if (!first) putchar(' '); first = 0; printf("%d", s); } }
|
||||
putchar('\n');
|
||||
free(times); free(edges); free(head);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,69 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef unsigned int u32;
|
||||
|
||||
static u32 press[25];
|
||||
|
||||
static void init_masks(void){
|
||||
for (int r = 0; r < 5; ++r){
|
||||
for (int c = 0; c < 5; ++c){
|
||||
int p = r * 5 + c;
|
||||
u32 m = 0U;
|
||||
m |= (1U << p);
|
||||
if (r > 0) m |= (1U << (p - 5));
|
||||
if (r < 4) m |= (1U << (p + 5));
|
||||
if (c > 0) m |= (1U << (p - 1));
|
||||
if (c < 4) m |= (1U << (p + 1));
|
||||
press[p] = m;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
typedef struct { u32 key; unsigned char used; unsigned char val; } Entry;
|
||||
|
||||
static Entry *map;
|
||||
static size_t cap;
|
||||
|
||||
static void map_init(size_t need){ size_t c = 1; while (c < need) c <<= 1; cap = c; map = (Entry*)calloc(cap, sizeof(Entry)); }
|
||||
|
||||
static void map_put(u32 key, unsigned char v){ size_t mask = cap - 1; size_t i = (size_t)(key & mask); for (;;){ if (!map[i].used){ map[i].used = 1; map[i].key = key; map[i].val = v; return; } if (map[i].key == key){ if (v < map[i].val) map[i].val = v; return; } i = (i + 1) & mask; } }
|
||||
|
||||
static int map_get(u32 key){ size_t mask = cap - 1; size_t i = (size_t)(key & mask); for (;;){ if (!map[i].used) return -1; if (map[i].key == key) return (int)map[i].val; i = (i + 1) & mask; } }
|
||||
|
||||
static int popcnt(u32 x){ return __builtin_popcount(x); }
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
init_masks();
|
||||
int T; if (scanf("%d", &T) != 1) return 0;
|
||||
u32 ones = 0x1FFFFFFU;
|
||||
int leftN = 12, rightN = 13;
|
||||
int leftIdx[12]; for (int i = 0; i < 12; ++i) leftIdx[i] = i;
|
||||
int rightIdx[13]; for (int i = 0; i < 13; ++i) rightIdx[i] = 12 + i;
|
||||
while (T--){
|
||||
u32 B = 0U;
|
||||
for (int r = 0; r < 5; ++r){
|
||||
for (int c = 0; c < 5; ++c){
|
||||
int v; scanf("%d", &v);
|
||||
if (v) B |= (1U << (r * 5 + c));
|
||||
}
|
||||
}
|
||||
u32 D = ones ^ B;
|
||||
size_t need = 16384;
|
||||
map_init(need);
|
||||
for (u32 s = 0; s < (1U << leftN); ++s){ int w = popcnt(s); if (w > 6) continue; u32 m = 0U; for (int i = 0; i < leftN; ++i){ if ((s >> i) & 1U) m ^= press[leftIdx[i]]; } map_put(m, (unsigned char)w); }
|
||||
int best = 7;
|
||||
for (u32 t = 0; t < (1U << rightN); ++t){ int wr = popcnt(t); if (wr > 6) continue; u32 mr = 0U; for (int i = 0; i < rightN; ++i){ if ((t >> i) & 1U) mr ^= press[rightIdx[i]]; } u32 needL = D ^ mr; int wl = map_get(needL); if (wl >= 0){ int s = wl + wr; if (s < best) best = s; } }
|
||||
if (best <= 6) printf("%d\n", best); else printf("-1\n");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef unsigned int u32;
|
||||
|
||||
static int MOD = 99989;
|
||||
|
||||
static int powmod(int a, unsigned long long e){
|
||||
long long r = 1 % MOD;
|
||||
long long x = a % MOD;
|
||||
while (e){
|
||||
if (e & 1ULL) r = (r * x) % MOD;
|
||||
x = (x * x) % MOD;
|
||||
e >>= 1ULL;
|
||||
}
|
||||
return (int)r;
|
||||
}
|
||||
|
||||
static int no_adj(u32 m){ return (m & (m << 1)) == 0U; }
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n; if (scanf("%d", &n) != 1) return 0;
|
||||
int maxH = 0; { int t = n; while (t >= 3){ ++maxH; t /= 3; } ++maxH; }
|
||||
int maxA = 0; { int t = n; while (t >= 2){ ++maxA; t /= 2; } }
|
||||
if (maxH < 1) maxH = 1;
|
||||
if (maxA < 0) maxA = 0;
|
||||
u32 **states = (u32**)malloc((size_t)(maxH + 1) * sizeof(u32*));
|
||||
int *state_count = (int*)malloc((size_t)(maxH + 1) * sizeof(int));
|
||||
for (int h = 1; h <= maxH; ++h){
|
||||
int cap = 1 << h;
|
||||
u32 *tmp = (u32*)malloc((size_t)cap * sizeof(u32));
|
||||
int cnt = 0;
|
||||
for (int m = 0; m < cap; ++m){ if (no_adj((u32)m)) tmp[cnt++] = (u32)m; }
|
||||
states[h] = (u32*)malloc((size_t)cnt * sizeof(u32));
|
||||
for (int i = 0; i < cnt; ++i) states[h][i] = tmp[i];
|
||||
state_count[h] = cnt;
|
||||
free(tmp);
|
||||
}
|
||||
unsigned long long ans = 1ULL;
|
||||
int r = 1;
|
||||
while (r <= n){
|
||||
int m = n / r;
|
||||
int R = n / m;
|
||||
int L = r;
|
||||
long long cR = (long long)R - (R / 2) - (R / 3) + (R / 6);
|
||||
long long Lm1 = (long long)(L - 1);
|
||||
long long cL = Lm1 - (Lm1 / 2) - (Lm1 / 3) + (Lm1 / 6);
|
||||
unsigned long long cnt_r = (unsigned long long)(cR - cL);
|
||||
int Amax = 0; { int t = m; while (t >= 2){ ++Amax; t /= 2; } }
|
||||
int *H = (int*)malloc(((size_t)Amax + 1) * sizeof(int));
|
||||
int tm = m;
|
||||
for (int a = 0; a <= Amax; ++a){
|
||||
int s = tm;
|
||||
int hb = 0; while (s >= 3){ ++hb; s /= 3; }
|
||||
H[a] = hb + 1;
|
||||
tm >>= 1;
|
||||
}
|
||||
int maxStates = 0;
|
||||
for (int a = 0; a <= Amax; ++a){ if (state_count[H[a]] > maxStates) maxStates = state_count[H[a]]; }
|
||||
int *dp_cur = (int*)calloc((size_t)maxStates, sizeof(int));
|
||||
int *dp_nxt = (int*)calloc((size_t)maxStates, sizeof(int));
|
||||
int h0 = H[0];
|
||||
for (int i = 0; i < state_count[h0]; ++i){ dp_cur[i] = 1; }
|
||||
for (int a = 0; a + 1 <= Amax; ++a){
|
||||
int h1 = H[a];
|
||||
int h2 = H[a+1];
|
||||
int c1 = state_count[h1];
|
||||
int c2 = state_count[h2];
|
||||
for (int j = 0; j < c2; ++j) dp_nxt[j] = 0;
|
||||
u32 *S1 = states[h1];
|
||||
u32 *S2 = states[h2];
|
||||
for (int i = 0; i < c1; ++i){
|
||||
int v = dp_cur[i]; if (!v) continue;
|
||||
u32 s1 = S1[i];
|
||||
for (int j = 0; j < c2; ++j){
|
||||
u32 s2 = S2[j];
|
||||
if ((s1 & s2) == 0U){
|
||||
int t = dp_nxt[j] + v;
|
||||
if (t >= MOD) t -= MOD;
|
||||
dp_nxt[j] = t;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int j = 0; j < c2; ++j) dp_cur[j] = dp_nxt[j];
|
||||
}
|
||||
int hlast = H[Amax];
|
||||
int cnt_last = state_count[hlast];
|
||||
int f_m = 0; for (int i = 0; i < cnt_last; ++i){ f_m += dp_cur[i]; if (f_m >= MOD) f_m -= MOD; }
|
||||
int contrib = powmod(f_m, cnt_r);
|
||||
ans = (ans * (unsigned long long)contrib) % MOD;
|
||||
free(dp_nxt); free(dp_cur); free(H);
|
||||
r = R + 1;
|
||||
}
|
||||
printf("%u\n", (unsigned int)ans);
|
||||
for (int h = 1; h <= maxH; ++h) free(states[h]);
|
||||
free(state_count); free(states);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
static int MOD = 99989;
|
||||
|
||||
static int popcnt(int x){
|
||||
int c = 0;
|
||||
while (x){ x &= (x - 1); ++c; }
|
||||
return c;
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int N, M;
|
||||
if (scanf("%d %d", &N, &M) != 2) return 0;
|
||||
int Smax = 1 << N;
|
||||
int *okrow = (int*)malloc((size_t)Smax * sizeof(int));
|
||||
int *bits = (int*)malloc((size_t)Smax * sizeof(int));
|
||||
int *list = (int*)malloc((size_t)Smax * sizeof(int));
|
||||
int cntS = 0;
|
||||
for (int m = 0; m < Smax; ++m){
|
||||
if ((m & (m << 1)) == 0){ okrow[m] = 1; bits[m] = popcnt(m); list[cntS++] = m; } else { okrow[m] = 0; bits[m] = popcnt(m); }
|
||||
}
|
||||
char **ok = (char**)malloc((size_t)cntS * sizeof(char*));
|
||||
for (int i = 0; i < cntS; ++i) ok[i] = (char*)malloc((size_t)cntS * sizeof(char));
|
||||
for (int i = 0; i < cntS; ++i){
|
||||
int a = list[i];
|
||||
for (int j = 0; j < cntS; ++j){
|
||||
int b = list[j];
|
||||
int bad = (a & b) | (a & (b << 1)) | (a & (b >> 1));
|
||||
ok[i][j] = (bad == 0) ? 1 : 0;
|
||||
}
|
||||
}
|
||||
int **dp_prev = (int**)malloc((size_t)cntS * sizeof(int*));
|
||||
int **dp_cur = (int**)malloc((size_t)cntS * sizeof(int*));
|
||||
for (int i = 0; i < cntS; ++i){ dp_prev[i] = (int*)calloc((size_t)M + 1, sizeof(int)); dp_cur[i] = (int*)calloc((size_t)M + 1, sizeof(int)); }
|
||||
for (int i = 0; i < cntS; ++i){ int b = bits[list[i]]; if (b <= M) dp_prev[i][b] = 1; }
|
||||
for (int r = 1; r < N; ++r){
|
||||
for (int j = 0; j < cntS; ++j){ for (int k = 0; k <= M; ++k) dp_cur[j][k] = 0; }
|
||||
for (int i = 0; i < cntS; ++i){
|
||||
for (int j = 0; j < cntS; ++j){ if (!ok[i][j]) continue; int add = bits[list[j]]; for (int k = 0; k + add <= M; ++k){ int v = dp_prev[i][k]; if (!v) continue; int t = dp_cur[j][k + add] + v; if (t >= MOD) t -= MOD; dp_cur[j][k + add] = t; } }
|
||||
}
|
||||
for (int j = 0; j < cntS; ++j){ for (int k = 0; k <= M; ++k) dp_prev[j][k] = dp_cur[j][k]; }
|
||||
}
|
||||
int ans = 0;
|
||||
for (int i = 0; i < cntS; ++i){ int v = dp_prev[i][M]; ans += v; if (ans >= MOD) ans -= MOD; }
|
||||
printf("%d\n", ans);
|
||||
for (int i = 0; i < cntS; ++i){ free(dp_prev[i]); free(dp_cur[i]); free(ok[i]); }
|
||||
free(dp_prev); free(dp_cur); free(ok); free(list); free(bits); free(okrow);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef unsigned long long ull;
|
||||
|
||||
int main(void)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
unsigned long long n;
|
||||
if (scanf("%llu", &n) != 1)
|
||||
return 0;
|
||||
unsigned long long ans = 0ULL;
|
||||
for (unsigned long long factor = 1ULL; factor <= n; factor *= 10ULL)
|
||||
{
|
||||
unsigned long long high = n / (factor * 10ULL);
|
||||
unsigned long long low = n % factor;
|
||||
unsigned long long cur = (n / factor) % 10ULL;
|
||||
unsigned long long term = factor * (high * 45ULL + (cur * (cur - 1ULL)) / 2ULL) + cur * (low + 1ULL);
|
||||
ans += term;
|
||||
}
|
||||
printf("%llu\n", ans);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,92 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef unsigned long long ull;
|
||||
|
||||
static const int MOD = 1000000007;
|
||||
|
||||
typedef struct { int c; int s; int q; } Node;
|
||||
|
||||
static ull digits[32];
|
||||
|
||||
static ull solve(ull n){
|
||||
if (n == (ull)-1) return 0ULL;
|
||||
int L = 0;
|
||||
if (n == 0ULL){ digits[L++] = 0ULL; }
|
||||
else { while (n){ digits[L++] = n % 10ULL; n /= 10ULL; } for (int i = 0, j = L - 1; i < j; ++i, --j){ ull t = digits[i]; digits[i] = digits[j]; digits[j] = t; } }
|
||||
static Node dp[2][2][2][6][6];
|
||||
static Node nx[2][2][2][6][6];
|
||||
for (int t = 0; t < 2; ++t) for (int a = 0; a < 2; ++a) for (int b = 0; b < 2; ++b) for (int m = 0; m < 6; ++m) for (int r = 0; r < 6; ++r){ dp[t][a][b][m][r].c = 0; dp[t][a][b][m][r].s = 0; dp[t][a][b][m][r].q = 0; }
|
||||
dp[1][1][0][0][0].c = 1;
|
||||
dp[1][1][0][0][0].s = 0;
|
||||
dp[1][1][0][0][0].q = 0;
|
||||
for (int pos = 0; pos < L; ++pos){
|
||||
int lim = (int)digits[pos];
|
||||
for (int t = 0; t < 2; ++t) for (int a = 0; a < 2; ++a) for (int b = 0; b < 2; ++b) for (int m = 0; m < 6; ++m) for (int r = 0; r < 6; ++r){ nx[t][a][b][m][r].c = 0; nx[t][a][b][m][r].s = 0; nx[t][a][b][m][r].q = 0; }
|
||||
for (int t = 0; t < 2; ++t){
|
||||
int up = t ? lim : 9;
|
||||
for (int a = 0; a < 2; ++a){
|
||||
for (int b = 0; b < 2; ++b){
|
||||
for (int m = 0; m < 6; ++m){
|
||||
for (int r = 0; r < 6; ++r){
|
||||
Node cur = dp[t][a][b][m][r];
|
||||
if (!cur.c && !cur.s && !cur.q) continue;
|
||||
for (int d = 0; d <= up; ++d){
|
||||
int nt = (t && (d == up)) ? 1 : 0;
|
||||
int na = (a && d == 0) ? 1 : 0;
|
||||
int nb = b || (d == 6);
|
||||
int nm = (m * 10 + d) % 6;
|
||||
int nr = (r + d) % 6;
|
||||
Node *dst = &nx[nt][na][nb][nm][nr];
|
||||
int cadd = cur.c;
|
||||
int sadd = (int)((10LL * cur.s + (long long)cadd * d) % MOD);
|
||||
int qadd = (int)((100LL * cur.q + (20LL * d % MOD) * cur.s + (long long)cadd * (long long)d * (long long)d) % MOD);
|
||||
dst->c += cadd; if (dst->c >= MOD) dst->c -= MOD;
|
||||
dst->s += sadd; if (dst->s >= MOD) dst->s -= MOD;
|
||||
dst->q += qadd; if (dst->q >= MOD) dst->q -= MOD;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int t = 0; t < 2; ++t) for (int a = 0; a < 2; ++a) for (int b = 0; b < 2; ++b) for (int m = 0; m < 6; ++m) for (int r = 0; r < 6; ++r){ dp[t][a][b][m][r] = nx[t][a][b][m][r]; }
|
||||
}
|
||||
long long ans = 0;
|
||||
for (int t = 0; t < 2; ++t){
|
||||
for (int a = 0; a < 2; ++a){
|
||||
for (int b = 0; b < 2; ++b){
|
||||
if (b) continue;
|
||||
for (int m = 0; m < 6; ++m){
|
||||
if (m == 0) continue;
|
||||
for (int r = 0; r < 6; ++r){
|
||||
if (r == 0) continue;
|
||||
ans += dp[t][a][b][m][r].q;
|
||||
if (ans >= MOD) ans -= MOD;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return (ull)ans;
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int T; if (scanf("%d", &T) != 1) return 0;
|
||||
while (T--){
|
||||
unsigned long long a, b; scanf("%llu %llu", &a, &b);
|
||||
ull x = solve(b);
|
||||
ull y = solve(a - 1ULL);
|
||||
ull ans = (x >= y) ? (x - y) : (x + MOD - y);
|
||||
printf("%llu\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1)
|
||||
return 0;
|
||||
unsigned int N = (1u << (n + 1)) - 1u;
|
||||
long long *w = (long long *)malloc(((size_t)N + 2) * sizeof(long long));
|
||||
long long *mx = (long long *)malloc(((size_t)N + 2) * sizeof(long long));
|
||||
for (unsigned int i = 1; i <= N; ++i)
|
||||
scanf("%lld", &w[i]);
|
||||
unsigned int first_leaf = (N >> 1) + 1u;
|
||||
for (unsigned int i = first_leaf; i <= N; ++i)
|
||||
mx[i] = w[i];
|
||||
long long add = 0;
|
||||
for (int i = (int)(first_leaf - 1u); i >= 1; --i)
|
||||
{
|
||||
long long L = mx[i << 1];
|
||||
long long R = mx[(i << 1) | 1];
|
||||
add += (L >= R) ? (L - R) : (R - L);
|
||||
mx[i] = w[i] + ((L >= R) ? L : R);
|
||||
}
|
||||
printf("%lld\n", add);
|
||||
free(w);
|
||||
free(mx);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
static const int MOD = 1000000007;
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int f; if (scanf("%d", &f) != 1) return 0;
|
||||
int *ns = (int*)malloc((size_t)f * sizeof(int));
|
||||
int maxN = 0;
|
||||
for (int i = 0; i < f; ++i){ scanf("%d", &ns[i]); if (ns[i] > maxN) maxN = ns[i]; }
|
||||
if (maxN < 0) maxN = 0;
|
||||
int *dp1 = (int*)calloc((size_t)maxN + 2, sizeof(int));
|
||||
int *dp2 = (int*)calloc((size_t)maxN + 2, sizeof(int));
|
||||
if (maxN >= 1){ dp1[1] = 3; dp2[1] = 0; }
|
||||
for (int n = 2; n <= maxN; ++n){
|
||||
long long a = (2LL * dp1[n-1] + 2LL * dp2[n-1]) % MOD;
|
||||
long long b = (1LL * dp1[n-1]) % MOD;
|
||||
dp1[n] = (int)a;
|
||||
dp2[n] = (int)b;
|
||||
}
|
||||
for (int i = 0; i < f; ++i){
|
||||
int n = ns[i];
|
||||
if (n == 0){ printf("1\n"); continue; }
|
||||
int ans = dp1[n]; ans += dp2[n]; if (ans >= MOD) ans -= MOD;
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
free(dp2); free(dp1); free(ns);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,223 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
static const int P = 61;
|
||||
|
||||
static int C[61][61];
|
||||
static int pow2_small[400];
|
||||
|
||||
static int pow2_mod(unsigned long long e)
|
||||
{
|
||||
unsigned long long b = 2ULL;
|
||||
unsigned long long r = 1ULL;
|
||||
while (e)
|
||||
{
|
||||
if (e & 1ULL)
|
||||
r = (r * b) % P;
|
||||
b = (b * b) % P;
|
||||
e >>= 1ULL;
|
||||
}
|
||||
return (int)r;
|
||||
}
|
||||
|
||||
static int sum_prefix_mod61(unsigned long long k, long long t)
|
||||
{
|
||||
if (t < 0)
|
||||
return 0;
|
||||
if ((unsigned long long)t >= k)
|
||||
return pow2_mod(k);
|
||||
int Kdig[16], Tdig[16];
|
||||
int L = 0;
|
||||
unsigned long long kk = k;
|
||||
while (kk)
|
||||
{
|
||||
Kdig[L++] = (int)(kk % P);
|
||||
kk /= P;
|
||||
}
|
||||
if (L == 0)
|
||||
{
|
||||
Kdig[L++] = 0;
|
||||
}
|
||||
unsigned long long tt = (unsigned long long)t;
|
||||
int Lt = 0;
|
||||
while (tt)
|
||||
{
|
||||
Tdig[Lt++] = (int)(tt % P);
|
||||
tt /= P;
|
||||
}
|
||||
while (Lt < L)
|
||||
{
|
||||
Tdig[Lt++] = 0;
|
||||
}
|
||||
int Krev[16], Trev[16];
|
||||
for (int i = 0; i < L; ++i)
|
||||
{
|
||||
Krev[i] = Kdig[L - 1 - i];
|
||||
Trev[i] = Tdig[L - 1 - i];
|
||||
}
|
||||
int suffix_sum_digits[17];
|
||||
suffix_sum_digits[L] = 0;
|
||||
for (int i = L - 1; i >= 0; --i)
|
||||
suffix_sum_digits[i] = suffix_sum_digits[i + 1] + Krev[i];
|
||||
int res = 0;
|
||||
for (int i = 0; i < L; ++i)
|
||||
{
|
||||
int limit = Trev[i];
|
||||
int nd = Krev[i];
|
||||
int up = (limit < nd) ? limit : nd;
|
||||
for (int w = 0; w < up; ++w)
|
||||
{
|
||||
int cv = C[nd][w];
|
||||
if (!cv)
|
||||
continue;
|
||||
int tail = suffix_sum_digits[i + 1];
|
||||
int add = (int)((cv * (long long)pow2_small[tail]) % P);
|
||||
res += add;
|
||||
if (res >= P)
|
||||
res -= P;
|
||||
}
|
||||
if (up >= 0)
|
||||
{
|
||||
int w = up;
|
||||
int cv = C[nd][w];
|
||||
if (!cv)
|
||||
{
|
||||
return res;
|
||||
}
|
||||
if (w < limit)
|
||||
{
|
||||
int tail = suffix_sum_digits[i + 1];
|
||||
int add = (int)((cv * (long long)pow2_small[tail]) % P);
|
||||
res += add;
|
||||
if (res >= P)
|
||||
res -= P;
|
||||
return res;
|
||||
}
|
||||
}
|
||||
}
|
||||
res += 1;
|
||||
if (res >= P)
|
||||
res -= P;
|
||||
return res;
|
||||
}
|
||||
|
||||
static inline char map_char(int x)
|
||||
{
|
||||
if (x <= 9)
|
||||
return (char)('0' + x);
|
||||
if (x <= 35)
|
||||
return (char)('A' + (x - 10));
|
||||
return (char)('a' + (x - 36));
|
||||
}
|
||||
|
||||
static int read_int_fast()
|
||||
{
|
||||
int c = getchar();
|
||||
while (c != EOF && (c <= ' '))
|
||||
c = getchar();
|
||||
if (c == EOF)
|
||||
return -1;
|
||||
int x = 0;
|
||||
while (c > ' ')
|
||||
{
|
||||
x = x * 10 + (c - '0');
|
||||
c = getchar();
|
||||
}
|
||||
return x;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
for (int n = 0; n <= 60; ++n)
|
||||
{
|
||||
C[n][0] = 1 % P;
|
||||
for (int r = 1; r <= n; ++r)
|
||||
{
|
||||
int v = (C[n - 1][r - 1] + C[n - 1][r]) % P;
|
||||
C[n][r] = v;
|
||||
}
|
||||
}
|
||||
pow2_small[0] = 1 % P;
|
||||
for (int i = 1; i < 400; ++i)
|
||||
{
|
||||
pow2_small[i] = (pow2_small[i - 1] * 2) % P;
|
||||
}
|
||||
int Q = read_int_fast();
|
||||
unsigned char *A = (unsigned char *)malloc((size_t)Q + 5);
|
||||
int head = 0, tail = 0;
|
||||
long long cnt0 = 0, cnt1 = 0, cntq = 0;
|
||||
int last = 0;
|
||||
int outputs = 0;
|
||||
for (int qi = 0; qi < Q; ++qi)
|
||||
{
|
||||
int x = read_int_fast();
|
||||
x ^= (last & 3);
|
||||
if (x == 0)
|
||||
{
|
||||
A[tail++] = 0;
|
||||
++cnt0;
|
||||
}
|
||||
else if (x == 1)
|
||||
{
|
||||
A[tail++] = 1;
|
||||
++cnt1;
|
||||
}
|
||||
else if (x == 2)
|
||||
{
|
||||
A[tail++] = 2;
|
||||
++cntq;
|
||||
}
|
||||
else
|
||||
{
|
||||
unsigned char v = A[head++];
|
||||
if (v == 0)
|
||||
--cnt0;
|
||||
else if (v == 1)
|
||||
--cnt1;
|
||||
else
|
||||
--cntq;
|
||||
}
|
||||
int L = tail - head;
|
||||
if ((L & 1) == 1)
|
||||
{
|
||||
long long ones = cnt1;
|
||||
long long k = cntq;
|
||||
long long T = (L + 1) / 2;
|
||||
long long need = T - ones;
|
||||
int ans;
|
||||
if (need <= 0)
|
||||
{
|
||||
ans = pow2_mod((unsigned long long)k);
|
||||
}
|
||||
else if (need > k)
|
||||
{
|
||||
ans = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
unsigned long long K = (unsigned long long)k;
|
||||
unsigned long long sum0 = sum_prefix_mod61(K, (long long)(need - 1));
|
||||
int twoK = pow2_mod(K);
|
||||
ans = twoK - (int)sum0;
|
||||
if (ans < 0)
|
||||
ans += P;
|
||||
}
|
||||
char ch = map_char(ans);
|
||||
putchar(ch);
|
||||
putchar('\n');
|
||||
last = ans;
|
||||
++outputs;
|
||||
}
|
||||
}
|
||||
free(A);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,240 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef struct
|
||||
{
|
||||
int x, y;
|
||||
} Pt;
|
||||
|
||||
static int manh(Pt a, Pt b)
|
||||
{
|
||||
int dx = a.x - b.x;
|
||||
if (dx < 0)
|
||||
dx = -dx;
|
||||
int dy = a.y - b.y;
|
||||
if (dy < 0)
|
||||
dy = -dy;
|
||||
return dx + dy;
|
||||
}
|
||||
|
||||
static void gen_segment(Pt a, Pt b)
|
||||
{
|
||||
int sx = (b.x > a.x) ? 1 : (b.x < a.x ? -1 : 0);
|
||||
int sy = (b.y > a.y) ? 1 : (b.y < a.y ? -1 : 0);
|
||||
while (a.x != b.x)
|
||||
{
|
||||
a.x += sx;
|
||||
printf(" (%d,%d)", a.x, a.y);
|
||||
}
|
||||
while (a.y != b.y)
|
||||
{
|
||||
a.y += sy;
|
||||
printf(" (%d,%d)", a.x, a.y);
|
||||
}
|
||||
}
|
||||
|
||||
static int perm_next(int *p, int n)
|
||||
{
|
||||
int i = n - 2;
|
||||
while (i >= 0 && p[i] > p[i + 1])
|
||||
--i;
|
||||
if (i < 0)
|
||||
return 0;
|
||||
int j = n - 1;
|
||||
while (p[j] < p[i])
|
||||
--j;
|
||||
int t = p[i];
|
||||
p[i] = p[j];
|
||||
p[j] = t;
|
||||
int l = i + 1, r = n - 1;
|
||||
while (l < r)
|
||||
{
|
||||
t = p[l];
|
||||
p[l] = p[r];
|
||||
p[r] = t;
|
||||
++l;
|
||||
--r;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void best_route(Pt S, Pt *grp, int k, int *best_len, int *best_order)
|
||||
{
|
||||
int idx[4];
|
||||
for (int i = 0; i < k; ++i)
|
||||
idx[i] = i;
|
||||
int first = 1;
|
||||
do
|
||||
{
|
||||
int sum = 0;
|
||||
Pt cur = S;
|
||||
for (int i = 0; i < k; ++i)
|
||||
{
|
||||
sum += manh(cur, grp[idx[i]]);
|
||||
cur = grp[idx[i]];
|
||||
}
|
||||
if (first || sum < *best_len)
|
||||
{
|
||||
*best_len = sum;
|
||||
for (int i = 0; i < k; ++i)
|
||||
best_order[i] = idx[i];
|
||||
first = 0;
|
||||
}
|
||||
} while (perm_next(idx, k));
|
||||
}
|
||||
|
||||
typedef struct
|
||||
{
|
||||
Pt *pts;
|
||||
int cnt;
|
||||
} Bucket;
|
||||
|
||||
int main(void)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int N;
|
||||
if (scanf("%d", &N) != 1)
|
||||
return 0;
|
||||
Pt *emps = (Pt *)malloc((size_t)N * sizeof(Pt));
|
||||
for (int i = 0; i < N; ++i)
|
||||
scanf("%d %d", &emps[i].x, &emps[i].y);
|
||||
Pt S;
|
||||
scanf("%d %d", &S.x, &S.y);
|
||||
Pt *eff = (Pt *)malloc((size_t)N * sizeof(Pt));
|
||||
int M = 0;
|
||||
for (int i = 0; i < N; ++i)
|
||||
{
|
||||
if (emps[i].x == S.x && emps[i].y == S.y)
|
||||
continue;
|
||||
eff[M++] = emps[i];
|
||||
}
|
||||
if (M == 0)
|
||||
{
|
||||
printf("0\n0\n");
|
||||
free(eff);
|
||||
free(emps);
|
||||
return 0;
|
||||
}
|
||||
Bucket bkt[8];
|
||||
for (int i = 0; i < 8; ++i)
|
||||
{
|
||||
bkt[i].pts = (Pt *)malloc((size_t)M * sizeof(Pt));
|
||||
bkt[i].cnt = 0;
|
||||
}
|
||||
for (int i = 0; i < M; ++i)
|
||||
{
|
||||
int dx = eff[i].x - S.x, dy = eff[i].y - S.y;
|
||||
int id = 0;
|
||||
if (dx > 0 && dy > 0)
|
||||
id = 0;
|
||||
else if (dx < 0 && dy > 0)
|
||||
id = 1;
|
||||
else if (dx > 0 && dy < 0)
|
||||
id = 2;
|
||||
else if (dx < 0 && dy < 0)
|
||||
id = 3;
|
||||
else if (dx == 0 && dy > 0)
|
||||
id = 4;
|
||||
else if (dx == 0 && dy < 0)
|
||||
id = 5;
|
||||
else if (dy == 0 && dx > 0)
|
||||
id = 6;
|
||||
else
|
||||
id = 7;
|
||||
bkt[id].pts[bkt[id].cnt++] = eff[i];
|
||||
}
|
||||
int groups = 0;
|
||||
int cap = (M + 3) / 4;
|
||||
Pt **grp_pts = (Pt **)malloc((size_t)cap * sizeof(Pt *));
|
||||
int *grp_sizes = (int *)malloc((size_t)cap * sizeof(int));
|
||||
for (int id = 0; id < 8; ++id)
|
||||
{
|
||||
int c = bkt[id].cnt;
|
||||
if (c == 0)
|
||||
continue;
|
||||
int *ord = (int *)malloc((size_t)c * sizeof(int));
|
||||
for (int i = 0; i < c; ++i)
|
||||
ord[i] = i;
|
||||
for (int i = 0; i < c; ++i)
|
||||
{
|
||||
for (int j = i + 1; j < c; ++j)
|
||||
{
|
||||
if (manh(S, bkt[id].pts[ord[i]]) > manh(S, bkt[id].pts[ord[j]]))
|
||||
{
|
||||
int t = ord[i];
|
||||
ord[i] = ord[j];
|
||||
ord[j] = t;
|
||||
}
|
||||
}
|
||||
}
|
||||
int i = 0;
|
||||
while (i < c)
|
||||
{
|
||||
int k = c - i;
|
||||
if (k > 4)
|
||||
k = 4;
|
||||
Pt *arr = (Pt *)malloc((size_t)k * sizeof(Pt));
|
||||
for (int t = 0; t < k; ++t)
|
||||
arr[t] = bkt[id].pts[ord[i + t]];
|
||||
grp_pts[groups] = arr;
|
||||
grp_sizes[groups] = k;
|
||||
++groups;
|
||||
i += k;
|
||||
}
|
||||
free(ord);
|
||||
}
|
||||
int *lens = (int *)malloc((size_t)groups * sizeof(int));
|
||||
int **order = (int **)malloc((size_t)groups * sizeof(int *));
|
||||
for (int g = 0; g < groups; ++g)
|
||||
{
|
||||
order[g] = (int *)malloc(4 * sizeof(int));
|
||||
int bl = 0;
|
||||
best_route(S, grp_pts[g], grp_sizes[g], &bl, order[g]);
|
||||
lens[g] = bl;
|
||||
}
|
||||
int total = 0;
|
||||
for (int g = 0; g < groups; ++g)
|
||||
total += lens[g];
|
||||
printf("%d\n", total);
|
||||
printf("%d\n", groups);
|
||||
for (int g = 0; g < groups; ++g)
|
||||
{
|
||||
printf("%d", lens[g]);
|
||||
for (int i = 0; i < grp_sizes[g]; ++i)
|
||||
{
|
||||
Pt p = grp_pts[g][i];
|
||||
printf("(%d,%d)%s", p.x, p.y, (i + 1 == grp_sizes[g]) ? " " : " ");
|
||||
}
|
||||
printf(": ");
|
||||
Pt cur = S;
|
||||
printf("(%d,%d)", cur.x, cur.y);
|
||||
for (int i = 0; i < grp_sizes[g]; ++i)
|
||||
{
|
||||
Pt nxt = grp_pts[g][order[g][i]];
|
||||
gen_segment(cur, nxt);
|
||||
cur = nxt;
|
||||
}
|
||||
printf("\n");
|
||||
}
|
||||
for (int g = 0; g < groups; ++g)
|
||||
{
|
||||
free(order[g]);
|
||||
free(grp_pts[g]);
|
||||
}
|
||||
free(order);
|
||||
free(grp_pts);
|
||||
free(grp_sizes);
|
||||
free(lens);
|
||||
for (int i = 0; i < 8; ++i)
|
||||
free(bkt[i].pts);
|
||||
free(eff);
|
||||
free(emps);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef struct { char *name; char *path; } Node;
|
||||
|
||||
static char* dupstr(const char* s){ size_t n = strlen(s); char* p = (char*)malloc(n + 1); if (!p) exit(1); memcpy(p, s, n + 1); return p; }
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
Node *nodes = (Node*)malloc(2000 * sizeof(Node));
|
||||
int cap = 2000, cnt = 0;
|
||||
int last_idx[2048];
|
||||
for (int i = 0; i < 2048; ++i) last_idx[i] = -1;
|
||||
char buf[4096];
|
||||
while (fgets(buf, sizeof(buf), stdin)){
|
||||
size_t len = strlen(buf);
|
||||
while (len && (buf[len-1] == '\n' || buf[len-1] == '\r')) buf[--len] = '\0';
|
||||
while (len && buf[len-1] == ' ') buf[--len] = '\0';
|
||||
if (len == 0) continue;
|
||||
if (strcmp(buf, "#") == 0) break;
|
||||
size_t i = 0; while (buf[i] == ' ') ++i;
|
||||
int level = (int)i;
|
||||
const char *name = buf + i;
|
||||
if (*name == '\0') continue;
|
||||
size_t nlen = strlen(name);
|
||||
char *path;
|
||||
if (level == 0){
|
||||
path = (char*)malloc(1 + nlen + 1);
|
||||
path[0] = '/';
|
||||
memcpy(path + 1, name, nlen);
|
||||
path[1 + nlen] = '\0';
|
||||
} else {
|
||||
const char *parent_path = nodes[last_idx[level - 1]].path;
|
||||
size_t plen = strlen(parent_path);
|
||||
path = (char*)malloc(plen + 1 + nlen + 1);
|
||||
memcpy(path, parent_path, plen);
|
||||
path[plen] = '/';
|
||||
memcpy(path + plen + 1, name, nlen);
|
||||
path[plen + 1 + nlen] = '\0';
|
||||
}
|
||||
if (cnt == cap){ cap <<= 1; nodes = (Node*)realloc(nodes, (size_t)cap * sizeof(Node)); }
|
||||
nodes[cnt].name = dupstr(name);
|
||||
nodes[cnt].path = path;
|
||||
last_idx[level] = cnt;
|
||||
++cnt;
|
||||
}
|
||||
if (!fgets(buf, sizeof(buf), stdin)) return 0;
|
||||
size_t len = strlen(buf);
|
||||
while (len && (buf[len-1] == '\n' || buf[len-1] == '\r')) buf[--len] = '\0';
|
||||
while (len && buf[len-1] == ' ') buf[--len] = '\0';
|
||||
size_t j = 0; while (buf[j] == ' ') ++j; const char *q = buf + j;
|
||||
int found = 0;
|
||||
for (int i = 0; i < cnt; ++i){ if (strcmp(nodes[i].name, q) == 0){ puts(nodes[i].path); found = 1; } }
|
||||
if (!found) puts("NULL");
|
||||
for (int i = 0; i < cnt; ++i){ free(nodes[i].name); free(nodes[i].path); }
|
||||
free(nodes);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
#include <stdio.h>
|
||||
|
||||
typedef struct { int x, y; } P;
|
||||
|
||||
static int n;
|
||||
static P a[105];
|
||||
static int vis[105];
|
||||
|
||||
static void dfs(int u)
|
||||
{
|
||||
vis[u] = 1;
|
||||
for (int v = 0; v < n; ++v)
|
||||
{
|
||||
if (!vis[v] && (a[v].x == a[u].x || a[v].y == a[u].y))
|
||||
dfs(v);
|
||||
}
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
for (int i = 0; i < n; ++i)
|
||||
scanf("%d %d", &a[i].x, &a[i].y);
|
||||
for (int i = 0; i < n; ++i) vis[i] = 0;
|
||||
int comp = 0;
|
||||
for (int i = 0; i < n; ++i)
|
||||
{
|
||||
if (!vis[i])
|
||||
{
|
||||
++comp;
|
||||
dfs(i);
|
||||
}
|
||||
}
|
||||
printf("%d\n", comp - 1);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n, m;
|
||||
if (scanf("%d %d", &n, &m) != 2) return 0;
|
||||
int *head = (int *)malloc(((size_t)n + 2) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) head[i] = -1;
|
||||
int E = m * 2;
|
||||
int *to = (int *)malloc(((size_t)E + 5) * sizeof(int));
|
||||
int *next = (int *)malloc(((size_t)E + 5) * sizeof(int));
|
||||
int idx = 0;
|
||||
for (int i = 0; i < m; ++i)
|
||||
{
|
||||
int a, b; scanf("%d %d", &a, &b);
|
||||
to[idx] = b; next[idx] = head[a]; head[a] = idx++;
|
||||
to[idx] = a; next[idx] = head[b]; head[b] = idx++;
|
||||
}
|
||||
int x; scanf("%d", &x);
|
||||
int *dist = (int *)malloc(((size_t)n + 2) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) dist[i] = -1;
|
||||
int *q = (int *)malloc(((size_t)n + 5) * sizeof(int));
|
||||
int hh = 0, tt = 0;
|
||||
dist[x] = 0; q[tt++] = x;
|
||||
while (hh < tt)
|
||||
{
|
||||
int u = q[hh++];
|
||||
for (int i = head[u]; i != -1; i = next[i])
|
||||
{
|
||||
int v = to[i];
|
||||
if (dist[v] == -1)
|
||||
{
|
||||
dist[v] = dist[u] + 1;
|
||||
q[tt++] = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
int ans = 0;
|
||||
for (int i = 1; i <= n; ++i)
|
||||
if (dist[i] > ans) ans = dist[i];
|
||||
printf("%d\n", ans);
|
||||
free(head); free(to); free(next); free(dist); free(q);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
#include <stdio.h>
|
||||
|
||||
static int parent[105][105];
|
||||
static unsigned char used[105];
|
||||
|
||||
static int findc(int c, int x)
|
||||
{
|
||||
int p = parent[c][x];
|
||||
while (p != x)
|
||||
{
|
||||
int gp = parent[c][p];
|
||||
parent[c][x] = gp;
|
||||
x = p;
|
||||
p = gp;
|
||||
}
|
||||
return x;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n, m;
|
||||
if (scanf("%d %d", &n, &m) != 2) return 0;
|
||||
for (int c = 1; c <= m; ++c)
|
||||
{
|
||||
for (int i = 1; i <= n; ++i)
|
||||
parent[c][i] = i;
|
||||
used[c] = 0;
|
||||
}
|
||||
for (int i = 0; i < m; ++i)
|
||||
{
|
||||
int x, y, c;
|
||||
scanf("%d %d %d", &x, &y, &c);
|
||||
used[c] = 1;
|
||||
int rx = findc(c, x);
|
||||
int ry = findc(c, y);
|
||||
if (rx != ry) parent[c][rx] = ry;
|
||||
}
|
||||
int q;
|
||||
scanf("%d", &q);
|
||||
while (q--)
|
||||
{
|
||||
int u, v;
|
||||
scanf("%d %d", &u, &v);
|
||||
int ans = 0;
|
||||
for (int c = 1; c <= m; ++c)
|
||||
{
|
||||
if (!used[c]) continue;
|
||||
int ru = findc(c, u);
|
||||
int rv = findc(c, v);
|
||||
if (ru == rv) ++ans;
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n; if (scanf("%d", &n) != 1) return 0;
|
||||
int E = (n - 1) * 2;
|
||||
int *head = (int *)malloc(((size_t)n + 2) * sizeof(int));
|
||||
int *to = (int *)malloc(((size_t)E + 5) * sizeof(int));
|
||||
int *next = (int *)malloc(((size_t)E + 5) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) head[i] = -1;
|
||||
int idx = 0;
|
||||
for (int i = 0; i < n - 1; ++i)
|
||||
{
|
||||
int u, v; scanf("%d %d", &u, &v);
|
||||
to[idx] = v; next[idx] = head[u]; head[u] = idx++;
|
||||
to[idx] = u; next[idx] = head[v]; head[v] = idx++;
|
||||
}
|
||||
int *color = (int *)malloc(((size_t)n + 2) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) color[i] = -1;
|
||||
int *q = (int *)malloc(((size_t)n + 5) * sizeof(int));
|
||||
int hh = 0, tt = 0;
|
||||
color[1] = 0; q[tt++] = 1;
|
||||
while (hh < tt)
|
||||
{
|
||||
int u = q[hh++];
|
||||
for (int i = head[u]; i != -1; i = next[i])
|
||||
{
|
||||
int v = to[i];
|
||||
if (color[v] == -1)
|
||||
{
|
||||
color[v] = color[u] ^ 1;
|
||||
q[tt++] = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
long long a = 0, b = 0;
|
||||
for (int i = 1; i <= n; ++i) if (color[i] == 0) ++a; else ++b;
|
||||
long long ans = a * b - (long long)(n - 1);
|
||||
printf("%lld\n", ans);
|
||||
free(head); free(to); free(next); free(color); free(q);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <limits.h>
|
||||
|
||||
typedef struct { int v, w, next; } Edge;
|
||||
typedef struct { long long d; int u, m; } HN;
|
||||
|
||||
static int n, m, p;
|
||||
static int *head;
|
||||
static Edge *E;
|
||||
static int ec;
|
||||
static int *pc, *pa, *pb, *pt;
|
||||
|
||||
static HN *heap;
|
||||
static int hsz;
|
||||
|
||||
static void hpush(HN x)
|
||||
{
|
||||
int i = hsz++;
|
||||
heap[i] = x;
|
||||
while (i)
|
||||
{
|
||||
int p = (i - 1) >> 1;
|
||||
if (heap[p].d <= heap[i].d) break;
|
||||
HN t = heap[p]; heap[p] = heap[i]; heap[i] = t; i = p;
|
||||
}
|
||||
}
|
||||
|
||||
static HN hpop()
|
||||
{
|
||||
HN r = heap[0];
|
||||
heap[0] = heap[--hsz];
|
||||
int i = 0;
|
||||
for (;;)
|
||||
{
|
||||
int l = i * 2 + 1, rgt = l + 1, s = i;
|
||||
if (l < hsz && heap[l].d < heap[s].d) s = l;
|
||||
if (rgt < hsz && heap[rgt].d < heap[s].d) s = rgt;
|
||||
if (s == i) break;
|
||||
HN t = heap[i]; heap[i] = heap[s]; heap[s] = t; i = s;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
if (scanf("%d %d %d", &n, &m, &p) != 3) return 0;
|
||||
head = (int *)malloc(((size_t)n + 2) * sizeof(int));
|
||||
E = (Edge *)malloc(((size_t)m * 2 + 5) * sizeof(Edge));
|
||||
for (int i = 1; i <= n; ++i) head[i] = -1;
|
||||
ec = 0;
|
||||
for (int i = 0; i < m; ++i)
|
||||
{
|
||||
int u, v, w; scanf("%d %d %d", &u, &v, &w);
|
||||
E[ec].v = v; E[ec].w = w; E[ec].next = head[u]; head[u] = ec++;
|
||||
E[ec].v = u; E[ec].w = w; E[ec].next = head[v]; head[v] = ec++;
|
||||
}
|
||||
pc = (int *)malloc(((size_t)p + 2) * sizeof(int));
|
||||
pa = (int *)malloc(((size_t)p + 2) * sizeof(int));
|
||||
pb = (int *)malloc(((size_t)p + 2) * sizeof(int));
|
||||
pt = (int *)malloc(((size_t)p + 2) * sizeof(int));
|
||||
for (int i = 0; i < p; ++i)
|
||||
{
|
||||
int c, a, b, t; scanf("%d %d %d %d", &c, &a, &b, &t);
|
||||
pc[i] = c; pa[i] = a; pb[i] = b; pt[i] = t;
|
||||
}
|
||||
int M = 1 << p;
|
||||
long long *dist = (long long *)malloc(((size_t)n * (size_t)M) * sizeof(long long));
|
||||
for (size_t i = 0; i < (size_t)n * (size_t)M; ++i) dist[i] = LLONG_MAX;
|
||||
heap = (HN *)malloc(((size_t)n * (size_t)M + 5) * sizeof(HN));
|
||||
hsz = 0;
|
||||
dist[(0) * (size_t)n + (size_t)(1 - 1)] = 0;
|
||||
hpush((HN){0LL, 1, 0});
|
||||
while (hsz)
|
||||
{
|
||||
HN cur = hpop();
|
||||
long long cd = cur.d; int u = cur.u; int mask = cur.m;
|
||||
if (cd != dist[(size_t)mask * (size_t)n + (size_t)(u - 1)]) continue;
|
||||
if (u == n)
|
||||
{
|
||||
printf("%lld\n", cd);
|
||||
free(head); free(E); free(pc); free(pa); free(pb); free(pt); free(dist); free(heap);
|
||||
return 0;
|
||||
}
|
||||
for (int i = head[u]; i != -1; i = E[i].next)
|
||||
{
|
||||
int v = E[i].v; long long nd = cd + (long long)E[i].w;
|
||||
size_t idx = (size_t)mask * (size_t)n + (size_t)(v - 1);
|
||||
if (nd < dist[idx]) { dist[idx] = nd; hpush((HN){nd, v, mask}); }
|
||||
}
|
||||
for (int i = 0; i < p; ++i)
|
||||
{
|
||||
int bit = 1 << i;
|
||||
if (!(mask & bit) && u == pc[i])
|
||||
{
|
||||
int nmask = mask | bit;
|
||||
size_t idx = (size_t)nmask * (size_t)n + (size_t)(u - 1);
|
||||
if (cd < dist[idx]) { dist[idx] = cd; hpush((HN){cd, u, nmask}); }
|
||||
}
|
||||
if (mask & bit)
|
||||
{
|
||||
if (u == pa[i])
|
||||
{
|
||||
int v = pb[i]; long long nd = cd + (long long)pt[i];
|
||||
size_t idx = (size_t)mask * (size_t)n + (size_t)(v - 1);
|
||||
if (nd < dist[idx]) { dist[idx] = nd; hpush((HN){nd, v, mask}); }
|
||||
}
|
||||
if (u == pb[i])
|
||||
{
|
||||
int v = pa[i]; long long nd = cd + (long long)pt[i];
|
||||
size_t idx = (size_t)mask * (size_t)n + (size_t)(v - 1);
|
||||
if (nd < dist[idx]) { dist[idx] = nd; hpush((HN){nd, v, mask}); }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,85 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <limits.h>
|
||||
|
||||
typedef struct { int v, w, next; } Edge;
|
||||
typedef struct { long long d; int u; } HN;
|
||||
|
||||
static long long *dij(int n, int *head, Edge *E, int src)
|
||||
{
|
||||
long long *dist = (long long *)malloc(((size_t)n + 1) * sizeof(long long));
|
||||
for (int i = 1; i <= n; ++i) dist[i] = LLONG_MAX;
|
||||
HN *heap = (HN *)malloc(((size_t)n * 4 + 5) * sizeof(HN));
|
||||
int hsz = 0;
|
||||
dist[src] = 0; heap[hsz++] = (HN){0, src};
|
||||
for (int i = hsz - 1; i > 0; --i)
|
||||
{
|
||||
int p = (i - 1) >> 1;
|
||||
if (heap[p].d > heap[i].d) { HN t = heap[p]; heap[p] = heap[i]; heap[i] = t; }
|
||||
}
|
||||
while (hsz)
|
||||
{
|
||||
HN cur = heap[0];
|
||||
heap[0] = heap[--hsz];
|
||||
int i = 0;
|
||||
for (;;)
|
||||
{
|
||||
int l = i * 2 + 1, r = l + 1, s = i;
|
||||
if (l < hsz && heap[l].d < heap[s].d) s = l;
|
||||
if (r < hsz && heap[r].d < heap[s].d) s = r;
|
||||
if (s == i) break;
|
||||
HN t = heap[i]; heap[i] = heap[s]; heap[s] = t; i = s;
|
||||
}
|
||||
long long cd = cur.d; int u = cur.u;
|
||||
if (cd != dist[u]) continue;
|
||||
for (int e = head[u]; e != -1; e = E[e].next)
|
||||
{
|
||||
int v = E[e].v; long long nd = cd + (long long)E[e].w;
|
||||
if (nd < dist[v])
|
||||
{
|
||||
dist[v] = nd;
|
||||
int k = hsz++;
|
||||
heap[k] = (HN){nd, v};
|
||||
while (k)
|
||||
{
|
||||
int p = (k - 1) >> 1;
|
||||
if (heap[p].d <= heap[k].d) break;
|
||||
HN t = heap[p]; heap[p] = heap[k]; heap[k] = t; k = p;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
free(heap);
|
||||
return dist;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int N, M, X;
|
||||
if (scanf("%d %d %d", &N, &M, &X) != 3) return 0;
|
||||
int *h1 = (int *)malloc(((size_t)N + 2) * sizeof(int));
|
||||
int *h2 = (int *)malloc(((size_t)N + 2) * sizeof(int));
|
||||
Edge *E1 = (Edge *)malloc(((size_t)M + 5) * sizeof(Edge));
|
||||
Edge *E2 = (Edge *)malloc(((size_t)M + 5) * sizeof(Edge));
|
||||
for (int i = 1; i <= N; ++i) h1[i] = h2[i] = -1;
|
||||
int c1 = 0, c2 = 0;
|
||||
for (int i = 0; i < M; ++i)
|
||||
{
|
||||
int a, b, t; scanf("%d %d %d", &a, &b, &t);
|
||||
E1[c1].v = b; E1[c1].w = t; E1[c1].next = h1[a]; h1[a] = c1++;
|
||||
E2[c2].v = a; E2[c2].w = t; E2[c2].next = h2[b]; h2[b] = c2++;
|
||||
}
|
||||
long long *dx = dij(N, h1, E1, X);
|
||||
long long *rx = dij(N, h2, E2, X);
|
||||
long long ans = 0;
|
||||
for (int i = 1; i <= N; ++i)
|
||||
{
|
||||
long long a = rx[i]; long long b = dx[i];
|
||||
if (a == LLONG_MAX || b == LLONG_MAX) continue;
|
||||
long long s = a + b;
|
||||
if (s > ans) ans = s;
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(h1); free(h2); free(E1); free(E2); free(dx); free(rx);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
typedef struct { int v, next; } E;
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n; if (scanf("%d", &n) != 1) return 0;
|
||||
int *a = (int *)malloc(((size_t)n + 2) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
|
||||
int m = 2 * (n - 1) + n;
|
||||
int *head = (int *)malloc(((size_t)n + 2) * sizeof(int));
|
||||
E *e = (E *)malloc(((size_t)m + 5) * sizeof(E));
|
||||
for (int i = 1; i <= n; ++i) head[i] = -1;
|
||||
int idx = 0;
|
||||
for (int i = 1; i < n; ++i)
|
||||
{
|
||||
e[idx].v = i + 1; e[idx].next = head[i]; head[i] = idx++;
|
||||
e[idx].v = i; e[idx].next = head[i + 1]; head[i + 1] = idx++;
|
||||
}
|
||||
for (int i = 1; i <= n; ++i)
|
||||
{
|
||||
int v = a[i];
|
||||
e[idx].v = v; e[idx].next = head[i]; head[i] = idx++;
|
||||
}
|
||||
int *dist = (int *)malloc(((size_t)n + 2) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) dist[i] = -1;
|
||||
int *q = (int *)malloc(((size_t)n + 5) * sizeof(int));
|
||||
int hh = 0, tt = 0; q[tt++] = 1; dist[1] = 0;
|
||||
while (hh < tt)
|
||||
{
|
||||
int u = q[hh++];
|
||||
for (int i = head[u]; i != -1; i = e[i].next)
|
||||
{
|
||||
int v = e[i].v;
|
||||
if (dist[v] == -1)
|
||||
{
|
||||
dist[v] = dist[u] + 1;
|
||||
q[tt++] = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int i = 1; i <= n; ++i)
|
||||
{
|
||||
if (i > 1) putchar(' ');
|
||||
printf("%d", dist[i]);
|
||||
}
|
||||
putchar('\n');
|
||||
free(a); free(head); free(e); free(dist); free(q);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <limits.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n, m; long long L;
|
||||
if (scanf("%d %d %lld", &n, &m, &L) != 3) return 0;
|
||||
long long *dist = (long long *)malloc((size_t)(n + 1) * (size_t)(n + 1) * sizeof(long long));
|
||||
for (int i = 1; i <= n; ++i)
|
||||
for (int j = 1; j <= n; ++j)
|
||||
dist[(size_t)i * (n + 1) + j] = (i == j) ? 0LL : LLONG_MAX / 4;
|
||||
for (int i = 0; i < m; ++i)
|
||||
{
|
||||
int u, v; long long c; scanf("%d %d %lld", &u, &v, &c);
|
||||
long long *d1 = &dist[(size_t)u * (n + 1) + v];
|
||||
long long *d2 = &dist[(size_t)v * (n + 1) + u];
|
||||
if (c < *d1) *d1 = c;
|
||||
if (c < *d2) *d2 = c;
|
||||
}
|
||||
for (int k = 1; k <= n; ++k)
|
||||
{
|
||||
for (int i = 1; i <= n; ++i)
|
||||
{
|
||||
long long dik = dist[(size_t)i * (n + 1) + k];
|
||||
if (dik == LLONG_MAX / 4) continue;
|
||||
for (int j = 1; j <= n; ++j)
|
||||
{
|
||||
long long skj = dist[(size_t)k * (n + 1) + j];
|
||||
if (skj == LLONG_MAX / 4) continue;
|
||||
long long alt = dik + skj;
|
||||
long long *dij = &dist[(size_t)i * (n + 1) + j];
|
||||
if (alt < *dij) *dij = alt;
|
||||
}
|
||||
}
|
||||
}
|
||||
unsigned char *reach = (unsigned char *)malloc((size_t)(n + 1) * (size_t)(n + 1));
|
||||
for (int i = 1; i <= n; ++i)
|
||||
for (int j = 1; j <= n; ++j)
|
||||
reach[(size_t)i * (n + 1) + j] = (dist[(size_t)i * (n + 1) + j] <= L) ? 1 : 0;
|
||||
int *steps = (int *)malloc((size_t)(n + 1) * (size_t)(n + 1) * sizeof(int));
|
||||
int *q = (int *)malloc(((size_t)n + 5) * sizeof(int));
|
||||
for (int s = 1; s <= n; ++s)
|
||||
{
|
||||
for (int i = 1; i <= n; ++i) steps[(size_t)s * (n + 1) + i] = -1;
|
||||
int hh = 0, tt = 0; q[tt++] = s; steps[(size_t)s * (n + 1) + s] = 0;
|
||||
while (hh < tt)
|
||||
{
|
||||
int u = q[hh++];
|
||||
int du = steps[(size_t)s * (n + 1) + u];
|
||||
unsigned char *row = &reach[(size_t)u * (n + 1)];
|
||||
for (int v = 1; v <= n; ++v)
|
||||
{
|
||||
if (u == v) continue;
|
||||
if (row[v] && steps[(size_t)s * (n + 1) + v] == -1)
|
||||
{
|
||||
steps[(size_t)s * (n + 1) + v] = du + 1;
|
||||
q[tt++] = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
int qn; scanf("%d", &qn);
|
||||
while (qn--)
|
||||
{
|
||||
int s, t; scanf("%d %d", &s, &t);
|
||||
int d = steps[(size_t)s * (n + 1) + t];
|
||||
if (d == -1) puts("-1"); else printf("%d\n", d - 1);
|
||||
}
|
||||
free(dist); free(reach); free(steps); free(q);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
typedef struct { int u, v, w; } Edge;
|
||||
|
||||
static int cmp_edge(const void *a, const void *b)
|
||||
{
|
||||
const Edge *x = (const Edge *)a;
|
||||
const Edge *y = (const Edge *)b;
|
||||
return x->w - y->w;
|
||||
}
|
||||
|
||||
static int find(int *fa, int x)
|
||||
{
|
||||
while (fa[x] != x) { fa[x] = fa[fa[x]]; x = fa[x]; }
|
||||
return x;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n, k;
|
||||
if (scanf("%d %d", &n, &k) != 2) return 0;
|
||||
Edge *E = (Edge *)malloc(((size_t)k + 5) * sizeof(Edge));
|
||||
for (int i = 0; i < k; ++i) scanf("%d %d %d", &E[i].u, &E[i].v, &E[i].w);
|
||||
qsort(E, (size_t)k, sizeof(Edge), cmp_edge);
|
||||
int *fa = (int *)malloc(((size_t)n + 2) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) fa[i] = i;
|
||||
long long sum = 0;
|
||||
int used = 0;
|
||||
for (int i = 0; i < k; ++i)
|
||||
{
|
||||
int fu = find(fa, E[i].u);
|
||||
int fv = find(fa, E[i].v);
|
||||
if (fu != fv)
|
||||
{
|
||||
fa[fu] = fv;
|
||||
sum += E[i].w;
|
||||
++used;
|
||||
if (used == n - 1) break;
|
||||
}
|
||||
}
|
||||
if (used != n - 1) printf("-1\n"); else printf("%lld\n", sum);
|
||||
free(E); free(fa);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,124 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <limits.h>
|
||||
|
||||
typedef struct { int u, v, w; } Edge;
|
||||
|
||||
static int cmp_desc(const void *a, const void *b)
|
||||
{
|
||||
const Edge *x = (const Edge *)a;
|
||||
const Edge *y = (const Edge *)b;
|
||||
return y->w - x->w;
|
||||
}
|
||||
|
||||
static int find(int *fa, int x)
|
||||
{
|
||||
while (fa[x] != x) { fa[x] = fa[fa[x]]; x = fa[x]; }
|
||||
return x;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n, m;
|
||||
if (scanf("%d %d", &n, &m) != 2) return 0;
|
||||
Edge *E = (Edge *)malloc(((size_t)m + 5) * sizeof(Edge));
|
||||
for (int i = 0; i < m; ++i) scanf("%d %d %d", &E[i].u, &E[i].v, &E[i].w);
|
||||
qsort(E, (size_t)m, sizeof(Edge), cmp_desc);
|
||||
int *fa = (int *)malloc(((size_t)n + 2) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) fa[i] = i;
|
||||
int *head = (int *)malloc(((size_t)n + 2) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) head[i] = -1;
|
||||
int *to = (int *)malloc(((size_t)(n - 1) * 2 + 5) * sizeof(int));
|
||||
int *wt = (int *)malloc(((size_t)(n - 1) * 2 + 5) * sizeof(int));
|
||||
int *next = (int *)malloc(((size_t)(n - 1) * 2 + 5) * sizeof(int));
|
||||
int idx = 0;
|
||||
for (int i = 0; i < m; ++i)
|
||||
{
|
||||
int fu = find(fa, E[i].u);
|
||||
int fv = find(fa, E[i].v);
|
||||
if (fu != fv)
|
||||
{
|
||||
fa[fu] = fv;
|
||||
to[idx] = E[i].v; wt[idx] = E[i].w; next[idx] = head[E[i].u]; head[E[i].u] = idx++;
|
||||
to[idx] = E[i].u; wt[idx] = E[i].w; next[idx] = head[E[i].v]; head[E[i].v] = idx++;
|
||||
}
|
||||
}
|
||||
int LOG = 15;
|
||||
int *depth = (int *)malloc(((size_t)n + 2) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) depth[i] = -1;
|
||||
int *up = (int *)malloc((size_t)LOG * (size_t)(n + 1) * sizeof(int));
|
||||
int *mn = (int *)malloc((size_t)LOG * (size_t)(n + 1) * sizeof(int));
|
||||
int *q = (int *)malloc(((size_t)n + 5) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i)
|
||||
{
|
||||
if (depth[i] != -1) continue;
|
||||
int hh = 0, tt = 0; q[tt++] = i; depth[i] = 0; up[i] = i; mn[i] = INT_MAX;
|
||||
while (hh < tt)
|
||||
{
|
||||
int u = q[hh++];
|
||||
for (int e = head[u]; e != -1; e = next[e])
|
||||
{
|
||||
int v = to[e];
|
||||
if (depth[v] == -1)
|
||||
{
|
||||
depth[v] = depth[u] + 1;
|
||||
up[v] = u;
|
||||
mn[v] = wt[e];
|
||||
q[tt++] = v;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int k = 1; k < LOG; ++k)
|
||||
{
|
||||
for (int v = 1; v <= n; ++v)
|
||||
{
|
||||
int p = up[(k - 1) * (n + 1) + v];
|
||||
up[k * (n + 1) + v] = up[(k - 1) * (n + 1) + p];
|
||||
int a = mn[(k - 1) * (n + 1) + v];
|
||||
int b = mn[(k - 1) * (n + 1) + p];
|
||||
mn[k * (n + 1) + v] = (a < b) ? a : b;
|
||||
}
|
||||
}
|
||||
int qn; scanf("%d", &qn);
|
||||
while (qn--)
|
||||
{
|
||||
int x, y; scanf("%d %d", &x, &y);
|
||||
if (find(fa, x) != find(fa, y)) { puts("-1"); continue; }
|
||||
int res = INT_MAX;
|
||||
if (depth[x] < depth[y]) { int t = x; x = y; y = t; }
|
||||
int diff = depth[x] - depth[y];
|
||||
for (int k = LOG - 1; k >= 1; --k)
|
||||
{
|
||||
int step = 1 << k;
|
||||
if (diff >= step)
|
||||
{
|
||||
int val = mn[k * (n + 1) + x];
|
||||
if (val < res) res = val;
|
||||
x = up[k * (n + 1) + x];
|
||||
diff -= step;
|
||||
}
|
||||
}
|
||||
if (diff)
|
||||
{
|
||||
int val = mn[x]; if (val < res) res = val; x = up[x];
|
||||
}
|
||||
if (x == y) { printf("%d\n", res); continue; }
|
||||
for (int k = LOG - 1; k >= 1; --k)
|
||||
{
|
||||
int ux = up[k * (n + 1) + x];
|
||||
int uy = up[k * (n + 1) + y];
|
||||
if (ux != uy)
|
||||
{
|
||||
int vx = mn[k * (n + 1) + x]; if (vx < res) res = vx;
|
||||
int vy = mn[k * (n + 1) + y]; if (vy < res) res = vy;
|
||||
x = ux; y = uy;
|
||||
}
|
||||
}
|
||||
int vx = mn[x]; if (vx < res) res = vx; x = up[x];
|
||||
int vy = mn[y]; if (vy < res) res = vy; y = up[y];
|
||||
printf("%d\n", res);
|
||||
}
|
||||
free(E); free(fa); free(head); free(to); free(wt); free(next); free(depth); free(up); free(mn); free(q);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
typedef struct { int u, v; int w; } E;
|
||||
|
||||
static int cmp(const void *a, const void *b)
|
||||
{
|
||||
const E *x = (const E *)a; const E *y = (const E *)b;
|
||||
return (x->w < y->w) ? -1 : (x->w > y->w);
|
||||
}
|
||||
|
||||
static int find(int *fa, int x)
|
||||
{
|
||||
while (fa[x] != x) { fa[x] = fa[fa[x]]; x = fa[x]; }
|
||||
return x;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n, k;
|
||||
if (scanf("%d %d", &n, &k) != 2) return 0;
|
||||
int *X = (int *)malloc(((size_t)n + 2) * sizeof(int));
|
||||
int *Y = (int *)malloc(((size_t)n + 2) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) scanf("%d %d", &X[i], &Y[i]);
|
||||
size_t m = (size_t)n * (size_t)(n - 1) / 2;
|
||||
E *edges = (E *)malloc((m + 5) * sizeof(E));
|
||||
size_t idx = 0;
|
||||
for (int i = 1; i <= n; ++i)
|
||||
{
|
||||
for (int j = i + 1; j <= n; ++j)
|
||||
{
|
||||
long long dx = (long long)X[i] - (long long)X[j];
|
||||
long long dy = (long long)Y[i] - (long long)Y[j];
|
||||
long long w = dx * dx + dy * dy;
|
||||
edges[idx].u = i; edges[idx].v = j; edges[idx].w = (int)w; ++idx;
|
||||
}
|
||||
}
|
||||
qsort(edges, idx, sizeof(E), cmp);
|
||||
int *fa = (int *)malloc(((size_t)n + 2) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) fa[i] = i;
|
||||
int comps = n;
|
||||
double ans = 0.0;
|
||||
for (size_t i = 0; i < idx; ++i)
|
||||
{
|
||||
int u = edges[i].u, v = edges[i].v;
|
||||
int fu = find(fa, u), fv = find(fa, v);
|
||||
if (fu != fv)
|
||||
{
|
||||
if (comps > k)
|
||||
{
|
||||
fa[fu] = fv;
|
||||
--comps;
|
||||
}
|
||||
else
|
||||
{
|
||||
ans = (double)edges[i].w;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%.2f\n", ans);
|
||||
free(X); free(Y); free(edges); free(fa);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
static int M, N;
|
||||
static int CAP;
|
||||
static int *ks, *kn, *kf;
|
||||
static long long *kv;
|
||||
|
||||
static long long dfs(int s, int f, int cur)
|
||||
{
|
||||
if (cur == 0)
|
||||
return (s == 0 && f == 0) ? 1LL : 0LL;
|
||||
if (s == 0 && f == 0)
|
||||
return (cur == 0) ? 1LL : 0LL;
|
||||
int h = (((s * 37 + f) * 99991) ^ cur) & (CAP - 1);
|
||||
for (;;)
|
||||
{
|
||||
if (ks[h] == -1)
|
||||
break;
|
||||
if (ks[h] == s && kn[h] == f && kf[h] == cur)
|
||||
return kv[h];
|
||||
h = (h + 1) & (CAP - 1);
|
||||
}
|
||||
long long ans = 0;
|
||||
if (s > 0)
|
||||
ans += dfs(s - 1, f, cur * 2);
|
||||
if (f > 0 && cur >= 2)
|
||||
ans += dfs(s, f - 1, cur - 2);
|
||||
ks[h] = s; kn[h] = f; kf[h] = cur; kv[h] = ans;
|
||||
return ans;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
if (scanf("%d %d", &M, &N) != 2) return 0;
|
||||
CAP = 1 << 20;
|
||||
ks = (int *)malloc((size_t)CAP * sizeof(int));
|
||||
kn = (int *)malloc((size_t)CAP * sizeof(int));
|
||||
kf = (int *)malloc((size_t)CAP * sizeof(int));
|
||||
kv = (long long *)malloc((size_t)CAP * sizeof(long long));
|
||||
for (int i = 0; i < CAP; ++i) ks[i] = -1;
|
||||
long long ans = dfs(M, N, 5);
|
||||
printf("%lld\n", ans);
|
||||
free(ks); free(kn); free(kf); free(kv);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
#include <stdio.h>
|
||||
|
||||
static int n, m;
|
||||
static int cur[25];
|
||||
|
||||
static void dfs(int start, int k)
|
||||
{
|
||||
if (k == m)
|
||||
{
|
||||
for (int i = 0; i < m; ++i)
|
||||
{
|
||||
if (i) putchar(' ');
|
||||
printf("%d", cur[i]);
|
||||
}
|
||||
putchar('\n');
|
||||
return;
|
||||
}
|
||||
for (int i = start; i <= n - (m - k) + 1; ++i)
|
||||
{
|
||||
cur[k] = i;
|
||||
dfs(i + 1, k + 1);
|
||||
}
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
if (scanf("%d %d", &n, &m) != 2) return 0;
|
||||
dfs(1, 0);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
static long long target;
|
||||
static int L;
|
||||
static int K;
|
||||
static int found;
|
||||
static long long ans;
|
||||
|
||||
static void gen(int pos, int c4, int c7, long long cur)
|
||||
{
|
||||
if (found) return;
|
||||
if (pos == L)
|
||||
{
|
||||
if (c4 == K && c7 == K && cur >= target)
|
||||
{
|
||||
ans = cur;
|
||||
found = 1;
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (c4 < K) gen(pos + 1, c4 + 1, c7, cur * 10 + 4);
|
||||
if (!found && c7 < K) gen(pos + 1, c4, c7 + 1, cur * 10 + 7);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
long long n;
|
||||
if (scanf("%lld", &n) != 1) return 0;
|
||||
target = n;
|
||||
int len = 0; long long t = n;
|
||||
while (t) { ++len; t /= 10; }
|
||||
if (len == 0) len = 1;
|
||||
if ((len & 1) == 1)
|
||||
{
|
||||
L = len + 1; K = L / 2;
|
||||
long long cur = 0;
|
||||
for (int i = 0; i < K; ++i) cur = cur * 10 + 4;
|
||||
for (int i = 0; i < K; ++i) cur = cur * 10 + 7;
|
||||
printf("%lld\n", cur);
|
||||
return 0;
|
||||
}
|
||||
L = len; K = L / 2; found = 0; ans = 0;
|
||||
gen(0, 0, 0, 0);
|
||||
if (found)
|
||||
{
|
||||
printf("%lld\n", ans);
|
||||
return 0;
|
||||
}
|
||||
L = len + 2; K = L / 2;
|
||||
long long cur = 0;
|
||||
for (int i = 0; i < K; ++i) cur = cur * 10 + 4;
|
||||
for (int i = 0; i < K; ++i) cur = cur * 10 + 7;
|
||||
printf("%lld\n", cur);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,46 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
static int CAP;
|
||||
static int *K;
|
||||
|
||||
static int add(int x)
|
||||
{
|
||||
int h = (x * 1315423911u) & (CAP - 1);
|
||||
for (;;)
|
||||
{
|
||||
if (K[h] == -1) { K[h] = x; return 1; }
|
||||
if (K[h] == x) return 0;
|
||||
h = (h + 1) & (CAP - 1);
|
||||
}
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n; if (scanf("%d", &n) != 1) return 0;
|
||||
CAP = 1 << 18;
|
||||
K = (int *)malloc((size_t)CAP * sizeof(int));
|
||||
for (int i = 0; i < CAP; ++i) K[i] = -1;
|
||||
int *q = (int *)malloc(1024 * sizeof(int));
|
||||
int hh = 0, tt = 0;
|
||||
add(n); q[tt++] = n;
|
||||
int cnt = 1;
|
||||
while (hh < tt)
|
||||
{
|
||||
int x = q[hh++];
|
||||
int t = x;
|
||||
while (t >= 10) t /= 10;
|
||||
int h = t;
|
||||
int m = h / 2;
|
||||
int d = 1, y = x;
|
||||
while (y >= 10) { d *= 10; y /= 10; }
|
||||
for (int k = 1; k <= m; ++k)
|
||||
{
|
||||
int v = k * d * 10 + x;
|
||||
if (add(v)) { if (tt < 1024) q[tt++] = v; ++cnt; }
|
||||
}
|
||||
}
|
||||
printf("%d\n", cnt);
|
||||
free(K); free(q);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int K, N, M;
|
||||
if (scanf("%d %d %d", &K, &N, &M) != 3) return 0;
|
||||
int total = K * N * M;
|
||||
char *A = (char *)malloc((size_t)total);
|
||||
for (int z = 0; z < K; ++z)
|
||||
for (int i = 0; i < N; ++i)
|
||||
for (int j = 0; j < M; ++j)
|
||||
{
|
||||
char c;
|
||||
do { if (scanf(" %c", &c) != 1) return 0; } while (c != '.' && c != '#');
|
||||
A[z * N * M + i * M + j] = c;
|
||||
}
|
||||
int sx, sy; if (scanf("%d %d", &sx, &sy) != 2) return 0;
|
||||
int *q = (int *)malloc((size_t)(total + 5) * sizeof(int));
|
||||
unsigned char *vis = (unsigned char *)malloc((size_t)total);
|
||||
for (int i = 0; i < total; ++i) vis[i] = 0;
|
||||
int hh = 0, tt = 0;
|
||||
int sidx = 0 * N * M + (sx - 1) * M + (sy - 1);
|
||||
q[tt++] = sidx; vis[sidx] = 1;
|
||||
int infected = 1;
|
||||
const int dz[6] = {1,-1,0,0,0,0};
|
||||
const int dx[6] = {0,0,1,-1,0,0};
|
||||
const int dy[6] = {0,0,0,0,1,-1};
|
||||
while (hh < tt)
|
||||
{
|
||||
int idx = q[hh++];
|
||||
int z = idx / (N * M);
|
||||
int rem = idx % (N * M);
|
||||
int x = rem / M;
|
||||
int y = rem % M;
|
||||
for (int d = 0; d < 6; ++d)
|
||||
{
|
||||
int nz = z + dz[d];
|
||||
int nx = x + dx[d];
|
||||
int ny = y + dy[d];
|
||||
if (nz < 0 || nz >= K || nx < 0 || nx >= N || ny < 0 || ny >= M) continue;
|
||||
int nidx = nz * N * M + nx * M + ny;
|
||||
if (vis[nidx]) continue;
|
||||
if (A[nidx] == '.')
|
||||
{
|
||||
vis[nidx] = 1;
|
||||
q[tt++] = nidx;
|
||||
++infected;
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d\n", infected);
|
||||
free(A); free(q); free(vis);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,57 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n; if (scanf("%d", &n) != 1) return 0;
|
||||
int *a = (int *)malloc((size_t)n * (size_t)n * sizeof(int));
|
||||
int sx = -1, sy = -1;
|
||||
for (int i = 0; i < n; ++i)
|
||||
{
|
||||
for (int j = 0; j < n; ++j)
|
||||
{
|
||||
int v; scanf("%d", &v);
|
||||
a[i * n + j] = v;
|
||||
if (v == 2) { sx = i; sy = j; }
|
||||
}
|
||||
}
|
||||
int *dist = (int *)malloc((size_t)n * (size_t)n * sizeof(int));
|
||||
unsigned char *vis = (unsigned char *)malloc((size_t)n * (size_t)n);
|
||||
for (int i = 0; i < n * n; ++i) { dist[i] = -1; vis[i] = 0; }
|
||||
int *q = (int *)malloc(((size_t)n * (size_t)n + 5) * sizeof(int));
|
||||
int hh = 0, tt = 0;
|
||||
int sidx = sx * n + sy;
|
||||
dist[sidx] = 0; vis[sidx] = 1; q[tt++] = sidx;
|
||||
const int dx[4] = {1,-1,0,0};
|
||||
const int dy[4] = {0,0,1,-1};
|
||||
while (hh < tt)
|
||||
{
|
||||
int idx = q[hh++];
|
||||
int x = idx / n; int y = idx % n;
|
||||
for (int d = 0; d < 4; ++d)
|
||||
{
|
||||
int nx = x + dx[d]; int ny = y + dy[d];
|
||||
if (nx < 0) nx = n - 1; else if (nx >= n) nx = 0;
|
||||
if (ny < 0) ny = n - 1; else if (ny >= n) ny = 0;
|
||||
int nidx = nx * n + ny;
|
||||
if (vis[nidx]) continue;
|
||||
if (a[nidx] == 0) continue;
|
||||
vis[nidx] = 1;
|
||||
dist[nidx] = dist[idx] + 1;
|
||||
q[tt++] = nidx;
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < n; ++i)
|
||||
{
|
||||
for (int j = 0; j < n; ++j)
|
||||
{
|
||||
int idx = i * n + j;
|
||||
int out = (dist[idx] <= 0) ? 0 : dist[idx];
|
||||
if (j) putchar(' ');
|
||||
printf("%d", out);
|
||||
}
|
||||
putchar('\n');
|
||||
}
|
||||
free(a); free(dist); free(vis); free(q);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
static int len0;
|
||||
|
||||
static int get_len(int x){ int c = 0; do { ++c; x /= 10; } while (x); return c; }
|
||||
|
||||
static int has_zero(int x){ while (x){ if (x % 10 == 0) return 1; x /= 10; } return 0; }
|
||||
|
||||
static void to_digits(int x, int *d, int *L){ int t = x; int l = get_len(x); *L = l; for (int i = l - 1; i >= 0; --i){ d[i] = t % 10; t /= 10; } }
|
||||
|
||||
static int from_digits(int *d, int L){ int v = 0; for (int i = 0; i < L; ++i) v = v * 10 + d[i]; return v; }
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int s; if (scanf("%d", &s) != 1) return 0;
|
||||
len0 = get_len(s);
|
||||
int m; scanf("%d", &m);
|
||||
int *dist = (int *)malloc(100000 * sizeof(int));
|
||||
for (int i = 0; i < 100000; ++i) dist[i] = -1;
|
||||
int *q = (int *)malloc(70000 * sizeof(int));
|
||||
int hh = 0, tt = 0;
|
||||
dist[s] = 0; q[tt++] = s;
|
||||
int d[6], tmp[6];
|
||||
while (hh < tt)
|
||||
{
|
||||
int x = q[hh++];
|
||||
int L; to_digits(x, d, &L);
|
||||
for (int i = 0; i < L; ++i)
|
||||
{
|
||||
for (int j = i + 1; j < L; ++j)
|
||||
{
|
||||
for (int k = 0; k < L; ++k) tmp[k] = d[k];
|
||||
int t = tmp[i]; tmp[i] = tmp[j]; tmp[j] = t;
|
||||
int y = from_digits(tmp, L);
|
||||
if (dist[y] == -1){ dist[y] = dist[x] + 1; q[tt++] = y; }
|
||||
}
|
||||
}
|
||||
if (L >= 2)
|
||||
{
|
||||
for (int i = 0; i < L; ++i)
|
||||
{
|
||||
int p = 0; for (int k = 0; k < L; ++k){ if (k == i) continue; tmp[p++] = d[k]; }
|
||||
int y = from_digits(tmp, L - 1);
|
||||
if (dist[y] == -1){ dist[y] = dist[x] + 1; q[tt++] = y; }
|
||||
}
|
||||
}
|
||||
if (L + 1 <= len0)
|
||||
{
|
||||
for (int i = 0; i < L - 1; ++i)
|
||||
{
|
||||
if (d[i] < d[i + 1])
|
||||
{
|
||||
for (int xdig = d[i] + 1; xdig <= d[i + 1] - 1; ++xdig)
|
||||
{
|
||||
int p = 0; for (int k = 0; k <= i; ++k) tmp[p++] = d[k]; tmp[p++] = xdig; for (int k = i + 1; k < L; ++k) tmp[p++] = d[k];
|
||||
int y = from_digits(tmp, L + 1);
|
||||
if (dist[y] == -1){ dist[y] = dist[x] + 1; q[tt++] = y; }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (int i = 0; i < m; ++i)
|
||||
{
|
||||
int t; scanf("%d", &t);
|
||||
if (get_len(t) > len0 || has_zero(t)) { printf("-1\n"); continue; }
|
||||
printf("%d\n", dist[t]);
|
||||
}
|
||||
free(dist); free(q);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n, k;
|
||||
if (scanf("%d %d", &n, &k) != 2)
|
||||
return 0;
|
||||
char *t = (char *)malloc((size_t)n + 5);
|
||||
scanf("%s", t);
|
||||
int *pi = (int *)malloc(((size_t)n) * sizeof(int));
|
||||
pi[0] = 0;
|
||||
for (int i = 1; i < n; ++i)
|
||||
{
|
||||
int j = pi[i - 1];
|
||||
while (j > 0 && t[i] != t[j])
|
||||
j = pi[j - 1];
|
||||
if (t[i] == t[j])
|
||||
++j;
|
||||
pi[i] = j;
|
||||
}
|
||||
int L = pi[n - 1];
|
||||
int add = n - L;
|
||||
size_t total = (size_t)n + (size_t)(k - 1) * (size_t)add;
|
||||
char *s = (char *)malloc(total + 1);
|
||||
memcpy(s, t, (size_t)n);
|
||||
size_t pos = (size_t)n;
|
||||
for (int i = 1; i < k; ++i)
|
||||
{
|
||||
memcpy(s + pos, t + L, (size_t)add);
|
||||
pos += (size_t)add;
|
||||
}
|
||||
s[total] = '\0';
|
||||
printf("%s\n", s);
|
||||
free(t);
|
||||
free(pi);
|
||||
free(s);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
char *s = (char *)malloc(1000005);
|
||||
if (scanf("%1000000s", s) != 1) return 0;
|
||||
int n = (int)strlen(s);
|
||||
int *pi = (int *)malloc((size_t)n * sizeof(int));
|
||||
pi[0] = 0;
|
||||
for (int i = 1; i < n; ++i)
|
||||
{
|
||||
int j = pi[i - 1];
|
||||
while (j > 0 && s[i] != s[j]) j = pi[j - 1];
|
||||
if (s[i] == s[j]) ++j;
|
||||
pi[i] = j;
|
||||
}
|
||||
int L = pi[n - 1];
|
||||
int mx = 0;
|
||||
for (int i = 0; i < n - 1; ++i) if (pi[i] > mx) mx = pi[i];
|
||||
while (L > 0 && mx < L) L = pi[L - 1];
|
||||
if (L == 0)
|
||||
{
|
||||
printf("Just a legend\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
s[L] = '\0';
|
||||
printf("%s\n", s);
|
||||
}
|
||||
free(pi); free(s);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n, m;
|
||||
if (scanf("%d %d", &n, &m) != 2) return 0;
|
||||
int *nxt = (int *)malloc(((size_t)n + 1) * sizeof(int));
|
||||
int *vis = (int *)malloc(((size_t)n + 1) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) { nxt[i] = 0; vis[i] = 0; }
|
||||
int stamp = 1;
|
||||
for (int i = 0; i < m; ++i)
|
||||
{
|
||||
char op;
|
||||
int x, y;
|
||||
if (scanf(" %c %d %d", &op, &x, &y) != 3) return 0;
|
||||
if (op == 'A')
|
||||
{
|
||||
nxt[x] = y;
|
||||
if (nxt[y] == x) nxt[y] = 0;
|
||||
}
|
||||
else if (op == 'Q')
|
||||
{
|
||||
++stamp;
|
||||
int v = x;
|
||||
while (v && vis[v] != stamp)
|
||||
{
|
||||
vis[v] = stamp;
|
||||
if (v == y) break;
|
||||
v = nxt[v];
|
||||
}
|
||||
if (v == y) puts("Yes"); else puts("No");
|
||||
}
|
||||
}
|
||||
free(nxt); free(vis);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n, q;
|
||||
if (scanf("%d %d", &n, &q) != 2) return 0;
|
||||
int *next = (int *)malloc(((size_t)n + 1) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) next[i] = (i == n) ? 1 : (i + 1);
|
||||
int cur = 1, prev = n;
|
||||
while (next[cur] != cur)
|
||||
{
|
||||
for (int c = 1; c < q; ++c)
|
||||
{
|
||||
prev = cur;
|
||||
cur = next[cur];
|
||||
}
|
||||
next[prev] = next[cur];
|
||||
cur = next[cur];
|
||||
}
|
||||
printf("%d\n", cur);
|
||||
free(next);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
typedef struct Node {
|
||||
int id;
|
||||
char name[32];
|
||||
char gender[4];
|
||||
char birth[16];
|
||||
int zip;
|
||||
char addr[64];
|
||||
long long qq;
|
||||
long long phone;
|
||||
struct Node *next;
|
||||
} Node;
|
||||
|
||||
static void read_rec(Node *p)
|
||||
{
|
||||
char g[8];
|
||||
scanf("%d %31s %7s %15s %d %63s %lld %lld", &p->id, p->name, g, p->birth, &p->zip, p->addr, &p->qq, &p->phone);
|
||||
strcpy(p->gender, g);
|
||||
}
|
||||
|
||||
static void print_rec(Node *p)
|
||||
{
|
||||
printf("%d %s %s %s %d %s %lld %lld\n", p->id, p->name, p->gender, p->birth, p->zip, p->addr, p->qq, p->phone);
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int cnt; if (scanf("%d", &cnt) != 1) return 0;
|
||||
Node *head = NULL, *tail = NULL;
|
||||
for (int i = 0; i < cnt; ++i)
|
||||
{
|
||||
Node *p = (Node *)malloc(sizeof(Node));
|
||||
read_rec(p); p->next = NULL;
|
||||
if (!head) head = tail = p; else { tail->next = p; tail = p; }
|
||||
}
|
||||
int op; scanf("%d", &op);
|
||||
if (op == 1)
|
||||
{
|
||||
Node *p = (Node *)malloc(sizeof(Node));
|
||||
read_rec(p); p->next = NULL;
|
||||
if (!head) head = tail = p; else { tail->next = p; tail = p; }
|
||||
printf("The records is:\n");
|
||||
int sz = 0; for (Node *q = head; q; q = q->next) ++sz;
|
||||
Node **arr = (Node **)malloc((size_t)sz * sizeof(Node *));
|
||||
int idx = 0; for (Node *q = head; q; q = q->next) arr[idx++] = q;
|
||||
for (int i = sz - 1; i >= 0; --i) print_rec(arr[i]);
|
||||
free(arr);
|
||||
}
|
||||
else if (op == 2)
|
||||
{
|
||||
int did; scanf("%d", &did);
|
||||
Node *prev = NULL, *cur = head;
|
||||
while (cur && cur->id != did) { prev = cur; cur = cur->next; }
|
||||
if (cur)
|
||||
{
|
||||
if (prev) prev->next = cur->next; else head = cur->next;
|
||||
if (tail == cur) tail = prev;
|
||||
free(cur);
|
||||
}
|
||||
printf("The records is:\n");
|
||||
int sz = 0; for (Node *q = head; q; q = q->next) ++sz;
|
||||
Node **arr = (Node **)malloc((size_t)sz * sizeof(Node *));
|
||||
int idx = 0; for (Node *q = head; q; q = q->next) arr[idx++] = q;
|
||||
for (int i = sz - 1; i >= 0; --i) print_rec(arr[i]);
|
||||
free(arr);
|
||||
}
|
||||
else if (op == 3)
|
||||
{
|
||||
int fid; scanf("%d", &fid);
|
||||
Node *cur = head;
|
||||
while (cur && cur->id != fid) cur = cur->next;
|
||||
if (cur) print_rec(cur); else printf("not found\n");
|
||||
}
|
||||
else if (op == 4)
|
||||
{
|
||||
printf("The records is:\n");
|
||||
int sz = 0; for (Node *q = head; q; q = q->next) ++sz;
|
||||
Node **arr = (Node **)malloc((size_t)sz * sizeof(Node *));
|
||||
int idx = 0; for (Node *q = head; q; q = q->next) arr[idx++] = q;
|
||||
for (int i = sz - 1; i >= 0; --i) print_rec(arr[i]);
|
||||
free(arr);
|
||||
}
|
||||
for (Node *q = head; q; ) { Node *nq = q->next; free(q); q = nq; }
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
typedef struct { int c; int e; } T;
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n, m;
|
||||
if (scanf("%d %d", &n, &m) != 2) return 0;
|
||||
T *A = (T *)malloc((size_t)n * sizeof(T));
|
||||
T *B = (T *)malloc((size_t)m * sizeof(T));
|
||||
for (int i = 0; i < n; ++i) scanf("%d %d", &A[i].c, &A[i].e);
|
||||
for (int i = 0; i < m; ++i) scanf("%d %d", &B[i].c, &B[i].e);
|
||||
int i = 0, j = 0;
|
||||
while (i < n && j < m)
|
||||
{
|
||||
if (A[i].e == B[j].e)
|
||||
{
|
||||
int c = A[i].c + B[j].c;
|
||||
if (c != 0) printf("%d %d\n", c, A[i].e);
|
||||
++i; ++j;
|
||||
}
|
||||
else if (A[i].e < B[j].e)
|
||||
{
|
||||
if (A[i].c != 0) printf("%d %d\n", A[i].c, A[i].e);
|
||||
++i;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (B[j].c != 0) printf("%d %d\n", B[j].c, B[j].e);
|
||||
++j;
|
||||
}
|
||||
}
|
||||
while (i < n) { if (A[i].c != 0) printf("%d %d\n", A[i].c, A[i].e); ++i; }
|
||||
while (j < m) { if (B[j].c != 0) printf("%d %d\n", B[j].c, B[j].e); ++j; }
|
||||
free(A); free(B);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
|
||||
static uint64_t getv(FILE *f, int idx)
|
||||
{
|
||||
uint64_t v;
|
||||
long off = (long)idx * (long)sizeof(uint64_t);
|
||||
fseek(f, off, SEEK_SET);
|
||||
fread(&v, sizeof(uint64_t), 1, f);
|
||||
return v;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n; if (scanf("%d", &n) != 1) return 0;
|
||||
FILE *f = tmpfile();
|
||||
if (!f) return 0;
|
||||
for (int i = 0; i < n; ++i)
|
||||
{
|
||||
unsigned long long x; scanf("%llu", &x);
|
||||
fwrite(&x, sizeof(uint64_t), 1, f);
|
||||
}
|
||||
int *st = (int *)malloc((size_t)n * sizeof(int));
|
||||
int top = 0;
|
||||
long long ans = 0;
|
||||
size_t B = 1 << 20;
|
||||
uint64_t *buf = (uint64_t *)malloc(B * sizeof(uint64_t));
|
||||
long long pos = (long long)n - 1;
|
||||
while (pos >= 0)
|
||||
{
|
||||
size_t take = (pos + 1 < (long long)B) ? (size_t)(pos + 1) : B;
|
||||
long long start = pos - (long long)take + 1;
|
||||
long off = (long)(start * (long long)sizeof(uint64_t));
|
||||
fseek(f, off, SEEK_SET);
|
||||
fread(buf, sizeof(uint64_t), take, f);
|
||||
for (long long p = (long long)take - 1; p >= 0; --p)
|
||||
{
|
||||
int i = (int)(start + p);
|
||||
uint64_t h = buf[p];
|
||||
while (top > 0)
|
||||
{
|
||||
uint64_t t = getv(f, st[top - 1]);
|
||||
if (t < h) --top; else break;
|
||||
}
|
||||
if (top > 0) ans += (long long)(st[top - 1] - i - 1);
|
||||
else ans += (long long)(n - 1 - i);
|
||||
st[top++] = i;
|
||||
}
|
||||
pos = start - 1;
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(st); free(buf); fclose(f);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n; if (scanf("%d", &n) != 1) return 0;
|
||||
long long *st = (long long *)malloc((size_t)n * sizeof(long long));
|
||||
int top = 0;
|
||||
long long ans = 0;
|
||||
for (int i = 0; i < n; ++i)
|
||||
{
|
||||
long long d, h; scanf("%lld %lld", &d, &h);
|
||||
while (top > 0 && st[top - 1] > h) --top;
|
||||
if (h > 0 && (top == 0 || st[top - 1] < h)) { st[top++] = h; ++ans; }
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(st);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
static const long long MOD = 99887765LL;
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n; long long x;
|
||||
if (scanf("%d %lld", &n, &x) != 2) return 0;
|
||||
int *a = (int *)malloc(((size_t)n + 1) * sizeof(int));
|
||||
for (int i = 0; i <= n; ++i) scanf("%d", &a[i]);
|
||||
int *st = (int *)malloc(((size_t)n + 1) * sizeof(int));
|
||||
int top = 0;
|
||||
long long ans = 0;
|
||||
long long xmod = x % MOD; if (xmod < 0) xmod += MOD;
|
||||
long long pw = 1;
|
||||
for (int i = n; i >= 0; --i)
|
||||
{
|
||||
while (top > 0 && a[st[top - 1]] >= a[i]) --top;
|
||||
int bi = (top > 0) ? a[st[top - 1]] : 0;
|
||||
long long bmi = bi % MOD; if (bmi < 0) bmi += MOD;
|
||||
ans += (bmi * pw) % MOD;
|
||||
ans %= MOD;
|
||||
if (i > 0) { pw = (pw * xmod) % MOD; }
|
||||
st[top++] = i;
|
||||
}
|
||||
if (ans < 0) ans += MOD;
|
||||
printf("%lld\n", ans);
|
||||
free(a); free(st);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n, m;
|
||||
if (scanf("%d %d", &n, &m) != 2) return 0;
|
||||
if (m == 0) { printf("0\n"); return 0; }
|
||||
long long *a = (long long *)malloc((size_t)n * sizeof(long long));
|
||||
for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
|
||||
long long *p = (long long *)malloc(((size_t)n + 1) * sizeof(long long));
|
||||
p[0] = 0;
|
||||
for (int i = 1; i <= n; ++i) p[i] = p[i - 1] + a[i - 1];
|
||||
int *dq = (int *)malloc(((size_t)n + 1) * sizeof(int));
|
||||
int head = 0, tail = 0;
|
||||
dq[tail++] = 0;
|
||||
long long ans = p[1] - p[0];
|
||||
for (int i = 1; i <= n; ++i)
|
||||
{
|
||||
while (head < tail && dq[head] < i - m) ++head;
|
||||
if (head < tail)
|
||||
{
|
||||
long long val = p[i] - p[dq[head]];
|
||||
if (val > ans) ans = val;
|
||||
}
|
||||
while (head < tail && p[dq[tail - 1]] >= p[i]) --tail;
|
||||
dq[tail++] = i;
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(a); free(p); free(dq);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
typedef struct { long long x, y; } P;
|
||||
|
||||
static int cmpx(const void *a, const void *b){ const P *pa=a, *pb=b; if (pa->x<pb->x) return -1; if (pa->x>pb->x) return 1; return 0; }
|
||||
|
||||
static int ok(P *p, int n, long long W, long long D)
|
||||
{
|
||||
int *qmax = (int *)malloc((size_t)n * sizeof(int));
|
||||
int *qmin = (int *)malloc((size_t)n * sizeof(int));
|
||||
int hmax=0,tmax=0,hmin=0,tmin=0;
|
||||
int l=0;
|
||||
for (int r=0;r<n;++r)
|
||||
{
|
||||
while (tmax>hmax && p[qmax[tmax-1]].y<=p[r].y) --tmax;
|
||||
qmax[tmax++]=r;
|
||||
while (tmin>hmin && p[qmin[tmin-1]].y>=p[r].y) --tmin;
|
||||
qmin[tmin++]=r;
|
||||
while (p[r].x - p[l].x > W)
|
||||
{
|
||||
if (hmax<tmax && qmax[hmax]==l) ++hmax;
|
||||
if (hmin<tmin && qmin[hmin]==l) ++hmin;
|
||||
++l;
|
||||
}
|
||||
if (tmax>hmax && tmin>hmin)
|
||||
{
|
||||
long long mx = p[qmax[hmax]].y;
|
||||
long long mn = p[qmin[hmin]].y;
|
||||
if (mx - mn >= D) { free(qmax); free(qmin); return 1; }
|
||||
}
|
||||
}
|
||||
free(qmax); free(qmin); return 0;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int N; long long D;
|
||||
if (scanf("%d %lld", &N, &D) != 2) return 0;
|
||||
P *p = (P *)malloc((size_t)N * sizeof(P));
|
||||
for (int i=0;i<N;++i) scanf("%lld %lld", &p[i].x, &p[i].y);
|
||||
qsort(p, N, sizeof(P), cmpx);
|
||||
long long L=0, R=0;
|
||||
if (N>0) R = p[N-1].x - p[0].x;
|
||||
long long ans=-1;
|
||||
long long lo=L, hi=R;
|
||||
while (lo<=hi)
|
||||
{
|
||||
long long mid = lo + ((hi - lo) >> 1);
|
||||
if (ok(p, N, mid, D)) { ans = mid; hi = mid - 1; }
|
||||
else lo = mid + 1;
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(p);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,93 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
typedef long long LL;
|
||||
|
||||
static LL *low, *up; // max-heap(low), min-heap(up)
|
||||
static int szLow, szUp;
|
||||
static LL *qarr; static int qh, qt;
|
||||
|
||||
static LL *delKeys; static unsigned char *delUsed; static int DEL_CAP;
|
||||
|
||||
static unsigned int h64(LL x){ unsigned long long u = (unsigned long long)x; u ^= u >> 33; u *= 0xff51afd7ed558ccdULL; u ^= u >> 33; u *= 0xc4ceb9fe1a85aa39ULL; u ^= u >> 33; return (unsigned int)u; }
|
||||
|
||||
static void delInit(void){ DEL_CAP = 1<<20; delKeys = (LL*)malloc((size_t)DEL_CAP * sizeof(LL)); delUsed = (unsigned char*)malloc((size_t)DEL_CAP); for (int i=0;i<DEL_CAP;++i) delUsed[i]=0; }
|
||||
static void delClear(void){ for (int i=0;i<DEL_CAP;++i) delUsed[i]=0; }
|
||||
static void delMark(LL x){ unsigned int m = DEL_CAP-1; unsigned int h = h64(x) & m; while (delUsed[h] && delKeys[h]!=x){ h=(h+1)&m; } delKeys[h]=x; delUsed[h]=1; }
|
||||
static int delHas(LL x){ unsigned int m = DEL_CAP-1; unsigned int h = h64(x) & m; while (delUsed[h]){ if (delKeys[h]==x) return 1; h=(h+1)&m; } return 0; }
|
||||
|
||||
static void maxPush(LL *a, int *n, LL v){ int i=*n; a[i]=v; (*n)++; while (i>0){ int p=(i-1)/2; if (a[p] >= a[i]) break; LL t=a[p]; a[p]=a[i]; a[i]=t; i=p; } }
|
||||
static LL maxTop(LL *a, int n){ return n? a[0] : 0; }
|
||||
static void maxPop(LL *a, int *n){ int s=*n; if (s==0) return; a[0]=a[s-1]; (*n)--; s=*n; int i=0; while (1){ int l=2*i+1, r=2*i+2, b=i; if (l<s && a[l]>a[b]) b=l; if (r<s && a[r]>a[b]) b=r; if (b==i) break; LL t=a[i]; a[i]=a[b]; a[b]=t; i=b; } }
|
||||
|
||||
static void minPush(LL *a, int *n, LL v){ int i=*n; a[i]=v; (*n)++; while (i>0){ int p=(i-1)/2; if (a[p] <= a[i]) break; LL t=a[p]; a[p]=a[i]; a[i]=t; i=p; } }
|
||||
static LL minTop(LL *a, int n){ return n? a[0] : 0; }
|
||||
static void minPop(LL *a, int *n){ int s=*n; if (s==0) return; a[0]=a[s-1]; (*n)--; s=*n; int i=0; while (1){ int l=2*i+1, r=2*i+2, b=i; if (l<s && a[l]<a[b]) b=l; if (r<s && a[r]<a[b]) b=r; if (b==i) break; LL t=a[i]; a[i]=a[b]; a[b]=t; i=b; } }
|
||||
|
||||
static void pruneLow(void){ while (szLow>0){ LL v = maxTop(low, szLow); if (!delHas(v)) break; maxPop(low, &szLow); }
|
||||
}
|
||||
static void pruneUp(void){ while (szUp>0){ LL v = minTop(up, szUp); if (!delHas(v)) break; minPop(up, &szUp); }
|
||||
}
|
||||
|
||||
static int mcount(void){ return szLow + szUp; }
|
||||
static int targetK(void){ int m = mcount(); return m/2 + 1; }
|
||||
|
||||
static void rebalance(void)
|
||||
{
|
||||
pruneLow(); pruneUp();
|
||||
int k = targetK();
|
||||
while (szLow > 0 && szLow > k){ LL v = maxTop(low, szLow); maxPop(low, &szLow); minPush(up, &szUp, v); pruneLow(); }
|
||||
while (szUp > 0 && szLow < k){ LL v = minTop(up, szUp); minPop(up, &szUp); maxPush(low, &szLow, v); pruneUp(); }
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
delInit();
|
||||
int n; int cas=1; while (scanf("%d", &n)==1)
|
||||
{
|
||||
int cap = n + 5;
|
||||
low = (LL*)malloc((size_t)cap * sizeof(LL));
|
||||
up = (LL*)malloc((size_t)cap * sizeof(LL));
|
||||
qarr= (LL*)malloc((size_t)cap * sizeof(LL));
|
||||
szLow=szUp=0; qh=0; qt=0;
|
||||
delClear();
|
||||
printf("Case #%d:\n", cas++);
|
||||
for (int i=0;i<n;++i)
|
||||
{
|
||||
char op[16];
|
||||
if (scanf("%15s", op)!=1) return 0;
|
||||
if (op[0]=='i')
|
||||
{
|
||||
LL x; scanf("%lld", &x);
|
||||
qarr[qt++]=x;
|
||||
pruneLow();
|
||||
if (szLow==0){ maxPush(low, &szLow, x); }
|
||||
else{
|
||||
LL med = maxTop(low, szLow);
|
||||
if (x <= med) maxPush(low, &szLow, x);
|
||||
else minPush(up, &szUp, x);
|
||||
}
|
||||
rebalance();
|
||||
}
|
||||
else if (op[0]=='o')
|
||||
{
|
||||
LL v = qarr[qh++];
|
||||
pruneLow();
|
||||
LL med = szLow? maxTop(low, szLow) : (LL)0;
|
||||
delMark(v);
|
||||
if (szLow>0 && v <= med) { szLow--; }
|
||||
else { szUp--; }
|
||||
rebalance();
|
||||
}
|
||||
else
|
||||
{
|
||||
pruneLow();
|
||||
LL med = maxTop(low, szLow);
|
||||
printf("%lld\n", med);
|
||||
}
|
||||
}
|
||||
free(low); free(up); free(qarr);
|
||||
}
|
||||
free(delKeys); free(delUsed);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n; if (scanf("%d", &n) != 1) return 0;
|
||||
long long *a = (long long *)malloc(((size_t)n + 1) * sizeof(long long));
|
||||
for (int i = 1; i <= n; ++i) scanf("%lld", &a[i]);
|
||||
int *L = (int *)malloc(((size_t)n + 1) * sizeof(int));
|
||||
int *R = (int *)malloc(((size_t)n + 1) * sizeof(int));
|
||||
for (int i = 1; i <= n; ++i) { int l, r; scanf("%d %d", &l, &r); L[i] = l; R[i] = r; }
|
||||
int *stk = (int *)malloc(((size_t)n + 5) * sizeof(int));
|
||||
int top = 0;
|
||||
int cur = 1;
|
||||
int cnt = 0;
|
||||
int hasPrev = 0; long long prev = 0;
|
||||
while (cur != 0 || top > 0)
|
||||
{
|
||||
while (cur != 0)
|
||||
{
|
||||
stk[top++] = cur;
|
||||
cur = L[cur];
|
||||
}
|
||||
cur = stk[--top];
|
||||
if (!hasPrev) { prev = a[cur]; hasPrev = 1; }
|
||||
else { if (a[cur] <= prev) { printf("No\n"); free(a); free(L); free(R); free(stk); return 0; } prev = a[cur]; }
|
||||
++cnt;
|
||||
cur = R[cur];
|
||||
}
|
||||
if (cnt != n) { printf("No\n"); }
|
||||
else { printf("Yes\n"); }
|
||||
free(a); free(L); free(R); free(stk);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
static void minPush(long long *h, int *sz, long long v)
|
||||
{
|
||||
int i = (*sz);
|
||||
h[i] = v; (*sz)++;
|
||||
while (i > 0)
|
||||
{
|
||||
int p = (i - 1) >> 1;
|
||||
if (h[p] <= h[i]) break;
|
||||
long long t = h[p]; h[p] = h[i]; h[i] = t; i = p;
|
||||
}
|
||||
}
|
||||
|
||||
static long long minPop(long long *h, int *sz)
|
||||
{
|
||||
long long r = h[0];
|
||||
int s = --(*sz);
|
||||
h[0] = h[s];
|
||||
int i = 0;
|
||||
while (1)
|
||||
{
|
||||
int l = (i << 1) | 1, rgt = l + 1, b = i;
|
||||
if (l < s && h[l] < h[b]) b = l;
|
||||
if (rgt < s && h[rgt] < h[b]) b = rgt;
|
||||
if (b == i) break;
|
||||
long long t = h[i]; h[i] = h[b]; h[b] = t; i = b;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
int n; if (scanf("%d", &n) != 1) return 0;
|
||||
long long *h = (long long *)malloc((size_t)n * sizeof(long long));
|
||||
int sz = 0;
|
||||
for (int i = 0; i < n; ++i)
|
||||
{
|
||||
long long x; scanf("%lld", &x);
|
||||
minPush(h, &sz, x);
|
||||
}
|
||||
long long ans = 0;
|
||||
if (sz == 0) { printf("0\n"); free(h); return 0; }
|
||||
while (sz > 1)
|
||||
{
|
||||
long long a = minPop(h, &sz);
|
||||
long long b = minPop(h, &sz);
|
||||
long long c = a + b;
|
||||
ans += c;
|
||||
minPush(h, &sz, c);
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(h);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
static void minPush(long long *h, int *sz, long long v)
|
||||
{
|
||||
int i = (*sz);
|
||||
h[i] = v; (*sz)++;
|
||||
while (i > 0)
|
||||
{
|
||||
int p = (i - 1) >> 1;
|
||||
if (h[p] <= h[i]) break;
|
||||
long long t = h[p]; h[p] = h[i]; h[i] = t; i = p;
|
||||
}
|
||||
}
|
||||
|
||||
static long long minPop(long long *h, int *sz)
|
||||
{
|
||||
long long r = h[0];
|
||||
int s = --(*sz);
|
||||
h[0] = h[s];
|
||||
int i = 0;
|
||||
while (1)
|
||||
{
|
||||
int l = (i << 1) | 1, rgt = l + 1, b = i;
|
||||
if (l < s && h[l] < h[b]) b = l;
|
||||
if (rgt < s && h[rgt] < h[b]) b = rgt;
|
||||
if (b == i) break;
|
||||
long long t = h[i]; h[i] = h[b]; h[b] = t; i = b;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
int main(void)
|
||||
{
|
||||
char *s = (char *)malloc(200005);
|
||||
if (scanf("%200000s", s) != 1) return 0;
|
||||
long long cnt[26] = {0};
|
||||
for (char *p = s; *p; ++p) cnt[*p - 'A']++;
|
||||
int kinds = 0;
|
||||
for (int i = 0; i < 26; ++i) if (cnt[i] > 0) ++kinds;
|
||||
if (kinds == 0) { printf("0\n"); free(s); return 0; }
|
||||
long long *h = (long long *)malloc((size_t)kinds * sizeof(long long));
|
||||
int sz = 0;
|
||||
for (int i = 0; i < 26; ++i) if (cnt[i] > 0) minPush(h, &sz, cnt[i]);
|
||||
if (sz == 1)
|
||||
{
|
||||
long long ans = h[0];
|
||||
printf("%lld\n", ans);
|
||||
free(h); free(s); return 0;
|
||||
}
|
||||
long long ans = 0;
|
||||
while (sz > 1)
|
||||
{
|
||||
long long a = minPop(h, &sz);
|
||||
long long b = minPop(h, &sz);
|
||||
long long c = a + b;
|
||||
ans += c;
|
||||
minPush(h, &sz, c);
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(h); free(s);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
int main(void)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
long long *a = (long long*)malloc((size_t)n * sizeof(long long));
|
||||
long long sum = 0;
|
||||
for (int i = 0; i < n; ++i) { scanf("%lld", &a[i]); sum += a[i]; }
|
||||
long long avg = sum / n;
|
||||
|
||||
long long *s = (long long*)malloc((size_t)n * sizeof(long long));
|
||||
long long cur = 0;
|
||||
for (int i = 0; i < n; ++i) { cur += a[i] - avg; s[i] = cur; }
|
||||
|
||||
long long *t = (long long*)malloc((size_t)n * sizeof(long long));
|
||||
for (int i = 0; i < n; ++i) t[i] = s[i];
|
||||
int cmp(const void *x, const void *y) {
|
||||
long long ux = *(const long long*)x, uy = *(const long long*)y;
|
||||
return (ux > uy) - (ux < uy);
|
||||
}
|
||||
qsort(t, (size_t)n, sizeof(long long), cmp);
|
||||
long long med = t[n/2];
|
||||
|
||||
long long ans = 0;
|
||||
for (int i = 0; i < n; ++i) {
|
||||
long long d = s[i] - med; if (d < 0) d = -d; ans += d;
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
|
||||
free(t);
|
||||
free(s);
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef struct { long long w, s; long long key; } Man;
|
||||
|
||||
static int cmp(const void *a, const void *b) {
|
||||
const Man *x = (const Man*)a, *y = (const Man*)b;
|
||||
if (x->key < y->key) return -1;
|
||||
if (x->key > y->key) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
Man *a = (Man*)malloc((size_t)n * sizeof(Man));
|
||||
for (int i = 0; i < n; ++i) {
|
||||
long long w, s;
|
||||
scanf("%lld %lld", &w, &s);
|
||||
a[i].w = w; a[i].s = s; a[i].key = w + s;
|
||||
}
|
||||
qsort(a, (size_t)n, sizeof(Man), cmp);
|
||||
long long pref = 0, ans = -((long long)1<<62);
|
||||
for (int i = 0; i < n; ++i) {
|
||||
long long risk = pref - a[i].s;
|
||||
if (risk > ans) ans = risk;
|
||||
pref += a[i].w;
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
int main(void)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int T;
|
||||
if (scanf("%d", &T) != 1) return 0;
|
||||
while (T--)
|
||||
{
|
||||
long long n;
|
||||
if (scanf("%lld", &n) != 1) return 0;
|
||||
long long ans;
|
||||
if ((n & 1LL) == 0)
|
||||
{
|
||||
if (n == 2) ans = -1;
|
||||
else ans = n / 4;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (n < 9 || n == 11) ans = -1;
|
||||
else ans = (n - 9) / 4 + 1;
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
static int cmp_int(const void *a, const void *b) {
|
||||
int x = *(const int*)a, y = *(const int*)b;
|
||||
return (x > y) - (x < y);
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n, m;
|
||||
if (scanf("%d %d", &n, &m) != 2) return 0;
|
||||
int *d = (int*)malloc((size_t)n * sizeof(int));
|
||||
int *w = (int*)malloc((size_t)m * sizeof(int));
|
||||
for (int i = 0; i < n; ++i) scanf("%d", &d[i]);
|
||||
for (int i = 0; i < m; ++i) scanf("%d", &w[i]);
|
||||
qsort(d, (size_t)n, sizeof(int), cmp_int);
|
||||
qsort(w, (size_t)m, sizeof(int), cmp_int);
|
||||
int i = 0, j = 0;
|
||||
while (i < n && j < m) {
|
||||
if (w[j] >= d[i]) { ++i; ++j; }
|
||||
else { ++j; }
|
||||
}
|
||||
printf(i == n ? "YES\n" : "NO\n");
|
||||
free(d);
|
||||
free(w);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef struct { double l, r; } Seg;
|
||||
|
||||
static int cmp_seg(const void *a, const void *b) {
|
||||
const Seg *x = (const Seg*)a, *y = (const Seg*)b;
|
||||
if (x->r < y->r) return -1;
|
||||
if (x->r > y->r) return 1;
|
||||
if (x->l < y->l) return -1;
|
||||
if (x->l > y->l) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n, r;
|
||||
while (scanf("%d %d", &n, &r) == 2) {
|
||||
if (n == 0 && r == 0) break;
|
||||
Seg *a = (Seg*)malloc((size_t)n * sizeof(Seg));
|
||||
int ok = r >= 0;
|
||||
for (int i = 0; i < n; ++i) {
|
||||
int x, y;
|
||||
scanf("%d %d", &x, &y);
|
||||
double yy = (double)y;
|
||||
double rr = (double)r;
|
||||
if (!ok || yy > rr || yy < -rr) { ok = 0; continue; }
|
||||
double t = rr*rr - yy*yy;
|
||||
if (t < 0) { ok = 0; continue; }
|
||||
double dx = sqrt(t);
|
||||
a[i].l = (double)x - dx;
|
||||
a[i].r = (double)x + dx;
|
||||
}
|
||||
if (!ok) {
|
||||
printf("-1\n");
|
||||
free(a);
|
||||
continue;
|
||||
}
|
||||
qsort(a, (size_t)n, sizeof(Seg), cmp_seg);
|
||||
const double eps = 1e-12;
|
||||
double p = -1e300;
|
||||
int ans = 0;
|
||||
for (int i = 0; i < n; ++i) {
|
||||
if (a[i].l > p + eps) { ++ans; p = a[i].r; }
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
free(a);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
typedef struct { int b; ll c; } Type;
|
||||
|
||||
static int cmp_int(const void *a, const void *b) {
|
||||
int x = *(const int*)a, y = *(const int*)b;
|
||||
return (x > y) - (x < y);
|
||||
}
|
||||
|
||||
static int cmp_type(const void *a, const void *b) {
|
||||
const Type *x = (const Type*)a, *y = (const Type*)b;
|
||||
if (x->b < y->b) return -1;
|
||||
if (x->b > y->b) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ok(ll L, int n, const int *a, int m, const Type *t, const ll *pref, ll total) {
|
||||
for (int i = 0; i < n; ++i) {
|
||||
int ai = a[i];
|
||||
int l = 0, r = m;
|
||||
while (l < r) {
|
||||
int mid = (l + r) >> 1;
|
||||
if (t[mid].b >= ai) r = mid; else l = mid + 1;
|
||||
}
|
||||
ll need = total - pref[l];
|
||||
ll cap = (ll)(n - i) * L;
|
||||
if (need > cap) return 0;
|
||||
}
|
||||
return total <= (ll)n * L;
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
int *a = (int*)malloc((size_t)n * sizeof(int));
|
||||
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
|
||||
int m;
|
||||
scanf("%d", &m);
|
||||
Type *t = (Type*)malloc((size_t)m * sizeof(Type));
|
||||
for (int i = 0; i < m; ++i) scanf("%d", &t[i].b);
|
||||
for (int i = 0; i < m; ++i) scanf("%lld", &t[i].c);
|
||||
qsort(a, (size_t)n, sizeof(int), cmp_int);
|
||||
qsort(t, (size_t)m, sizeof(Type), cmp_type);
|
||||
int maxa = a[n - 1];
|
||||
int maxb = t[m - 1].b;
|
||||
if (maxb > maxa) {
|
||||
printf("-1\n");
|
||||
free(t); free(a);
|
||||
return 0;
|
||||
}
|
||||
ll *pref = (ll*)malloc(((size_t)m + 1) * sizeof(ll));
|
||||
pref[0] = 0;
|
||||
for (int i = 0; i < m; ++i) pref[i + 1] = pref[i] + t[i].c;
|
||||
ll total = pref[m];
|
||||
ll lo = (total + n - 1) / n, hi = total, ans = hi;
|
||||
while (lo <= hi) {
|
||||
ll mid = lo + ((hi - lo) >> 1);
|
||||
if (ok(mid, n, a, m, t, pref, total)) { ans = mid; hi = mid - 1; }
|
||||
else lo = mid + 1;
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(pref);
|
||||
free(t);
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
int main(void) {
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
int *p = (int*)malloc((size_t)n * sizeof(int));
|
||||
ll *d = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
for (int i = 0; i < n; ++i) scanf("%d", &p[i]);
|
||||
for (int i = 0; i < n; ++i) scanf("%lld", &d[i]);
|
||||
ll ans = p[n - 1];
|
||||
ll s = 0;
|
||||
int in = 0;
|
||||
int start = 0;
|
||||
for (int i = 0; i < n; ++i) {
|
||||
s += d[i];
|
||||
if (!in && s < 0) { in = 1; start = p[i]; }
|
||||
if (in && s >= 0) { ans += 2LL * (p[i] - start); in = 0; }
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(d);
|
||||
free(p);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,87 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef struct { int val; int nxt; } Node;
|
||||
|
||||
static Node *heap;
|
||||
static int hsz;
|
||||
|
||||
static void swap(Node *a, Node *b){ Node t=*a; *a=*b; *b=t; }
|
||||
static int cmp(Node a, Node b){ return a.nxt > b.nxt; }
|
||||
static void heap_push(Node x){
|
||||
int i = hsz++;
|
||||
heap[i] = x;
|
||||
while (i > 0) {
|
||||
int p = (i - 1) >> 1;
|
||||
if (cmp(heap[i], heap[p])) { swap(&heap[i], &heap[p]); i = p; } else break;
|
||||
}
|
||||
}
|
||||
static Node heap_top(){ return heap[0]; }
|
||||
static void heap_pop(){
|
||||
heap[0] = heap[--hsz];
|
||||
int i = 0;
|
||||
for (;;) {
|
||||
int l = i * 2 + 1, r = l + 1, m = i;
|
||||
if (l < hsz && cmp(heap[l], heap[m])) m = l;
|
||||
if (r < hsz && cmp(heap[r], heap[m])) m = r;
|
||||
if (m == i) break;
|
||||
swap(&heap[i], &heap[m]); i = m;
|
||||
}
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int N,m,p;
|
||||
while (scanf("%d %d %d", &N, &m, &p) == 3) {
|
||||
int *seq = (int*)malloc((size_t)p * sizeof(int));
|
||||
for (int i = 0; i < p; ++i) scanf("%d", &seq[i]);
|
||||
int INF = p + 1;
|
||||
int *nxt = (int*)malloc((size_t)p * sizeof(int));
|
||||
int *last = (int*)malloc(((size_t)m + 1) * sizeof(int));
|
||||
for (int i = 1; i <= m; ++i) last[i] = INF;
|
||||
for (int i = p - 1; i >= 0; --i) { int v = seq[i]; nxt[i] = last[v]; last[v] = i; }
|
||||
int *in = (int*)calloc((size_t)m + 1, sizeof(int));
|
||||
int *cur = (int*)malloc(((size_t)m + 1) * sizeof(int));
|
||||
for (int i = 1; i <= m; ++i) cur[i] = -1;
|
||||
heap = (Node*)malloc((size_t)p * sizeof(Node));
|
||||
hsz = 0;
|
||||
int cnt = 0;
|
||||
int miss = 0;
|
||||
for (int i = 0; i < p; ++i) {
|
||||
int v = seq[i];
|
||||
if (in[v]) {
|
||||
cur[v] = nxt[i];
|
||||
Node x = { v, nxt[i] };
|
||||
heap_push(x);
|
||||
} else {
|
||||
++miss;
|
||||
if (cnt < N) {
|
||||
in[v] = 1; cur[v] = nxt[i]; ++cnt; Node x = { v, nxt[i] }; heap_push(x);
|
||||
} else {
|
||||
for (;;) {
|
||||
if (hsz == 0) break;
|
||||
Node t = heap_top();
|
||||
if (!in[t.val] || cur[t.val] != t.nxt) { heap_pop(); continue; }
|
||||
in[t.val] = 0; cur[t.val] = -1; heap_pop(); break;
|
||||
}
|
||||
in[v] = 1; cur[v] = nxt[i]; Node x = { v, nxt[i] }; heap_push(x);
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%d\n", miss);
|
||||
free(heap);
|
||||
free(cur);
|
||||
free(in);
|
||||
free(last);
|
||||
free(nxt);
|
||||
free(seq);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
static int cmp_int(const void *a, const void *b){
|
||||
int x = *(const int*)a, y = *(const int*)b;
|
||||
return (x > y) - (x < y);
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
int *t = (int*)malloc((size_t)n * sizeof(int));
|
||||
for (int i = 0; i < n; ++i) scanf("%d", &t[i]);
|
||||
qsort(t, (size_t)n, sizeof(int), cmp_int);
|
||||
long long cur = 0, sum = 0;
|
||||
for (int i = 0; i < n; ++i){ sum += cur; cur += t[i]; }
|
||||
double ans = (double)sum / (double)n;
|
||||
printf("%.2f\n", ans);
|
||||
free(t);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,52 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
typedef struct { unsigned int a; ll w; } Item;
|
||||
|
||||
static int cmp(const void *x, const void *y){
|
||||
const Item *u = (const Item*)x, *v = (const Item*)y;
|
||||
if (u->a < v->a) return -1;
|
||||
if (u->a > v->a) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
Item *arr = (Item*)malloc((size_t)n * sizeof(Item));
|
||||
for (int i = 0; i < n; ++i){
|
||||
unsigned int a; ll w;
|
||||
scanf("%u %lld", &a, &w);
|
||||
arr[i].a = a; arr[i].w = w;
|
||||
}
|
||||
qsort(arr, (size_t)n, sizeof(Item), cmp);
|
||||
ll total = 0, sumMax = 0;
|
||||
int i = 0;
|
||||
while (i < n){
|
||||
unsigned int cat = arr[i].a;
|
||||
ll mx = arr[i].w;
|
||||
total += arr[i].w;
|
||||
int j = i + 1;
|
||||
while (j < n && arr[j].a == cat){
|
||||
if (arr[j].w > mx) mx = arr[j].w;
|
||||
total += arr[j].w;
|
||||
++j;
|
||||
}
|
||||
sumMax += mx;
|
||||
i = j;
|
||||
}
|
||||
ll ans = total - sumMax;
|
||||
printf("%lld\n", ans);
|
||||
free(arr);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
int *a = (int*)malloc((size_t)n * sizeof(int));
|
||||
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
|
||||
int *L = (int*)malloc((size_t)n * sizeof(int));
|
||||
int *R = (int*)malloc((size_t)n * sizeof(int));
|
||||
L[0] = 1;
|
||||
for (int i = 1; i < n; ++i){
|
||||
if (a[i] > a[i-1]) L[i] = L[i-1] + 1;
|
||||
else if (a[i] == a[i-1]) L[i] = L[i-1];
|
||||
else L[i] = 1;
|
||||
}
|
||||
R[n-1] = 1;
|
||||
for (int i = n-2; i >= 0; --i){
|
||||
if (a[i] > a[i+1]) R[i] = R[i+1] + 1;
|
||||
else if (a[i] == a[i+1]) R[i] = R[i+1];
|
||||
else R[i] = 1;
|
||||
}
|
||||
long long sum = 0;
|
||||
for (int i = 0; i < n; ++i){
|
||||
sum += (L[i] > R[i]) ? L[i] : R[i];
|
||||
}
|
||||
printf("%lld\n", sum);
|
||||
free(R);
|
||||
free(L);
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
static ll sum_min(int L, int n, const int *cnt_le, const ll *sum_le){
|
||||
return sum_le[L] + (ll)L * (ll)(n - cnt_le[L]);
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int m, n;
|
||||
if (scanf("%d %d", &m, &n) != 2) return 0;
|
||||
int *e = (int*)malloc((size_t)n * sizeof(int));
|
||||
int maxv = 0;
|
||||
ll sumE = 0;
|
||||
for (int i = 0; i < n; ++i){ scanf("%d", &e[i]); if (e[i] > maxv) maxv = e[i]; sumE += e[i]; }
|
||||
if (sumE <= (ll)m){ printf("0\n"); free(e); return 0; }
|
||||
int V = maxv + 1;
|
||||
int *freq = (int*)calloc((size_t)V, sizeof(int));
|
||||
for (int i = 0; i < n; ++i) ++freq[e[i]];
|
||||
int *cnt_le = (int*)malloc((size_t)V * sizeof(int));
|
||||
ll *sum_le = (ll*)malloc((size_t)V * sizeof(ll));
|
||||
ll *sumsq_le = (ll*)malloc((size_t)V * sizeof(ll));
|
||||
cnt_le[0] = freq[0];
|
||||
sum_le[0] = (ll)0 * (ll)freq[0];
|
||||
sumsq_le[0] = (ll)0;
|
||||
for (int v = 1; v < V; ++v){
|
||||
cnt_le[v] = cnt_le[v-1] + freq[v];
|
||||
sum_le[v] = sum_le[v-1] + (ll)v * (ll)freq[v];
|
||||
sumsq_le[v] = sumsq_le[v-1] + (ll)v * (ll)v * (ll)freq[v];
|
||||
}
|
||||
ll S = sumE - (ll)m;
|
||||
int lo = 0, hi = maxv, L = 0;
|
||||
while (lo <= hi){
|
||||
int mid = lo + ((hi - lo) >> 1);
|
||||
ll s = sum_min(mid, n, cnt_le, sum_le);
|
||||
if (s <= S){ L = mid; lo = mid + 1; } else { hi = mid - 1; }
|
||||
}
|
||||
ll base_sum = sum_min(L, n, cnt_le, sum_le);
|
||||
ll r = S - base_sum;
|
||||
ll base_sq = sumsq_le[L] + (ll)L * (ll)L * (ll)(n - cnt_le[L]);
|
||||
ll ans = base_sq + r * (ll)(2 * L + 1);
|
||||
printf("%lld\n", ans);
|
||||
free(sumsq_le);
|
||||
free(sum_le);
|
||||
free(cnt_le);
|
||||
free(freq);
|
||||
free(e);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
static int cmp_ll(const void *a, const void *b){
|
||||
ll x = *(const ll*)a, y = *(const ll*)b;
|
||||
return (x > y) - (x < y);
|
||||
}
|
||||
|
||||
static int lower_bound_ll(const ll *arr, int n, ll x){
|
||||
int l = 0, r = n;
|
||||
while (l < r){
|
||||
int m = (l + r) >> 1;
|
||||
if (arr[m] < x) l = m + 1; else r = m;
|
||||
}
|
||||
return l;
|
||||
}
|
||||
|
||||
static ll *bit; static int B;
|
||||
static void bit_add(int i, ll v){ for (; i <= B; i += i & -i) bit[i] += v; }
|
||||
static ll bit_sum(int i){ ll s = 0; for (; i > 0; i -= i & -i) s += i ? bit[i] : 0; return s; }
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n; ll t;
|
||||
if (scanf("%d %lld", &n, &t) != 2) return 0;
|
||||
ll *a = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
|
||||
ll *pref = (ll*)malloc(((size_t)n + 1) * sizeof(ll));
|
||||
pref[0] = 0;
|
||||
for (int i = 1; i <= n; ++i) pref[i] = pref[i-1] + (a[i-1] - t);
|
||||
ll *comp = (ll*)malloc(((size_t)n + 1) * sizeof(ll));
|
||||
for (int i = 0; i <= n; ++i) comp[i] = pref[i];
|
||||
qsort(comp, (size_t)n + 1, sizeof(ll), cmp_ll);
|
||||
int m = 0;
|
||||
for (int i = 0; i <= n; ++i){ if (i == 0 || comp[i] != comp[i-1]) comp[m++] = comp[i]; }
|
||||
B = m;
|
||||
bit = (ll*)calloc((size_t)B + 1, sizeof(ll));
|
||||
const ll MOD = 1000000007LL;
|
||||
ll ans = 0;
|
||||
for (int j = 0; j <= n; ++j){
|
||||
int idx = lower_bound_ll(comp, m, pref[j]) + 1;
|
||||
ll cnt = bit_sum(idx);
|
||||
ans += cnt;
|
||||
if (ans >= MOD) ans %= MOD;
|
||||
bit_add(idx, 1);
|
||||
}
|
||||
printf("%lld\n", ans % MOD);
|
||||
free(bit);
|
||||
free(comp);
|
||||
free(pref);
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
static int n, m;
|
||||
|
||||
static int ok(ll mid, const int *a){
|
||||
ll *pref = (ll*)malloc(((size_t)n + 1) * sizeof(ll));
|
||||
pref[0] = 0;
|
||||
for (int i = 1; i <= n; ++i) pref[i] = pref[i-1] + (ll)a[i-1] * 1000LL - mid;
|
||||
ll min_pref = 0;
|
||||
for (int i = m; i <= n; ++i){
|
||||
if (pref[i - m] < min_pref) min_pref = pref[i - m];
|
||||
if (pref[i] - min_pref >= 0) { free(pref); return 1; }
|
||||
}
|
||||
free(pref);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
if (scanf("%d %d", &n, &m) != 2) return 0;
|
||||
int *a = (int*)malloc((size_t)n * sizeof(int));
|
||||
int maxa = 0;
|
||||
for (int i = 0; i < n; ++i){ scanf("%d", &a[i]); if (a[i] > maxa) maxa = a[i]; }
|
||||
ll lo = 0, hi = (ll)maxa * 1000LL, ans = lo;
|
||||
while (lo <= hi){
|
||||
ll mid = lo + ((hi - lo) >> 1);
|
||||
if (ok(mid, a)){ ans = mid; lo = mid + 1; } else hi = mid - 1;
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
ll *a = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
|
||||
ll sum = 0;
|
||||
for (int i = 0; i < n; ++i) sum += a[i];
|
||||
if ((sum & 1LL) != 0){ printf("0\n"); free(a); return 0; }
|
||||
ll target = sum / 2;
|
||||
ll pref = 0;
|
||||
long long ans = 0;
|
||||
for (int i = 0; i < n - 1; ++i){
|
||||
pref += a[i];
|
||||
if (pref == target) ++ans;
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n,m;
|
||||
if (scanf("%d %d", &n, &m) != 2) return 0;
|
||||
int *cw = (int*)malloc((size_t)n * sizeof(int));
|
||||
int *cb = (int*)malloc((size_t)n * sizeof(int));
|
||||
int *cr = (int*)malloc((size_t)n * sizeof(int));
|
||||
char *row = (char*)malloc((size_t)m + 5);
|
||||
for (int i = 0; i < n; ++i){
|
||||
scanf("%s", row);
|
||||
int cW=0,cB=0,cR=0;
|
||||
for (int j = 0; j < m; ++j){
|
||||
char ch = row[j];
|
||||
if (ch != 'W') ++cW;
|
||||
if (ch != 'B') ++cB;
|
||||
if (ch != 'R') ++cR;
|
||||
}
|
||||
cw[i]=cW; cb[i]=cB; cr[i]=cR;
|
||||
}
|
||||
int *pW = (int*)malloc(((size_t)n + 1) * sizeof(int));
|
||||
int *pB = (int*)malloc(((size_t)n + 1) * sizeof(int));
|
||||
int *pR = (int*)malloc(((size_t)n + 1) * sizeof(int));
|
||||
pW[0]=0; pB[0]=0; pR[0]=0;
|
||||
for (int i = 1; i <= n; ++i){ pW[i]=pW[i-1]+cw[i-1]; pB[i]=pB[i-1]+cb[i-1]; pR[i]=pR[i-1]+cr[i-1]; }
|
||||
long long ans = (long long)n * m;
|
||||
for (int i = 1; i <= n-2; ++i){
|
||||
for (int j = i+1; j <= n-1; ++j){
|
||||
long long cur = (long long)pW[i] + (long long)(pB[j] - pB[i]) + (long long)(pR[n] - pR[j]);
|
||||
if (cur < ans) ans = cur;
|
||||
}
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(pR); free(pB); free(pW);
|
||||
free(row);
|
||||
free(cr); free(cb); free(cw);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
char *s = (char*)malloc((size_t)n + 5);
|
||||
scanf("%s", s);
|
||||
int cntH = 0;
|
||||
for (int i = 0; i < n; ++i) if (s[i] == 'H') ++cntH;
|
||||
int cntT = n - cntH;
|
||||
if (cntH == 0 || cntH == n){ printf("0\n"); free(s); return 0; }
|
||||
|
||||
char *d = (char*)malloc((size_t)2*n + 5);
|
||||
for (int i = 0; i < n; ++i){ d[i] = s[i]; d[i+n] = s[i]; }
|
||||
|
||||
int lenH = cntH;
|
||||
int t_in = 0;
|
||||
for (int i = 0; i < lenH; ++i) if (d[i] == 'T') ++t_in;
|
||||
int bestH = t_in;
|
||||
for (int i = 1; i < n; ++i){
|
||||
if (d[i-1] == 'T') --t_in;
|
||||
if (d[i+lenH-1] == 'T') ++t_in;
|
||||
if (t_in < bestH) bestH = t_in;
|
||||
}
|
||||
|
||||
int lenT = cntT;
|
||||
int h_in = 0;
|
||||
for (int i = 0; i < lenT; ++i) if (d[i] == 'H') ++h_in;
|
||||
int bestT = h_in;
|
||||
for (int i = 1; i < n; ++i){
|
||||
if (d[i-1] == 'H') --h_in;
|
||||
if (d[i+lenT-1] == 'H') ++h_in;
|
||||
if (h_in < bestT) bestT = h_in;
|
||||
}
|
||||
|
||||
int ans = bestH < bestT ? bestH : bestT;
|
||||
printf("%d\n", ans);
|
||||
free(d);
|
||||
free(s);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
static int cmp_ll(const void *a, const void *b){
|
||||
ll x = *(const ll*)a, y = *(const ll*)b;
|
||||
return (x > y) - (x < y);
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
ll *q = (ll*)malloc((size_t)(n > 1 ? n - 1 : 0) * sizeof(ll));
|
||||
for (int i = 0; i < n - 1; ++i) scanf("%lld", &q[i]);
|
||||
ll *s = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
s[0] = 0;
|
||||
for (int i = 1; i < n; ++i) s[i] = s[i-1] + q[i-1];
|
||||
ll *t = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
for (int i = 0; i < n; ++i) t[i] = s[i];
|
||||
qsort(t, (size_t)n, sizeof(ll), cmp_ll);
|
||||
for (int i = 1; i < n; ++i){ if (t[i] == t[i-1]){ printf("-1\n"); free(t); free(s); free(q); return 0; } }
|
||||
ll range = t[n-1] - t[0];
|
||||
if (range != (ll)n - 1){ printf("-1\n"); free(t); free(s); free(q); return 0; }
|
||||
ll shift = 1 - t[0];
|
||||
for (int i = 0; i < n; ++i){ ll v = s[i] + shift; printf("%lld%c", v, (i+1==n)?'\n':' '); }
|
||||
free(t); free(s); free(q);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
int main(void)
|
||||
{
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
|
||||
ll A, B, C, D;
|
||||
if (scanf("%lld %lld %lld %lld", &A, &B, &C, &D) != 4)
|
||||
return 0;
|
||||
ll lenX = B - A + 1;
|
||||
ll ans = 0;
|
||||
for (ll z = C; z <= D; ++z)
|
||||
{
|
||||
ll L = z - C;
|
||||
ll R = z - B;
|
||||
ll s1l = L, s1r = R < A - 1 ? R : A - 1;
|
||||
if (s1l <= s1r)
|
||||
ans += (s1r - s1l + 1) * lenX;
|
||||
ll s2l = L > A ? L : A;
|
||||
ll s2r = R < B - 1 ? R : B - 1;
|
||||
if (s2l <= s2r)
|
||||
{
|
||||
ll cnt = s2r - s2l + 1;
|
||||
ll sumk = (s2l + s2r) * cnt / 2;
|
||||
ans += cnt * B - sumk;
|
||||
}
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n,m;
|
||||
if (scanf("%d %d", &n, &m) != 2) return 0;
|
||||
int **a = (int**)malloc((size_t)n * sizeof(int*));
|
||||
for (int i = 0; i < n; ++i){
|
||||
a[i] = (int*)malloc((size_t)m * sizeof(int));
|
||||
for (int j = 0; j < m; ++j) scanf("%d", &a[i][j]);
|
||||
}
|
||||
ll ans = 0;
|
||||
ll *col = (ll*)malloc((size_t)m * sizeof(ll));
|
||||
ll *pref = (ll*)malloc(((size_t)m + 1) * sizeof(ll));
|
||||
int *st = (int*)malloc(((size_t)m + 1) * sizeof(int));
|
||||
for (int top = 0; top < n; ++top){
|
||||
for (int c = 0; c < m; ++c) col[c] = 0;
|
||||
for (int bottom = top; bottom < n; ++bottom){
|
||||
for (int c = 0; c < m; ++c) col[c] += a[bottom][c];
|
||||
pref[0] = 0;
|
||||
for (int i = 1; i <= m; ++i) pref[i] = pref[i-1] + col[i-1];
|
||||
int sz = 0;
|
||||
for (int i = 0; i <= m; ++i){
|
||||
if (sz == 0 || pref[i] < pref[st[sz-1]]) st[sz++] = i;
|
||||
}
|
||||
int k = sz - 1;
|
||||
for (int j = m; j >= 0 && k >= 0; --j){
|
||||
while (k >= 0 && pref[j] > pref[st[k]]){
|
||||
ll width = (ll)j - (ll)st[k];
|
||||
ll height = (ll)bottom - (ll)top + 1;
|
||||
ll area = width * height;
|
||||
if (area > ans) ans = area;
|
||||
--k;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(st);
|
||||
free(pref);
|
||||
free(col);
|
||||
for (int i = 0; i < n; ++i) free(a[i]);
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
ll *a = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
|
||||
ll sumabs = 0;
|
||||
for (int i = 0; i + 1 < n; ++i){
|
||||
ll d = a[i+1] - a[i];
|
||||
if (d < 0) d = -d;
|
||||
sumabs += d;
|
||||
}
|
||||
ll enddiff = a[n-1] - a[0];
|
||||
if (enddiff < 0) enddiff = -enddiff;
|
||||
ll ans = (sumabs + enddiff) / 2;
|
||||
printf("%lld\n", ans);
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n; ll h; int f;
|
||||
if (scanf("%d %lld %d", &n, &h, &f) != 3) return 0;
|
||||
ll *diff = (ll*)calloc((size_t)n + 2, sizeof(ll));
|
||||
for (int i = 0; i < f; ++i){
|
||||
int a,b; scanf("%d %d", &a, &b);
|
||||
if (a == b) continue;
|
||||
if (a > b){ int t = a; a = b; b = t; }
|
||||
int l = a + 1, r = b - 1;
|
||||
if (l <= r){ diff[l] += 1; diff[r+1] -= 1; }
|
||||
}
|
||||
ll cur = 0;
|
||||
for (int i = 1; i <= n; ++i){
|
||||
cur += diff[i];
|
||||
ll ans = h - cur;
|
||||
printf("%lld\n", ans);
|
||||
}
|
||||
free(diff);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
typedef struct { ll l, r; } Seg;
|
||||
|
||||
static int cmp_seg(const void *a, const void *b){
|
||||
const Seg *x = (const Seg*)a, *y = (const Seg*)b;
|
||||
if (x->l < y->l) return -1;
|
||||
if (x->l > y->l) return 1;
|
||||
if (x->r < y->r) return -1;
|
||||
if (x->r > y->r) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n; ll X;
|
||||
if (scanf("%d %lld", &n, &X) != 2) return 0;
|
||||
ll *a = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
|
||||
ll *b = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
Seg *seg = (Seg*)malloc((size_t)n * sizeof(Seg));
|
||||
int cnt = 0;
|
||||
for (int i = 0; i < n; ++i){
|
||||
if (cnt > 1) qsort(seg, (size_t)cnt, sizeof(Seg), cmp_seg);
|
||||
ll x = a[i];
|
||||
for (int j = 0; j < cnt; ++j){
|
||||
if (x < seg[j].l) break;
|
||||
if (x <= seg[j].r) x = seg[j].r + 1;
|
||||
}
|
||||
b[i] = x;
|
||||
ll L = x - (X - 1);
|
||||
ll R = x + (X - 1);
|
||||
seg[cnt].l = L;
|
||||
seg[cnt].r = R;
|
||||
++cnt;
|
||||
}
|
||||
for (int i = 0; i < n; ++i){
|
||||
if (i) putchar(' ');
|
||||
printf("%lld", b[i]);
|
||||
}
|
||||
putchar('\n');
|
||||
free(seg);
|
||||
free(b);
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
static int cmp_ll(const void *a, const void *b){
|
||||
ll x = *(const ll*)a, y = *(const ll*)b;
|
||||
return (x > y) - (x < y);
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
ll *a = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
ll *b = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
|
||||
for (int i = 0; i < n; ++i) scanf("%lld", &b[i]);
|
||||
ll *d = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
for (int i = 0; i < n; ++i) d[i] = a[i] - b[i];
|
||||
qsort(d, (size_t)n, sizeof(ll), cmp_ll);
|
||||
int ok = 1;
|
||||
for (int i = 0; i < n/2; ++i){
|
||||
if (d[i] + d[n-1-i] != 0){ ok = 0; break; }
|
||||
}
|
||||
printf(ok ? "YES\n" : "NO\n");
|
||||
free(d);
|
||||
free(b);
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
static int cmp_ll(const void *a, const void *b){
|
||||
ll x = *(const ll*)a, y = *(const ll*)b;
|
||||
return (x > y) - (x < y);
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
ll *a = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
|
||||
qsort(a, (size_t)n, sizeof(ll), cmp_ll);
|
||||
ll med = a[n/2];
|
||||
ll sum = 0;
|
||||
for (int i = 0; i < n; ++i){
|
||||
ll d = a[i] - med; if (d < 0) d = -d; sum += d;
|
||||
}
|
||||
printf("%lld\n", sum);
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,49 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
static int cmp_int(const void *a, const void *b){
|
||||
int x = *(const int*)a, y = *(const int*)b;
|
||||
return (x > y) - (x < y);
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
int *a = (int*)malloc((size_t)n * sizeof(int));
|
||||
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
|
||||
|
||||
int *odd = (int*)malloc((size_t)n * sizeof(int));
|
||||
int *even = (int*)malloc((size_t)n * sizeof(int));
|
||||
int *odd_pos = (int*)malloc((size_t)n * sizeof(int));
|
||||
int *even_pos = (int*)malloc((size_t)n * sizeof(int));
|
||||
int oc = 0, ec = 0;
|
||||
for (int i = 0; i < n; ++i){
|
||||
if ((a[i] & 1) != 0){ odd[oc] = a[i]; odd_pos[oc] = i; ++oc; }
|
||||
else { even[ec] = a[i]; even_pos[ec] = i; ++ec; }
|
||||
}
|
||||
qsort(odd, (size_t)oc, sizeof(int), cmp_int);
|
||||
qsort(even, (size_t)ec, sizeof(int), cmp_int);
|
||||
|
||||
int *ans = (int*)malloc((size_t)n * sizeof(int));
|
||||
for (int i = 0; i < oc; ++i) ans[odd_pos[i]] = odd[i];
|
||||
for (int i = 0; i < ec; ++i) ans[even_pos[i]] = even[i];
|
||||
|
||||
for (int i = 0; i < n; ++i){
|
||||
if (i) putchar(' ');
|
||||
printf("%d", ans[i]);
|
||||
}
|
||||
putchar('\n');
|
||||
free(ans);
|
||||
free(even_pos); free(odd_pos);
|
||||
free(even); free(odd);
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
char ord[32];
|
||||
if (scanf("%31s", ord) != 1) return 0;
|
||||
char *s = (char*)malloc(100005);
|
||||
if (scanf("%100000s", s) != 1){ free(s); return 0; }
|
||||
int rank[26];
|
||||
for (int i = 0; i < 26; ++i) rank[(int)(ord[i]-'a')] = i;
|
||||
int cnt[26];
|
||||
for (int i = 0; i < 26; ++i) cnt[i] = 0;
|
||||
for (char *p = s; *p; ++p){ cnt[rank[(int)(*p - 'a')]]++; }
|
||||
for (int i = 0; i < 26; ++i){
|
||||
int c = cnt[i]; char ch = ord[i];
|
||||
while (c--) putchar(ch);
|
||||
}
|
||||
putchar('\n');
|
||||
free(s);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
static int cmp_desc(const void *a, const void *b){
|
||||
int x = *(const int*)a, y = *(const int*)b;
|
||||
return (y > x) - (y < x);
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n,k;
|
||||
if (scanf("%d %d", &n, &k) != 2) return 0;
|
||||
int *a = (int*)malloc((size_t)n * sizeof(int));
|
||||
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
|
||||
qsort(a, (size_t)n, sizeof(int), cmp_desc);
|
||||
int threshold = a[k-1];
|
||||
int cnt = 0;
|
||||
for (int i = 0; i < n; ++i){
|
||||
if (a[i] >= threshold && a[i] > 0) ++cnt;
|
||||
}
|
||||
printf("%d\n", cnt);
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
int *a = (int*)malloc((size_t)n * sizeof(int));
|
||||
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
|
||||
int parity = 0;
|
||||
for (int i = 0; i < n; ++i){
|
||||
for (int j = i + 1; j < n; ++j){
|
||||
if (a[i] > a[j]) parity ^= 1;
|
||||
}
|
||||
}
|
||||
int m; scanf("%d", &m);
|
||||
for (int q = 0; q < m; ++q){
|
||||
int l,r; scanf("%d %d", &l, &r);
|
||||
ll len = (ll)r - (ll)l + 1;
|
||||
ll pairs = len * (len - 1) / 2;
|
||||
if ((pairs & 1LL) != 0) parity ^= 1;
|
||||
if (parity) printf("odd\n"); else printf("even\n");
|
||||
}
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int N; ll K;
|
||||
if (scanf("%d %lld", &N, &K) != 2) return 0;
|
||||
ll *L = (ll*)malloc((size_t)N * sizeof(ll));
|
||||
ll maxL = 0;
|
||||
for (int i = 0; i < N; ++i){
|
||||
scanf("%lld", &L[i]);
|
||||
if (L[i] > maxL) maxL = L[i];
|
||||
}
|
||||
ll lo = 1, hi = maxL, ans = 0;
|
||||
while (lo <= hi){
|
||||
ll mid = (lo + hi) / 2;
|
||||
ll cnt = 0;
|
||||
for (int i = 0; i < N; ++i){
|
||||
cnt += L[i] / mid;
|
||||
if (cnt >= K) break;
|
||||
}
|
||||
if (cnt >= K){ ans = mid; lo = mid + 1; }
|
||||
else { hi = mid - 1; }
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(L);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
static int cmp_double_desc(const void *a, const void *b){
|
||||
double x = *(const double*)a, y = *(const double*)b;
|
||||
return (y > x) - (y < x);
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n, m;
|
||||
if (scanf("%d %d", &n, &m) != 2) return 0;
|
||||
double *v = (double*)malloc((size_t)n * sizeof(double));
|
||||
double *c = (double*)malloc((size_t)n * sizeof(double));
|
||||
for (int i = 0; i < n; ++i) scanf("%lf", &v[i]);
|
||||
for (int i = 0; i < n; ++i) scanf("%lf", &c[i]);
|
||||
double *s = (double*)malloc((size_t)n * sizeof(double));
|
||||
double lo = 0.0, hi = 1000.0;
|
||||
for (int it = 0; it < 70; ++it){
|
||||
double mid = (lo + hi) * 0.5;
|
||||
for (int i = 0; i < n; ++i) s[i] = v[i] - mid * c[i];
|
||||
qsort(s, (size_t)n, sizeof(double), cmp_double_desc);
|
||||
double sum = 0.0;
|
||||
for (int i = 0; i < m; ++i) sum += s[i];
|
||||
if (sum >= 0.0) lo = mid; else hi = mid;
|
||||
}
|
||||
printf("%.3f\n", lo);
|
||||
free(s);
|
||||
free(c);
|
||||
free(v);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
static int cmp_ll_asc(const void *a, const void *b){
|
||||
ll x = *(const ll*)a, y = *(const ll*)b;
|
||||
return (x > y) - (x < y);
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int N, M;
|
||||
if (scanf("%d %d", &N, &M) != 2) return 0;
|
||||
ll *x = (ll*)malloc((size_t)N * sizeof(ll));
|
||||
for (int i = 0; i < N; ++i) scanf("%lld", &x[i]);
|
||||
qsort(x, (size_t)N, sizeof(ll), cmp_ll_asc);
|
||||
ll lo = 0, hi = x[N-1] - x[0], ans = 0;
|
||||
while (lo <= hi){
|
||||
ll mid = (lo + hi) / 2;
|
||||
int cnt = 1;
|
||||
ll last = x[0];
|
||||
for (int i = 1; i < N; ++i){
|
||||
if (x[i] - last >= mid){
|
||||
++cnt;
|
||||
last = x[i];
|
||||
if (cnt >= M) break;
|
||||
}
|
||||
}
|
||||
if (cnt >= M){ ans = mid; lo = mid + 1; }
|
||||
else { hi = mid - 1; }
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(x);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int N; ll M;
|
||||
if (scanf("%d %lld", &N, &M) != 2) return 0;
|
||||
ll *h = (ll*)malloc((size_t)N * sizeof(ll));
|
||||
ll mx = 0;
|
||||
for (int i = 0; i < N; ++i){
|
||||
scanf("%lld", &h[i]);
|
||||
if (h[i] > mx) mx = h[i];
|
||||
}
|
||||
ll lo = 0, hi = mx, ans = 0;
|
||||
while (lo <= hi){
|
||||
ll mid = (lo + hi) / 2;
|
||||
ll got = 0;
|
||||
for (int i = 0; i < N; ++i){
|
||||
if (h[i] > mid){
|
||||
got += h[i] - mid;
|
||||
if (got >= M) break;
|
||||
}
|
||||
}
|
||||
if (got >= M){ ans = mid; lo = mid + 1; }
|
||||
else { hi = mid - 1; }
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(h);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
static int cmp_ll(const void *a, const void *b){
|
||||
ll x = *(const ll*)a, y = *(const ll*)b;
|
||||
return (x > y) - (x < y);
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n; ll t;
|
||||
if (scanf("%lld %d", &t, &n) != 2) return 0;
|
||||
ll *neg = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
ll *pos = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
int ln = 0, rn = 0;
|
||||
for (int i = 0; i < n; ++i){
|
||||
ll x; scanf("%lld", &x);
|
||||
if (x < 0) neg[ln++] = -x;
|
||||
else pos[rn++] = x;
|
||||
}
|
||||
qsort(neg, (size_t)ln, sizeof(ll), cmp_ll);
|
||||
qsort(pos, (size_t)rn, sizeof(ll), cmp_ll);
|
||||
int j = rn;
|
||||
ll ans = 0;
|
||||
for (int i = 0; i <= ln; ++i){
|
||||
ll A = (i == 0 ? 0 : neg[i-1]);
|
||||
while (j > 0){
|
||||
ll B = pos[j-1];
|
||||
ll v1 = 2*A + B;
|
||||
ll v2 = A + 2*B;
|
||||
ll need = v1 < v2 ? v1 : v2;
|
||||
if (need <= t) break;
|
||||
--j;
|
||||
}
|
||||
ll cur = (ll)i + (ll)j;
|
||||
if (cur > ans) ans = cur;
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(pos);
|
||||
free(neg);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
static ll gcdll(ll a, ll b){ while (b){ ll t = a % b; a = b; b = t; } return a; }
|
||||
|
||||
static int ok(ll V, ll cnt1, ll cnt2, ll x, ll y){
|
||||
ll mx = V / x;
|
||||
ll my = V / y;
|
||||
ll l = x / gcdll(x, y) * y;
|
||||
ll mxy = V / l;
|
||||
ll a_only = my - mxy;
|
||||
ll b_only = mx - mxy;
|
||||
ll both = V - mx - my + mxy;
|
||||
ll needA = cnt1 - a_only; if (needA < 0) needA = 0;
|
||||
ll needB = cnt2 - b_only; if (needB < 0) needB = 0;
|
||||
return needA + needB <= both;
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
ll cnt1, cnt2, x, y;
|
||||
if (scanf("%lld %lld %lld %lld", &cnt1, &cnt2, &x, &y) != 4) return 0;
|
||||
ll lo = 1, hi = 1;
|
||||
while (!ok(hi, cnt1, cnt2, x, y)){
|
||||
hi <<= 1;
|
||||
if (hi <= 0) { hi = (ll)4e18; break; }
|
||||
}
|
||||
ll ans = hi;
|
||||
while (lo <= hi){
|
||||
ll mid = lo + ((hi - lo) >> 1);
|
||||
if (ok(mid, cnt1, cnt2, x, y)){ ans = mid; hi = mid - 1; }
|
||||
else lo = mid + 1;
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
static ll *seg;
|
||||
static ll *lazyTag;
|
||||
|
||||
static inline ll minll(ll a, ll b){ return a < b ? a : b; }
|
||||
|
||||
static void build(int idx, int l, int r, ll *arr){
|
||||
if (l == r){ seg[idx] = arr[l]; return; }
|
||||
int mid = (l + r) >> 1;
|
||||
build(idx<<1, l, mid, arr);
|
||||
build(idx<<1|1, mid+1, r, arr);
|
||||
seg[idx] = minll(seg[idx<<1], seg[idx<<1|1]);
|
||||
}
|
||||
|
||||
static inline void apply(int idx, ll val){ seg[idx] += val; lazyTag[idx] += val; }
|
||||
|
||||
static inline void pushDown(int idx){
|
||||
ll tag = lazyTag[idx];
|
||||
if (tag != 0){
|
||||
apply(idx<<1, tag);
|
||||
apply(idx<<1|1, tag);
|
||||
lazyTag[idx] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
static void range_add(int idx, int l, int r, int L, int R, ll val){
|
||||
if (L <= l && r <= R){ apply(idx, val); return; }
|
||||
pushDown(idx);
|
||||
int mid = (l + r) >> 1;
|
||||
if (L <= mid) range_add(idx<<1, l, mid, L, R, val);
|
||||
if (R > mid) range_add(idx<<1|1, mid+1, r, L, R, val);
|
||||
seg[idx] = minll(seg[idx<<1], seg[idx<<1|1]);
|
||||
}
|
||||
|
||||
static ll range_min(int idx, int l, int r, int L, int R){
|
||||
if (L <= l && r <= R) return seg[idx];
|
||||
pushDown(idx);
|
||||
int mid = (l + r) >> 1;
|
||||
ll res = (ll)0x7fffffffffffffffLL;
|
||||
if (L <= mid){ ll v = range_min(idx<<1, l, mid, L, R); res = minll(res, v); }
|
||||
if (R > mid){ ll v = range_min(idx<<1|1, mid+1, r, L, R); res = minll(res, v); }
|
||||
return res;
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n, m;
|
||||
if (scanf("%d %d", &n, &m) != 2) return 0;
|
||||
ll *r = (ll*)malloc(((size_t)n + 1) * sizeof(ll));
|
||||
for (int i = 1; i <= n; ++i) scanf("%lld", &r[i]);
|
||||
seg = (ll*)calloc(((size_t)4*n + 5), sizeof(ll));
|
||||
lazyTag = (ll*)calloc(((size_t)4*n + 5), sizeof(ll));
|
||||
build(1, 1, n, r);
|
||||
int bad = 0, badId = -1;
|
||||
for (int j = 1; j <= m; ++j){
|
||||
ll d; int s, t;
|
||||
if (scanf("%lld %d %d", &d, &s, &t) != 3) { bad = 1; badId = j; break; }
|
||||
ll mn = range_min(1, 1, n, s, t);
|
||||
if (mn >= d){ range_add(1, 1, n, s, t, -d); }
|
||||
else { bad = 1; badId = j; break; }
|
||||
}
|
||||
if (!bad){ printf("0\n"); }
|
||||
else { printf("-1\n%d\n", badId); }
|
||||
free(lazyTag);
|
||||
free(seg);
|
||||
free(r);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n;
|
||||
if (scanf("%d", &n) != 1) return 0;
|
||||
ll sum = 0, mx = 0;
|
||||
for (int i = 0; i < n; ++i){
|
||||
ll x; scanf("%lld", &x);
|
||||
sum += x;
|
||||
if (x > mx) mx = x;
|
||||
}
|
||||
ll g = (sum + (ll)(n - 2)) / (ll)(n - 1);
|
||||
if (g < mx) g = mx;
|
||||
printf("%lld\n", g);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,170 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
typedef struct { ll a, b; } Item;
|
||||
|
||||
static int cmp_item(const void *p, const void *q){
|
||||
const Item *x = (const Item*)p, *y = (const Item*)q;
|
||||
if (x->a < y->a) return -1;
|
||||
if (x->a > y->a) return 1;
|
||||
if (x->b < y->b) return -1;
|
||||
if (x->b > y->b) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void heap_push(ll *h, int *sz, ll v){
|
||||
int i = ++(*sz);
|
||||
h[i] = v;
|
||||
while (i > 1){
|
||||
int p = i >> 1;
|
||||
if (h[p] >= h[i]) break;
|
||||
ll t = h[p]; h[p] = h[i]; h[i] = t;
|
||||
i = p;
|
||||
}
|
||||
}
|
||||
|
||||
static ll heap_top(ll *h){ return h[1]; }
|
||||
|
||||
static void heap_pop(ll *h, int *sz){
|
||||
int n = *sz;
|
||||
h[1] = h[n];
|
||||
--(*sz);
|
||||
int i = 1;
|
||||
while (1){
|
||||
int l = i << 1, r = l + 1, m = i;
|
||||
if (l <= *sz && h[l] > h[m]) m = l;
|
||||
if (r <= *sz && h[r] > h[m]) m = r;
|
||||
if (m == i) break;
|
||||
ll t = h[m]; h[m] = h[i]; h[i] = t;
|
||||
i = m;
|
||||
}
|
||||
}
|
||||
|
||||
static int lower_bound_a(ll *A, int n, ll val){
|
||||
int l = 1, r = n, ans = n + 1;
|
||||
while (l <= r){
|
||||
int mid = (l + r) >> 1;
|
||||
if (A[mid] >= val){ ans = mid; r = mid - 1; }
|
||||
else l = mid + 1;
|
||||
}
|
||||
return ans;
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
ll v; int n, m;
|
||||
if (scanf("%lld %d %d", &v, &n, &m) != 3) return 0;
|
||||
Item *it = (Item*)malloc(((size_t)n + 1) * sizeof(Item));
|
||||
for (int i = 1; i <= n; ++i){
|
||||
scanf("%lld %lld", &it[i].a, &it[i].b);
|
||||
}
|
||||
qsort(it + 1, (size_t)n, sizeof(Item), cmp_item);
|
||||
ll *A = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
|
||||
ll *B = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
|
||||
for (int i = 1; i <= n; ++i){ A[i] = it[i].a; B[i] = it[i].b; }
|
||||
ll INF = 9000000000000000000LL;
|
||||
int k = m / 2;
|
||||
ll *prefK = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
|
||||
ll *sufK = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
|
||||
ll *prefK1 = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
|
||||
ll *sufK1 = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
|
||||
for (int i = 0; i <= n + 1; ++i){ prefK[i] = INF; sufK[i] = INF; prefK1[i] = INF; sufK1[i] = INF; }
|
||||
if (k == 0){ for (int i = 0; i <= n + 1; ++i){ prefK[i] = 0; sufK[i] = 0; } }
|
||||
else{
|
||||
ll *heap = (ll*)malloc(((size_t)n + 5) * sizeof(ll)); int sz = 0; ll sum = 0;
|
||||
for (int i = 1; i <= n; ++i){
|
||||
heap_push(heap, &sz, B[i]); sum += B[i];
|
||||
if (sz > k){ sum -= heap_top(heap); heap_pop(heap, &sz); }
|
||||
if (sz == k) prefK[i] = sum; else prefK[i] = INF;
|
||||
}
|
||||
sz = 0; sum = 0;
|
||||
for (int i = n; i >= 1; --i){
|
||||
heap_push(heap, &sz, B[i]); sum += B[i];
|
||||
if (sz > k){ sum -= heap_top(heap); heap_pop(heap, &sz); }
|
||||
if (sz == k) sufK[i] = sum; else sufK[i] = INF;
|
||||
}
|
||||
free(heap);
|
||||
}
|
||||
int k1 = k - 1;
|
||||
if (k1 <= 0){ for (int i = 0; i <= n + 1; ++i){ prefK1[i] = 0; sufK1[i] = 0; } }
|
||||
else{
|
||||
ll *heap = (ll*)malloc(((size_t)n + 5) * sizeof(ll)); int sz = 0; ll sum = 0;
|
||||
for (int i = 1; i <= n; ++i){
|
||||
heap_push(heap, &sz, B[i]); sum += B[i];
|
||||
if (sz > k1){ sum -= heap_top(heap); heap_pop(heap, &sz); }
|
||||
if (sz == k1) prefK1[i] = sum; else prefK1[i] = INF;
|
||||
}
|
||||
sz = 0; sum = 0;
|
||||
for (int i = n; i >= 1; --i){
|
||||
heap_push(heap, &sz, B[i]); sum += B[i];
|
||||
if (sz > k1){ sum -= heap_top(heap); heap_pop(heap, &sz); }
|
||||
if (sz == k1) sufK1[i] = sum; else sufK1[i] = INF;
|
||||
}
|
||||
free(heap);
|
||||
}
|
||||
ll *leftCostWith = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
|
||||
ll *rightCostWith = (ll*)malloc(((size_t)n + 2) * sizeof(ll));
|
||||
ll *suffixMin = (ll*)malloc(((size_t)n + 3) * sizeof(ll));
|
||||
for (int i = 1; i <= n; ++i){
|
||||
if (prefK1[i-1] >= INF/2) leftCostWith[i] = INF; else leftCostWith[i] = prefK1[i-1] + B[i];
|
||||
}
|
||||
for (int j = 1; j <= n; ++j){
|
||||
if (sufK1[j+1] >= INF/2) rightCostWith[j] = INF; else rightCostWith[j] = B[j] + sufK1[j+1];
|
||||
}
|
||||
suffixMin[n+1] = INF;
|
||||
for (int j = n; j >= 1; --j){
|
||||
ll vmin = rightCostWith[j];
|
||||
if (suffixMin[j+1] < vmin) vmin = suffixMin[j+1];
|
||||
suffixMin[j] = vmin;
|
||||
}
|
||||
ll lo = 0, hi = A[n], ans = 0;
|
||||
while (lo <= hi){
|
||||
ll mid = (lo + hi) >> 1;
|
||||
int ok = 0;
|
||||
if ((m & 1) != 0){
|
||||
for (int i = 1; i <= n; ++i){
|
||||
if (A[i] < mid) continue;
|
||||
ll left = prefK[i-1];
|
||||
ll right = sufK[i+1];
|
||||
if (left >= INF/2 || right >= INF/2) continue;
|
||||
ll cost = left + right + B[i];
|
||||
if (cost <= v){ ok = 1; break; }
|
||||
}
|
||||
} else {
|
||||
for (int i = 1; i <= n; ++i){
|
||||
if (leftCostWith[i] >= INF/2) continue;
|
||||
ll need = 2*mid - A[i];
|
||||
int j = lower_bound_a(A, n, need);
|
||||
if (j <= i) j = i + 1;
|
||||
if (j > n) continue;
|
||||
ll rc = suffixMin[j];
|
||||
if (rc >= INF/2) continue;
|
||||
ll cost = leftCostWith[i] + rc;
|
||||
if (cost <= v){ ok = 1; break; }
|
||||
}
|
||||
}
|
||||
if (ok){ ans = mid; lo = mid + 1; }
|
||||
else hi = mid - 1;
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(suffixMin);
|
||||
free(rightCostWith);
|
||||
free(leftCostWith);
|
||||
free(sufK1);
|
||||
free(prefK1);
|
||||
free(sufK);
|
||||
free(prefK);
|
||||
free(B);
|
||||
free(A);
|
||||
free(it);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
static int cmp_ll(const void *a, const void *b){
|
||||
ll x = *(const ll*)a, y = *(const ll*)b;
|
||||
return (x > y) - (x < y);
|
||||
}
|
||||
|
||||
static ll count_leq(ll *a, int n, ll d){
|
||||
ll cnt = 0;
|
||||
int j = 0;
|
||||
for (int i = 0; i < n; ++i){
|
||||
while (a[i] - a[j] > d) ++j;
|
||||
cnt += (ll)(i - j);
|
||||
}
|
||||
return cnt;
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n; ll k;
|
||||
if (scanf("%d %lld", &n, &k) != 2) return 0;
|
||||
ll *a = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
for (int i = 0; i < n; ++i) scanf("%lld", &a[i]);
|
||||
qsort(a, (size_t)n, sizeof(ll), cmp_ll);
|
||||
ll lo = 0, hi = a[n-1] - a[0], ans = hi;
|
||||
while (lo <= hi){
|
||||
ll mid = lo + ((hi - lo) >> 1);
|
||||
ll cnt = count_leq(a, n, mid);
|
||||
if (cnt >= k){ ans = mid; hi = mid - 1; }
|
||||
else lo = mid + 1;
|
||||
}
|
||||
printf("%lld\n", ans);
|
||||
free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,38 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
static int cmp_ll(const void *a, const void *b){
|
||||
ll x = *(const ll*)a, y = *(const ll*)b;
|
||||
return (x > y) - (x < y);
|
||||
}
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n; if (scanf("%d", &n) != 1) return 0;
|
||||
ll *a = (ll*)malloc((size_t)n * sizeof(ll));
|
||||
ll sum = 0;
|
||||
for (int i = 0; i < n; ++i){ scanf("%lld", &a[i]); sum += a[i]; }
|
||||
ll avg = sum / (ll)n;
|
||||
ll *s = (ll*)malloc((size_t)(n) * sizeof(ll));
|
||||
ll pref = 0;
|
||||
for (int i = 0; i < n; ++i){
|
||||
pref += a[i] - avg;
|
||||
s[i] = pref;
|
||||
}
|
||||
qsort(s, (size_t)n, sizeof(ll), cmp_ll);
|
||||
ll med = s[n/2];
|
||||
ll ans = 0;
|
||||
for (int i = 0; i < n; ++i){ ll d = s[i] - med; if (d < 0) d = -d; ans += d; }
|
||||
printf("%lld\n", ans);
|
||||
free(s); free(a);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef unsigned long long ull;
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int m,n;
|
||||
if (scanf("%d %d", &m, &n) != 2) return 0;
|
||||
int S = m * (n - 1);
|
||||
if (S <= 0){ printf("1\n"); return 0; }
|
||||
ull a = 1, b = 1;
|
||||
for (int i = 2; i <= S; ++i){ ull c = a + b; a = b; b = c; }
|
||||
printf("%llu\n", b);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef struct { int nxt[26]; int end; } Node;
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
char buf[1024];
|
||||
Node *tr = (Node*)malloc((size_t)1 * sizeof(Node));
|
||||
int cap = 1, sz = 1;
|
||||
for (int i = 0; i < 26; ++i) tr[0].nxt[i] = -1; tr[0].end = 0;
|
||||
while (scanf("%1023s", buf) == 1){
|
||||
if (buf[0] == '.' && buf[1] == '\0') break;
|
||||
int u = 0;
|
||||
for (int k = 0; buf[k]; ++k){
|
||||
int c = buf[k] - 'A';
|
||||
if (c < 0 || c >= 26) { u = -1; break; }
|
||||
int v = tr[u].nxt[c];
|
||||
if (v == -1){
|
||||
if (sz == cap){ cap = cap * 2 + 4; tr = (Node*)realloc(tr, (size_t)cap * sizeof(Node)); }
|
||||
v = sz++;
|
||||
for (int i = 0; i < 26; ++i) tr[v].nxt[i] = -1; tr[v].end = 0;
|
||||
tr[u].nxt[c] = v;
|
||||
}
|
||||
u = v;
|
||||
}
|
||||
if (u >= 0) tr[u].end = 1;
|
||||
}
|
||||
size_t S_cap = 200005;
|
||||
char *S = (char*)malloc(S_cap);
|
||||
size_t S_len = 0;
|
||||
while (scanf("%1023s", buf) == 1){
|
||||
size_t L = strlen(buf);
|
||||
if (S_len + L + 1 > S_cap){
|
||||
while (S_len + L + 1 > S_cap) S_cap = S_cap * 2 + 8;
|
||||
S = (char*)realloc(S, S_cap);
|
||||
}
|
||||
memcpy(S + S_len, buf, L);
|
||||
S_len += L;
|
||||
}
|
||||
S[S_len] = '\0';
|
||||
int n = (int)S_len;
|
||||
char *dp = (char*)malloc((size_t)n + 1);
|
||||
for (int i = 0; i <= n; ++i) dp[i] = 0;
|
||||
dp[0] = 1;
|
||||
int ans = 0;
|
||||
for (int i = 0; i < n; ++i){
|
||||
if (!dp[i]) continue;
|
||||
int u = 0;
|
||||
for (int step = 1; step <= 10; ++step){
|
||||
int j = i + step;
|
||||
if (j > n) break;
|
||||
int c = S[j-1] - 'A';
|
||||
if (c < 0 || c >= 26) break;
|
||||
int v = tr[u].nxt[c];
|
||||
if (v == -1) break;
|
||||
u = v;
|
||||
if (tr[u].end){ dp[j] = 1; if (j > ans) ans = j; }
|
||||
}
|
||||
}
|
||||
printf("%d\n", ans);
|
||||
free(dp);
|
||||
free(S);
|
||||
free(tr);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n,k;
|
||||
if (scanf("%d %d", &n, &k) != 2) return 0;
|
||||
const int MOD = 114584;
|
||||
int *dp = (int*)malloc(((size_t)n + 1) * sizeof(int));
|
||||
int *pre = (int*)malloc(((size_t)n + 1) * sizeof(int));
|
||||
dp[0] = 1;
|
||||
pre[0] = 1;
|
||||
for (int i = 1; i <= n; ++i){
|
||||
long long sum = pre[i-1];
|
||||
int idx = i - k - 1;
|
||||
if (idx >= 0) sum -= pre[idx];
|
||||
int val = (int)(sum % MOD);
|
||||
if (val < 0) val += MOD;
|
||||
dp[i] = val;
|
||||
pre[i] = pre[i-1] + dp[i];
|
||||
if (pre[i] >= MOD) pre[i] -= MOD;
|
||||
}
|
||||
printf("%d\n", dp[n]);
|
||||
free(pre);
|
||||
free(dp);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
ll x,n,m,k;
|
||||
if (scanf("%lld %lld %lld %lld", &x, &n, &m, &k) != 4) return 0;
|
||||
const int MOD = 1000000007;
|
||||
if (x < 0){ printf("impossible\n"); return 0; }
|
||||
int X = (int)x;
|
||||
int *dp = (int*)malloc(((size_t)X + 1) * sizeof(int));
|
||||
for (int i = 0; i <= X; ++i) dp[i] = 0;
|
||||
dp[0] = 1;
|
||||
for (int i = 1; i <= X; ++i){
|
||||
long long s = 0;
|
||||
if (i - (int)n >= 0) s += dp[i - (int)n];
|
||||
if (i - (int)m >= 0) s += dp[i - (int)m];
|
||||
if (i - (int)k >= 0) s += dp[i - (int)k];
|
||||
dp[i] = (int)(s % MOD);
|
||||
}
|
||||
if (dp[X] == 0) printf("impossible\n"); else printf("%d\n", dp[X]);
|
||||
free(dp);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#ifdef _WIN32
|
||||
#include <windows.h>
|
||||
#endif
|
||||
|
||||
typedef long long ll;
|
||||
|
||||
int main(void){
|
||||
#ifdef _WIN32
|
||||
system("chcp 65001 > nul");
|
||||
SetConsoleOutputCP(65001);
|
||||
SetConsoleCP(65001);
|
||||
#endif
|
||||
int n; ll MOD;
|
||||
if (scanf("%d %lld", &n, &MOD) != 2) return 0;
|
||||
int *f = (int*)malloc(((size_t)n + 3) * sizeof(int));
|
||||
long long *diff = (long long*)calloc(((size_t)n + 5), sizeof(long long));
|
||||
long long pref = 0;
|
||||
long long Dcur = 0;
|
||||
for (int x = 1; x <= n; ++x){
|
||||
Dcur += diff[x];
|
||||
Dcur %= MOD;
|
||||
if (Dcur < 0) Dcur += MOD;
|
||||
if (x == 1) f[x] = 1 % (int)MOD; else f[x] = (int)((pref + Dcur) % MOD);
|
||||
pref += f[x];
|
||||
pref %= MOD;
|
||||
int maxz = n / x;
|
||||
for (int z = 2; z <= maxz; ++z){
|
||||
int l = x * z;
|
||||
int r = l + z - 1;
|
||||
if (r > n) r = n;
|
||||
diff[l] += f[x];
|
||||
diff[r + 1] -= f[x];
|
||||
}
|
||||
}
|
||||
printf("%d\n", (int)(f[n] % (int)MOD));
|
||||
free(diff);
|
||||
free(f);
|
||||
return 0;
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user