text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int inf = 987654321;
const long long int INF = 123456789987654321;
int N, K, S, T;
vector<pair<int, int> > car;
vector<int> gas, dist, psum;
void get_psum() {
psum.resize(dist.size());
for (int i = 0; i < dist.size(); i++) {
psum[i] = dist[i];
if (i != 0) psum[i] += psum[i - 1];
}
}
int g(int x) {
int s = 0, e = dist.size() - 1;
int ret = -1;
while (s <= e) {
int m = (s + e) >> 1;
if (2 * dist[m] <= x) {
ret = m;
s = m + 1;
} else
e = m - 1;
}
return ret;
}
int main() {
scanf("%d %d %d %d", &N, &K, &S, &T);
car.resize(N);
for (int i = 0; i < N; i++) {
int c, v;
scanf("%d %d", &c, &v);
car[i] = pair<int, int>(c, v);
}
gas.resize(K);
for (int i = 0; i < K; i++) {
scanf("%d", &gas[i]);
}
sort(gas.begin(), gas.end());
dist.push_back(gas[0]);
for (int i = 1; i < K; i++) {
dist.push_back(gas[i] - gas[i - 1]);
}
dist.push_back(S - gas.back());
sort(dist.begin(), dist.end());
get_psum();
int mini = 2 * inf;
for (int i = 0; i < N; i++) {
int f = car[i].second;
if (dist.back() > f) continue;
int t = g(f);
int d = t == -1 ? 0 : psum[t];
int tm = d;
tm += 3 * (psum.back() - d) - (dist.size() - 1 - t) * f;
if (tm <= T) {
mini = min(mini, car[i].first);
}
}
if (mini != 2 * inf)
printf("%d", mini);
else
printf("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, s, t;
long long ans1[200009], ans2[200009];
long long pos[200009];
bool check(long long mid) {
long long cnt = 0;
for (int i = 0; i < m + 1; i++) {
long long k = pos[i + 1] - pos[i];
if (k > mid)
return false;
else {
long long cha = mid - k;
if (mid - k > k)
cnt += k;
else
cnt += cha + (k - cha) * 2;
}
if (cnt > t) return false;
}
return cnt <= t;
}
int main() {
cin >> n >> m >> s >> t;
for (long long i = 0; i < n; i++) {
scanf("%lld%lld", &ans1[i], &ans2[i]);
}
for (long long i = 0; i < m; i++) {
scanf("%lld", &pos[i]);
}
pos[m] = 0, pos[m + 1] = s;
sort(pos, pos + m + 2);
long long ks = 0, js = 2e9;
while (ks < js) {
long long mid = (ks + js) >> 1;
if (check(mid))
js = mid;
else
ks = mid + 1;
}
long long min_ = 2e9;
for (long long i = 0; i < n; i++)
if (ans2[i] >= ks)
if (ans1[i] < min_) min_ = ans1[i];
if (min_ == (long long)2e9) min_ = -1;
cout << min_ << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int p = 31, N = 1e5 + 10, M = (long long int)1e9 + 1;
const int mod = 1e9 + 7;
bool is(vector<long long int> g, long long int t, long long int v) {
long long int i, j, dist, f, ti = 0;
long long int x1, x2, k = g.size();
for (i = 1; i < k; i++) {
dist = g[i] - g[i - 1];
f = v;
x1 = f - dist;
if (x1 < 0) return false;
x1 = min(dist, f - dist);
x2 = dist - x1;
ti += x1 + 2 * x2;
if (ti > t) return false;
}
return true;
}
int main() {
ios_base::sync_with_stdio(0);
long long int n, k, s, t;
cin >> n >> k >> s >> t;
long long int i;
vector<pair<long long int, long long int> > a(n);
for (i = 0; i < n; i++) {
long long int c, v;
cin >> c >> v;
a[i] = {v, c};
}
vector<long long int> g(k + 2);
g[0] = 0;
for (i = 1; i <= k; i++) cin >> g[i];
g[k + 1] = s;
sort(g.begin(), g.end());
long long int lo = 1, hi = 1e9 + 10, ok = 0;
while (lo < hi) {
long long int m = lo + (hi - lo) / 2;
if (is(g, t, m)) {
ok = 1;
hi = m;
} else
lo = m + 1;
}
long long int ans = INT_MAX, capa = lo;
for (i = 0; i < n; i++) {
if (a[i].first >= capa) ans = min(ans, a[i].second);
}
if (ans == INT_MAX)
cout << -1;
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, i;
long long s, t, x;
pair<long long, long long> cars[200011];
vector<long long> gas;
long long ans, solution;
long long check(long long vol) {
long long ans = 0;
for (int i = 1; i < gas.size(); i++) {
long long dim = gas[i] - gas[i - 1];
ans += 2 * dim - min(dim, vol - dim);
}
return ans;
}
int main() {
scanf("%d%d%lld%lld", &n, &k, &s, &t);
for (i = 1; i <= n; i++) scanf("%lld%lld", &cars[i].first, &cars[i].second);
gas = {0, s};
for (i = 1; i <= k; i++) {
scanf("%lld", &x);
gas.push_back(x);
}
sort(gas.begin(), gas.end());
gas.resize(unique(gas.begin(), gas.end()) - gas.begin());
for (i = 1; i < gas.size(); i++) ans = max(ans, gas[i] - gas[i - 1] - 1);
for (long long step = (1LL << 33); step > 0; step >>= 1) {
if (check(ans + step) > t) ans += step;
}
ans++;
solution = 1LL << 60;
for (i = 1; i <= n; i++) {
if (cars[i].second < ans) continue;
solution = min(solution, cars[i].first);
}
if (solution == 1LL << 60) {
printf("-1");
return 0;
}
printf("%lld", solution);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, T;
int g[500010];
struct dian {
int c;
int v;
} node[500010];
int cmp1(dian a, dian b) { return a.v < b.v; }
int cmp2(dian a, dian b) { return a.c < b.c; }
bool judge(int sum) {
int t = 0;
for (int i = 2; i <= k; i++) {
int dis = g[i] - g[i - 1];
if (sum < dis) return false;
if (sum >= 2 * dis)
t += dis;
else
t += 3 * dis - sum;
if (t > T) return false;
}
return true;
}
int main() {
while (~scanf("%d %d %d %d", &n, &k, &s, &T)) {
for (int i = 1; i <= n; i++) {
scanf("%d %d", &node[i].c, &node[i].v);
}
for (int i = 1; i <= k; i++) {
scanf("%d", &g[i]);
}
g[++k] = 0;
g[++k] = s;
sort(g + 1, g + 1 + k);
sort(node + 1, node + 1 + n, cmp1);
int ans = -1;
int l = 1;
int r = n;
while (l <= r) {
int mid = (l + r) / 2;
if (judge(node[mid].v)) {
ans = mid;
r = mid - 1;
} else {
l = mid + 1;
}
}
if (ans == -1) {
printf("-1\n");
} else {
int min = 1000000000;
for (int i = 1; i <= n; i++) {
if (node[i].v >= node[ans].v && node[i].c < min) min = node[i].c;
}
cout << min << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
const int MAXV = 200000;
int g[MAXV + 10], n, s, k, t;
struct Car {
int v, c;
bool operator<(const Car& rhs) const { return v < rhs.v; }
} cars[MAXN + 10];
bool check(int val) {
double t_cnt = 0;
for (int i = 0; i <= k; i++) {
if (g[i + 1] - g[i] > val) return false;
t_cnt += 2.0 * (g[i + 1] - g[i]);
int oth = val - g[i + 1] + g[i];
if (oth > g[i + 1] - g[i])
t_cnt -= 1.0 * (g[i + 1] - g[i]);
else
t_cnt -= 1.0 * oth;
}
return t_cnt <= t;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 1; i <= n; i++) scanf("%d%d", &cars[i].c, &cars[i].v);
sort(cars + 1, cars + 1 + n);
for (int i = 1; i <= k; i++) scanf("%d", &g[i]);
sort(g + 1, g + 1 + k);
g[k + 1] = s;
int L = 0, R = cars[n].v, ans = -1;
while (L <= R) {
int mid = (L + R) >> 1;
if (check(mid)) {
ans = mid;
R = mid - 1;
} else
L = mid + 1;
}
if (ans == -1) {
printf("-1\n");
return 0;
}
int op = 0x3f3f3f3f;
for (int i = n; i >= 1; i--) {
if (cars[i].v < ans) break;
op = min(op, cars[i].c);
}
printf("%d\n", op);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
long long a[200200][2];
long long b[200200];
bool pd(long long now, int n, int t) {
long long sum = 0;
long long pre = 0;
for (int i = 0; i <= n; ++i) {
long long jl = b[i] - pre;
if (jl > now) return false;
long long temp = now - jl;
sum += max(jl, 2 * jl - temp);
pre = b[i];
}
if (sum <= t) return true;
return false;
}
long long erfen(long long l, long long r, int n, int t) {
while (l < r) {
long long mid = (l + r) >> 1;
if (pd(mid, n, t))
r = mid;
else
l = mid + 1;
}
return l;
}
int main() {
long long n, m, s, t;
scanf("%I64d%I64d%I64d%I64d", &n, &m, &s, &t);
for (int i = 0; i < n; ++i) scanf("%I64d%I64d", &a[i][0], &a[i][1]);
for (int i = 0; i < m; ++i) scanf("%I64d", b + i);
if (s > t) {
printf("-1\n");
return 0;
}
b[m] = s;
sort(b, b + m + 1);
long long ma = erfen(1, 2 * s, m, t);
long long ans = LLINF;
for (int i = 0; i < n; ++i)
if (a[i][1] >= ma) ans = min(ans, a[i][0]);
if (ans == LLINF) ans = -1;
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
long long n, k, s, t;
cin >> n >> k >> s >> t;
vector<long long> c(n), v(n), g(k + 1, 1e9 + 5), f(k + 2, 0);
for (int i = 0; i < n; i++) cin >> c[i] >> v[i];
for (int i = 0; i < k; i++) cin >> g[i];
sort(g.begin(), g.end());
g[k] = s;
for (int i = k - 1; i >= 0; i--) g[i + 1] -= g[i];
sort(g.begin(), g.end());
for (int i = 1; i <= k + 1; i++) f[i] = f[i - 1] + g[i - 1];
long long ret = -1;
for (int i = 0; i < n; i++)
if (g[k] <= v[i]) {
long long x = upper_bound(g.begin(), g.end(), v[i] / 2) - g.begin();
if (2 * s - f[x] - (k + 1 - x) * v[i] + (f[k + 1] - f[x]) <= t) {
if (ret == -1)
ret = c[i];
else
ret = min(ret, c[i]);
}
}
cout << ret << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 56;
const int inf = 1e9 + 7;
int c[N], v[N], l[N], p[N];
long long sum[N];
int main() {
int n, k, s, t;
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
scanf("%d %d", c + i, v + i);
}
for (int i = 0; i < k; i++) {
scanf("%d", p + i);
}
sort(p, p + k);
int now = 0;
for (int i = 0; i < k; i++) {
l[i] = p[i] - now;
now = p[i];
}
l[k++] = s - now;
sort(l, l + k);
sum[0] = 0;
for (int i = 0; i < k; i++) sum[i + 1] = sum[i] + l[i];
int ans = inf;
for (int i = 0; i < n; i++) {
if (v[i] < l[k - 1]) continue;
int id = upper_bound(l, l + k, v[i] / 2) - l;
long long cur = sum[id] + (sum[k] - sum[id]) * 3 - 1LL * v[i] * (k - id);
if (cur <= t) ans = min(ans, c[i]);
}
if (ans >= inf) ans = -1;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int64_t inf = 2e12 + 42;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
int64_t n, k, s, t;
cin >> n >> k >> s >> t;
int64_t c[n], v[n];
for (int64_t i = 0; i < n; i++) cin >> c[i] >> v[i];
int64_t g[k + 2];
for (int64_t i = 1; i <= k; i++) cin >> g[i];
g[0] = 0, g[k + 1] = s;
sort(g, g + k + 2);
int64_t p[n];
iota(p, p + n, 0);
sort(p, p + n, [&](int64_t a, int64_t b) { return v[a] < v[b]; });
int64_t l = -1, r = n;
while (r - l > 1) {
int64_t m = (l + r) / 2;
int64_t V = v[p[m]];
int64_t T = 0;
for (int64_t i = 1; i <= k + 1; i++) {
int64_t dist = g[i] - g[i - 1];
int64_t k2 = V - dist;
int64_t k1 = dist - k2;
if (k2 < 0) T = inf;
if (k1 < 0) {
k1 = 0, k2 = dist;
}
assert(T >= inf ||
k1 + k2 == dist && 2 * k2 + k1 <= V && k1 >= 0 && k2 >= 0);
T += 2 * k1 + k2;
}
if (T <= t)
r = m;
else
l = m;
}
if (r == n) {
cout << -1 << endl;
return 0;
}
int64_t ans = inf;
for (int64_t i = 0; i < n; i++)
if (v[i] >= v[p[r]]) ans = min(ans, c[i]);
if (ans == inf)
cout << -1 << endl;
else
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, k, s, t;
cin >> n >> k >> s >> t;
long long g[200005];
long long cc[200005];
long long vv[200005];
for (int i = 0; i < n; i++) {
cin >> cc[i] >> vv[i];
}
for (int i = 1; i <= k; i++) {
cin >> g[i];
}
g[0] = 0;
g[k + 1] = s;
sort(g, g + k + 1);
long long dif[200005];
for (int i = 0; i < k + 1; i++) {
dif[i] = g[i + 1] - g[i];
}
sort(dif, dif + k + 1);
long long mini = inf;
long long maxi = 0;
long long low = 1;
long long high = 1e10;
while (low <= high) {
long long mid = (low + high) / 2;
bool b = true;
long long tt = 0;
for (int i = 0; i < k + 1; i++) {
if (dif[i] > mid) b = false;
tt += max(3 * dif[i] - mid, dif[i]);
}
if (b && tt <= t) {
high = mid - 1;
} else {
low = mid + 1;
}
}
for (int i = 0; i < n; i++) {
if (vv[i] >= low) {
mini = min(mini, cc[i]);
}
}
if (mini == inf)
cout << -1 << endl;
else
cout << mini << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long b[200 * 1000 + 10], c[200 * 1000 + 10], v[200 * 1000 + 10];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, k, s, t;
cin >> n >> k >> s >> t;
for (long long i = 1; i <= n; i++) cin >> c[i] >> v[i];
for (long long j = 1; j <= k; j++) cin >> b[j];
sort(b + 1, b + k + 1);
b[k + 1] = s;
long long l = 0, r = 1e9;
long long tc = 0;
for (long long j = 1; j <= k + 1; j++) {
if (b[j] - b[j - 1] > r) {
cout << "-1\n";
return 0;
}
tc += (b[j] - b[j - 1]) * 2 - min(r - (b[j] - b[j - 1]), b[j] - b[j - 1]);
}
if (tc > t) {
cout << "-1";
return 0;
}
while (r - l > 1) {
long long m = (l + r) / 2;
tc = 0;
for (long long j = 1; j <= k + 1; j++) {
if (b[j] - b[j - 1] > m) {
l = m;
goto m1;
}
tc += (b[j] - b[j - 1]) * 2 - min(m - (b[j] - b[j - 1]), b[j] - b[j - 1]);
}
if (tc <= t)
r = m;
else
l = m;
m1:;
}
long long ans = LLONG_MAX;
for (long long i = 1; i <= n; i++) {
if (v[i] >= r && c[i] < ans) ans = c[i];
}
if (ans == LLONG_MAX)
cout << "-1";
else
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod = 1e9 + 7;
long long powmod(long long a, long long b) {
long long res = 1;
if (a >= mod) a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a;
if (res >= mod) res %= mod;
a = a * a;
if (a >= mod) a %= mod;
}
return res;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
static struct IO {
char tmp[1 << 10];
char cur;
inline char nextChar() { return cur = getc(stdin); }
inline char peekChar() { return cur; }
inline operator bool() { return peekChar(); }
inline static bool isBlank(char c) { return (c < '-' && c); }
inline bool skipBlanks() {
while (isBlank(nextChar()))
;
return peekChar() != 0;
}
inline IO& operator>>(char& c) {
c = nextChar();
return *this;
}
inline IO& operator>>(char* buf) {
if (skipBlanks()) {
if (peekChar()) {
*(buf++) = peekChar();
while (!isBlank(nextChar())) *(buf++) = peekChar();
}
*(buf++) = 0;
}
return *this;
}
inline IO& operator>>(string& s) {
if (skipBlanks()) {
s.clear();
s += peekChar();
while (!isBlank(nextChar())) s += peekChar();
}
return *this;
}
inline IO& operator>>(double& d) {
if ((*this) >> tmp) sscanf(tmp, "%lf", &d);
return *this;
}
inline IO& operator>>(int& n) {
if (skipBlanks()) {
int sign = +1;
if (peekChar() == '-') {
sign = -1;
n = nextChar() - '0';
} else
n = peekChar() - '0';
while (!isBlank(nextChar())) {
n += n + (n << 3) + peekChar() - 48;
}
n *= sign;
}
return *this;
}
inline IO& operator>>(unsigned int& n) {
if (skipBlanks()) {
int sign = +1;
if (peekChar() == '-') {
sign = -1;
n = nextChar() - '0';
} else
n = peekChar() - '0';
while (!isBlank(nextChar())) {
n += n + (n << 3) + peekChar() - 48;
}
n *= sign;
}
return *this;
}
inline IO& operator>>(long long& n) {
if (skipBlanks()) {
int sign = +1;
if (peekChar() == '-') {
sign = -1;
n = nextChar() - '0';
} else
n = peekChar() - '0';
while (!isBlank(nextChar())) {
n += n + (n << 3) + peekChar() - 48;
}
n *= sign;
}
return *this;
}
inline void putChar(char c) { putc(c, stdout); }
inline IO& operator<<(char c) {
putChar(c);
return *this;
}
inline IO& operator<<(const char* s) {
while (*s) putChar(*s++);
return *this;
}
inline IO& operator<<(const string& s) {
for (int i = 0; i < (int)s.size(); ++i) putChar(s[i]);
return *this;
}
char* toString(double d) {
sprintf(tmp, "%lf%c", d, '\0');
return tmp;
}
inline IO& operator<<(double d) { return (*this) << toString(d); }
inline char* toString(int n) {
char* p = (tmp + 30);
if (n) {
bool isNeg = 0;
if (n < 0) isNeg = 1, n = -n;
while (n) *--p = (n % 10) + '0', n /= 10;
if (isNeg) *--p = '-';
} else
*--p = '0';
return p;
}
inline IO& operator<<(int n) { return (*this) << toString(n); }
inline char* toString(long long n) {
char* p = (tmp + 30);
if (n) {
bool isNeg = 0;
if (n < 0) isNeg = 1, n = -n;
while (n) *--p = (n % 10) + '0', n /= 10;
if (isNeg) *--p = '-';
} else
*--p = '0';
return p;
}
inline IO& operator<<(long long n) { return (*this) << toString(n); }
} __io__;
const int N = 200000 + 5;
long long n, k, s, t, len[N], c[N], v[N], g[N], sum[N];
int ans = mod;
long long maxlen;
inline bool ok(long long cap) {
long long tim = 0;
int idx = upper_bound(len, len + k, cap / 2) - len;
if (idx) tim += sum[idx - 1];
if (idx != k) {
tim -= cap * 1LL * (k - idx);
tim += 3 * sum[k - 1];
if (idx) tim -= 3 * sum[idx - 1];
}
return tim <= t;
}
int main() {
int i, j;
__io__ >> n >> k >> s >> t;
for (i = 0; i < n; i++) {
__io__ >> c[i] >> v[i];
}
for (i = 0; i < k; i++) {
__io__ >> g[i];
}
sort(g, g + k);
g[k] = s;
int last = 0;
for (i = 0; i <= k; i++) {
len[i] = g[i] - last;
last = g[i];
maxlen = max(maxlen, len[i]);
}
k++;
sort(len, len + k);
sum[0] = len[0];
for (i = 1; i < k; i++) sum[i] = len[i] + sum[i - 1];
for (i = 0; i < n; i++) {
if (v[i] >= maxlen && ans > c[i] && ok(v[i])) ans = c[i];
}
if (ans == mod) ans = -1;
__io__ << ans << ('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void die() {
cout << -1 << endl;
exit(0);
}
const int maxN = 100 * 1000 * 3 + 100;
pair<int, int> a[maxN];
int p[maxN];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, k, s, t;
cin >> n >> k >> s >> t;
if (t < s) die();
for (int i = 0; i < n; i++) cin >> a[i].second >> a[i].first;
k++;
for (int i = 1; i < k; i++) cin >> p[i];
p[k++] = s;
sort(p, p + k);
sort(a, a + n);
int st = -1, en = n;
while (en - st > 1) {
int m = (st + en) / 2;
int cap = a[m].first;
int speed = max(2 * s - t, 0);
bool canDo = true;
for (int i = 1; i < k; i++)
if (p[i] - p[i - 1] > cap) {
canDo = false;
break;
} else
speed -= min(speed, min(p[i] - p[i - 1], cap - (p[i] - p[i - 1])));
if (canDo && speed == 0)
en = m;
else
st = m;
}
if (en == n) die();
int mn = a[en].second;
for (int i = en + 1; i < n; i++) mn = min(mn, a[i].second);
cout << mn << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int cars_cnt, fs_cnt, distance, til_time;
cin >> cars_cnt >> fs_cnt >> distance >> til_time;
vector<pair<int, int>> cars;
cars.reserve(cars_cnt);
for (int i = 0; i < cars_cnt; i++) {
int ci, vi;
cin >> ci >> vi;
cars.push_back(make_pair(vi, ci));
}
vector<int> gas_stations;
gas_stations.reserve(fs_cnt);
for (int i = 0; i < fs_cnt; i++) {
int tmp;
cin >> tmp;
gas_stations.push_back(tmp);
}
gas_stations.push_back(distance);
sort(gas_stations.begin(), gas_stations.end());
sort(cars.begin(), cars.end());
int l = -1, r = cars_cnt, m;
while (r - l > 1) {
m = l + (r - l) / 2;
int t = 0;
int fuel_max = cars[m].first;
int p = 0;
int dist = 0;
bool ok = true;
while (p < gas_stations.size()) {
int travel = gas_stations[p] - dist;
if (travel > fuel_max) {
ok = false;
break;
}
t += 2 * travel - min(travel, fuel_max - travel);
dist = gas_stations[p];
p++;
}
if (t <= til_time && ok) {
r = m;
} else {
l = m;
}
}
int mm = 1000000001;
for (int i = r; i < cars_cnt; i++) {
if (cars[i].second < mm) {
mm = cars[i].second;
}
}
if (mm == 1000000001) {
cout << -1 << endl;
} else {
cout << mm << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
constexpr int N = 1e5 + 5;
constexpr int INF = 2e9;
int n, g, L, t;
vector<pair<int, int>> cars;
vector<int> gas;
vector<int> distances;
bool possible(int v) {
const int capacity = v;
LL T = 0;
for (auto D : distances) {
if (D > capacity) return false;
LL x = min(D, capacity - D);
LL y = D - x;
T += x + 2 * y;
assert(x + y == D);
assert(capacity >= 2 * x + y);
}
if (T > t) return false;
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> g >> L >> t;
cars.resize(n);
gas.resize(g);
for (auto& p : cars) cin >> p.second >> p.first;
for (auto& p : gas) cin >> p;
gas.push_back(0);
gas.push_back(L);
g += 2;
sort(begin(cars), end(cars));
sort(begin(gas), end(gas));
for (int i = 0; i + 1 < g; i++) {
distances.push_back(gas[i + 1] - gas[i]);
}
int v = -1;
int l = 1, r = 1e9;
while (l <= r) {
int m = (l + r) / 2;
if (possible(m)) {
v = m;
r = m - 1;
} else {
l = m + 1;
}
}
if (v == -1)
cout << -1;
else {
int ans = INF;
for (int i = 0; i < n; i++)
if (cars[i].first >= v) ans = min(ans, cars[i].second);
cout << (ans == INF ? -1 : ans) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2 * 100000;
int c[MAXN + 1], v[MAXN + 1], n, k, s, t;
vector<int> res;
vector<pair<int, int> > gt;
bool check(int vol) {
long long sum = 0;
for (auto it : gt) {
int dist = it.first;
int l = 0, r = 1e9 + 1, mid;
while (r > l + 1) {
mid = (l + r) / 2;
if (2 * mid + max(0, dist - mid) <= vol)
l = mid;
else
r = mid;
}
sum += (long long)it.second * (min(l, dist) + (dist - min(l, dist)) * 2);
}
return sum <= t;
}
int main() {
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) scanf("%d%d", &c[i], &v[i]);
res.push_back(0);
res.push_back(s);
for (int i = 0; i < k; i++) {
int x;
scanf("%d", &x);
res.push_back(x);
}
sort(res.begin(), res.end());
int mx = 0;
map<int, int> calc;
for (int i = 1; i < (int)res.size(); i++) {
mx = max(mx, res[i] - res[i - 1]);
calc[res[i] - res[i - 1]]++;
}
for (auto it : calc) gt.push_back({it.first, it.second});
int l = mx - 1, r = 1e9 + 1, mid;
while (r > l + 1) {
mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
int ans = 1e9 + 1;
for (int i = 0; i < n; i++)
if (v[i] >= r) ans = min(ans, c[i]);
if (ans == 1e9 + 1)
cout << "-1\n";
else
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, len, tim, i, k, dis[200020];
pair<long long, long long> a[200020];
inline bool solve(long long cap) {
long long i, ans = 0;
for (i = 1; i <= k; i++) {
long long dist = dis[i] - dis[i - 1];
if (dist > cap) return false;
long long slow = dist;
long long fastt = min(slow, cap - slow);
slow -= fastt;
ans += (2 * slow) + fastt;
}
if (ans <= tim) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k >> len >> tim;
for (i = 1; i <= n; i++) {
cin >> a[i].first;
cin >> a[i].second;
}
for (i = 1; i <= k; i++) {
cin >> dis[i];
}
sort(dis + 1, dis + k + 1);
k++;
dis[k] = len;
long long low = 1, high = 9999999999;
long long best_time = 99999999999;
while (low <= high) {
long long mid = (low + high) / 2;
if (solve(mid)) {
best_time = min(best_time, mid);
high = mid - 1;
} else
low = mid + 1;
}
if (best_time == 99999999999) {
cout << "-1";
return 0;
}
long long ans = 99999999999;
for (i = 1; i <= n; i++) {
if (a[i].second >= best_time) {
ans = min(ans, a[i].first);
}
}
if (ans == 99999999999) {
cout << -1;
return 0;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, s, t;
vector<pair<int, int> > c;
vector<int> g;
vector<int> d;
const int inf = 1 << 30;
bool ok(int cap) {
int time = 0;
for (auto dis : d) {
if (cap < dis) return false;
if (cap >= 2 * dis)
time += dis;
else
time += 3 * dis - cap;
}
return time <= t;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> s >> t;
c.resize(n);
g.resize(m);
for (auto& v : c) {
cin >> v.second >> v.first;
}
for (auto& v : g) {
cin >> v;
}
sort(c.begin(), c.end());
g.push_back(0);
g.push_back(s);
sort(g.begin(), g.end());
for (int i = 1; i < g.size(); i++) d.push_back(g[i] - g[i - 1]);
int l = 0;
int r = c.size() - 1;
int piv = inf;
int ans = inf;
while (l <= r) {
int mid = (l + r) >> 1;
int cap = c[mid].first;
if (ok(cap)) {
piv = cap;
r = mid - 1;
} else {
l = mid + 1;
}
}
for (int i = 0; i < c.size(); i++)
if (c[i].first >= piv && ans > c[i].second) ans = c[i].second;
if (ans == inf) ans = -1;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
long long c[200010], v[200010], p[200010];
long long n, m, s, t;
bool ok(long long x) {
long long ti = 0;
for (long long k = 0; k <= m; k++) {
long long di = p[k + 1] - p[k];
if (x < di) return false;
if (x >= 2 * di) {
ti += di;
} else {
ti += (3 * di - x);
}
}
if (ti <= t) return true;
return false;
}
int main() {
int k;
scanf("%I64d%I64d%I64d%I64d", &n, &m, &s, &t);
for (k = 1; k <= n; k++) scanf("%I64d%I64d", &c[k], &v[k]);
for (k = 1; k <= m; k++) scanf("%I64d", &p[k]);
std::sort(p + 1, p + m + 1);
p[0] = 0;
p[m + 1] = s;
long long ans = 2e9;
long long L = 0, R = 2e9, M, max = 0;
for (k = 0; k <= m; k++) {
if (max < p[k + 1] - p[k]) max = p[k + 1] - p[k];
}
L = max;
while (L + 3 < R) {
M = (L + R) / 2;
if (ok(M))
R = M;
else
L = M;
}
long long qq = -1;
for (k = L; k <= R; k++) {
if (ok(k)) {
qq = k;
break;
}
}
ans = 2e9;
if (qq == -1) {
puts("-1");
return 0;
}
for (k = 1; k <= n; k++) {
if (v[k] >= qq)
if (c[k] < ans) ans = c[k];
}
if (ans != 2e9)
printf("%I64d", ans);
else
puts("-1");
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t;
bool can(int c, vector<int> st) {
long long ans = 0;
for (int i = 1; i < (int)st.size(); i++) {
int gap = st[i] - st[i - 1];
if (gap > c) return false;
if (c >= 2 * gap)
ans += gap;
else
ans += 1LL * 3 * gap - c;
}
return ans <= t;
}
int main() {
scanf("%d %d %d %d", &n, &k, &s, &t);
vector<pair<int, int> > cars(n);
for (int i = 0; i < n; i++) scanf("%d %d", &cars[i].second, &cars[i].first);
vector<int> st(k + 2);
int dist = 0;
st[0] = 0;
st[k + 1] = s;
for (int i = 1; i <= k; i++) cin >> st[i];
sort(st.begin(), st.end());
sort(cars.begin(), cars.end());
int low = 0, high = n;
int ans = -1;
while (high > low) {
int mid = (high + low) / 2;
if (can(cars[mid].first, st)) {
ans = mid;
high = mid;
} else
low = mid + 1;
}
if (ans == -1) {
cout << -1;
return 0;
}
int pr = 2000000000;
for (int i = 0; i < n; i++)
if (cars[i].first >= cars[ans].first) pr = min(pr, cars[i].second);
printf("%d", pr);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXNK = 2e5 + 10;
const long long INF = 1e18;
struct abc {
int c, v;
};
abc a[MAXNK];
int p[MAXNK];
int n, k, s;
long long t;
long long fi = INF;
bool cmp1(abc a, abc b) { return a.v < b.v; }
bool judge(int sum) {
long long tt = 0;
for (int i = 1; i <= k; i++) {
int dis = p[i] - p[i - 1];
if (dis * 2 <= sum)
tt += p[i] - p[i - 1];
else {
if (sum >= dis) {
tt += 3 * dis - sum;
} else {
return false;
}
}
if (tt > t) return false;
}
return true;
}
int main() {
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) scanf("%d%d", &a[i].c, &a[i].v);
p[0] = 0;
for (int i = 1; i <= k; i++) scanf("%d", &p[i]);
sort(a + 1, a + 1 + n, cmp1);
sort(p + 1, p + 1 + k);
k++;
p[k] = s;
int l = 1, r = n, ans = -1;
while (l <= r) {
int m = (l + r) >> 1;
if (judge(a[m].v)) {
ans = m;
r = m - 1;
} else
l = m + 1;
}
if (ans == -1) {
puts("-1");
return 0;
}
for (int i = 1; i <= n; i++) {
if (a[i].v >= a[ans].v && a[i].c < fi) fi = a[i].c;
}
cout << fi << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool check(int x, int t, int n, vector<int>& g) {
int u = 0;
for (int i = 0; i <= n; i++) {
int d = g[i + 1] - g[i];
if (x < d) return false;
u += d * 2 - min(d, x - d);
if (t < u) return false;
}
return true;
}
int main() {
int n, m, s, t, ans = -1;
scanf("%d%d%d%d", &n, &m, &s, &t);
vector<pair<int, int> > second(n);
vector<int> g(m);
for (int i = 0; i < n; i++)
scanf("%d%d", &second[i].first, &second[i].second);
for (int i = 0; i < m; i++) scanf("%d", &g[i]);
g.push_back(0);
g.push_back(s);
sort(g.begin(), g.end());
sort(second.begin(), second.end());
for (int i = 1; i < n; i++)
second[i].second = max(second[i].second, second[i - 1].second);
for (int l = 0, r = n; l < r;) {
int k = (l + r) >> 1;
if (!check(second[k].second, t, m, g))
l = k + 1;
else {
ans = second[k].first;
r = k;
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace placeholders;
const int MAXN = 2E5 + 10;
int n, K, S, T;
int v[MAXN], c[MAXN];
int a[MAXN];
int s[MAXN];
int main() {
scanf("%d%d%d%d", &n, &K, &S, &T);
for (int i = 1; i <= n; ++i) scanf("%d%d", c + i, v + i);
for (int i = 1; i <= K; ++i) scanf("%d", a + i);
a[++K] = S;
sort(a + 1, a + K + 1);
for (int i = K; i > 0; --i) a[i] -= a[i - 1];
sort(a + 1, a + K + 1);
for (int i = 1; i <= K; ++i) s[i] = s[i - 1] + a[i];
const int INF = 2E9;
int ans = INF;
for (int i = 1; i <= n; ++i) {
if (a[K] > v[i]) continue;
int r = lower_bound(a + 1, a + K + 1, v[i] + 1 >> 1) - a - 1;
long long cost = s[r] + (s[K] - s[r]) * 3ll - (long long)(K - r) * v[i];
if (cost <= T) ans = min(ans, c[i]);
}
printf("%d\n", ans == INF ? -1 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
void debug(T a, T b) {
;
}
template <class T>
void chmin(T& a, const T& b) {
if (a > b) a = b;
}
template <class T>
void chmax(T& a, const T& b) {
if (a < b) a = b;
}
namespace std {
template <class S, class T>
ostream& operator<<(ostream& out, const pair<S, T>& a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
} // namespace std
long long int readL() {
long long int res;
scanf("%I64d", &res);
return res;
}
void printL(long long int res) { printf("%I64d", res); }
int n, k, s, t;
pair<int, int> car[200005];
int gas[200005];
int len[200005], m;
long long int sum[200005];
int main() {
cin >> n >> k >> s >> t;
for (int i = 0; i < (n); ++i) scanf("%d%d", &car[i].first, &car[i].second);
sort(car, car + n);
for (int i = 0; i < (k); ++i) scanf("%d", &gas[i]);
gas[k++] = 0;
gas[k++] = s;
sort(gas, gas + k);
m = k - 1;
for (int i = 0; i < (m); ++i) len[i] = gas[i + 1] - gas[i];
sort(len, len + m);
for (int i = 0; i < (m); ++i) sum[i + 1] += sum[i] + len[i];
for (int i = 0; i < (n); ++i) {
int a = car[i].second;
;
;
if (a < len[m - 1]) continue;
if (a % 2 == 0) {
int lim = a / 2;
int p = upper_bound(len, len + m, lim) - len;
long long int time = sum[p];
time += (sum[m] - sum[p]) * 3 - (lim * (m - p) * 2);
;
;
;
;
if (time <= t) {
printf("%d\n", car[i].first);
return 0;
}
} else {
int lim = a / 2;
int p = upper_bound(len, len + m, lim) - len;
int p2 = upper_bound(len, len + m, lim + 1) - len;
long long int time = sum[p2] + (p2 - p);
;
;
time += (sum[m] - sum[p2]) * 3 - ((lim * 2 + 1) * (m - p2));
;
;
;
;
;
;
;
;
if (time <= t) {
printf("%d\n", car[i].first);
return 0;
}
}
}
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K, S, T;
int main() {
vector<int> p, l;
scanf("%d %d %d %d", &N, &K, &S, &T);
vector<pair<int, int> > car;
for (int i = 0; i < N; i++) {
int c, g;
scanf("%d %d", &c, &g);
car.push_back({g, c});
}
sort(car.begin(), car.end());
for (int i = 0; i < K; i++) {
int x;
scanf("%d", &x);
p.push_back(x);
}
p.push_back(0);
p.push_back(S);
sort(p.begin(), p.end());
for (int i = 1; i < p.size(); i++) l.push_back(p[i] - p[i - 1]);
sort(l.begin(), l.end());
long long sum = 0;
int i = 0;
long long fullt = 0, subc = 0, subt = 0;
for (int x : l) {
subc++;
subt += x * 3ll;
}
int ans = 0x7fffffff;
for (auto p : car) {
if (p.first < l.back()) continue;
while (i < l.size() && l[i] * 2 < p.first) {
subc--;
subt -= l[i] * 3ll;
fullt += l[i];
i++;
}
long long now = subt - subc * p.first + fullt;
if (now <= T) {
if (ans > p.second) ans = p.second;
}
}
if (ans == 0x7fffffff) ans = -1;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 1000000001;
const long long LINF = 1000000000000000001LL;
int main() {
ios_base::sync_with_stdio(0);
int n, k, s, t;
cin >> n >> k >> s >> t;
vector<pair<int, int> > car(n);
for (int i = (0); i <= (n - 1); ++i) {
cin >> car[i].first >> car[i].second;
}
vector<int> stat(k);
for (int i = (0); i <= (k - 1); ++i) {
cin >> stat[i];
}
sort(stat.begin(), stat.end());
vector<int> dist(k + 1);
for (int i = (0); i <= (k - 1); ++i) {
dist[i] = stat[i] - (i ? stat[i - 1] : 0);
}
dist[k] = s - stat.back();
sort(dist.begin(), dist.end());
vector<int> distSum = dist;
for (int i = (1); i <= (k); ++i) {
distSum[i] += distSum[i - 1];
}
int minPrice = INF;
for (auto &c : car) {
int price = c.first, tank = c.second;
if (tank < dist.back()) {
continue;
}
int ind = upper_bound(dist.begin(), dist.end(), tank / 2) - dist.begin();
int big = s - (ind ? distSum[ind - 1] : 0);
int bigCnt = (int)(dist).size() - ind;
long long timeTaken = s + (2 * big - (long long)tank * bigCnt);
if (timeTaken <= t) {
minPrice = min(minPrice, price);
}
}
if (minPrice == INF) {
cout << -1;
} else {
cout << minPrice;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c[200005], v[200005];
int n, k, s;
long long int t;
bool can(long long int m, vector<int> &dist) {
int maxi = *max_element(dist.begin(), dist.end());
if (maxi > m) return false;
long long int time = 0;
for (int i = 0; i < dist.size(); i++) {
long long int d = dist[i];
int l = 0, r = d, ans = -1;
while (l <= r) {
long long int x = l + (r - l) / 2;
long long int y = d - x;
if (2 * x + y <= m) {
ans = x;
l = x + 1;
} else {
r = x - 1;
}
}
assert(ans >= 0);
long long int x = ans, y = d - x;
time += (x + 2 * y);
}
return (time <= t);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> s >> t;
for (int i = 0; i < n; i++) {
cin >> c[i] >> v[i];
}
vector<int> sta(k);
for (int i = 0; i < k; i++) cin >> sta[i];
sort(sta.begin(), sta.end());
vector<int> dist(k + 1);
int past = 0;
int pos = 0;
for (int i = 0; i < k; i++) {
int x = sta[i];
dist[pos++] = x - past;
past = x;
}
dist[pos] = s - past;
long long int l = 1, r = 1e9;
long long int mini = 1e9 + 5;
while (l <= r) {
long long int m = l + (r - l) / 2;
if (can(m, dist)) {
mini = m;
r = m - 1;
} else {
l = m + 1;
}
}
if (mini > 1e9) {
cout << -1 << '\n';
return 0;
}
int ans = 1e9 + 5;
for (int i = 0; i < n; i++) {
if (v[i] >= mini) {
ans = min(ans, c[i]);
}
}
if (ans > 1e9)
cout << -1 << '\n';
else
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
const int NN = 1e6 * 4 + 1;
const double INF = 1e9 + 7;
int n, k, s, t;
int c[N], v[N];
int g[N];
int mn = INF;
bool f(int x) {
int cnt = 0;
g[k + 1] = s;
for (int i = 1; i <= k + 1; i++) {
int dist = g[i] - g[i - 1];
if (dist > x) {
return false;
}
cnt += min(dist, x - dist);
cnt += (dist - min(dist, x - dist)) * 2;
}
if (cnt > t) {
return false;
}
return true;
}
int main() {
scanf("%d%d%d%d", &n, &k, &s, &t);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &c[i], &v[i]);
}
for (int i = 1; i <= k; i++) {
scanf("%d", &g[i]);
}
sort(g + 1, g + 1 + k);
int l = 1;
int r = int(2e9);
while (r - l > 1) {
int mid = (l + r) / 2;
if (f(mid)) {
r = mid;
} else {
l = mid;
}
}
if (f(l)) {
for (int i = 1; i <= n; i++) {
if (v[i] >= l) {
mn = min(mn, c[i]);
}
}
}
if (f(r)) {
for (int i = 1; i <= n; i++) {
if (v[i] >= r) {
mn = min(mn, c[i]);
}
}
}
if (mn == INF) {
cout << -1;
} else {
cout << mn;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1 << 18;
int n, k, s, t, c[N], v[N], p[N];
bool judge(int c) {
int sum = 0;
for (int i = 1; i <= k; i++) {
int d = p[i] - p[i - 1];
if (d > c) return 0;
sum += d + max(d + d - c, 0);
}
return sum <= t;
}
int main() {
cin >> n >> k >> s >> t;
for (int i = 1; i <= n; i++) scanf("%d%d", v + i, c + i);
for (int i = 1; i <= k; i++) scanf("%d", p + i);
p[++k] = s, sort(p + 1, p + k + 1);
int L = 1, R = 1 << 30;
for (; L < R;) {
int mid = (L + R) >> 1;
if (judge(mid))
R = mid;
else
L = mid + 1;
}
if (!judge(L))
puts("-1");
else {
int res = (1 << 30);
for (int i = 1; i <= n; i++)
if (c[i] >= L) res = min(res, v[i]);
if (res == 1 << 30)
puts("-1");
else
cout << res << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, s, t, c[200005], v[200005], g[200005], minv, minc = -1;
long long f(long long x, long long y) {
if (y >= x * 2) return x;
return 3 * x - y;
}
long long time_use(int x) {
long long tu = 0;
if (g[0] > x) return 2e9 + 1;
tu += f(g[0], x);
for (int i = 1; i < k; i++) {
if (g[i] - g[i - 1] > x) return 2e9 + 1;
tu += f(g[i] - g[i - 1], x);
}
if (s - g[k - 1] > x) return 2e9 + 1;
tu += f(s - g[k - 1], x);
return tu;
}
int main() {
scanf("%d %d %d %d", &n, &k, &s, &t);
for (int i = 0; i < n; i++) scanf("%d %d", &c[i], &v[i]);
for (int i = 0; i < k; i++) scanf("%d", &g[i]);
sort(g, g + k);
for (long long l = 1, r = 2e9;;) {
if (l == r) {
minv = l;
break;
}
long long mid = (l + r) / 2;
if (time_use(mid) <= t)
r = mid;
else
l = mid + 1;
}
for (int i = 0; i < n; i++)
if (v[i] >= minv && (minc == -1 || c[i] < minc)) minc = c[i];
printf("%d\n", minc);
}
|
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1e9 + 7;
int inf = 2e9;
long long INF = 8e18;
int fre[26][5001];
int ts[5001];
int ff[5001];
int fac[5001];
int nf[5001];
string s;
long long fe(long long x, int e) {
long long r = 1;
while (e) {
if (e & 1) r = (r * x) % MOD;
x = (x * x) % MOD;
e >>= 1;
}
return r;
}
long long ncr(int n, int r) {
long long re = fac[n];
re = (re * fe(fac[r], MOD - 2)) % MOD;
re = (re * fe(fac[n - r], MOD - 2)) % MOD;
return re;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
fac[0] = 1;
for (int i = 1; i <= 5000; i++) {
fac[i] = ((long long)fac[i - 1] * (long long)i) % MOD;
}
memset(ff, 0, sizeof ff);
memset(fre, 0, sizeof fre);
int n;
long long ans = 0;
cin >> n;
cin >> s;
for (int i = 0; i < n; i++) {
ts[i] = (int)(s[i] - 'a');
}
for (int i = 0; i < n; i++) {
nf[1] = 1;
for (int j = 2; j <= n; j++) {
nf[j] = (ff[j - 1] - fre[ts[i]][j - 1] + MOD) % MOD;
}
for (int j = 1; j <= n; j++) {
ff[j] = (ff[j] - fre[ts[i]][j] + nf[j] + MOD) % MOD;
}
for (int j = 1; j <= n; j++) {
fre[ts[i]][j] = nf[j];
}
}
for (int i = 1; i <= n; i++) {
ans = (ans + (long long)ff[i] * ncr(n - 1, i - 1)) % MOD;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MX = 5e3 + 5;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
long long F[MX], invF[MX];
long long power(long long a, long long b) {
long long ret = 1;
while (b) {
if (b & 1) ret = (ret * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ret;
}
void init() {
F[0] = 1;
for (int i = 1; i < MX; i++) {
F[i] = (F[i - 1] * i) % mod;
}
invF[MX - 1] = power(F[MX - 1], mod - 2);
for (int i = MX - 2; i >= 0; i--) {
invF[i] = invF[i + 1] * (i + 1) % mod;
}
}
long long C(int n, int m) {
if (n < 0 || m < 0 || m > n) return 0;
if (m == 0 || m == n) return 1;
return F[n] * invF[n - m] % mod * invF[m] % mod;
}
int n, m;
char s[MX];
long long sum[MX], num[MX][26];
int solve() {
long long ret = 0;
sum[0] = 1;
for (int i = 1; i <= n; i++) {
for (int len = n; len >= 1; len--) {
int id = s[i] - 'a', last = num[len][id];
num[len][id] = (sum[len - 1] - num[len - 1][id]) % mod;
sum[len] = (sum[len] - last + num[len][id]) % mod;
}
}
for (int len = 1; len <= n; len++) {
sum[len] = (sum[len] + mod) % mod;
ret = (ret + C(m - 1, len - 1) * sum[len]) % mod;
}
return ret;
}
int main() {
init();
scanf("%d%s", &n, s + 1);
m = n;
n = unique(s + 1, s + 1 + n) - s - 1;
printf("%d\n", solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T lcm(T a, T b) {
a = abs(a);
b = abs(b);
return (a / gcd(a, b)) * b;
}
template <class T, class X>
inline bool getbit(T a, X i) {
T t = 1;
return ((a & (t << i)) > 0);
}
template <class T, class X>
inline T setbit(T a, X i) {
T t = 1;
return (a | (t << i));
}
template <class T, class X>
inline T resetbit(T a, X i) {
T t = 1;
return (a & (~(t << i)));
}
inline long long power(long long a, long long b) {
long long multiply = 1;
for (int i = (1); i <= (b); i++) {
multiply *= a;
}
return multiply;
}
inline long long ABS(long long a) { return (a >= 0) ? a : -a; }
int n;
string s, s1;
long long dp[5007][5007], ultacum[5007][26];
int main() {
cin >> n >> s;
s1.push_back(s[0]);
if (s.size() > 1) {
for (int i = (1); i <= (s.size() - 1); i++) {
if (s[i] != s1[s1.size() - 1]) s1.push_back(s[i]);
}
}
n--;
int m = s1.size() - 1;
for (int i = (0); i <= (m); i++) dp[n][i] = 1;
memset(ultacum, 0, sizeof(ultacum));
ultacum[m][s1[m] - 'a'] = 1;
for (int i = (m - 1); i >= (0); i--) {
for (int j = (0); j <= (25); j++) ultacum[i][j] = ultacum[i + 1][j];
ultacum[i][s1[i] - 'a'] = 1;
}
for (int i = (n - 1); i >= (0); i--) {
for (int j = (0); j <= (m); j++) {
dp[i][j] = 0;
for (int k = (0); k <= (25); k++) dp[i][j] += ultacum[j][k];
dp[i][j] %= 1000000007LL;
}
memset(ultacum, 0, sizeof(ultacum));
ultacum[m][s1[m] - 'a'] = dp[i][m];
for (int j = (m - 1); j >= (0); j--) {
for (int k = (0); k <= (25); k++) ultacum[j][k] = ultacum[j + 1][k];
ultacum[j][s1[j] - 'a'] = dp[i][j];
}
}
long long ans = 0;
for (int i = (0); i <= (25); i++) ans += ultacum[0][i];
ans %= 1000000007LL;
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5001;
int n, C[N][N], mod = 1e9 + 7;
string s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
C[0][0] = 1;
for (int i = 1; i < N; i++) {
C[i][0] = 1;
for (int j = 1; j < N; j++) {
C[i][j] = C[i - 1][j] + C[i - 1][j - 1];
if (C[i][j] >= mod) C[i][j] -= mod;
}
}
cin >> n >> s;
vector<vector<int> > dp(26, vector<int>(n + 1));
vector<int> tot(n + 1);
for (auto &c : s) {
int idx = c - 'a';
for (int i = 1; i <= n; i++) {
tot[i] -= dp[idx][i];
if (tot[i] < 0) tot[i] += mod;
}
for (int i = 2; i <= n; i++) dp[idx][i] = tot[i - 1];
dp[idx][1] = 1;
for (int i = 1; i <= n; i++) {
tot[i] += dp[idx][i];
if (tot[i] >= mod) tot[i] -= mod;
}
}
int ans = 0;
for (int i = 1; i <= n; i++)
ans = (ans + 1LL * C[n - 1][i - 1] * tot[i]) % mod;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = (const int)(5e3 + 11);
const int MOD = (const int)(1e9 + 7);
int D[MAX][MAX];
int C[MAX][MAX];
int P[30];
int N;
char A[MAX];
static inline void f(int &a, int b) {
int64_t x = 0LL + a + b;
if (x >= MOD) x -= MOD;
a = (int)x;
}
static inline void g(int &a, int b) {
int64_t x = 1LL * a * b;
if (x >= MOD) x -= MOD;
a = (int)x;
}
static void solve(std::int32_t test) {
memset(D, 0, sizeof(D));
memset(C, 0, sizeof(C));
memset(P, 0xFF, sizeof(P));
C[0][0] = 1;
for (int n = 1; n < MAX; ++n)
for (int k = 1; k <= n; ++k) {
f(C[n][k], C[n - 1][k - 1]);
f(C[n][k], C[n - 1][k]);
}
cin >> N;
cin >> A;
for (int i = 0; i < N; ++i) {
if (A[i] == A[i - 1]) continue;
int w = A[i] - 'a';
D[i][1] = 1;
for (int c = 0; c < 26; ++c) {
if (P[c] != -1 && c != w) {
for (int j = 1; j < i + 1; ++j) {
f(D[i][j + 1], D[P[c]][j]);
}
}
}
P[w] = i;
}
int64_t res = 0;
for (int c = 0; c < 26; ++c) {
if (P[c] != -1) {
for (int k = 1; k <= N; ++k) {
res += 1LL * C[N][k] * D[P[c]][k];
res %= MOD;
}
}
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(0);
cout << setprecision(12) << fixed;
solve(0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N = 1000000007;
vector<vector<long long>> binom(5001, vector<long long>(5001));
void find_binom() {
for (int i = 0; i < binom.size(); ++i) {
for (int j = 0; j < binom[1].size(); ++j) {
if (j <= i) {
if (j == 0 || j == i) {
binom[i][j] = 1;
} else {
binom[i][j] = binom[i - 1][j - 1] + binom[i - 1][j];
binom[i][j] %= N;
}
}
}
}
}
int main() {
find_binom();
int n;
cin >> n;
string sl;
cin >> sl;
vector<vector<long long>> dt(30, vector<long long>(n));
for (int i = 0; i < n; ++i) {
int l = sl[i] - 'a';
for (int j = 0; j <= i; ++j) {
if (j == 0) {
dt[l][j] = 1;
} else {
dt[l][j] = 0;
for (int k = 0; k < 30; ++k) {
if (k != l) {
dt[l][j] += dt[k][j - 1];
}
}
}
dt[l][j] %= N;
}
}
long long res = 0;
for (int i = 0; i < 30; ++i) {
for (int j = 0; j < n; ++j) {
if (dt[i][j] > 0) {
res += dt[i][j] * binom[n - 1][j];
res %= N;
}
}
}
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 5005;
const long long mod = 1e9 + 7;
long long dp[26][N];
long long dpsum[N];
long long n;
long long fact[N];
long long inv[N];
char buf[N];
vector<long long> colors;
long long powmod(long long a, long long b) {
long long res = 1ll;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1ll) {
if (b & 1ll) res = res * a % mod;
a = a * a % mod;
}
return res;
}
void pre() {
fact[0] = 1, inv[0] = 1;
for (long long i = 1; i < N; i++) {
fact[i] = fact[i - 1] * i;
inv[i] = powmod(fact[i], mod - 2);
fact[i] %= mod;
}
}
long long choose(long long a, long long b) {
long long res = 1;
res *= fact[a];
res %= mod;
res *= inv[b];
res %= mod;
res *= inv[a - b];
res %= mod;
return res;
}
int main() {
scanf("%I64d", &n);
scanf("%s", buf + 1);
pre();
long long start = 1;
while (start <= n) {
while (buf[start] == buf[start + 1] and start < n) {
start++;
}
colors.emplace_back(buf[start] - 'a');
start++;
}
long long ans = 0;
dpsum[0] = 1;
for (long long i = 0; i < colors.size(); i++) {
long long cur = colors[i];
for (long long j = 1; j <= colors.size(); j++) {
dpsum[j] -= (dp[cur][j]);
dp[cur][j] = (dpsum[j - 1] - dp[cur][j - 1]);
dp[cur][j] %= mod;
dpsum[j] += (dp[cur][j]);
dpsum[j] += mod;
dpsum[j] %= mod;
}
}
for (long long i = 1; i <= colors.size(); i++) {
ans += dpsum[i] * choose(n - 1, i - 1);
ans %= mod;
}
printf("%I64d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1000000007;
struct mint {
int val = 0;
mint() {}
mint(int a) : val(a) {
while (val < 0) {
val += M;
}
while (val >= M) {
val -= M;
}
}
mint(long long a) : val(a % M) {
if (val < 0) {
val += M;
}
}
mint operator+=(mint oth) {
val += oth.val;
val -= (val >= M) ? M : 0;
return *this;
}
mint operator-=(mint oth) {
val -= oth.val;
val += (val < 0) ? M : 0;
return *this;
}
mint operator*=(mint oth) {
val = 1LL * val * oth.val % M;
return *this;
}
void operator++() {
++val;
if (val == M) {
val = 0;
}
}
void operator--() {
--val;
if (val == -1) {
val = M - 1;
}
}
mint operator-() {
mint res;
res.val = (val == 0) ? 0 : M - val;
return res;
}
friend mint operator+(mint a, mint b) { return mint(a) += b; }
friend mint operator-(mint a, mint b) { return mint(a) -= b; }
friend mint operator*(mint a, mint b) { return mint(a) *= b; }
friend bool operator==(mint a, mint b) { return a.val == b.val; }
friend bool operator!=(mint a, mint b) { return a.val != b.val; }
friend ostream& operator<<(ostream& out, mint a) {
out << a.val;
return out;
}
friend mint pow(mint b, long long e = M - 2) {
mint res = 1;
while (e > 0) {
if (e % 2 == 1) {
res *= b;
}
b *= b;
e /= 2;
}
return res;
}
};
const int N = 5000 + 1;
const int A = 26;
mint ways[N][N];
int nxt[N][A];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
string s;
cin >> n >> s;
fill(nxt[n], nxt[n] + A, n);
for (int i = n - 1; i >= 0; --i) {
for (int j = 0; j < A; ++j) {
nxt[i][j] = s[i] - 'a' == j ? i : nxt[i + 1][j];
}
}
ways[0][0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
for (int k = 0; k < A; ++k) {
if (nxt[j][k] < n) {
ways[i + 1][nxt[j][k]] += ways[i][j];
}
}
}
}
cout << accumulate(ways[n], ways[n] + n, (mint)0) << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5003;
const int mod = (int)1e9 + 7;
static __attribute__((aligned(16))) int dp[maxn][26];
static __attribute__((aligned(16))) int dps[maxn];
static __attribute__((aligned(16))) int un[maxn];
static __attribute__((aligned(16))) int f[maxn];
static __attribute__((aligned(16))) int rf[maxn];
void norm(int &x) {
if (x < 0) {
x += mod;
} else if (x >= mod) {
x -= mod;
}
}
int bpow(int x, int p) {
int res = 1;
while (p) {
if (p & 1)
res = ((signed long long int)res * (signed long long int)x) % mod;
x = ((signed long long int)x * (signed long long int)x) % mod;
p >>= 1;
}
return res;
}
inline int comb(int n, int k) {
return ((((signed long long int)f[n] * (signed long long int)rf[k]) % mod) *
(signed long long int)rf[n - k]) %
mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
f[0] = f[1] = rf[0] = rf[1] = 1;
for (int i = 2; i < maxn; ++i) {
f[i] = ((signed long long int)f[i - 1] * (signed long long int)i) % mod;
rf[i] = bpow(f[i], mod - 2);
}
string s;
int n, m = 0, ans = 0;
cin >> n >> s;
for (int i = 0; i < n; ++i) {
while (i + 1 != n && s[i] == s[i + 1]) ++i;
un[++m] = s[i] - 'a';
}
dps[0] = 1;
for (int lst = 1; lst <= m; ++lst) {
int ch = un[lst];
for (int len = 1; len <= lst; ++len) {
dps[len] -= dp[len][ch];
dp[len][ch] = dps[len - 1] - dp[len - 1][ch];
norm(dp[len][ch]);
dps[len] += dp[len][ch];
norm(dps[len]);
}
}
for (int len = 1; len <= m; ++len) {
ans = ((signed long long int)ans +
(signed long long int)dps[len] *
(signed long long int)comb(n - 1, len - 1)) %
mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
long long INF = 1e9;
const int N = 5031;
int n;
string st;
vector<char> blocks;
int le[N];
int same[N];
int dp[N][N], S[N][N];
int main() {
cin >> n;
cin >> st;
for (int i = 0; i < st.size(); i++) {
if (i == 0 || st[i] != st[i - 1]) blocks.push_back(st[i]);
}
for (int i = 'a'; i <= 'z'; i++) {
le[i] = -1;
}
for (int i = 0; i < blocks.size(); i++) {
int here = blocks[i];
same[i] = le[here];
le[here] = i;
}
for (int i = 1; i <= n; i++) {
for (int cur_block = 0; cur_block < blocks.size(); cur_block++) {
if (i == 1) {
if (same[cur_block] == -1) dp[i][cur_block] = 1;
continue;
}
int cl = same[cur_block] + 1;
dp[i][cur_block] = S[i - 1][cur_block];
if (cl > 0) dp[i][cur_block] -= S[i - 1][cl - 1];
if (dp[i][cur_block] < 0) dp[i][cur_block] += 1000000007;
}
for (int cur_block = 0; cur_block < blocks.size(); cur_block++) {
S[i][cur_block] = dp[i][cur_block];
if (cur_block) S[i][cur_block] += S[i][cur_block - 1];
if (S[i][cur_block] >= 1000000007) S[i][cur_block] -= 1000000007;
}
}
long long ans = 0;
for (int i = 0; i < blocks.size(); i++) {
ans = ans + dp[n][i];
ans %= 1000000007;
}
cout << ans << endl;
cin.get();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const string NAME = "vd";
const int MOD = 1e9 + 7;
int td[8] = {-1, 0, 1, 0, -1, -1, 1, 1}, tc[8] = {0, 1, 0, -1, -1, 1, 1, -1};
long long n, ans[5005], dp[30][5005];
string s;
signed main() {
ios::sync_with_stdio(0), cin.tie(NULL), cout.tie(NULL);
cin >> n >> s;
s = " " + s;
for (int i = 1; i <= n; ++i) {
int idx = s[i] - 'a' + 1;
long long tmp = 1;
for (int j = 1; j <= n; ++j) {
ans[j] = (ans[j] - dp[idx][j] + MOD) % MOD;
dp[idx][j] = tmp % MOD;
tmp = (tmp + ans[j]) % MOD;
ans[j] = (ans[j] + dp[idx][j]) % MOD;
}
}
cout << ans[n] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5000 + 77, L = 26, Mod = 1000000007;
int n, A, dp[N][L], Sdp[N], C[N][N];
char S[N];
int main() {
for (int i = 0; i < N; ++i) C[0][i] = C[i][i] = 1;
for (int i = 1; i < N; ++i)
for (int j = i + 1; j < N; ++j)
C[i][j] = (C[i - 1][j - 1] + C[i][j - 1]) % Mod;
scanf("%d %s", &n, S + 1);
Sdp[0] = 1;
for (int i = 1; i <= n; ++i) {
int c = S[i] - 'a';
for (int t = i; t > 0; --t) {
Sdp[t] = (Sdp[t] - dp[t][c] + Mod) % Mod;
dp[t][c] = (Sdp[t - 1] - dp[t - 1][c]) % Mod;
if (dp[t][c] < 0) dp[t][c] += Mod;
Sdp[t] = (Sdp[t] + dp[t][c]) % Mod;
}
}
for (int t = 1; t <= n; ++t) {
int w = Sdp[t];
w = w * 1ll * C[t - 1][n - 1] % Mod;
A = (A + w) % Mod;
}
printf("%d\n", A);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, cur[5001][27], tot[5005], ext[5005], C[5005][5005];
string s;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> s;
s = "$" + s;
cur[1][s[1] - 'a' + 1] = 1;
tot[1] = 1;
for (long long int i = 2; i <= n; ++i) {
long long int c = s[i] - 'a' + 1;
ext[1] = 1;
for (long long int len = 2; len <= n; ++len)
ext[len] = ((tot[len - 1] - cur[len - 1][c]) % 1000000007 + 1000000007) %
1000000007;
for (long long int len = 1; len <= n; ++len) {
long long int tem = cur[len][c];
cur[len][c] = (ext[len]) % 1000000007;
tot[len] = (tot[len] + ext[len]) % 1000000007;
tot[len] = (tot[len] - tem) % 1000000007;
tot[len] += 1000000007;
tot[len] %= 1000000007;
}
}
for (long long int i = 0; i <= n; ++i) C[i][0] = 1;
for (long long int i = 1; i <= n; ++i)
for (long long int j = 1; j <= i; ++j) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % 1000000007;
}
long long int ans = 0;
for (long long int len = 1; len <= n; ++len) {
ans = (ans + (C[n - 1][len - 1] * tot[len]) % 1000000007) % 1000000007;
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = (const int)(5e3 + 11);
const int MOD = (const int)(1e9 + 7);
int D[MAX][MAX];
int C[MAX][MAX];
int P[30];
int N;
char A[MAX];
static inline void add(int &a, int b) {
int64_t x = 0LL + a + b;
if (x >= MOD) x -= MOD;
a = (int)x;
}
static void solve(std::int32_t test) {
memset(D, 0, sizeof(D));
memset(C, 0, sizeof(C));
memset(P, 0xFF, sizeof(P));
C[0][0] = 1;
for (int n = 1; n < MAX; ++n)
for (int k = 1; k <= n; ++k) {
add(C[n][k], C[n - 1][k - 1]);
add(C[n][k], C[n - 1][k]);
}
cin >> N;
cin >> A;
for (int i = 0; i < N; ++i) {
if (A[i] == A[i - 1]) continue;
int w = A[i] - 'a';
D[i][1] = 1;
for (int c = 0; c < 26; ++c) {
if (P[c] != -1 && c != w) {
for (int j = 1; j < i + 1; ++j) {
add(D[i][j + 1], D[P[c]][j]);
}
}
}
P[w] = i;
}
int64_t res = 0;
for (int c = 0; c < 26; ++c) {
if (P[c] != -1) {
for (int k = 1; k <= N; ++k) {
res += 1LL * C[N][k] * D[P[c]][k];
res %= MOD;
}
}
}
cout << res;
}
int main() {
ios_base::sync_with_stdio(0);
cout << setprecision(12) << fixed;
solve(0);
return 0;
}
|
#include <bits/stdc++.h>
int add(int a, int b) { return (a + b) % ((long long)1e9 + 7); }
int sub(int a, int b) {
return (a - b + ((long long)1e9 + 7)) % ((long long)1e9 + 7);
}
int main() {
static char s[5000 + 1];
static int choose[5000 + 1][5000 + 1], dp[5000][5000], aa[26], bb[5000];
int n, l, i, j, cnt;
scanf("%d", &n);
scanf("%s", s);
for (i = 0; i < 26; i++) aa[i] = -1;
for (i = 0; i < n; i++) {
int c = s[i] - 'a';
if (aa[c] == -1) dp[0][i] = 1;
bb[i] = aa[c];
aa[c] = i;
}
for (l = 0; l < n - 1; l++) {
int sum;
memset(aa, 0, 26 * sizeof *aa);
sum = 0;
for (i = l; i < n; i++) {
int c = s[i] - 'a';
dp[l + 1][i] = sub(sum, aa[c]);
sum = add(sum, dp[l][i]);
aa[c] = add(aa[c], dp[l][i]);
}
for (i = n - 1; i > l; i--)
if ((j = bb[i]) >= 0) dp[l + 1][i] = sub(dp[l + 1][i], dp[l + 1][j]);
}
for (i = 0; i <= n; i++) {
choose[i][0] = 1;
for (j = 1; j <= i; j++)
choose[i][j] = add(choose[i - 1][j], choose[i - 1][j - 1]);
}
cnt = 0;
for (l = 0; l < n; l++) {
for (i = 1; i < n; i++) dp[l][i] = add(dp[l][i - 1], dp[l][i]);
cnt = add(
cnt, (long long)dp[l][n - 1] * choose[n - 1][l] % ((long long)1e9 + 7));
}
printf("%d\n", cnt);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 7, M = 30 + 7;
const long long MOD = 1e9 + 7;
int n, m, k, t;
int ans[N], _dp[M][N];
int main() {
scanf("%d\n", &n);
char ch[n];
scanf("%s", &ch);
memset(ans, 0, sizeof ans), memset(_dp, 0, sizeof _dp);
for (int i = 1; i <= n; i++) {
int p = 1, idx = ch[i - 1] - 'a';
for (int j = 1; j <= n; j++) {
ans[j] = (ans[j] - _dp[idx][j] + MOD) % MOD;
_dp[idx][j] = p, p = (p + ans[j]) % MOD;
ans[j] = (ans[j] + _dp[idx][j]) % MOD;
}
}
printf("%d", ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 1000 + 10;
const int maxn5 = 1 * 1000 * 100 + 10;
const int maxn3 = 200 + 10;
const long long mod = 1000 * 1000 * 1000 + 7;
const long long inf = 1LL * 2 * 1000 * 1000 * 1000 * 1000 * 1000 * 1000 + 10;
long long ps[maxn5], last[30], dp[maxn5], fact[maxn5];
long long pw(long long a, long long b) {
return (b == 0 ? 1LL
: ((pw(a * a % mod, b / 2) * (b & 1 == 1 ? a : 1LL)) % mod));
}
long long cmb(long long n, long long k) {
return (fact[n] * pw(fact[k] * fact[n - k] % mod, mod - 2) % mod);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
fact[0] = 1;
for (int i = 1; i < maxn5; i++) fact[i] = fact[i - 1] * i % mod;
int n;
string s;
cin >> n >> s;
fill(last, last + 30, -1);
ps[0] = 1;
last[s[0] - 'a'] = 0;
for (int i = 1; i < n; i++) {
ps[i] = ps[i - 1];
if (last[s[i] - 'a'] == -1) ps[i]++;
last[s[i] - 'a'] = i;
}
long long ans = ps[n - 1];
for (int len = 2; len <= n; len++) {
fill(last, last + 30, -1);
last[s[0] - 'a'] = 0;
dp[0] = 0;
for (int i = 1; i < n; i++) {
dp[i] = (mod + ps[i - 1] -
(last[s[i] - 'a'] == -1 ? 0 : ps[last[s[i] - 'a']])) %
mod;
last[s[i] - 'a'] = i;
}
ps[0] = 0;
for (int i = 1; i < n; i++) ps[i] = (ps[i - 1] + dp[i]) % mod;
long long x = ps[n - 1];
ans += cmb(n - 1, len - 1) * x;
ans %= mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5003;
const int mod = (int)1e9 + 7;
static __attribute__((aligned(16))) int dp[26][maxn];
static __attribute__((aligned(16))) int dps[maxn];
static __attribute__((aligned(16))) int un[maxn];
static __attribute__((aligned(16))) int f[maxn];
static __attribute__((aligned(16))) int rf[maxn];
void norm(int &x) {
if (x < 0) {
x += mod;
} else if (x >= mod) {
x -= mod;
}
}
int bpow(int x, int p) {
int res = 1;
while (p) {
if (p & 1)
res = ((signed long long int)res * (signed long long int)x) % mod;
x = ((signed long long int)x * (signed long long int)x) % mod;
p >>= 1;
}
return res;
}
inline int comb(int n, int k) {
return ((((signed long long int)f[n] * (signed long long int)rf[k]) % mod) *
(signed long long int)rf[n - k]) %
mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
f[0] = f[1] = rf[0] = rf[1] = 1;
for (int i = 2; i < maxn; ++i) {
f[i] = ((signed long long int)f[i - 1] * (signed long long int)i) % mod;
rf[i] = bpow(f[i], mod - 2);
}
string s;
int n, m = 0, ans = 0;
cin >> n >> s;
for (int i = 0; i < n; ++i) {
while (i + 1 != n && s[i] == s[i + 1]) ++i;
un[++m] = s[i] - 'a';
}
dps[0] = 1;
for (int lst = 1; lst <= m; ++lst) {
int ch = un[lst];
for (int len = 1; len <= lst; ++len) {
dps[len] -= dp[ch][len];
dp[ch][len] = dps[len - 1] - dp[ch][len - 1];
norm(dp[ch][len]);
dps[len] += dp[ch][len];
norm(dps[len]);
}
}
for (int len = 1; len <= m; ++len) {
ans = ((signed long long int)ans +
(signed long long int)dps[len] *
(signed long long int)comb(n - 1, len - 1)) %
mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, ways[5050][5050], last[27], fat[5050], ifat[5050];
char s[5050];
int expo(int b, int e) {
if (!e) return 1;
if (e & 1)
return 1LL * b * expo(1LL * b * b % 1000000007, e >> 1) % 1000000007;
return expo(1LL * b * b % 1000000007, e >> 1);
}
int invmod(int x) { return expo(x, 1000000007 - 2); }
void prep() {
fat[0] = 1;
for (int i = 1; i < 5050; i++) fat[i] = 1LL * fat[i - 1] * i % 1000000007;
ifat[5050 - 1] = invmod(fat[5050 - 1]);
for (int i = 5050 - 1; i > 0; i--)
ifat[i - 1] = 1LL * ifat[i] * i % 1000000007;
assert(ifat[0] == 1);
}
long long nCr(int n, int k) {
return 1LL * fat[n] * ifat[k] % 1000000007 * ifat[n - k] % 1000000007;
}
int main() {
scanf("%d %s", &n, s + 1);
prep();
s[0] = char('a' + 26);
last[26] = n + 1;
ways[n + 1][0] = 1;
for (int i = n; i >= 0; i--) {
for (int c = 0; c < 27; c++) {
if (c == (s[i] - 'a') || (last[c] == 0)) continue;
for (int j = 0; j < (n - i + 1); j++) {
ways[i][j + 1] += ways[last[c]][j];
if (ways[i][j + 1] >= 1000000007) ways[i][j + 1] -= 1000000007;
}
}
last[s[i] - 'a'] = i;
}
long long ans = 0;
for (int i = 2; i <= n + 1; i++) {
ans = (ans + nCr(n - 1, i - 2) * ways[0][i]) % 1000000007;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, lst[350], acum[5005][5005], dp[5005][5005];
string s;
int main() {
scanf("%d", &n);
cin >> s;
string aux = "";
aux += s[0];
for (int i = 1; i < n; i++)
if (s[i] != aux.back()) aux += s[i];
dp[0][0] = 1;
for (int i = 0; i < 5005; i++) acum[0][i] = acum[i][0] = 1;
for (int i = 1; i <= aux.size(); i++) {
int sum = 0;
for (int j = 1; j <= n; j++) {
dp[i][j] = acum[i - 1][j - 1] -
(lst[aux[i - 1]] == 0 ? 0 : acum[lst[aux[i - 1]]][j - 1]);
if (dp[i][j] < 0) dp[i][j] += 1000000007;
sum += dp[i][j];
if (sum >= 1000000007) sum -= 1000000007;
acum[i][j] = sum + acum[i - 1][j];
if (acum[i][j] >= 1000000007) acum[i][j] -= 1000000007;
}
lst[aux[i - 1]] = i;
}
int ans = 0;
for (int i = 1; i <= aux.size(); i++) {
ans += dp[i][n];
if (ans >= 1000000007) ans -= 1000000007;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int l;
char A[5003];
int DP[5003][2];
int AC[5003][2];
int M[256];
int cmb[5003];
int fastpow(int b, int e) {
int ans = 1;
while (e) {
if ((e & 1)) ans = ((long long)ans * b) % 1000000007;
e >>= 1;
b = ((long long)b * b) % 1000000007;
}
return ans;
}
int main(int nargs, char **args) {
cin >> l >> A;
A[l++] = '$';
cmb[0] = 1;
for (int i = 1; i < l; i++) {
cmb[i] = ((long long)cmb[i - 1] * (l - i - 1) % 1000000007) *
fastpow(i, 1000000007 - 2) % 1000000007;
}
for (int i = 1; i <= l; i++) {
DP[i][1] = (M[A[i - 1]] == 0);
AC[i][1] = AC[i - 1][1] + DP[i][1];
M[A[i - 1]] = i;
}
int ans = 0;
for (int j = 2; j <= l; j++) {
memset(M, 0, sizeof M);
int ci = (j & 1);
for (int i = 1; i <= l; i++) {
char c = A[i - 1];
DP[i][ci] = (AC[i - 1][!ci] - AC[M[c]][!ci] + 1000000007) % 1000000007;
AC[i][ci] = (AC[i - 1][ci] + DP[i][ci]) % 1000000007;
M[c] = i;
}
ans = (ans + (long long)DP[l][ci] * cmb[j - 2]) % 1000000007;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5010;
const int M = 300100;
const int INF = 0x3f3f3f3f;
const int mod = 1000000007;
void MOD(long long &a) {
if (a >= mod) a -= mod;
}
void MOD(long long &a, long long c) {
if (a >= c) a -= c;
}
void ADD(long long &a, long long b) {
a += b;
MOD(a);
}
void ADD(long long &a, long long b, long long c) {
a += b;
MOD(a, c);
}
long long qpow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a;
a = a * a;
b /= 2;
}
return ans;
}
long long qpow(long long a, long long b, long long c) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % c;
a = a * a % c;
b /= 2;
}
return ans;
}
int n, c[N][N], dp[N][N], last[26];
char s[N];
int main() {
scanf("%d%s", &n, s + 1);
for (int i = (c[0][0] = 1); i <= n; i++)
for (int j = (c[i][0] = 1); j <= i; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % mod;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++) dp[i][j] = dp[i - 1][j];
for (int j = 1; j <= n; j++) {
if (last[s[i] - 'a'])
dp[i][j] += dp[i - 1][j - 1] - dp[last[s[i] - 'a']][j - 1];
else
dp[i][j] += dp[i - 1][j - 1];
dp[i][j] %= mod;
dp[i][j] += mod;
dp[i][j] %= mod;
}
last[s[i] - 'a'] = i;
}
long long ans = 0;
for (int i = 1; i <= n; i++)
ans = (ans + 1ll * c[n - 1][i - 1] * dp[n][i]) % mod;
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int A = 26;
const int maxn = 5e3 + 5;
const long long mod = 1e9 + 7;
char s[maxn];
int n;
int nxt[maxn][A];
long long fat[maxn], inv[maxn];
long long dp[maxn][maxn];
string t;
void fillNxtTable() {
t = s;
t = "$" + t;
int last[A];
fill(last, last + A, n + 1);
for (int i = n; i >= 0; i--) {
for (int j = 0; j < A; j++) nxt[i][j] = last[j];
if (i) last[t[i] - 'a'] = i;
}
}
long long exp(long long a, long long b) {
long long result = 1;
while (b) {
if (b & 1) result = (result * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return result;
}
void preComputeBinomial() {
fat[0] = 1;
inv[0] = 1;
for (int i = 1; i < maxn; i++) {
fat[i] = (fat[i - 1] * i) % mod;
inv[i] = exp(fat[i], mod - 2);
}
}
long long C(int n, int k) {
if (k < 0) return 0;
return (((fat[n] * inv[n - k]) % mod) * inv[k]) % mod;
}
long long solve(int pos, int k) {
if (pos > n) return 0;
long long &ans = dp[pos][k];
if (ans != -1) return ans;
ans = C(n - 1, k - 1);
for (int i = 0; i < A; i++) {
if ((t[pos] - 'a') != i) {
ans = (ans + solve(nxt[pos][i], k + 1));
}
}
ans %= mod;
return ans;
}
int main() {
scanf("%d", &n);
scanf("%s", s);
fillNxtTable();
preComputeBinomial();
memset(dp, -1, sizeof(dp));
printf("%lld\n", solve(0, 0));
return 0;
}
|
#include <bits/stdc++.h>
static const int MAXN = 5004;
static const int ALPHA = 26;
static const int MODULUS = 1e9 + 7;
int n;
char s[MAXN];
int binom[MAXN][MAXN];
int f[MAXN][ALPHA] = {{0}}, f_rowsum[MAXN] = {0};
void preprocess_binomials() {
binom[0][0] = 1;
for (int i = 1; i < MAXN; ++i) {
binom[i][0] = 1;
for (int j = 1; j <= i; ++j)
binom[i][j] = (binom[i - 1][j - 1] + binom[i - 1][j]) % MODULUS;
}
}
int main() {
preprocess_binomials();
scanf("%d", &n);
getchar();
for (int i = 0; i < n; ++i) s[i] = getchar() - 'a';
f_rowsum[0] = 1;
for (int i = 0; i < n; ++i) {
for (int len = i + 1; len >= 1; --len) {
int increment =
((f_rowsum[len - 1] - f[len - 1][s[i]] - f[len][s[i]]) % MODULUS +
MODULUS) %
MODULUS;
(f[len][s[i]] += increment) %= MODULUS;
(f_rowsum[len] += increment) %= MODULUS;
}
}
int ans = 0;
for (int i = 1; i <= n; ++i)
for (int j = 0; j < ALPHA; ++j)
ans =
((long long)ans + (long long)f[i][j] * binom[n - 1][i - 1]) % MODULUS;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int block_size = 320;
const long long mod = 1e9 + 7;
const long double eps = 1e-9;
const int inf = mod;
const double PI = atan(1) * 4;
template <typename T>
inline int sign(const T& a) {
if (a < 0) return -1;
if (a > 0) return 1;
return 0;
}
template <typename T>
inline void in(T& x) {
x = 0;
T f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
template <typename A, typename B>
inline void in(A& x, B& y) {
in(x);
in(y);
}
template <typename A, typename B, typename C>
inline void in(A& x, B& y, C& z) {
in(x);
in(y);
in(z);
}
template <typename A, typename B, typename C, typename D>
inline void in(A& x, B& y, C& z, D& xx) {
in(x);
in(y);
in(z);
in(xx);
}
template <class T>
void upd(T& a, T& b) {
a = max(a, b);
}
inline void add(int& a, int b) {
a += b;
a %= mod;
}
int n;
char s[5010];
int last[5010][27];
long long tot[5010][5010];
int vis[27];
int main() {
scanf("%d %s", &n, s + 1);
for (int i = 1; i < n + 1; i++) s[i] = s[i] - 'a' + 1;
for (int i = 0; i < 27; i++) last[0][i] = -1;
for (int i = 1; i < n + 1; i++) {
for (int j = 0; j < 27; j++) {
if (j == s[i]) {
last[i][j] = -1;
continue;
}
if (s[i - 1] == j) {
last[i][j] = i - 1;
} else {
last[i][j] = last[i - 1][j];
}
}
}
for (int i = 0; i < 5010; i++) tot[i][0] = 1;
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < n + 1; j++) {
for (int k = 1; k < 27; k++) {
if (last[j][k] == -1) continue;
tot[i][j] += tot[i - 1][last[j][k]];
}
tot[i][j] += tot[i - 1][j] + 1;
tot[i][j] %= mod;
}
}
long long ans = 0;
for (int i = n + 1; i >= 1; i--) {
if (vis[s[i]]) continue;
vis[s[i]] = 1;
ans += tot[n][i] - tot[n - 1][i];
}
cout << (ans % mod + mod) % mod;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5000 + 77, L = 26, Mod = 1000000007;
int n, A, dp[N][L], Sdp[N], C[N][N];
char S[N];
int main() {
for (int i = 0; i < N; ++i) C[0][i] = C[i][i] = 1;
for (int i = 1; i < N; ++i)
for (int j = i + 1; j < N; ++j)
C[i][j] = (C[i - 1][j - 1] + C[i][j - 1]) % Mod;
scanf("%d %s", &n, S + 1);
Sdp[0] = 1;
for (int i = 1; i <= n; ++i) {
int c = S[i] - 'a';
for (int t = i; t > 0; --t) {
Sdp[t] = (Sdp[t] - dp[t][c] + Mod) % Mod;
dp[t][c] = (Sdp[t - 1] - dp[t - 1][c]) % Mod;
if (dp[t][c] < 0) dp[t][c] += Mod;
Sdp[t] = (Sdp[t] + dp[t][c]) % Mod;
}
}
for (int t = 1; t <= n; ++t) {
int w = Sdp[t];
w = w * 1ll * C[t - 1][n - 1] % Mod;
A = (A + w) % Mod;
}
printf("%d\n", A);
return 0;
}
|
#include <bits/stdc++.h>
const int maxn = 5001, mod = 1000000007;
int n, pos[27], f[maxn][maxn];
char str[maxn];
void mod_add(int &x, int y) {
if ((x += y) >= mod) x -= mod;
}
void mod_sub(int &x, int y) {
if ((x -= y) < 0) x += mod;
}
int main() {
scanf("%d%s", &n, str);
f[0][0] = 1;
for (int i = 1; i <= n; ++i) {
int pre = pos[str[i - 1]];
pos[str[i - 1]] = i;
memcpy(f[i], f[i - 1], (n + 1) * sizeof(int));
for (int j = 1; j <= n; ++j) {
mod_add(f[i][j], f[i][j - 1]);
if (pre) mod_sub(f[i][j], f[pre][j - 1]);
}
}
printf("%d\n", f[n][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool is_palindrome(const string& s) {
return std::equal(s.begin(), s.end(), s.rbegin());
}
const long long MOD = 1000000007;
const long long INF = 1e9 + 5;
const double eps = 1e-7;
const double PI = acos(-1.0);
inline void debug_vi(vector<int> a) {
for (long long i = (long long)(0); i < (long long)(a.size()); i++)
cout << a[i] << " ";
}
inline void debug_vll(vector<long long> a) {
for (long long i = (long long)(0); i < (long long)(a.size()); i++)
cout << a[i] << " ";
}
const int N = 5005;
long long dp[N][26], totalsum[N], last[26] = {-1}, n, sz;
string s, t;
const int MAXN = 1e4 + 5;
long long factorial[MAXN], inverse[MAXN];
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long modInverse(long long a, long long m) { return power(a, m - 2, m); }
void pre() {
factorial[0] = 1LL;
inverse[0] = modInverse(factorial[0], MOD);
for (int i = 1; i < MAXN; i++) {
factorial[i] = factorial[i - 1] * i % MOD;
inverse[i] = modInverse(factorial[i], MOD);
}
}
long long binomial_coefficient(long long n, long long k) {
return factorial[n] * inverse[k] % MOD * inverse[n - k] % MOD;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> sz >> t;
pre();
s = "";
char prev = t[0];
for (long long i = (long long)(1); i < (long long)(t.size()); i++) {
if (t[i] == prev) continue;
s.push_back(prev);
prev = t[i];
}
s.push_back(prev);
memset(dp, 0, sizeof(dp));
memset(totalsum, 0, sizeof(totalsum));
memset(last, -1, sizeof(last));
n = s.size();
totalsum[0] = 1;
for (long long i = (long long)(0); i < (long long)(n); i++) {
int val = s[i] - 'a';
for (long long j = (long long)(1); j < (long long)(i + 2); j++) {
totalsum[j] = (totalsum[j] - dp[j][val] + MOD) % MOD;
totalsum[j] =
totalsum[j] + (totalsum[j - 1] - dp[j - 1][val] + MOD) % MOD;
dp[j][val] = (totalsum[j - 1] - dp[j - 1][val] + MOD) % MOD;
}
}
long long ans = 0;
for (long long i = (long long)(1); i < (long long)(n + 1); i++) {
ans += (totalsum[i] * binomial_coefficient(sz - 1, i - 1)) % MOD;
ans %= MOD;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5e3 + 5;
const int MOD = 1e9 + 7;
int n;
char str[MAX];
int prv[MAX][26];
int binom[MAX][MAX], dp[MAX][MAX];
inline int add(int a, int b) {
a += b;
if (a >= MOD) {
a -= MOD;
} else if (0 > MOD) {
a += MOD;
}
return a;
}
inline int mult(int a, int b) { return (1LL * a * b) % MOD; }
int main() {
scanf("%d%*c", &n);
for (int i = int(1); i < int(n + 1); i++) {
scanf("%c", str + i);
}
for (int i = int(0); i < int(n + 1); i++) {
for (int j = int(0); j < int(i + 1); j++) {
if (i == j || j == 0) {
binom[i][j] = 1;
} else {
binom[i][j] = add(binom[i - 1][j], binom[i - 1][j - 1]);
}
}
}
int last[26];
memset(last, -1, sizeof last);
memset(prv, -1, sizeof prv);
for (int i = int(1); i < int(n + 1); i++) {
for (int j = int(0); j < int(26); j++) {
prv[i][j] = last[j];
}
last[str[i] - 'a'] = i;
}
int ans = 0;
for (int i = int(1); i < int(n + 1); i++) {
for (int j = int(1); j < int(n + 1); j++) {
int v = str[j] - 'a';
if (i == 1) {
dp[i][j] = 1;
continue;
}
for (int k = int(0); k < int(26); k++) {
if (k != v && prv[j][k] != -1) {
dp[i][j] = add(dp[i][j], dp[i - 1][prv[j][k]]);
}
}
}
for (int j = int(0); j < int(26); j++) {
if (last[j] != -1) {
ans = add(ans, mult(binom[n - 1][i - 1], dp[i][last[j]]));
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 5050;
const long long MOD = 1000000007;
long long dp[2][MAXN][26];
long long dpSum[2][MAXN];
int ind[26];
int main() {
int n;
scanf("%d", &n);
char str[MAXN];
scanf("%s", str);
vector<int> v;
v.push_back(str[0] - 'a');
char c = str[0];
for (int i = 1; i < n; i++) {
if (str[i] != c) {
v.push_back(str[i] - 'a');
c = str[i];
}
}
int len = v.size();
for (int j = 1; j <= n; j++) dp[0][j][v[0]] = 1;
for (int j = 1; j <= n; j++) {
for (int x = 0; x < 26; x++)
dpSum[0][j] = (dpSum[0][j] + dp[0][j][x]) % MOD;
}
for (int i = 1; i < len; i++) {
long long sum = 1;
for (int j = 1; j <= n; j++) {
dp[1][j][v[i]] = sum;
sum = (sum + dpSum[0][j] - dp[0][j][v[i]] + MOD) % MOD;
}
for (int j = 1; j <= n; j++) {
dpSum[1][j] = (dpSum[0][j] - dp[0][j][v[i]] + dp[1][j][v[i]] + MOD) % MOD;
}
for (int j = 1; j <= n; j++) {
dp[0][j][v[i]] = dp[1][j][v[i]];
dpSum[0][j] = dpSum[1][j];
}
}
cout << dpSum[0][n];
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200000;
int n;
string s;
int dp[5050][5050];
int b[5050][5050];
int ans;
int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
cin >> s;
for (int i = 1; i <= n; i++) {
int j = s[i - 1] - 'a';
for (int l = 0; l < i; l++) {
dp[l + 1][j] = 0;
for (int t = 0; t <= 26; t++) {
if (t == j) continue;
dp[l + 1][j] = (dp[l + 1][j] + dp[l][t]);
if (dp[l + 1][j] >= mod) dp[l + 1][j] -= mod;
}
if (l == 0) {
dp[l + 1][j]++;
if (dp[l + 1][j] >= mod) dp[l + 1][j] -= mod;
}
}
}
for (int i = 0; i <= n; i++) b[i][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
b[i][j] = (b[i - 1][j - 1] + b[i - 1][j]) % mod;
}
}
for (int i = 1; i <= n; i++) {
int x = 0;
for (int j = 0; j < 26; j++) x = (x + dp[i][j]) % mod;
ans = (ans + (long long)x * b[n - 1][i - 1]) % mod;
}
cout << ans;
}
|
#include <bits/stdc++.h>
int add(int a, int b) { return (a + b) % ((long long)1e9 + 7); }
int main() {
static char s[5000 + 1];
static int choose[5000 + 1][5000 + 1], dp[5000][5000 + 1], next[5000][26];
int n, c, i, j, cnt;
scanf("%d", &n);
scanf("%s", s);
for (c = 0; c < 26; c++) next[n - 1][c] = s[n - 1] == c + 'a' ? n - 1 : -1;
for (i = n - 2; i >= 0; i--)
for (c = 0; c < 26; c++) next[i][c] = s[i] == c + 'a' ? i : next[i + 1][c];
for (c = 0; c < 26; c++)
if (next[0][c] >= 0) dp[next[0][c]][1] = 1;
for (i = 0; i < n; i++)
for (j = 1; j < n; j++)
if (dp[i][j] > 0)
for (c = 0; c < 26; c++)
if (s[i] != c + 'a') {
int i_ = next[i][c];
if (i_ >= 0) dp[i_][j + 1] = add(dp[i_][j + 1], dp[i][j]);
}
for (i = 0; i <= n; i++) {
choose[i][0] = 1;
for (j = 1; j <= i; j++)
choose[i][j] = add(choose[i - 1][j], choose[i - 1][j - 1]);
}
cnt = 0;
for (j = 1; j <= n; j++) {
for (i = 1; i < n; i++) dp[i][j] = add(dp[i - 1][j], dp[i][j]);
cnt = add(cnt, (long long)dp[n - 1][j] * choose[n - 1][j - 1] %
((long long)1e9 + 7));
}
printf("%d\n", cnt);
return 0;
}
|
#include <bits/stdc++.h>
char s[5001];
int dp[27][5001], sum[5001];
int c[5001][5001];
const int mod = 1000000007;
inline int add(int a, int b) { return a + b - mod >= 0 ? a + b - mod : a + b; }
inline int sub(int a, int b) { return a - b + (a - b < 0 ? mod : 0); }
void cnk(int n) {
for (int i = 0; i <= n; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++) c[i][j] = add(c[i - 1][j - 1], c[i - 1][j]);
}
}
int main() {
int n, ans = 0;
scanf("%d%s", &n, s + 1);
cnk(n);
sum[0] = 1;
for (int i = 1; s[i]; i++) {
int ch = s[i] - 'a';
for (int j = i; j; j--) {
sum[j] = add(sum[j], sub(sub(sum[j - 1], dp[ch][j]), dp[ch][j - 1]));
dp[ch][j] = sub(sum[j - 1], dp[ch][j - 1]);
}
}
for (int j = 1; j <= n; j++) {
ans = add(ans, (long long)c[n - 1][j - 1] * sum[j] % mod);
}
printf("%d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MAX_N = 5000, SIGMA_SIZE = 26;
int pos[MAX_N][SIGMA_SIZE], f[MAX_N][MAX_N];
char s[MAX_N + 1];
int main() {
int n;
scanf("%d %s", &n, s);
for (int i = 0; i < n; ++i) s[i] -= 'a';
fill_n(pos[n - 1], SIGMA_SIZE, -1);
pos[n - 1][s[n - 1]] = n - 1;
for (int i = n - 2; i >= 0; --i) {
copy(pos[i + 1], pos[i + 1] + SIGMA_SIZE, pos[i]);
pos[i][s[i]] = i;
}
fill_n(f[n - 1], n, 1);
for (int i = n - 2; i >= 0; --i) {
f[i][n - 1] = f[i + 1][n - 1];
for (int j = n - 2; j >= 0; --j)
f[i][j] = ((long long)f[i][j + 1] -
(pos[j + 1][s[j]] >= 0 ? f[i + 1][pos[j + 1][s[j]]] : 0) +
f[i + 1][j] + MOD) %
MOD;
}
int ans = 0;
for (int j = 0; j < SIGMA_SIZE; ++j) ans = (ans + f[0][pos[0][j]]) % MOD;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5001;
int n, C[N][N], mod = 1e9 + 7;
string s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
C[0][0] = 1;
for (int i = 1; i < N; i++) {
C[i][0] = 1;
for (int j = 1; j < N; j++) {
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
}
cin >> n >> s;
vector<vector<int> > dp(26, vector<int>(n + 1));
vector<int> tot(n + 1);
for (auto &c : s) {
int idx = c - 'a';
for (int i = 1; i <= n; i++) tot[i] = (tot[i] - dp[idx][i] + mod) % mod;
for (int i = 2; i <= n; i++) dp[idx][i] = tot[i - 1];
dp[idx][1] = 1;
for (int i = 1; i <= n; i++) tot[i] = (tot[i] + dp[idx][i]) % mod;
}
int ans = 0;
for (int i = 1; i <= n; i++)
ans = (ans + 1LL * C[n - 1][i - 1] * tot[i]) % mod;
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int occurrence[5002], o[5002];
int mod = 1000000007, dp[5002][5002];
string a;
int n;
int main() {
cin >> n >> a;
for (int i = 0; i < 26; i++) o[i] = n;
for (int i = a.size() - 1; i >= 0; i--) {
occurrence[i] = o[a[i] - 'a'];
o[a[i] - 'a'] = i;
}
for (int i = 0; i < n; i++) dp[i][n] = 1;
for (int i = n - 1; i >= 0; i--) {
for (int j = n - 1; j >= 0; j--) {
dp[i][j] = (dp[i + 1][j] + dp[i][j + 1]) % mod;
if (occurrence[i] < n) {
dp[i][j] = (dp[i][j] + mod - dp[occurrence[i]][j + 1]) % mod;
}
}
}
cout << dp[0][0] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long res;
int n, nn;
int c[5001][5001];
vector<vector<int> > sum;
vector<int> p, d;
string s;
void f() {
string t = s;
s = t[0];
for (int i = 1; i < t.length(); ++i)
if (t[i] != t[i - 1]) s += t[i];
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> s;
nn = n;
f();
n = s.length();
for (int i = 0; i < 5001; ++i) c[i][i] = c[i][0] = 1;
for (int i = 2; i < 5001; ++i) {
for (int j = 1; j < i; ++j) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
if (c[i][j] >= mod) c[i][j] -= mod;
}
}
p.assign(26, -1);
d.assign(n + 1, 0);
sum.assign(n + 1, vector<int>(n + 1, 0));
sum[0][0] = 1;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) d[j + 1] = sum[i][j];
int h = p[int(s[i] - 'a')];
if (h != -1) {
for (int j = 0; j < n; ++j) {
d[j + 1] = d[j + 1] + (mod - sum[h + 1][j]);
if (d[j + 1] >= mod) d[j + 1] -= mod;
}
}
for (int j = 0; j < n + 1; ++j) {
sum[i + 1][j] = sum[i][j] + d[j];
if (sum[i + 1][j] >= mod) sum[i + 1][j] -= mod;
}
p[int(s[i] - 'a')] = i;
}
res = 0;
for (int j = 1; j < n + 1; ++j)
res = (res + sum[n][j] * (long long)c[nn - 1][nn - j]) % mod;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 5000 + 100;
const int M = 1e5 + 100;
const long long mod = 1e9 + 7;
const double EPS = 1e-9;
using namespace std;
int base[N], n, tot;
char s[N];
long long dp[N][30], sum[N], C[N][N];
int main() {
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = 1; i <= n; i++) {
if (tot == 0)
base[++tot] = s[i] - 'a';
else if (base[tot] != s[i] - 'a')
base[++tot] = s[i] - 'a';
}
for (int i = 1; i <= tot; i++) {
int x = base[i];
for (int j = i; j >= 2; j--) {
long long r = (sum[j - 1] - dp[j - 1][x] - dp[j][x] + mod) % mod;
dp[j][x] = (dp[j][x] + r) % mod;
sum[j] = (sum[j] + r) % mod;
}
if (dp[1][x] == 0) dp[1][x] = 1, sum[1] = (1 + sum[1]) % mod;
}
for (int i = 0; i <= n; i++) {
C[i][0] = 1;
for (int j = 1; j <= i; j++)
C[i][j] = (C[i - 1][j] + C[i - 1][j - 1]) % mod;
}
long long ans = 0;
for (int i = 1; i <= tot; i++)
ans = (ans + (long long)C[n - 1][i - 1] * sum[i] % mod) % mod;
printf("%lld\n", (ans % mod + mod) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
inline long long gcd(long long a, long long b) {
a = ((a) < 0 ? -(a) : (a));
b = ((b) < 0 ? -(b) : (b));
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
long long ext_gcd(long long A, long long B, long long* X, long long* Y) {
long long x2, y2, x1, y1, x, y, r2, r1, q, r;
x2 = 1;
y2 = 0;
x1 = 0;
y1 = 1;
for (r2 = A, r1 = B; r1 != 0;
r2 = r1, r1 = r, x2 = x1, y2 = y1, x1 = x, y1 = y) {
q = r2 / r1;
r = r2 % r1;
x = x2 - (q * x1);
y = y2 - (q * y1);
}
*X = x2;
*Y = y2;
return r2;
}
inline long long modInv(long long a, long long m) {
long long x, y;
ext_gcd(a, m, &x, &y);
x %= m;
if (x < 0) x += m;
return x;
}
inline long long power(long long a, long long p) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
inline long long bigmod(long long a, long long p, long long m) {
long long res = 1 % m, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
const long long inf = 2147383647;
const long long mod = 1000000007;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
int n, ans, oc[5005][30];
char s[5005];
int dp[2][5005];
int main() {
memset(oc, -1, sizeof(oc));
cin >> n >> s;
for (long long i = (n - 1); i >= (0); --i) {
for (int j = 0; j < 26; j++) {
oc[i][j] = oc[i + 1][j];
}
oc[i][s[i] - 'a'] = i;
}
for (long long i = (0); i <= (n - 1); ++i) dp[0][i] = dp[1][i] = 1;
for (long long i = (n - 2); i >= (0); --i) {
for (long long j = (n - 1); j >= (0); --j) {
dp[0][j] = 0;
dp[0][j] = (dp[0][j + 1] + dp[1][j]) % mod;
if (oc[j + 1][s[j] - 'a'] != -1) {
dp[0][j] = (dp[0][j] - dp[1][oc[j + 1][s[j] - 'a']]) % mod;
if (dp[0][j] >= mod) dp[0][j] -= mod;
if (dp[0][j] < 0) dp[0][j] += mod;
;
}
}
for (long long j = (0); j <= (n - 1); ++j) dp[1][j] = dp[0][j];
}
for (int i = 0; i < 26; i++) {
if (oc[0][i] != -1) ans = (ans + dp[0][oc[0][i]]) % mod;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5003;
const int mod = (int)1e9 + 7;
int dp[maxn][26], dps[maxn], un[maxn], f[maxn], rf[maxn];
void norm(int &x) {
if (x < 0) {
x += mod;
} else if (x >= mod) {
x -= mod;
}
}
int bpow(int x, int p) {
int res = 1;
while (p) {
if (p & 1)
res = ((signed long long int)res * (signed long long int)x) % mod;
x = ((signed long long int)x * (signed long long int)x) % mod;
p >>= 1;
}
return res;
}
inline int comb(int n, int k) {
return ((((signed long long int)f[n] * (signed long long int)rf[k]) % mod) *
(signed long long int)rf[n - k]) %
mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
f[0] = f[1] = rf[0] = rf[1] = 1;
for (int i = 2; i < maxn; ++i) {
f[i] = ((signed long long int)f[i - 1] * (signed long long int)i) % mod;
rf[i] = bpow(f[i], mod - 2);
}
string s;
int n, m = 0, ans = 0;
cin >> n >> s;
for (int i = 0; i < n; ++i) {
while (i + 1 != n && s[i] == s[i + 1]) ++i;
un[++m] = s[i] - 'a';
}
dps[0] = 1;
for (int lst = 1; lst <= m; ++lst) {
int ch = un[lst];
for (int len = 1; len <= lst; ++len) {
dps[len] -= dp[len][ch];
dp[len][ch] = dps[len - 1] - dp[len - 1][ch];
norm(dp[len][ch]);
dps[len] += dp[len][ch];
norm(dps[len]);
}
}
for (int len = 1; len <= m; ++len) {
ans = ((signed long long int)ans +
(signed long long int)dps[len] *
(signed long long int)comb(n - 1, len - 1)) %
mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const double pi = 3.1415926535897932384626433832795;
const double eln = 2.718281828459045235360287471352;
const long long mod = 1e9 + 7;
long long sum[5005];
bool b[27];
long long c[5005];
char s[5005], s1[5005];
long long dp[5005][27];
int i, j, k, l, m, n;
long long ans;
long long mi(long long x, long long y) {
long long aa = 1;
while (y > 0) {
if (y & 1) aa = (aa * x) % mod;
x = (x * x) % mod;
y >>= 1;
}
return aa;
}
int main() {
scanf("%d\n", &n);
if (n - 1 <= 1)
c[0] = c[1] = 1;
else {
l = n - 1;
c[0] = 1;
c[1] = l;
for (i = 2; i <= l; i++) {
c[i] = c[i - 1];
c[i] *= (long long)(l - i + 1);
c[i] %= mod;
c[i] *= mi((long long)i, mod - 2);
c[i] %= mod;
}
}
gets(s1 + 1);
m = 1;
s[1] = s1[1];
for (i = 2; i <= n; i++)
if (s1[i] != s1[i - 1]) s[++m] = s1[i];
memset(b, 0, sizeof(b));
for (i = 1; i <= m; i++) {
int t = s[i] - 96;
if (!b[t]) {
sum[1]++;
dp[1][t] = 1;
b[t] = true;
}
for (k = 2; k <= m; k++) {
long long t1 = (sum[k - 1] - dp[k - 1][t] + mod) % mod;
long long t2 = dp[k][t];
dp[k][t] = t1;
sum[k] = (sum[k] + mod + t1 - t2) % mod;
}
}
for (i = 1; i <= m; i++) {
ans += (sum[i] * c[i - 1]) % mod;
ans %= mod;
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
int main() {
iostream::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
string s;
cin >> s;
for (char &c : s) c -= 'a';
vector<long long> sum(n + 1, 0);
sum[0] = 1;
vector<vector<long long> > dp(n + 1, vector<long long>(26, 0));
const long long md = 1e9 + 7;
for (char c : s) {
for (int i = n; i; i--) {
sum[i] += sum[i - 1] - dp[i - 1][c] - dp[i][c];
dp[i][c] = sum[i - 1] - dp[i - 1][c];
sum[i] %= md;
dp[i][c] += md;
}
}
vector<vector<long long> > c(n + 1, vector<long long>(n + 1, 0));
c[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++) {
if (j) c[i][j] += c[i - 1][j - 1];
c[i][j] += c[i - 1][j];
c[i][j] %= md;
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
ans += ((sum[i] + md) * c[n - 1][i - 1]) % md;
ans %= md;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
static const int N = 5005;
static const long long MOD = 1000 * 1000 * 1000 + 7;
int head[127];
int f[N][N];
char s[N];
int n;
int mod_add(int x, int y) {
x += y;
if (x >= MOD) x -= MOD;
return x;
}
int mod_sub(int x, int y) {
x -= y;
if (x < 0) x += MOD;
return x;
}
int solve() {
scanf("%d", &n);
scanf("%s", s);
f[0][0] = 1;
for (int i = 1; i <= n; ++i) {
char c = s[i - 1];
int last = head[c];
head[c] = i;
f[i][0] = f[i - 1][0];
for (int j = 1; j <= n; ++j) {
f[i][j] = mod_add(f[i - 1][j], f[i][j - 1]);
if (last) f[i][j] = mod_sub(f[i][j], f[last][j - 1]);
}
}
printf("%d\n", f[n][n]);
return 0;
}
int main(int argc, char* argv[]) {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_n = 5000, SGM = 26, MOD = 1000 * 1000 * 1000 + 7;
char str[MAX_n + 1];
int sum[MAX_n + 1];
int dp[MAX_n + 1][SGM];
int add(int a, int b) { return (a + b) % MOD; }
int pow(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = (long long)ret * a % MOD;
a = (long long)a * a % MOD, b >>= 1;
}
return ret;
}
int main() {
int n;
scanf("%d %s", &n, str);
sum[0] = 1;
for (int i = 0; i < n; ++i) {
int c = str[i] - 'a';
for (int j = 1; j <= i + 1; ++j) {
int delta = add(sum[j - 1], -add(dp[j - 1][c], dp[j][c]));
dp[j][c] = add(dp[j][c], delta);
sum[j] = add(sum[j], delta);
}
}
long long C = 1;
int ans = 0;
for (int i = 1; i <= n; ++i) {
ans = add(ans, C * sum[i] % MOD);
C = C * (n - i) % MOD * pow(i, MOD - 2) % MOD;
}
ans = (ans + MOD) % MOD;
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5000 + 77, L = 26, Mod = 1000000007;
int n, A, dp[N][L], Sdp[N], C[N][N];
char S[N];
int main() {
for (int i = 0; i < N; ++i) C[0][i] = C[i][i] = 1;
for (int i = 1; i < N; ++i)
for (int j = i + 1; j < N; ++j)
C[i][j] = (C[i - 1][j - 1] + C[i][j - 1]) % Mod;
scanf("%d %s", &n, S + 1);
Sdp[0] = 1;
for (int i = 1; i <= n; ++i) {
int c = S[i] - 'a';
for (int t = i; t > 0; --t) {
Sdp[t] = (Sdp[t] - dp[t][c] + Mod) % Mod;
dp[t][c] = (Sdp[t - 1] - dp[t - 1][c]) % Mod;
if (dp[t][c] < 0) dp[t][c] += Mod;
Sdp[t] = (Sdp[t] + dp[t][c]) % Mod;
}
}
for (int t = 1; t <= n; ++t) {
int w = Sdp[t];
w = w * 1ll * C[t - 1][n - 1] % Mod;
A = (A + w) % Mod;
}
printf("%d\n", A);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5000 + 20;
long long int a[N], DP[N][N], dp[2][N], mark[30], jolo[30];
const long long int q = 1000 * 1000 * 1000 + 7;
vector<int> vec;
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i <= n; i++) {
DP[i][0] = 1;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= i; j++) {
DP[i][j] = (DP[i - 1][j] + DP[i - 1][j - 1]) % q;
}
}
for (int i = 0; i < n; i++) {
while (!vec.empty() and vec.back() == (s[i] - 'a')) {
vec.pop_back();
}
vec.push_back(s[i] - 'a');
}
int m = vec.size();
int ans = 0;
dp[1][0] = 1;
mark[vec[0]] = 1;
for (int j = 1; j < m; j++) {
dp[1][j] = dp[1][j - 1];
if (mark[vec[j]] == 0) {
dp[1][j]++;
}
mark[vec[j]] = 1;
}
ans = dp[1][m - 1];
for (int i = 2; i <= m; i++) {
fill(mark, mark + 30, 0);
fill(jolo, jolo + 30, 0);
jolo[vec[0]] = dp[1][0];
for (int j = 1; j < m; j++) {
dp[0][j] = (dp[1][j - 1] + q - jolo[vec[j]]) % q;
mark[vec[j]] = 1;
jolo[vec[j]] = dp[1][j];
}
dp[1][0] = 0;
for (int j = 1; j < m; j++) {
dp[1][j] = (dp[1][j - 1] + dp[0][j]) % q;
}
ans += (dp[1][m - 1] * DP[n - 1][i - 1]) % q;
ans %= q;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
void ga(int N, int *A) {
for (int i(0); i < N; i++) scanf("%d", A + i);
}
long long f[5005] = {1, 1}, I[5005] = {1, 1}, J[5005] = {1, 1};
void pre() {
for (int k(2); k < 5005; k++)
f[k] = f[k - 1] * k % (1000000007),
J[k] =
-(1000000007) / k * J[(1000000007) % k] % (1000000007) + (1000000007),
I[k] = I[k - 1] * J[k] % (1000000007);
;
}
long long C(int N, int K) {
return N < K ? 0 : (f[N] * I[K] % (1000000007)) * I[N - K] % (1000000007);
}
char s[5005];
int S, N, a;
long long dp[5005][27];
int main(void) {
pre();
scanf("%d%s", &N, s);
for (int i(0); i < N; i++) {
for (int j = i; j; --j)
a = j ? (dp[j - 1][26] - dp[j - 1][s[i] - 97] + (1000000007)) %
(1000000007)
: 0 + 1,
dp[j][26] += (1000000007) - dp[j][s[i] - 97], dp[j][s[i] - 97] = a,
dp[j][26] += a, dp[j][26] %= (1000000007);
if (!dp[0][s[i] - 97]) dp[0][s[i] - 97] = 1, ++dp[0][26];
}
for (int i(0); i < N; i++) S = (S + C(N - 1, i) * dp[i][26]) % (1000000007);
printf("%d\n", S);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 5010, modP = 1e9 + 7, oo = 23041997;
int n, f[maxN][26], res, c[maxN][maxN];
char s[maxN];
int main() {
scanf("%d\n", &n);
scanf("%s", s);
for (int i = 0; i <= n; ++i) c[i][0] = 1, c[0][i] = 0;
c[0][0] = 1;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= i; ++j)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % modP;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= i; ++j) {
f[j][s[i - 1] - 'a'] = 0;
for (int t = 0; t < 26; ++t)
if (t != s[i - 1] - 'a') {
f[j][s[i - 1] - 'a'] += f[j - 1][t];
f[j][s[i - 1] - 'a'] %= modP;
}
}
f[1][s[i - 1] - 'a'] = 1;
}
for (int i = 1; i <= n; ++i)
for (int j = 0; j < 26; ++j) {
int tmp = (1ll * f[i][j] * c[n - 1][i - 1]) % modP;
res = (res + tmp) % modP;
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5000 + 77, L = 26, Mod = 1000000007;
int n, A, dp[N][L], Sdp[N], C[N][N];
char S[N];
int main() {
for (int i = 0; i < N; ++i) C[0][i] = C[i][i] = 1;
for (int i = 1; i < N; ++i)
for (int j = i + 1; j < N; ++j)
C[i][j] = (C[i - 1][j - 1] + C[i][j - 1]) % Mod;
scanf("%d %s", &n, S + 1);
Sdp[0] = 1;
for (int i = 1; i <= n; ++i) {
int c = S[i] - 'a';
for (int t = i; t > 0; --t) {
Sdp[t] = (Sdp[t] - dp[t][c] + Mod) % Mod;
dp[t][c] = (Sdp[t - 1] - dp[t - 1][c]) % Mod;
if (dp[t][c] < 0) dp[t][c] += Mod;
Sdp[t] = (Sdp[t] + dp[t][c]) % Mod;
}
}
for (int t = 1; t <= n; ++t) {
int w = Sdp[t];
w = w * 1ll * C[t - 1][n - 1] % Mod;
A = (A + w) % Mod;
}
printf("%d\n", A);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int block_size = 320;
const long long mod = 1e9 + 7;
const long double eps = 1e-9;
const int inf = mod;
const double PI = atan(1) * 4;
template <typename T>
inline int sign(const T& a) {
if (a < 0) return -1;
if (a > 0) return 1;
return 0;
}
template <typename T>
inline void in(T& x) {
x = 0;
T f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
x *= f;
}
template <typename A, typename B>
inline void in(A& x, B& y) {
in(x);
in(y);
}
template <typename A, typename B, typename C>
inline void in(A& x, B& y, C& z) {
in(x);
in(y);
in(z);
}
template <typename A, typename B, typename C, typename D>
inline void in(A& x, B& y, C& z, D& xx) {
in(x);
in(y);
in(z);
in(xx);
}
template <class T>
void upd(T& a, T& b) {
a = max(a, b);
}
inline void add(int& a, int b) {
a += b;
a %= mod;
}
int n;
char s[5010];
int last[5010][27];
long long tot[5010][5010];
int vis[27];
int main() {
scanf("%d %s", &n, s + 1);
for (int i = 1; i < n + 1; i++) s[i] = s[i] - 'a' + 1;
for (int i = 0; i < 27; i++) last[0][i] = -1;
for (int i = 1; i < n + 1; i++) {
for (int j = 0; j < 27; j++) {
if (j == s[i]) {
last[i][j] = -1;
continue;
}
if (s[i - 1] == j) {
last[i][j] = i - 1;
} else {
last[i][j] = last[i - 1][j];
}
}
}
for (int i = 0; i < 5010; i++) tot[i][0] = 1;
for (int i = 1; i < n + 1; i++) {
for (int j = 1; j < n + 1; j++) {
for (int k = 1; k < 27; k++) {
if (last[j][k] == -1) continue;
tot[i][j] += tot[i - 1][last[j][k]];
}
tot[i][j] += tot[i - 1][j] + 1;
tot[i][j] %= mod;
}
}
long long ans = 0;
for (int i = n + 1; i >= 1; i--) {
if (vis[s[i]]) continue;
vis[s[i]] = 1;
ans += tot[n][i] - tot[n - 1][i];
}
cout << (ans % mod + mod) % mod;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[5010][26];
long long total[5010];
long long comb[5010];
long long inverseModp(long long a, long long p) {
long long ex = p - 2, result = 1;
while (ex > 0) {
if (ex % 2 == 1) {
result = (result * a) % p;
}
a = (a * a) % p;
ex /= 2;
}
return result;
}
void nCrModp(long long n, long long p) {
comb[0] = 1;
long long r = 0;
long long result = 1;
for (long long i = n, x = 1; i > r; --i, ++x) {
result = (result * i) % p;
comb[x] = result;
}
result = 1;
for (long long i = n, x = 1; i > r; --i, ++x) {
result = (result * inverseModp(x, p)) % p;
comb[x] = (comb[x] * result) % p;
}
}
int32_t main() {
long long n, N;
cin >> n;
N = n;
string tmp, s = "";
cin >> tmp;
s += tmp[0];
for (long long i = 1; i < tmp.size(); i++)
if (tmp[i] != tmp[i - 1]) s += tmp[i];
n = s.size();
for (long long i = 0; i <= n; i++) {
for (long long j = 0; j < 26; j++) dp[i][j] = 0;
total[i] = 0;
}
nCrModp(N - 1, 1000000007);
for (long long i = 0; i < n; i++) {
long long c = s[i] - 'a';
total[0] -= dp[0][c];
dp[0][c] = 1;
total[0] += dp[0][c];
for (long long j = 1; j < n && total[j - 1]; j++) {
total[j] -= dp[j][c];
if (total[j] < 0) total[j] += 1000000007;
dp[j][c] = total[j - 1] - dp[j - 1][c];
if (dp[j][c] < 0) dp[j][c] += 1000000007;
total[j] = (total[j] + dp[j][c]) % 1000000007;
}
}
long long res = 0;
for (long long i = 0; i < n; i++)
res = (res + (total[i] * comb[i]) % 1000000007) % 1000000007;
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5003;
const int mod = (int)1e9 + 7;
int dp[maxn][26], dps[maxn], un[maxn], c[maxn][maxn];
void norm(int &x) {
if (x < 0) {
x += mod;
} else if (x >= mod) {
x -= mod;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
for (int i = 0; i < maxn; ++i) c[i][0] = 1;
for (int i = 1; i < maxn; ++i) {
for (int j = 1; j < maxn; ++j) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
if (c[i][j] > mod) c[i][j] -= mod;
}
}
string s;
int n, m = 0, ans = 0;
cin >> n >> s;
for (int i = 0; i < n; ++i) {
while (i + 1 != n && s[i] == s[i + 1]) ++i;
un[++m] = s[i] - 'a';
}
dps[0] = 1;
for (int lst = 1; lst <= m; ++lst) {
int ch = un[lst];
for (int len = 1; len <= lst; ++len) {
dps[len] -= dp[len][ch];
dp[len][ch] = dps[len - 1] - dp[len - 1][ch];
norm(dp[len][ch]);
dps[len] += dp[len][ch];
norm(dps[len]);
}
}
for (int len = 1; len <= m; ++len) {
ans = ((signed long long int)ans +
(signed long long int)dps[len] *
(signed long long int)c[n - 1][len - 1]) %
mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MAXN = 5050;
const int MOD = 1e9 + 7;
int C[MAXN][MAXN];
int dp[2][5001][27], n;
int f[2][MAXN];
char str[MAXN];
void upd(int &x, int y) {
x += y;
if (x >= MOD)
x -= MOD;
else if (x < 0)
x += MOD;
}
int main() {
for (int i = (0); i < (MAXN); i++) {
C[i][0] = 1;
for (int j = (1); j < (i + 1); j++) {
C[i][j] = C[i - 1][j];
upd(C[i][j], C[i - 1][j - 1]);
}
}
cin >> n;
cin >> str + 1;
f[0][0] = 1;
int p = 0, q = 1;
int now = 0, nxt = 1;
for (int i = (1); i < (n + 1); i++) {
f[now][0] = 1;
for (int j = (1); j < (i + 1); j++) {
for (int k = (0); k < (26); k++) {
if (k + 'a' == str[i])
dp[p][j][k] = f[now][j - 1], upd(dp[p][j][k], -dp[q][j - 1][k]);
else
dp[p][j][k] = dp[q][j][k];
upd(f[nxt][j], dp[p][j][k]);
}
}
swap(p, q);
swap(nxt, now);
memset(f[nxt], 0, sizeof(int) * n);
}
int ans = 0;
for (int i = (1); i < (n + 1); i++) {
upd(ans, (long long)C[n - 1][i - 1] * f[now][i] % MOD);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[27][5001], c[5001][5001];
int main() {
int n, ans;
string s;
cin >> n >> s;
dp[0][0] = 1;
for (auto c : s) {
int i = c - 'a' + 1;
for (int j = 0; j <= n; j++)
dp[0][j] = (dp[0][j] - dp[i][j] + 1000000007) % 1000000007;
for (int j = 1; j <= n; j++) dp[i][j] = dp[0][j - 1];
for (int j = 0; j <= n; j++) dp[0][j] = (dp[0][j] + dp[i][j]) % 1000000007;
}
c[0][0] = 1;
for (int i = 1; i <= n; i++) {
c[i][0] = 1;
for (int j = 1; j <= i; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % 1000000007;
}
ans = 0;
for (int i = 1; i <= n; i++) {
int ansx = (1ll * dp[0][i] * c[n - 1][i - 1]) % 1000000007;
ans = (ans + ansx) % 1000000007;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long num = 0, neg = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') neg = -1;
c = getchar();
}
while (isdigit(c)) {
num = (num << 3) + (num << 1) + c - '0';
c = getchar();
}
return num * neg;
}
const long long mod = 1e9 + 7;
char str[5010];
long long fac[5010], inv[5010], n;
long long f[30][5010], tot[5010], ans;
long long sum[30][5010];
inline long long qpow(long long x, long long k) {
long long res = 1;
while (k) {
if (k & 1) res = res * x % mod;
x = x * x % mod;
k >>= 1;
}
return res;
}
inline long long C(long long n, long long m) {
if (n == m || m == 0) return 1;
return fac[n] * inv[m] % mod * inv[n - m] % mod;
}
signed main() {
n = read();
scanf("%s", str + 1);
fac[0] = inv[0] = 1;
for (long long i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % mod;
inv[n] = qpow(fac[n], mod - 2);
for (long long i = n - 1; i >= 1; i--) inv[i] = inv[i + 1] * (i + 1) % mod;
tot[0] = 1;
for (long long i = 1; i <= n; i++) {
long long u = str[i] - 'a';
for (long long j = i; j >= 1; j--) {
f[u][j] = ((tot[j - 1] - sum[u][j - 1]) % mod + mod) % mod;
tot[j] = ((tot[j] + f[u][j] - sum[u][j]) % mod + mod) % mod;
sum[u][j] = f[u][j];
}
}
for (long long i = 1; i <= n; i++)
ans = (ans + tot[i] * C(n - 1, i - 1) % mod) % mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long t[20000];
long long binpow(long long a, long long n) {
long long ans = 1;
while (n) {
if (n & 1) ans = ans * a % mod;
a = a * a % mod;
n >>= 1;
}
return ans;
}
long long inv(long long x) { return binpow(x, mod - 2); }
long long c_n_k(long long n, long long k) {
return t[n] * inv(t[k]) % mod * inv(t[n - k]) % mod;
}
const long long maxn = 5005, k = 26;
long long dp[maxn][maxn];
long long cnt[maxn];
long long p[maxn][k];
int main() {
t[0] = 1;
for (long long i = 1; i < 20000; i++) t[i] = i * t[i - 1] % mod;
long long n;
cin >> n;
string s;
cin >> s;
for (long long i = 0; i < k; i++) p[n][i] = n;
for (long long i = n - 1; i >= 0; i--) {
memcpy(p[i], p[i + 1], sizeof(p[i]));
p[i][s[i] - 'a'] = i;
}
for (long long i = 0; i < 26; i++) dp[p[0][i]][1] = 1;
for (long long i = 0; i < n; i++) {
p[i][s[i] - 'a'] = n;
for (long long l = 1; l <= n; l++) {
dp[i][l] %= mod;
if (dp[i][l] == 0) continue;
for (long long j = 0; j < k; j++) dp[p[i][j]][l + 1] += dp[i][l];
cnt[l] = (cnt[l] + dp[i][l]) % mod;
}
}
long long ans = 0;
for (long long l = 1; l <= n; l++) {
long long r = n - l;
ans = (ans + cnt[l] * c_n_k(r + l - 1, r)) % mod;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 7, M = 30 + 7;
const long long MOD = 1e9 + 7;
int n, m, k, t;
int ans[N], _dp[M][N];
int main() {
scanf("%d\n", &n);
char ch[n];
scanf("%s", &ch);
memset(ans, 0, sizeof ans), memset(_dp, 0, sizeof _dp);
for (int i = 1; i <= n; i++) {
int p = 1, idx = ch[i - 1] - 'a';
for (int j = 1; j <= n; j++) {
ans[j] = (ans[j] - _dp[idx][j] + MOD) % MOD;
_dp[idx][j] = p, p = (p + ans[j]) % MOD;
ans[j] = (ans[j] + _dp[idx][j]) % MOD;
}
}
printf("%d", ans[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[5100][5100];
int s[5100];
int comb[5100][5100];
int main() {
int n;
s[0] = 1;
string sir;
cin >> n >> sir;
for (int i(0); i < sir.size(); i++) {
if (i && sir[i] == sir[i - 1]) continue;
char c(sir[i] - 'a');
for (int i(1); i <= n; i++) {
s[i] = (s[i] - dp[i][c] + 1000000007ll) % 1000000007ll;
dp[i][c] = (s[i - 1] - dp[i - 1][c] + 1000000007ll) % 1000000007ll;
s[i] = (s[i] + dp[i][c]) % 1000000007ll;
}
}
for (int i(0); i <= n; i++) comb[i][0] = 1;
for (int i(1); i <= n; i++)
for (int j(1); j <= n; j++)
comb[i][j] = (comb[i - 1][j] + comb[i - 1][j - 1]) % 1000000007ll;
long long ans(0);
for (int i(1); i <= n; i++)
ans = (ans + 1ll * s[i] * comb[n - 1][i - 1]) % 1000000007ll;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 5000 + 15;
const long long MOD = 1e9 + 7;
int dp[MAXN][MAXN] = {0};
int cnk[MAXN][MAXN] = {0};
bool used[MAXN][MAXN] = {false};
long long count(int n, int k) {
if (k == 0 || n == k) {
return 1;
}
if (used[n][k]) return cnk[n][k];
used[n][k] = true;
long long a = count(n - 1, k - 1);
long long b = count(n - 1, k);
long long c = (a + b + MOD) % MOD;
cnk[n][k] = (int)c;
return cnk[n][k];
}
int main() {
int n = 0;
std::cin >> n;
std::string s;
std::cin >> s;
int dpSum[MAXN] = {0};
for (int i = 0; i < n; i++) {
int sym = s[i] - 'a';
if (!dp[sym][1]) {
dpSum[1] = (1ll + dpSum[1] + MOD) % MOD;
dp[sym][1] = 1;
}
for (int l = i + 1; l >= 2; l--) {
long long tmp = dp[sym][l];
dp[sym][l] = (0ll + dpSum[l - 1] - dp[sym][l - 1] + MOD) % MOD;
dpSum[l] = (0ll + dpSum[l] + dp[sym][l] - tmp) % MOD;
}
}
long long ans = 0;
for (int l = 1; l <= n; l++) {
long long sum = 0;
for (int j = 0; j <= 25; j++) {
sum = (sum + dp[j][l]) % MOD;
}
if (sum) {
ans = (ans + sum * count(n - 1, l - 1)) % MOD;
}
}
std::cout << ans << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<string, long long int> mark;
void EE(long long int a, long long int b, long long int& x, long long int& y) {
if (a % b == 0) {
x = 0;
y = 1;
return;
}
EE(b, a % b, x, y);
long long int temp = x;
x = y;
y = temp - y * (a / b);
}
long long int inverse(long long int a, long long int m) {
long long int x, y;
EE(a, m, x, y);
if (x < 0) x += m;
return x;
}
int inv[200000], fact[200000], dp[30][6000];
string c;
char s[200000];
int main() {
long long int n;
string s;
fact[0] = 1;
inv[0] = 1;
for (int i = 1; i < 200000; i++) {
fact[i] = ((long long int)fact[i - 1] * (long long int)i) % 1000000007;
inv[i] =
((long long int)inverse(i, 1000000007) * (long long int)inv[i - 1]) %
1000000007;
}
cin >> n;
int total = n;
cin >> s;
int f = 0;
c.push_back(s[0]);
for (int i = 1; i < n; i++) {
if (s[i] != s[i - 1]) {
c.push_back(s[i]);
}
}
n = c.size();
for (int i = (n - 1); i >= 0; i--) {
int upd = (c[i] - 'a');
dp[upd][1] = 1;
for (int j = 2; j <= (n - i); j++) {
int val = 0;
for (int k = 0; k < 26; k++) {
if (k != upd) val = (val + dp[k][j - 1]) % 1000000007;
}
dp[upd][j] = val;
}
}
int ans = 0;
for (int i = 0; i < 26; i++) {
for (int j = 1; j <= n; j++) {
int x = (total - j);
int r = j;
int val = ((long long int)fact[x + r - 1] * (long long int)inv[r - 1]) %
1000000007;
val = ((long long int)val * (long long int)inv[x]) % 1000000007;
val = ((long long int)val * (long long int)dp[i][j]) % 1000000007;
ans = (ans + val) % 1000000007;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T BM(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T mdINV(T a, T M) {
return BM(a, M - 2, M);
}
template <class T>
inline T PW(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
template <class T>
string NTS(T Number) {
stringstream ss;
ss << Number;
return ss.str();
}
template <class T>
T stringtonumber(const string &Text) {
istringstream ss(Text);
T result;
return ss >> result ? result : 0;
}
template <class T>
bool ISLEFT(T a, T b, T c) {
if (((a.first.first - b.first.first) * (b.second.second - c.second.second) -
(b.first.first - c.first.first) * (a.second.second - b.second.second)) <
0.0)
return 1;
else
return 0;
}
char a[5005];
int n;
int dp[5005][5005];
int ind[5005ll][27];
int go(int in, int last) {
if (in > n) {
return 1;
}
int &ret = dp[in][last];
if (ret != -1) return ret;
ret = 0;
for (int j = 1; j <= 26; j++) {
if (ind[last][j] <= n) {
ret += go(in + 1, ind[last][j]);
if (ret >= 1000000007) ret -= 1000000007;
}
}
return ret;
}
int main() {
scanf("%d", &n);
scanf("%s", a + 1);
for (int i = 1; i <= 26; i++) ind[n + 1][i] = n + 1;
for (int i = n; i >= 1; i--) {
for (int j = 1; j <= 26; j++) ind[i][j] = ind[i + 1][j];
int first = a[i] - 'a' + 1;
ind[i][first] = i;
}
dp[0][1] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= 26; k++) {
if (ind[j][k] <= n) {
dp[i][ind[j][k]] += dp[i - 1][j];
if (dp[i][ind[j][k]] >= 1000000007) dp[i][ind[j][k]] -= 1000000007;
}
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++) {
ans += dp[n][i];
if (ans >= 1000000007) ans -= 1000000007;
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcdex(long long a, long long b, long long &x, long long &y) {
if (a == 0) {
x = 0;
y = 1;
return b;
}
long long x1, y1;
long long d = gcdex(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
long long inverse(int a, int m) {
long long x, y;
long long g = gcdex(a, m, x, y);
return (x % m + m) % m;
}
int main() {
long long mod = 1e9 + 7;
int N = 5010;
long long fak[N];
fak[0] = 1;
for (int i = 1; i < N; i++) fak[i] = (fak[i - 1] * i) % mod;
int n;
cin >> n;
string s;
cin >> s;
long long p[n][n + 1];
long long sum[n + 1];
for (int j = 1; j <= n; j++) sum[j] = 0;
int last[26];
for (int j = 0; j < 26; j++) last[j] = -1;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= n; j++) p[i][j] = 0;
p[i][1] = 1;
for (int j = 1; j < n; j++) {
p[i][j + 1] = sum[j];
if (last[s[i] - 'a'] != -1)
p[i][j + 1] = (p[i][j + 1] - p[last[s[i] - 'a']][j] + mod) % mod;
}
for (int j = 1; j <= n; j++) {
sum[j] = (sum[j] + p[i][j]) % mod;
if (last[s[i] - 'a'] != -1)
sum[j] = (sum[j] - p[last[s[i] - 'a']][j] + mod) % mod;
}
last[s[i] - 'a'] = i;
}
long long res = 0;
for (int k = 1; k <= n; k++) {
long long add = (fak[n - 1] * inverse(fak[k - 1], mod)) % mod;
add = (add * inverse(fak[n - k], mod)) % mod;
res = (res + add * sum[k]) % mod;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using vi = vector<int>;
using pii = pair<int, int>;
using vpii = vector<pair<int, int>>;
using vll = vector<LL>;
using LD = long double;
template <typename T>
void check(T& a, const T& b) {
if (a >= b) {
a %= b;
}
}
template <typename T>
T gcd(T u, T v) {
if (u == v) return u;
if (u == 0) return v;
if (v == 0) return u;
if (~u & 1) {
if (v & 1)
return gcd(u >> 1, v);
else
return gcd(u >> 1, v >> 1) << 1;
}
if (~v & 1) return gcd(u, v >> 1);
if (u > v) return gcd((u - v) >> 1, v);
return gcd((v - u) >> 1, u);
}
LL mulmod(LL a, LL b, const LL& m) {
LL q = (LL)(((LD)a * (LD)b) / (LD)m);
LL r = a * b - q * m;
if (r > m) r %= m;
if (r < 0) r += m;
return r;
}
template <typename T, typename S>
T expo(T e, S n) {
T x = 1, p = e;
while (n) {
if (n & 1) x = x * p;
p = p * p;
n >>= 1;
}
return x;
}
template <typename T>
T powerL(T e, T n, const T& m) {
T x = 1, p = e;
while (n) {
if (n & 1) x = mulmod(x, p, m);
p = mulmod(p, p, m);
n >>= 1;
}
return x;
}
const LL MOD = (int)1e9 + 7;
LL ncr[5001][5001], dp[27][5001], sum[5001];
void pre() {
ncr[0][0] = 1;
for (int i = 1; i <= 5000; i++) {
ncr[i][0] = ncr[i][i] = 1;
for (int j = 1; j < i; j++) {
ncr[i][j] = ncr[i - 1][j - 1] + ncr[i - 1][j];
check(ncr[i][j], MOD);
}
}
}
string conv(string& s) {
string temp = "";
int n = (int)s.size();
for (int i = 0; i < n; i++) {
if (i < n - 1 && s[i] == s[i + 1]) continue;
temp += s[i];
}
return temp;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cerr.tie(NULL);
;
pre();
string s;
int n;
cin >> n >> s;
s = conv(s);
int n1 = (int)s.size();
sum[0] = 1;
for (int i = 0; i < n1; i++) {
char c = s[i] - 'a';
for (int j = 1; j <= n1; j++) {
sum[j] = (sum[j] - dp[c][j] + MOD);
check(sum[j], MOD);
sum[j] = sum[j] + (sum[j - 1] - dp[c][j - 1] + MOD);
check(sum[j], MOD);
dp[c][j] = sum[j - 1] - dp[c][j - 1] + MOD;
check(dp[c][j], MOD);
}
}
LL ans = 0;
for (int i = 1; i <= n; i++) {
ans = ans + (1LL * (sum[i]) * 1LL * (ncr[n - 1][i - 1])) % MOD;
check(ans, MOD);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int ara[5005], after[5005], seen[30];
long long dp[2][5005];
int ncr[5005][5005];
long long BinomialCoefficient(int nn, int rr) {
int &ret = ncr[nn][rr];
if (ret != -1) return ret;
if (rr == 0 || rr == nn) return ret = 1;
return ret = (0LL + BinomialCoefficient(nn - 1, rr - 1) +
BinomialCoefficient(nn - 1, rr)) %
1000000007;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
cin >> s;
char bef = '#';
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == bef) continue;
ara[cnt++] = s[i] - 'a';
bef = s[i];
}
for (int i = 0; i < 30; i++) seen[i] = cnt;
memset(ncr, -1, sizeof(ncr));
int cur = 0;
for (int i = cnt - 1; i >= 0; i--) {
after[i] = seen[ara[i]];
dp[cur][i] = dp[cur][i + 1];
dp[cur][i] += (after[i] == cnt) ? 1 : 0;
seen[ara[i]] = i;
}
long long ans = dp[0][0];
for (int i = 1; i < cnt; i++) {
for (int j = 0; j <= cnt; j++) dp[cur ^ 1][j] = 0;
for (int j = cnt - i - 1; j >= 0; j--) {
dp[cur ^ 1][j] =
(dp[cur][j + 1] - dp[cur][after[j]] + 1000000007) % 1000000007;
dp[cur ^ 1][j] = (dp[cur ^ 1][j + 1] + dp[cur ^ 1][j]) % 1000000007;
}
cur ^= 1;
long long tmp =
(1LL * dp[cur][0] * BinomialCoefficient(n - 1, i)) % 1000000007;
ans = (ans + tmp) % 1000000007;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5003;
const int mod = (int)1e9 + 7;
int dp[maxn][26], dps[maxn], un[maxn], c[maxn][maxn], f[maxn], rf[maxn];
void norm(int &x) {
if (x < 0) {
x += mod;
} else if (x >= mod) {
x -= mod;
}
}
int bpow(int x, int p) {
int res = 1;
while (p) {
if (p & 1)
res = ((signed long long int)res * (signed long long int)x) % mod;
x = ((signed long long int)x * (signed long long int)x) % mod;
p >>= 1;
}
return res;
}
inline int comb(int n, int k) {
return ((((signed long long int)f[n] * (signed long long int)rf[k]) % mod) *
(signed long long int)rf[n - k]) %
mod;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
f[0] = f[1] = rf[0] = rf[1] = 1;
for (int i = 2; i < maxn; ++i) {
f[i] = ((signed long long int)f[i - 1] * (signed long long int)i) % mod;
rf[i] = bpow(f[i], mod - 2);
}
string s;
int n, m = 0, ans = 0;
cin >> n >> s;
for (int i = 0; i < n; ++i) {
while (i + 1 != n && s[i] == s[i + 1]) ++i;
un[++m] = s[i] - 'a';
}
dps[0] = 1;
for (int lst = 1; lst <= m; ++lst) {
int ch = un[lst];
for (int len = 1; len <= lst; ++len) {
dps[len] -= dp[len][ch];
dp[len][ch] = dps[len - 1] - dp[len - 1][ch];
norm(dp[len][ch]);
dps[len] += dp[len][ch];
norm(dps[len]);
}
}
for (int len = 1; len <= m; ++len) {
ans = ((signed long long int)ans +
(signed long long int)dps[len] *
(signed long long int)comb(n - 1, len - 1)) %
mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5003;
const int mod = (int)1e9 + 7;
int dp[maxn][26], dps[maxn], un[maxn], c[maxn][maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
for (int i = 0; i < maxn; ++i) c[i][0] = 1;
for (int i = 1; i < maxn; ++i) {
for (int j = 1; j < maxn; ++j) {
c[i][j] = c[i - 1][j] + c[i - 1][j - 1];
if (c[i][j] > mod) c[i][j] -= mod;
}
}
int n;
cin >> n;
string s;
cin >> s;
int m = 0;
for (int i = 0; i < n; ++i) {
while (i + 1 != n && s[i] == s[i + 1]) ++i;
un[++m] = s[i] - 'a';
}
for (int lst = 1; lst <= m; ++lst) {
int ch = un[lst];
dp[1][ch] = 1;
for (int len = 2; len <= lst; ++len) {
dp[len][ch] = 0;
for (int k = 0; k < 26; ++k) {
if (k != ch) {
dp[len][ch] += dp[len - 1][k];
if (dp[len][ch] > mod) dp[len][ch] -= mod;
}
}
}
}
int ans = 0;
for (int len = 1; len <= m; ++len) {
int sum = 0;
for (int k = 0; k < 26; ++k) {
sum += dp[len][k];
if (sum > mod) sum -= mod;
}
ans =
((signed long long int)ans +
(signed long long int)sum * (signed long long int)c[n - 1][len - 1]) %
mod;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 5000 + 15;
const long long MOD = 1e9 + 7;
int dp[MAXN][MAXN] = {0};
int cnk[MAXN][MAXN] = {0};
bool used[MAXN][MAXN] = {false};
long long count(int n, int k) {
if (k == 0 || n == k) {
return 1;
}
if (used[n][k]) return cnk[n][k];
used[n][k] = true;
long long a = count(n - 1, k - 1);
long long b = count(n - 1, k);
long long c = (a + b + MOD) % MOD;
cnk[n][k] = (int)c;
return cnk[n][k];
}
int main() {
int n = 0;
std::cin >> n;
std::string s;
std::cin >> s;
for (int i = 0; i < n; i++) {
int sym = s[i] - 'a';
dp[sym][1] = 1;
for (int l = 2; l <= i + 1; l++) {
dp[sym][l] = 0;
for (int j = 0; j <= 25; j++) {
if (sym != j && dp[j][l - 1]) {
dp[sym][l] = (dp[sym][l] + dp[j][l - 1]) % MOD;
}
}
}
}
long long ans = 0;
for (int l = 1; l <= n; l++) {
long long sum = 0;
for (int j = 0; j <= 25; j++) {
sum = (sum + dp[j][l]) % MOD;
}
if (sum) {
ans = (ans + sum * count(n - 1, l - 1)) % MOD;
}
}
std::cout << ans << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
const int MAXN = 5555;
const int MOD = 1000000007;
int fact[MAXN], rev[MAXN];
int dp[33][MAXN];
int sum[MAXN];
int N;
std::string str;
ll power(ll x, ll y, ll m) {
if (y == 0) return 1;
ll p = power(x, y / 2, m) % m;
p = (p * p) % m;
return (y % 2 == 0) ? p : (x * p) % m;
}
ll inv_mod(ll a, ll m) { return power(a, m - 2, m); }
int choose(int a, int b) {
int ret = fact[a];
ret = ((ll)ret * rev[b]) % MOD;
ret = ((ll)ret * rev[a - b]) % MOD;
return ret;
}
void solve() {
for (int x = 0; x < str.size(); ++x) {
int cur = str[x] - 'a';
dp[cur][1] = 1;
for (int l = 2; l <= str.size(); ++l) {
dp[cur][l] = 0;
for (int j = 0; j < 26; ++j) {
if (j == cur) continue;
dp[cur][l] = (dp[cur][l] + dp[j][l - 1]) % MOD;
}
}
}
}
void optimized() {
sum[0] = 1;
for (int x = 0; x < str.size(); ++x) {
int cur = str[x] - 'a';
for (int l = str.size(); l >= 0; --l) {
sum[l + 1] = (sum[l + 1] - dp[cur][l + 1] + MOD) % MOD;
dp[cur][l + 1] = (sum[l] - dp[cur][l] + MOD) % MOD;
sum[l + 1] = (sum[l + 1] + dp[cur][l + 1]) % MOD;
}
}
}
int main() {
fact[0] = 1;
rev[0] = inv_mod(fact[0], MOD);
for (int i = 1; i < MAXN; ++i) {
fact[i] = ((ll)fact[i - 1] * i) % MOD;
rev[i] = inv_mod(fact[i], MOD);
}
std::ios_base::sync_with_stdio(false);
std::cin >> N;
std::cin >> str;
str.erase(std::unique(str.begin(), str.end()), str.end());
optimized();
ll ret = 0;
for (int l = 1; l <= str.size(); ++l) {
for (int i = 0; i < 26; ++i) {
ret = (ret + (ll)dp[i][l] * choose(N - 1, l - 1)) % MOD;
}
}
std::cout << ret << std::endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[114514] = {1, 0, 0, 0, 1, 0, 1, 0, 2, 1, 1, 2, 0, 1, 0, 0};
int main() {
int n, m = 0;
scanf("%d", &n);
if (n == 0) m = 1;
while (n != 0) m += s[n % 16], n /= 16;
printf("%d", m);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.