text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
bool debug = 1;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
int x[30];
long long ps[100005], ans;
char s[100005];
map<long long, int> mp[30];
int main() {
for (int(j) = 0; (j) < (int)(26); (j)++) scanf("%d", x + j);
scanf("%s", s + 1);
n = strlen(s + 1);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
int j = s[i] - 'a';
ps[i] = ps[i - 1] + x[j];
if (mp[j].find(ps[i - 1]) != mp[j].end()) ans += mp[j][ps[i - 1]];
mp[j][ps[i]]++;
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void reader(int *x) {
int k, m = 0;
*x = 0;
for (;;) {
(k) = getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
*x = k - '0';
break;
}
}
for (;;) {
(k) = getchar();
if (k < '0' || k > '9') break;
*x = (*x) * 10 + k - '0';
}
if (m) (*x) = -(*x);
}
void reader(long long *x) {
int k, m = 0;
*x = 0;
for (;;) {
(k) = getchar();
if (k == '-') {
m = 1;
break;
}
if ('0' <= k && k <= '9') {
*x = k - '0';
break;
}
}
for (;;) {
(k) = getchar();
if (k < '0' || k > '9') break;
*x = (*x) * 10 + k - '0';
}
if (m) (*x) = -(*x);
}
void reader(double *x) { scanf("%lf", x); }
int reader(char c[]) {
int i, s = 0;
for (;;) {
(i) = getchar();
if (i != ' ' && i != '\n' && i != '\r' && i != '\t' && i != EOF) break;
}
c[s++] = i;
for (;;) {
(i) = getchar();
if (i == ' ' || i == '\n' || i == '\r' || i == '\t' || i == EOF) break;
c[s++] = i;
}
c[s] = '\0';
return s;
}
template <class T, class S>
void reader(T *x, S *y) {
reader(x);
reader(y);
}
template <class T, class S, class U>
void reader(T *x, S *y, U *z) {
reader(x);
reader(y);
reader(z);
}
template <class T, class S, class U, class V>
void reader(T *x, S *y, U *z, V *w) {
reader(x);
reader(y);
reader(z);
reader(w);
}
void writer(int x, char c) {
int s = 0, m = 0;
char f[10];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar('-');
while (s--) putchar(f[s] + '0');
putchar(c);
}
void writer(long long x, char c) {
int s = 0, m = 0;
char f[20];
if (x < 0) m = 1, x = -x;
while (x) f[s++] = x % 10, x /= 10;
if (!s) f[s++] = 0;
if (m) putchar('-');
while (s--) putchar(f[s] + '0');
putchar(c);
}
void writer(double x, char c) {
printf("%.15f", x);
putchar(c);
}
void writer(const char c[]) {
int i;
for (i = 0; c[i] != '\0'; i++) putchar(c[i]);
}
void writer(const char x[], char c) {
int i;
for (i = 0; x[i] != '\0'; i++) putchar(x[i]);
putchar(c);
}
template <class T>
void writerLn(T x) {
writer(x, '\n');
}
template <class T, class S>
void writerLn(T x, S y) {
writer(x, ' ');
writer(y, '\n');
}
template <class T, class S, class U>
void writerLn(T x, S y, U z) {
writer(x, ' ');
writer(y, ' ');
writer(z, '\n');
}
template <class T>
void writerArr(T x[], int n) {
int i;
if (!n) {
putchar('\n');
return;
}
for (i = 0; i < n - 1; i++) writer(x[i], ' ');
writer(x[n - 1], '\n');
}
char memarr[17000000];
void *mem = memarr;
template <class T>
struct ullHash {
unsigned long long *key;
T *val;
unsigned memory, size, mask;
void clear() { memset(val, 0, size * sizeof(T)); }
void clear(int sz) {
size = 1;
while (size < sz) size *= 2;
mask = size - 1;
clear();
}
void init(int mem, int sz) {
memory = mem;
size = 1;
while (size < sz) size *= 2;
mask = size - 1;
if (memory < size) memory = size;
key = (unsigned long long *)malloc(memory * sizeof(unsigned long long));
val = (T *)malloc(memory * sizeof(T));
if (size) clear();
}
int function(unsigned long long a) {
return (a * 97531 + a / 65536 * 76321) & mask;
}
T get(unsigned long long a) {
int i = function(a);
for (; key[i] != a && val[i] != 0;) i = (i + 1) & mask;
if (key[i] != a) return 0;
return val[i];
}
void set(unsigned long long a, T v) {
int i = function(a);
for (; key[i] != a && val[i] != 0;) i = (i + 1) & mask;
key[i] = a;
val[i] = v;
}
T increase(unsigned long long a, T v = 1) {
int i = function(a);
for (; key[i] != a && val[i] != 0;) i = (i + 1) & mask;
key[i] = a;
return val[i] += v;
}
};
int N;
int X[26];
long long sum[110000];
char S[110000];
int main() {
int i, j, k;
long long res = 0;
ullHash<int> hs;
for (i = 0; i < 26; i++) reader(X + i);
N = reader(S);
sum[0] = 0;
for (i = 0; i < N; i++) sum[i + 1] = sum[i] + X[S[i] - 'a'];
hs.init(150000, 150000);
for (k = 0; k < 26; k++) {
hs.clear(150000);
for (i = 0; i < N; i++)
if (S[i] == 'a' + k) {
res += hs.get(sum[i] - X[k]);
hs.increase(sum[i]);
}
}
writerLn(res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
long long int arr[26];
map<long long int, long long int> mp[26];
long long int ans = 0, tmp = 0;
string s;
for (size_t i = 0; i < 26; ++i) cin >> arr[i];
cin >> s;
for (size_t i = 0; i < s.size(); ++i) {
ans += mp[s[i] - 'a'][tmp];
tmp += arr[s[i] - 'a'];
mp[s[i] - 'a'][tmp]++;
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mi2 = 500000004;
const long long mi3 = 333333336;
const long long MOD = 1000000007;
int xcod[4] = {-1, 0, 1, 0};
int ycod[4] = {0, 1, 0, -1};
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
struct HASH {
size_t operator()(const pair<long long, long long>& x) const {
return hash<long long>()(((long long)x.first) ^
(((long long)x.second) << 32));
}
};
long long powermod(long long x, long long n, long long M) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
vector<long long> readll() {
cin >> ws;
vector<long long> v;
string input;
getline(cin, input);
cout << input;
istringstream is(input);
long long num;
while (is >> num) v.push_back(num);
return v;
}
long long modinv(long long n, long long p) { return powermod(n, p - 2, p); }
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long fact[1000005], invf[1000005];
void facmod(long long n, long long M) {
long long i;
fact[0] = fact[1] = 1;
for (i = 2; i <= n; ++i) {
fact[i] = ((fact[i - 1]) % M * (i % M)) % M;
}
invf[n] = modinv(fact[n], M);
for (i = n - 1; i >= 0; --i) {
invf[i] = invf[i + 1] * (i + 1);
invf[i] %= M;
}
}
void solve() {
long long i, n;
long long happiness[30];
for (i = 0; i < 26; ++i) cin >> happiness[i];
string s;
cin >> s;
n = s.size();
unordered_map<pair<long long, long long>, long long, HASH> mpt;
long long sm = 0, ans = 0;
for (i = 0; i < n; ++i) {
ans += mpt[{sm, s[i] - 'a'}];
sm += happiness[s[i] - 'a'];
mpt[{sm, s[i] - 'a'}]++;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 26;
int main() {
vector<int> vec(N);
for (int i = 0; i < N; i++) {
cin >> vec[i];
}
string str;
cin >> str;
long long cnt = 0, tmp = 0;
map<long long, long long> m[N];
for (int i = 0; i < (int)str.size(); i++) {
int chr = str[i] - 'a';
cnt += m[chr][tmp];
tmp += vec[chr];
m[chr][tmp]++;
}
cout << cnt << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> m[26];
long long sum[100005];
int main() {
long long a[26], i, ans = 0;
char c[100005];
for (i = 0; i < 26; i++) cin >> a[i];
cin >> c;
sum[0] = a[c[0] - 'a'];
m[c[0] - 'a'][sum[0]] += 1;
for (i = 1; i < strlen(c); i++) {
sum[i] = sum[i - 1] + a[c[i] - 'a'];
m[c[i] - 'a'][sum[i]] += 1;
ans += m[c[i] - 'a'][sum[i - 1]];
if (sum[i] == sum[i - 1]) ans--;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long s[300000];
char str[300000];
struct node {
char c;
long long cnt;
long long s;
} tem;
int get_hash(long long s) {
if (s < 0) s *= -7;
return s % 100007;
}
vector<struct node> vec[100007];
void insert(long long &s, char c) {
int hash, len, i;
hash = get_hash(s);
len = vec[hash].size();
for (i = 0; i < len; i++) {
if (vec[hash][i].c == c && vec[hash][i].s == s) {
vec[hash][i].cnt++;
break;
}
}
if (i == len) {
tem.cnt = 1;
tem.c = c;
tem.s = s;
vec[hash].push_back(tem);
}
}
long long find(long long s, char c) {
int hash, len, i;
hash = get_hash(s);
len = vec[hash].size();
for (i = 0; i < len; i++) {
if (vec[hash][i].c == c && vec[hash][i].s == s) {
return vec[hash][i].cnt;
}
}
return 0;
}
int main() {
int i, j, k, n, m, len;
long long sum, cnt;
int a[30];
while (scanf("%d", &a[0]) != EOF) {
sum = 0;
for (i = 0; i < 100007; i++) vec[i].clear();
for (i = 1; i < 26; i++) {
scanf("%d", &a[i]);
}
scanf("%s", str);
len = strlen(str);
s[0] = a[str[0] - 'a'];
insert(s[0], str[0]);
for (i = 1; i < len; i++) {
s[i] = s[i - 1] + a[str[i] - 'a'];
cnt = find(s[i - 1], str[i]);
sum += cnt;
insert(s[i], str[i]);
}
printf("%I64d\n", sum);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100010;
int alpha[26];
vector<int> idx[26];
long long cs[MAXN];
long long ans;
char s[MAXN];
long long get(int l, int r) { return cs[r - 1] - cs[l]; }
int main() {
for (int i = 0; i < 26; i++) scanf("%d", &alpha[i]);
scanf("%s", s);
int n = strlen(s);
for (int i = 1; i <= n; i++) cs[i] = cs[i - 1] + alpha[s[i - 1] - 'a'];
for (int i = 0; i < n; i++) idx[s[i] - 'a'].push_back(i + 1);
for (int i = 0; i < 26; i++) {
map<long long, int> poj;
for (int j = 0; j < idx[i].size(); j++) {
long long cur = cs[idx[i][j]];
long long match = cs[idx[i][j] - 1];
ans += 1ll * poj[match];
poj[cur]++;
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class P, class Q>
inline void smin(P &a, Q b) {
if (b < a) a = b;
}
template <class P, class Q>
inline void smax(P &a, Q b) {
if (a < b) a = b;
}
const int maxn = 100000 + 100;
int n;
string s;
int val[26];
long long p[maxn];
map<long long, int> m[26];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
for (int i = 0, _n = (int)(26); i < _n; i++) cin >> val[i];
cin >> s;
n = (int((s).size()));
for (int i = 0, _n = (int)(n); i < _n; i++) p[i + 1] = p[i] + val[s[i] - 'a'];
long long ans = 0;
for (int i = 0, _n = (int)(n); i < _n; i++) {
ans += m[s[i] - 'a'][p[i]];
m[s[i] - 'a'][p[i + 1]]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cst[33];
char s[100011];
int n;
long long pre[100011];
map<long long, int> H;
long long MAXS = 10000000000ll;
long long ans = 0;
int main() {
for (int i = 0; i < 26; i++) scanf("%d", &cst[i]);
scanf("%s", s + 1);
n = strlen(s + 1);
pre[0] = 0;
for (int i = 1; i <= n; i++) pre[i] = pre[i - 1] + cst[s[i] - 'a'];
for (int i = 'a'; i <= 'z'; i++) {
H.clear();
for (int j = 1; j <= n; j++) {
if (s[j] == i) {
H[pre[j - 1] + MAXS]++;
}
}
for (int j = 1; j <= n; j++) {
if (s[j] == i) {
H[pre[j - 1] + MAXS]--;
ans += H[pre[j] + MAXS];
}
}
}
printf("%I64d", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int a[30];
char s[100005];
long long cnt[100005];
map<long long, long long> mp[26];
int main() {
long long ans = 0, tmp = 0;
for (int i = 0; i < 26; i++) scanf("%d", &a[i]);
scanf("%s", s + 1);
for (int i = 1; s[i]; i++) cnt[i] += cnt[i - 1] + a[s[i] - 'a'];
for (int i = 1; s[i]; i++) {
ans += mp[s[i] - 'a'][cnt[i - 1]];
mp[s[i] - 'a'][cnt[i]]++;
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
long long t, d, ct, q, ans, l, m, r, n, mx, mn, i, j, k, x, y, z, s;
char ch;
string ss = "", str = "";
long long a[200003], b[200003];
long long pref[200003];
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr);
s = k = d = l = mx = m = mn = r = q = i = j = z = x = y = ct = ans = 0;
for (i = 0; i < 26; i++) cin >> a[i];
cin >> ss;
n = ss.length();
pref[1] = a[ss[0] - 'a'];
for (i = 1; i < n; i++) pref[i + 1] = pref[i] + a[ss[i] - 'a'];
vector<long long> v[26];
for (i = 0; i < n; i++) v[ss[i] - 'a'].push_back(i + 1);
for (i = 0; i < 26; i++) {
m = v[i].size();
if (m <= 1) continue;
y = 0;
vector<long long> diff;
for (auto h : v[i]) diff.push_back(pref[h - 1]);
map<long long, long long> mp;
for (j = 0; j < diff.size(); j++) {
ans += mp[diff[j] - a[i]];
mp[diff[j]]++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> m[26];
long long int sum[100001], num[26], ans, a;
string s;
int main() {
for (int i = 0; i < 26; i++) cin >> num[i];
cin >> s;
for (int i = 0; i < s.size(); i++) {
a = s[i] - 'a';
sum[i] = num[a];
if (i) sum[i] += sum[i - 1];
ans += m[a][sum[i] - num[a]];
m[a][sum[i]]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
void TestCase() {
vector<long long int> x(26);
for (int i = 0; i < 26; i++) cin >> x[i];
string s;
cin >> s;
long long int ans = 0, n = s.length();
vector<long long int> pref(n + 1);
pref[0] = x[s[0] - 'a'];
for (int i = 1; i < n; i++) pref[i] = pref[i - 1] + x[s[i] - 'a'];
map<pair<char, long long int>, int> m;
m.insert({{s[0], pref[0]}, 1});
for (int i = 1; i < n; i++) {
if (m.find({s[i], pref[i] - (x[s[i] - 'a'])}) != m.end()) {
ans += m[{s[i], pref[i] - (x[s[i] - 'a'])}];
}
m[{s[i], pref[i]}]++;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int T = 1;
while (T--) {
TestCase();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 100005;
long long i, n, s, cost[30];
long long sol;
char a[nmax];
unordered_map<long long, long long> M[30];
int main() {
cin.sync_with_stdio(false);
for (i = 0; i < 26; i++) cin >> cost[i];
cin >> a + 1;
n = strlen(a + 1);
for (i = 1; i <= n; i++) {
sol += M[a[i] - 'a'][s];
s += cost[a[i] - 'a'];
M[a[i] - 'a'][s]++;
}
cout << sol;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
std::string values;
std::getline(std::cin, values);
std::stringstream stream(values);
std::array<int, 26> alph;
for (auto i = 0u; i < 26; ++i) stream >> alph[i];
std::string s;
std::getline(std::cin, s);
std::vector<long long> part_sum(s.size());
std::array<std::vector<int>, 26> pos;
for (auto i = 0u; i < s.size(); ++i) {
if (!i)
part_sum[0] = alph[s[0] - 'a'];
else
part_sum[i] = part_sum[i - 1] + alph[s[i] - 'a'];
pos[s[i] - 'a'].push_back(i);
}
long long total = 0;
for (auto i = 0; i < 26; ++i) {
std::unordered_map<long long, int> m;
for (auto j = 0u; j < pos[i].size(); ++j) {
if (m.count(part_sum[pos[i][j]] - alph[i]))
total += m.find(part_sum[pos[i][j]] - alph[i])->second;
if (m.count(part_sum[pos[i][j]]))
++m.find(part_sum[pos[i][j]])->second;
else
m.emplace(part_sum[pos[i][j]], 1);
}
}
std::cout << total;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[26];
char s[100001];
long long sum[100001];
int main() {
map<long long, long long> M[26];
for (int i = 0; i < 26; i++) scanf("%d", &a[i]);
scanf("%s", s + 1);
int len = strlen(s + 1);
sum[0] = 0;
for (int i = 1; i <= len; i++) sum[i] = sum[i - 1] + a[s[i] - 'a'];
long long ans = 0;
for (int i = 1; i <= len; i++) {
int k = s[i] - 'a';
long long l = sum[i];
if (i > 1) l -= a[k];
ans += M[k][l];
M[k][sum[i]]++;
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1.0);
const int MOD = 1000 * 1000 * 1000 + 7;
const int INF = 2000 * 1000 * 1000;
const int MAXN = 100010;
template <typename T>
inline T sqr(T n) {
return n * n;
}
int cnt[26];
vector<int> pos[MAXN];
char s[MAXN];
int n;
long long sum[MAXN], ans;
int main() {
for (int i = 0; i < 26; i++) {
scanf("%d", &cnt[i]);
}
getchar();
gets(s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
sum[i] = cnt[s[i] - 'a'];
sum[i] += sum[i - 1];
pos[s[i] - 'a'].push_back(i);
}
for (int cc = 0; cc < 26; cc++) {
map<long long, int> Map;
for (size_t i = 0; i < pos[cc].size(); i++) {
int p = pos[cc][i];
ans += Map[sum[p - 1]];
Map[sum[p]]++;
}
Map.clear();
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int val[26];
for (int i = 0; i < 26; i++) cin >> val[i];
string s;
cin >> s;
map<long long, int> maa;
long long sum = 0;
long long ans = 0;
for (int i = 0; i < 26; i++) {
maa.clear();
sum = 0;
for (int j = 0; j < s.size(); j++) {
if (j && s[j - 1] - 'a' == i) {
maa[sum]++;
}
if (s[j] - 'a' == i) {
ans += maa[sum];
}
sum += val[s[j] - 'a'];
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> pos[100000];
long long sum[100000];
long long ans;
int cnt[26];
int main() {
for (int i = 0; i < 26; i++) {
scanf("%d", &cnt[i]);
}
string s;
cin >> s;
int n = s.size();
for (int i = 0; i < n; i++) {
sum[i] = cnt[s[i] - 'a'];
sum[i] += sum[i - 1];
pos[s[i] - 'a'].push_back(i);
}
for (int i = 0; i < 26; i++) {
map<long long, int> Map;
for (int k = 0; k < pos[i].size(); k++) {
int p = pos[i][k];
ans += Map[sum[p - 1]];
Map[sum[p]]++;
}
Map.clear();
}
printf("%I64d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
int n;
long long int val[30], presum[maxn];
char str[maxn];
map<long long int, int> G[30];
int main() {
for (int i = 0; i < 26; i++) cin >> val[i];
cin >> str;
n = strlen(str);
for (int i = 0; i < n; i++) {
if (i == 0)
presum[0] = val[str[i] - 'a'];
else
presum[i] = presum[i - 1] + val[str[i] - 'a'];
}
long long int ans = 0;
G[str[0] - 'a'][val[str[0] - 'a']]++;
for (int i = 1; i < n; i++) {
int c = str[i] - 'a';
long long int pn = presum[i - 1];
long long int pr = presum[i];
ans += G[c][pn];
G[c][pr]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long Pw(long long int b, long long int p) {
if (!p) return 1;
long long int sq = Pw(b, p / 2);
sq *= sq;
if (p % 2) sq *= b;
return sq;
}
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long sd(long long x) { return x < 10 ? x : x % 10 + sd(x / 10); }
long long lcm(long long a, long long b) { return ((a * b) / gcd(a, b)); }
vector<long long> get_divisors(long long n) {
vector<long long> arr;
long long i = 1;
for (i; i * i <= n; i++) {
if (n % i == 0) {
arr.push_back(i);
if (i * i != n) arr.push_back(n / i);
}
}
return arr;
}
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int p[200500];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
map<pair<char, long long>, long long> mp;
long long sum = 0, c = 0;
int arr[26];
string s;
for (long long i = 0; i < 26; i++) cin >> arr[i];
cin >> s;
for (long long i = 0; i < s.size(); i++) {
c += mp[{s[i], sum}];
sum += arr[s[i] - 'a'];
mp[{s[i], sum}]++;
}
cout << c;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
int64_t mod = 1e9 + 7;
int64_t mod1 = 1e9 + 5;
int64_t power(int64_t a, int64_t b) {
if (b == 0)
return 1;
else if (b % 2 == 0)
return power((((a % mod) * (a % mod)) % mod), b / 2) % mod;
else
return ((a % mod) * (power((((a % mod) * (a % mod)) % mod), b / 2) % mod)) %
mod;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int64_t a[26];
for (int64_t i = 0; i < 26; ++i) cin >> a[i];
string s;
cin >> s;
int64_t n = s.length();
int64_t ans = 0;
char ch = 'a';
for (int64_t i = 0; i < 26; ++i) {
map<int64_t, int64_t> m;
char temp = ch + i;
int64_t sum[n + 1];
sum[0] = 0;
for (int64_t j = 1; j <= n; ++j) {
sum[j] = sum[j - 1] + a[s[j - 1] - 'a'];
if (s[j - 1] == temp) {
m[sum[j - 1]]++;
}
}
for (int64_t j = 1; j <= n; ++j) {
if (s[j - 1] == temp) {
int64_t an = sum[j - 1];
m[an]--;
ans += m[sum[j]];
}
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int x[30], st[30];
string s;
vector<pair<long long, int> > v;
int main() {
ios_base::sync_with_stdio(false);
long long sum = 0, ans = 0;
for (int i = 0; i < 26; i++) cin >> x[i];
string s;
cin >> s;
int n = s.length();
for (int i = 0; i < n; i++) {
sum += x[s[i] - 'a'];
v.push_back({sum, i});
}
sort(v.begin(), v.end());
int ii = 0, jj = 0;
while (ii < n) {
fill(st, st + 26, 0);
while (jj < n && v[jj].first == v[ii].first) {
int id = v[jj].second;
st[s[id] - 'a']++;
if (id + 1 < n) ans += st[s[id + 1] - 'a'];
jj++;
}
ii = jj;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
for (int i = 1; i < 2; i++)
;
int brr[28];
for (int i = 0; i < 26; i++) cin >> brr[i];
for (int j = 1; j < 2; j++)
;
char arr[100001];
cin >> arr;
int len = strlen(arr);
long long int dp[len + 100];
dp[0] = 0;
vector<int> pos[10001];
dp[0] = brr[arr[0] - 'a'];
pos[arr[0] - 'a'].push_back(0);
for (int i = 1; i < len; i++) {
dp[i] = dp[i - 1] + brr[arr[i] - 'a'];
pos[arr[i] - 'a'].push_back(i);
}
unsigned long long int ans = 0;
for (int i = 0; i < 26; i++) {
map<long long int, int> ma;
for (int j = 0; j < pos[i].size(); j++) {
int kk = pos[i][j];
ans += ma[dp[kk - 1]];
ma[dp[kk]]++;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[100005];
map<pair<char, long long>, long long> mp;
int main() {
cin.sync_with_stdio();
int l[26];
for (int i = 0; i < 26; i++) cin >> l[i];
string s;
cin >> s;
memset(dp, 0, sizeof dp);
long long res = 0;
for (int i = 0; i < s.size(); i++) {
dp[i] = l[s[i] - 'a'] + (i > 0 ? dp[i - 1] : 0);
long long x = dp[i] - l[s[i] - 'a'];
if (mp.find(make_pair(s[i], x)) != mp.end()) res += mp[make_pair(s[i], x)];
mp[make_pair(s[i], dp[i])]++;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
vector<long long> val(26);
for (long long i = 0; i < 26; i++) cin >> val[i];
map<long long, vector<long long> > ma;
string s;
cin >> s;
long long n = s.length();
vector<long long> pre(n);
pre[0] = val[s[0] - 'a'];
for (long long i = 1; i < n; i++) pre[i] = pre[i - 1] + val[s[i] - 'a'];
long long count = 0;
for (long long i = 0; i < n; i++) {
if (ma.find(pre[i]) != ma.end()) {
if (i + 1 < n) count += ma[pre[i]][s[i + 1] - 'a'];
ma[pre[i]][s[i] - 'a']++;
} else {
vector<long long> temp(26, 0);
temp[s[i] - 'a']++;
ma[pre[i]] = temp;
}
}
for (long long i = 1; i < n; i++) {
if (s[i] == s[i - 1]) count++;
}
cout << count << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x[26];
for (long long i = 0; i < 26; i++) cin >> x[i];
string s;
cin >> s;
long long n = s.length();
s += "|";
map<pair<long long, long long>, long long> m;
long long pre_sum[n];
pre_sum[0] = x[s[0] - 97];
m[{pre_sum[0], s[0] - 97}]++;
long long result = 0;
for (long long i = 1; i < n; i++) {
pre_sum[i] = pre_sum[i - 1] + x[s[i] - 97];
result += m[{pre_sum[i], s[i + 1] - 97}];
m[{pre_sum[i], s[i] - 97}]++;
if (s[i - 1] == s[i]) {
result++;
}
}
cout << result << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp[26];
long long sum, res, x[26];
string s;
int main() {
ios_base::sync_with_stdio(0);
for (int i = 0; i < 26; i++) cin >> x[i];
cin >> s;
for (int i = 0; i < s.size(); i++) {
res += mp[s[i] - 'a'][sum];
mp[s[i] - 'a'][sum += x[s[i] - 'a']]++;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int in[30];
char s[N];
long long sum[N];
map<long long, int> mp[26];
int main() {
for (int i = 0; i < 26; ++i) {
scanf("%d", in + i);
}
scanf("%s", s + 1);
long long res = 0;
int n = strlen(s + 1);
for (int i = 1; i <= n; ++i) {
sum[i] = sum[i - 1] + in[s[i] - 'a'];
}
for (int i = 1; i <= n; ++i) {
res += mp[s[i] - 'a'][sum[i - 1]];
mp[s[i] - 'a'][sum[i]]++;
}
printf("%I64d\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
map<long long, long long> m[26];
long long c[26], sum[N];
string s;
int main() {
for (int i = 0; i < 26; ++i) cin >> c[i];
cin >> s;
sum[0] = 0;
long long ans = 0;
int n = s.length();
for (int i = 1; i <= n; ++i) {
int k = s[i - 1] - 'a';
sum[i] = sum[i - 1] + c[k];
ans += m[k][sum[i - 1]];
m[k][sum[i]]++;
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 3;
char str[MAXN];
long long sum[MAXN];
int val[26];
map<long long, vector<int> > mp[26];
int main() {
for (int i = 0; i < 26; i++) scanf("%d", &val[i]);
scanf("%s", str);
int len = strlen(str);
sum[0] = val[str[0] - 97];
mp[str[0] - 97][sum[0]].push_back(0);
long long c = 0;
for (int i = 1; i < len - 1; i++) {
if (str[i] == str[i - 1]) c++;
sum[i] = sum[i - 1] + val[str[i] - 97];
if (mp[str[i + 1] - 97].find(sum[i]) != mp[str[i + 1] - 97].end())
c += mp[str[i + 1] - 97][sum[i]].size();
mp[str[i] - 97][sum[i]].push_back(i);
}
if (len != 1 && str[len - 1] == str[len - 2]) c++;
printf("%lld\n", c);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long X, T, V[256], i;
string S;
map<pair<long long, long long>, long long> M;
int main() {
for (i = 0; i < 26; i++) cin >> V['a' + i];
cin >> S;
for (i = 0; i < S.size(); i++)
X += M[{S[i], T}], T += V[S[i]], M[{S[i], T}]++;
cout << X;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nm = 100002;
int n;
char s[nm];
long long a[30];
map<long long, int> x;
int main() {
for (int i = 0; i < 26; ++i) scanf("%I64d", &a[i]);
scanf("%s", s);
n = strlen(s);
long long kq = 0, sum;
for (int i = 0; i < 26; ++i) {
x.clear();
sum = 0;
for (int j = 0; j < n; ++j) {
sum += a[s[j] - 97];
if (s[j] - 97 == i) {
kq += (long long)x[sum - 2ll * a[s[j] - 97]];
x[sum - a[s[j] - 97]]++;
}
}
}
printf("%I64d\n", kq);
}
|
#include <bits/stdc++.h>
using namespace std;
long long st[30];
string s;
vector<map<long long, long long>> g(30);
int main() {
long long ans = 0;
for (int i = 0; i < 26; i++) cin >> st[i];
cin >> s;
long long count = 0;
for (int i = 0; i < s.length(); i++) {
int x = (int)s[i] - 97;
if (g[x].find(count) != g[x].end()) ans += g[x][count];
count += st[x];
if (g[x].find(count) != g[x].end()) {
g[x][count]++;
} else
g[x][count] = 1;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
void online_judge() {}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
online_judge();
{
long long int a[26];
for (long long int i = 0; i < 26; i++) {
cin >> a[i];
}
string s;
cin >> s;
long long int n = s.size();
long long int prefix[n];
memset(prefix, 0, sizeof(prefix));
prefix[0] = a[s[0] - 'a'];
for (long long int i = 1; i < n; ++i) {
prefix[i] = prefix[i - 1] + a[s[i] - 'a'];
}
long long int gg = 0;
map<char, vector<long long int>> same_letters;
long long int sum = 0;
for (long long int i = 7; i <= 20; i++) {
sum += a[s[i] - 'a'];
}
for (long long int i = 0; i < n; i++) {
same_letters[s[i]].push_back(i);
}
long long int ans = 0;
for (auto x : same_letters) {
if (x.second.size() < 2) continue;
vector<long long int> temp;
for (long long int i = 0; i < x.second.size() - 1; i++) {
long long int r = x.second[i + 1];
long long int l = x.second[i];
temp.push_back(prefix[r] - prefix[l]);
}
long long int required_cost = a[x.first - 'a'];
long long int curr_sum = 0;
map<long long int, long long int> sums;
sums[curr_sum]++;
for (long long int i = 0; i < temp.size(); i++) {
curr_sum += temp[i];
ans += sums[curr_sum - required_cost];
sums[curr_sum]++;
}
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-9;
const double PI = acos(-1.0);
const int MOD = 1000 * 1000 * 1000 + 7;
const int INF = 2000 * 1000 * 1000;
const int MAXN = 100010;
template <typename T>
inline T sqr(T n) {
return n * n;
}
int cnt[26];
vector<int> pos[MAXN];
char s[MAXN];
int n;
long long sum[MAXN], ans;
int main() {
for (int i = 0; i < 26; i++) {
scanf("%d", &cnt[i]);
}
getchar();
gets(s + 1);
n = strlen(s + 1);
for (int i = 1; i <= n; i++) {
sum[i] = cnt[s[i] - 'a'];
sum[i] += sum[i - 1];
pos[s[i] - 'a'].push_back(i);
}
for (int cc = 0; cc < 26; cc++) {
map<long long, int> Map;
for (size_t i = 0; i < pos[cc].size(); i++) {
int p = pos[cc][i];
ans += Map[sum[p - 1]];
Map[sum[p]]++;
}
Map.clear();
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long rd(long long &x) { return scanf("%lld", &x); }
long long rd(long long &x, long long &y) { return scanf("%lld %lld", &x, &y); }
long long rd(long long &x, long long &y, long long &z) {
return scanf("%lld %lld %lld", &x, &y, &z);
}
long long rd(long long &x, long long &y, long long &z, long long &s) {
return scanf("%lld %lld %lld %lld", &x, &y, &z, &s);
}
struct debugger {
template <class T>
debugger &operator,(const T &v) {
cerr << v << " ";
return *this;
}
} dbg;
void debugv(vector<long long> vec) {
cerr << "printing vector:: ";
for (long long i = 0; i < (vec.size()); i++) {
cout << vec[i] << " ";
}
cerr << endl;
}
void debugs(set<long long> s) {
cerr << "printing set:: ";
for (auto it = s.begin(); it != s.end(); it++) {
cout << (*it) << " ";
}
cerr << endl;
}
long long c[26], n, ans, cnt[100005];
string s;
map<pair<char, long long>, long long> mpp;
int main() {
for (long long i = 0; i < (26); i++) rd(c[i]);
cin >> s;
n = s.length();
s = "8" + s;
for (long long i = 1; i <= (n - 1); i++) {
if (s[i] == s[i + 1]) ans++;
}
for (long long i = 1; i <= (n - 1); i++) {
cnt[i] = cnt[i - 1] + c[s[i] - 'a'];
ans += mpp[make_pair(s[i + 1], cnt[i])];
mpp[make_pair(s[i], cnt[i])]++;
}
cout << (long long)ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma warning(disable : 4996)
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
const double EPS = 1e-9;
const int N = 1e5 + 1;
int arr[27];
long long prefix[N];
string str;
char s[N];
map<long long, int> mp[27];
int n;
int solve(int test) {
for (register int i = 0; i < 26; i++) scanf("%d", &arr[i]);
scanf("%s", s);
str = s;
n = str.size();
long long out = 0;
for (register int i = 0; i < n; i++) {
prefix[i] = prefix[max(0, i - 1)];
prefix[i] += arr[str[i] - 'a'];
if (i) out += (str[i] == str[i - 1]);
}
for (register int i = 0; i < n; i++) {
if (i != n - 1) {
out += mp[str[i + 1] - 'a'][prefix[i]];
}
mp[str[i] - 'a'][prefix[i]]++;
}
printf("%lld", out);
return test;
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) solve(i);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[1000005];
long long ps[1000005];
vector<long long> v[1000005];
signed main() {
ios_base::sync_with_stdio(false);
cout.tie(0);
cin.tie(0);
long long i, j, k, l, m, n, t;
for (long long i = 0; i < 26; i++) {
cin >> a[i];
}
string str;
cin >> str;
n = str.length();
str = "0" + str;
for (i = 1; i <= n; i++) {
ps[i] = ps[i - 1] + a[str[i] - 'a'];
}
for (i = 1; i <= n; i++) {
v[str[i] - 'a'].push_back(i);
}
long long ans = 0;
for (i = 0; i < 26; i++) {
map<long long, long long> mp;
for (long long it : v[i]) {
mp[ps[it - 1]]++;
}
for (long long it : v[i]) {
mp[ps[it - 1]]--;
ans += mp[ps[it]];
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
string numtostr(long long n) {
string str = "";
long long x;
while (n > 0) {
x = n % 10;
n = n / 10;
str = ((char)('0' + x)) + str;
}
return str;
}
long long strtonum(string str) {
long long num = 0, i;
for (i = 0; i < str.size(); i++) {
num = num * 10 + (str[i] - '0');
}
return num;
}
int main() {
long long arr[26];
map<long long, long long> Map[26];
long long i, ans = 0, temp = 0;
string str;
for (i = 0; i < 26; i++) scanf("%lld", &arr[i]);
cin >> str;
for (i = 0; i < str.size(); i++) {
ans += Map[str[i] - 'a'][temp];
temp += arr[str[i] - 'a'];
Map[str[i] - 'a'][temp]++;
}
printf("%lld", ans);
printf("\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int v[26];
char s[100005];
map<long long, int> a[26];
long long x, ans;
int main() {
for (int i = (0); i < (26); i++) scanf("%d", &v[i]);
scanf("%s", s);
for (int i = 0; s[i]; i++) {
s[i] -= 'a';
ans += a[s[i]][x];
x += v[s[i]];
a[s[i]][x]++;
}
printf("%I64d\n", ans);
scanf("\n");
}
|
#include <bits/stdc++.h>
using namespace std;
long long int modexp(long long int a, long long int b) {
long long int res = 1;
while (b) {
if (b & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b >>= 1;
}
return res;
}
int cv[30];
string str;
long long int sv[100005];
map<long long int, long long int> mp[26];
int main() {
int i;
long long int ans = 0;
for (i = 0; i < 26; ++i) cin >> cv[i];
cin >> str;
for (i = 0; i < str.size(); ++i) sv[i] = cv[str[i] - 'a'];
for (i = 1; i < str.size(); ++i) {
sv[i] += sv[i - 1];
}
for (i = str.size() - 1; i >= 0; --i) {
ans += mp[str[i] - 'a'][sv[i] + cv[str[i] - 'a']];
mp[str[i] - 'a'][sv[i]]++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
map<long long int, int> match[26];
string str;
long long int sum[MAXN], val[30];
int main() {
int i;
long long int ans = 0LL;
for (i = 1; i <= 26; ++i) cin >> val[i];
cin >> str;
sum[0] = val[str[0] - 'a' + 1];
for (i = 1; i < str.length(); ++i)
sum[i] = sum[i - 1] + val[str[i] - 'a' + 1];
for (i = str.length() - 2; i >= 0; --i) {
match[str[i + 1] - 'a'][sum[i]]++;
ans += match[str[i] - 'a'][sum[i]];
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Max = 100006;
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
vector<int> graph[Max], vis(Max);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
vector<int> val(26);
for (int i = 0; i < 26; i++) cin >> val[i];
string s;
cin >> s;
vector<map<long long int, long long int>> v(26);
long long int ans = 0, n = s.length();
long long int sum;
for (int i = 0; i < n - 1; i++) {
if (s[i] == s[i + 1]) ans++;
sum += val[s[i] - 'a'];
char c = s[i + 1];
ans += v[c - 'a'][sum];
v[s[i] - 'a'][sum]++;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long v[30];
int main() {
for (int i = 0; i < 26; i++) cin >> v[i];
string s;
cin >> s;
map<pair<char, long long>, long long> cnt;
long long sum = 0, ans = 0;
for (auto ch : s) {
pair<char, long long> pi = make_pair(ch, sum);
if (cnt.find(pi) != cnt.end()) ans += cnt[pi];
sum += v[ch - 'a'];
pi = make_pair(ch, sum);
if (cnt.find(pi) != cnt.end())
cnt[pi]++;
else
cnt[pi] = 1;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(time(0));
const long long inf = 0x3f3f3f3f3f3f3f3fLL;
const long long N = 3e5 + 10;
const long long MOD = 1e9 + 7;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
vector<long long> cnt(26);
for (long long i = 0; i < 26; i++) {
cin >> cnt[i];
}
string s;
cin >> s;
long long n = (long long)s.size();
vector<long long> sum(n + 1);
vector<vector<long long>> pos(26);
for (long long i = 0; i < n; i++) {
sum[i + 1] = cnt[s[i] - 'a'];
sum[i + 1] += sum[i];
pos[s[i] - 'a'].push_back(i + 1);
}
long long ans = 0;
for (long long i = 0; i < 26; i++) {
map<long long, long long> mp;
for (long long j = 0; j < pos[i].size(); j++) {
long long p = pos[i][j];
ans += mp[sum[p - 1]];
mp[sum[p]]++;
}
mp.clear();
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int maxm = 2e5 + 10;
const long long mod = 1e9 + 7;
const int inf = 0x3ffffff;
const double eps = 1e-5;
long long sum[maxn];
long long a[26];
string s;
map<pair<long long, char>, int> m;
long long ans;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
for (int i = 0; i < 26; i++) cin >> a[i];
s.push_back('.');
string temp;
cin >> temp;
s += temp;
m[make_pair(0, s[1])]++;
for (int i = 1; i < s.size(); i++) {
sum[i] += (sum[i - 1] + a[s[i] - 'a']);
if (i != s.size() - 1) {
ans += m[make_pair(sum[i] - a[s[i + 1] - 'a'], s[i + 1])];
m[make_pair(sum[i], s[i + 1])]++;
}
}
cout << ans;
return ~~(0 - 0);
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
long long dp[100002];
int main() {
long long values[26];
string line;
for (int i = 0; i < 26; i++) cin >> values[i];
cin >> line;
int n = line.size();
dp[0] = values[(int)(line[0] - 'a')];
for (int i = 1; i < n; i++) dp[i] = dp[i - 1] + values[(int)(line[i] - 'a')];
long long ans = 0;
map<long long, long long> MAP;
for (char i = 'a'; i <= 'z'; i++) {
long long shift = values[(int)(i - 'a')];
for (int j = n - 1; j >= 0; j--) {
if (i == line[j]) {
long long Dpj = dp[j] + shift;
ans += MAP[Dpj];
MAP[dp[j]]++;
}
}
MAP.clear();
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 123456;
const int ALPHA = 26;
vector<int> value;
string word;
int n;
long long solve(int c) {
int v = value[c];
unordered_map<long long, long long> mp;
long long cnt = 0;
long long sum = 0;
long long res = 0;
for (int i = 0; i < n; i++) {
if (word[i] - 'a' == c) {
if (cnt == 0) {
sum = 0;
mp[0] = 1;
} else {
long long s = sum + v * (cnt - 1);
res += mp[s];
mp[s + v]++;
}
cnt++;
} else {
sum += value[word[i] - 'a'];
}
}
return res;
}
int main() {
int a;
long long ans = 0;
for (int i = 0; i < ALPHA; i++) {
cin >> a;
value.push_back(a);
}
cin >> word;
n = word.size();
for (int i = 0; i < ALPHA; i++) {
ans += solve(i);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return (b == 0) ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
long long powmod(long long a, long long b) {
long long res = 1;
if (a >= 1000000007) a %= 1000000007;
for (; b; b >>= 1) {
if (b & 1) res = res * a;
if (res >= 1000000007) res %= 1000000007;
a = a * a;
if (a >= 1000000007) a %= 1000000007;
}
return res;
}
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(0);
}
void fileIO() {
freopen("input.in", "r", stdin);
freopen("output1.txt", "w", stdout);
}
map<long long, int> m[26];
string s;
int x;
const int N = 1e5 + 5;
long long ans, sum, cost[N];
int main() {
for (int i = 0; i < 26; i++) {
cin >> x;
cost[i] = x;
}
cin >> s;
for (int i = 0; i < s.length(); i++) {
ans += m[s[i] - 'a'][sum];
sum += cost[s[i] - 'a'];
m[s[i] - 'a'][sum]++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long p;
map<long long, int> m[123];
int main() {
int characters_value[26];
long long i;
for (i = 0; i < 26; i++) cin >> characters_value[i];
string s;
cin >> s;
long long ans = 0;
for (i = 0; i < s.size(); i++) {
ans += m[s[i]][p];
p += characters_value[s[i] - 'a'];
m[s[i]][p]++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a[26], sum[100000], ans = 0;
string s;
map<pair<long long, char>, long long> m;
for (int i = 0; i < 26; ++i) cin >> a[i];
cin >> s;
sum[0] = a[s[0] - 'a'];
for (int i = 1; i < s.length(); ++i) sum[i] = sum[i - 1] + a[s[i] - 'a'];
for (int i = 0; i < s.length() - 1; ++i) {
++m[make_pair(sum[i], s[i])];
ans += m[make_pair(sum[i], s[i + 1])];
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1005;
long long a[30];
map<long long, long long> mp[30];
int main() {
for (int i = 1; i <= 26; i++) scanf("%I64d", &a[i]);
char s[100005];
scanf("%s", s);
int len = strlen(s);
long long ans = 0, sum = 0;
for (int i = 0; i < len; i++) {
if (mp[s[i] - 'a' + 1].count(sum)) {
ans += mp[s[i] - 'a' + 1][sum];
}
sum += a[s[i] - 'a' + 1];
mp[s[i] - 'a' + 1][sum]++;
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
const long double eps = 1e-7;
const string alpha = "abcdefghijklmnopqrstuvwxyz";
int dx[8] = {+1, +1, +1, 0, 0, -1, -1, -1};
int dy[8] = {+1, 0, -1, +1, -1, +1, 0, -1};
long long power(long long x, long long y) {
long long res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
template <typename T>
T gcd(T a, T mp) {
if (a == 0) return mp;
return gcd(mp % a, a);
}
template <typename T>
T powm(T a, T mp, long long m) {
T cnt = 1;
while (mp > 0) {
if (mp % 2 == 1) cnt = (cnt * a) % m;
mp /= 2;
a = (a * a) % m;
}
return cnt % m;
}
long long ncr(long long n, long long r) {
long long res = 1;
if (r > n) return 0;
if (r > n - r) r = n - r;
for (long long i = 0; i < r; i++) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
long long sqr(long long x) { return x * x; }
void prec() {}
long long pre[N], ans;
void run() {
long long a[26];
for (long long i = (0); i <= (25); ++i) cin >> a[i];
string s;
cin >> s;
int n = (long long)s.size();
s = '?' + s;
for (int i = 1; i <= n; ++i) pre[i] = pre[i - 1] + a[s[i] - 'a'];
for (char ch = 'a'; ch <= 'z'; ch++) {
map<long long, long long> now;
for (long long i = 1; i <= n; i++) {
if (s[i] != ch) continue;
ans += now[pre[i] - a[s[i] - 'a']];
now[pre[i]]++;
}
}
cout << ans;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin.exceptions(cin.failbit);
int tc = 1;
prec();
for (long long i = 0; i < tc; ++i) run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class p1328D {
public:
void solve() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
vector<int> t(n);
for (int i = 0; i < n; i++) cin >> t[i];
int sum = 1;
for (int i = 1; i < n; i++) {
if (t[i] == t[i - 1]) sum++;
}
if (sum == n) {
cout << 1 << endl;
for (int i = 0; i < n; i++) cout << 1 << " ";
cout << endl;
} else if (n % 2 == 0 || t.back() == t.front()) {
cout << 2 << endl;
for (int i = 0; i < n; i++) cout << i % 2 + 1 << " ";
cout << endl;
} else if (sum > 1) {
cout << 2 << endl;
bool can = true;
for (int i = 0; i < n; i++) {
if (can && i > 0 && t[i] == t[i - 1]) {
cout << (i - 1) % 2 + 1 << " ";
can = false;
} else if (!can)
cout << (i - 1) % 2 + 1 << ' ';
else
cout << i % 2 + 1 << ' ';
}
cout << endl;
} else {
cout << 3 << endl;
for (int i = 0; i < n - 1; i++) cout << i % 2 + 1 << " ";
cout << 3 << endl;
}
}
}
};
class p1327E {
public:
long long MOD = 998244353;
long long fastpow(long long x, long long n) {
if (n == 0) return 1ll;
if (n == 1) return x;
long long temp = fastpow(x, n / 2);
if (n % 2 == 0)
return (temp * temp) % MOD;
else
return (((x * temp) % MOD) * temp) % MOD;
}
void solve() {
int n;
cin >> n;
if (n < 2) {
cout << 10 << endl;
return;
}
int maxn = 2e5 + 10;
vector<long long> dp(maxn, 1);
for (int i = 1; i <= maxn; i++) {
dp[i] = (dp[i - 1] * 10) % MOD;
}
for (int i = 1; i < n; i++) {
long long res = 2 * 10 * 9 * dp[n - i - 1] % MOD;
res += (n - i - 1) * 10 * 9 * 9 * dp[n - i - 2] % MOD;
cout << res % MOD << " ";
}
cout << 10 << endl;
}
};
class p161D {
public:
long long res, k, n;
vector<vector<int>> e;
vector<vector<long long>> dp;
void dfs(int cur, int fa) {
dp[cur][0] = 1;
for (int c : e[cur]) {
if (c == fa) continue;
dfs(c, cur);
for (int i = 1; i <= k; i++) {
dp[cur][i] += dp[c][i - 1];
}
}
res += dp[cur][k];
long long temp = 0;
for (int c : e[cur]) {
if (c == fa) continue;
for (int i = 0; k - 2 - i >= 0; i++) {
temp += dp[c][i] * (dp[cur][k - i - 1] - dp[c][k - i - 2]);
}
}
res += temp / 2;
}
void solve() {
cin >> n >> k;
e = vector<vector<int>>(n + 1);
dp = vector<vector<long long>>(n + 1, vector<long long>(k + 1, 0));
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
e[a].push_back(b);
e[b].push_back(a);
}
res = 0;
dfs(1, 0);
cout << res << endl;
}
};
class p1437C {
public:
void solve() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
vector<int> t(n);
for (int i = 0; i < n; i++) cin >> t[i];
sort(t.begin(), t.end());
vector<vector<int>> dp(2 * n + 1, vector<int>(n + 1, 0x3f3f3f3f));
dp[0][0] = 0;
int res = 0x3f3f3f3f;
for (int k = 1; k <= 2 * n; k++) {
for (int i = 1; i <= n; i++) {
for (int pre = 0; pre <= k - 1; pre++) {
dp[k][i] = min(dp[k][i], dp[pre][i - 1] + abs(t[i - 1] - k));
}
}
res = min(res, dp[k][n]);
}
cout << res << endl;
}
}
};
class p1038D {
public:
void solve() {
int n;
cin >> n;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << a[0] << endl;
return;
}
long long ans = 0, minval = 0x3f3f3f3f;
bool pos = 0, neg = 0;
for (int i = 0; i < n; i++) {
ans += abs(a[i]);
pos |= (a[i] >= 0);
neg |= (a[i] <= 0);
minval = min(minval, abs(a[i]));
}
if (pos && neg)
cout << ans << endl;
else
cout << ans - 2 * minval << endl;
}
};
class p1286A {
public:
void solve() {
int n;
cin >> n;
vector<int> p(n);
unordered_set<int> cnt;
for (int i = 1; i <= n; i++) cnt.insert(i);
for (int i = 0; i < n; i++) {
cin >> p[i];
if (p[i] != 0) cnt.erase(p[i]);
}
int odd = 0, even = 0;
for (int i : cnt)
if (i % 2)
odd++;
else
even++;
vector<vector<vector<int>>> dp(
n + 1, vector<vector<int>>(n + 1, vector<int>(2, 0x3f3f3f3f)));
dp[0][0][0] = dp[0][0][1] = 0;
for (int i = 1; i <= n; i++) {
int cur = p[i - 1] % 2;
for (int j = 0; j <= min(odd, i); j++) {
if (p[i - 1] != 0) {
dp[i][j][cur] =
min(dp[i - 1][j][0] + (0 ^ cur), dp[i - 1][j][1] + (1 ^ cur));
} else {
if (j >= 1) {
dp[i][j][1] = min(
dp[i][j][1], min(dp[i - 1][j - 1][0] + 1, dp[i - 1][j - 1][1]));
}
dp[i][j][0] =
min(dp[i][j][0], min(dp[i - 1][j][0], dp[i - 1][j][1] + 1));
}
}
}
cout << min(dp[n][odd][0], dp[n][odd][1]) << endl;
}
};
class p580D {
public:
void solve() {
int n, m, k;
cin >> n >> m >> k;
vector<long long> a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
vector<vector<long long>> cost(n + 1, vector<long long>(n + 1, 0));
vector<vector<long long>> dp(1 << n, vector<long long>(n + 1, 0));
for (int i = 0; i < k; i++) {
long long x, y, c;
cin >> x >> y >> c;
cost[x][y] = c;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
dp[1 << (i - 1)][i] = a[i];
}
for (int i = 1; i < (1 << n); i++) {
int cnt = bitset<32>(i).count();
for (int j = 1; j <= n; j++) {
if ((i & (1 << (j - 1))) != 0) {
int pre = i ^ (1 << (j - 1));
for (int k = 1; k <= n; k++) {
if ((pre & (1 << (k - 1))) == 0) continue;
dp[i][j] = max(dp[i][j], dp[pre][k] + cost[k][j] + a[j]);
}
if (cnt == m) ans = max(ans, dp[i][j]);
}
}
}
cout << ans << endl;
}
};
class p1335E2 {
public:
void solve() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
vector<vector<int>> sum(n + 1, vector<int>(205, 0));
vector<vector<int>> pos(205);
int res = 0;
for (int i = 1; i <= n; i++) {
sum[i][a[i]]++;
for (int j = 1; j <= 200; j++) {
sum[i][j] += sum[i - 1][j];
res = max(res, sum[i][j]);
}
pos[a[i]].push_back(i);
}
for (int i = 1; i <= 200; i++) {
int len = pos[i].size();
for (int k = 0; k < len - 1 - k; k++) {
int l = pos[i][k], r = pos[i][len - 1 - k] - 1;
int mid = 0;
for (int j = 1; j <= 200; j++) {
mid = max(mid, sum[r][j] - sum[l][j]);
}
res = max(res, 2 * (k + 1) + mid);
}
}
cout << res << endl;
}
}
};
class p1221D {
public:
void solve() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<long long> a(n + 1), b(n + 1);
a[0] = 0;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i];
vector<vector<long long>> dp(n + 1, vector<long long>(4, -1));
dp[0][0] = dp[0][1] = dp[0][2] = dp[0][3] = 0;
long long res = LONG_LONG_MAX;
for (long long i = 1; i <= n; i++) {
for (long long j = 0; j <= 2; j++) {
for (int k = 0; k <= 2; k++) {
if (a[i] + j != a[i - 1] + k) {
auto cur = j * b[i] + dp[i - 1][k];
dp[i][j] = dp[i][j] == -1 ? cur : min(dp[i][j], cur);
}
}
if (i == n) res = min(res, dp[i][j]);
}
}
cout << res << endl;
}
}
};
class p543A {
public:
void solve() {
int n, m, b, md;
cin >> n >> m >> b >> md;
vector<int> a(n + 1);
for (int i = 1; i <= n; i++) cin >> a[i];
vector<vector<int>> dp(m + 1, vector<int>(b + 1, 0));
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int k = 0; k <= m; k++) {
for (int j = 0; j <= b; j++) {
if (j >= a[i] && k > 0)
dp[k][j] = (dp[k][j] + dp[k - 1][j - a[i]]) % md;
}
}
}
long long res = 0;
for (int i = 0; i <= b; i++) res = (res + dp[m][i]) % md;
cout << res << endl;
}
};
class p1142A {
public:
void solve() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int left = a[0];
bool ok = 1;
int mx = 0;
for (int i = 1; i < n; i++) {
if (mx > a[i]) {
ok = false;
break;
}
a[i] -= mx;
if (left >= a[i])
left = a[i];
else {
mx += a[i] - left;
}
}
if (ok)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
}
};
class p1244D {
public:
vector<int> node;
vector<vector<int>> e;
void dfs(int cur, int fa) {
node.push_back(cur);
for (int c : e[cur]) {
if (c == fa) continue;
dfs(c, cur);
}
}
void solve() {
int n;
cin >> n;
vector<vector<long long>> cost(n + 1, vector<long long>(3, 0));
for (int j = 0; j < 3; j++) {
for (int i = 1; i <= n; i++) {
cin >> cost[i][j];
}
}
e = vector<vector<int>>(n + 1);
for (int i = 0; i < n - 1; i++) {
int u, v;
cin >> u >> v;
e[u].push_back(v);
e[v].push_back(u);
if (e[u].size() > 2 || e[v].size() > 2) {
cout << -1 << endl;
return;
}
}
int start = -1;
for (int i = 1; i <= n; i++) {
if (e[i].size() == 1) {
start = i;
break;
}
}
dfs(start, -1);
long long res = 4e18;
int x = -1, y = -1;
for (int i = 0; i < 3; i++) {
for (int k = 0; k < 3; k++) {
if (k == i) continue;
long long temp = 0;
temp += cost[node[0]][i] + cost[node[1]][k];
int a = i, b = k;
for (int j = 2; j < node.size(); j++) {
for (int l = 0; l < 3; l++) {
if (l == a || l == b) continue;
temp += cost[node[j]][l];
a = b;
b = l;
break;
}
}
if (temp < res) {
res = temp;
x = i;
y = k;
}
}
}
cout << res << endl;
vector<int> ans(n + 1, 0);
ans[node[0]] = x;
ans[node[1]] = y;
for (int i = 2; i < node.size(); i++) {
for (int l = 0; l < 3; l++) {
if (l == x || l == y) continue;
ans[node[i]] = l;
x = y;
y = l;
break;
}
}
for (int i = 1; i <= n; i++) cout << ans[i] + 1 << " ";
cout << endl;
}
};
class p519D {
public:
void solve() {
vector<long long> cnt(26, 0);
for (int i = 0; i < 26; i++) cin >> cnt[i];
string s;
cin >> s;
int n = s.size();
vector<long long> sum(n + 1, 0);
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + cnt[s[i - 1] - 'a'];
}
long long res = 0;
unordered_map<long long, long long> mp[26];
for (int i = 1; i <= n; i++) {
int cur = s[i - 1] - 'a';
res += mp[cur][sum[i] - cnt[cur]];
mp[cur][sum[i]]++;
}
cout << res << endl;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
p519D ans;
ans.solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> v[125];
long int a[100];
int main() {
string s;
long long int i, j, l, ct = 0, sum = 0;
for (i = 0; i < 26; i++) cin >> a[i];
cin >> s;
l = s.length();
for (i = 0; i < l; i++) {
ct += v[s[i] - 'a'][sum];
v[s[i] - 'a'][sum += a[s[i] - 'a']]++;
}
cout << ct << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int scores[26];
for (int i = 0; i < 26; i++) cin >> scores[i];
string s;
cin >> s;
unordered_map<long long, vector<int>> mp;
long long ans = 0;
long long sum = 0;
for (int i = 0; i < s.length(); i++) {
if (i + 1 < s.length() && s[i] == s[i + 1]) ans++;
int sc = scores[s[i] - 'a'];
sum += sc;
if (mp[sum].size() == 0) {
vector<int> vec(26, 0);
mp[sum] = vec;
}
if (i + 1 < s.length()) ans += mp[sum][s[i + 1] - 'a'];
mp[sum][s[i] - 'a']++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int val[26];
unordered_map<long long, int> ht[26];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
for (int i = 0; i < 26; ++i) {
cin >> val[i];
}
string str;
cin >> str;
long long cm = 0, ans = 0;
for (int i = 0; i < ((int)(str).size()); ++i) {
ans += ht[str[i] - 'a'][cm];
cm += val[str[i] - 'a'];
++ht[str[i] - 'a'][cm];
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, int> mp[26];
char s[100010];
int main() {
int a[26];
for (int i = 0; i < 26; i++) scanf("%d", &a[i]);
scanf("%s", s);
long long sum = 0;
long long ans = 0;
for (int i = 0; s[i]; i++) {
int x = s[i] - 'a';
if (mp[x].count(sum)) ans += mp[x][sum];
sum += a[x];
mp[x][sum]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
int main() {
int price[30];
for (int i = 0; i < 26; ++i) {
cin >> price[i];
}
string s;
cin >> s;
const int N = 1e5 + 5;
long long pref[N] = {
0,
};
int n = s.size();
for (int i = 1; i <= n; ++i) {
pref[i] = pref[i - 1] + price[s[i - 1] - 'a'];
}
map<long long, long long> quantity[26];
long long answer = 0;
for (int end = 1; end <= n; ++end) {
int c = s[end - 1] - 'a';
long long sum = pref[end - 1];
answer += quantity[c][sum];
++quantity[c][pref[end]];
}
cout << answer << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[30];
char s[100100];
map<long long, int> m[30];
int main() {
long long ans = 0, sum = 0;
for (int i = 1; i <= 26; i++) scanf("%d", &a[i]);
scanf("%s", s);
for (int i = 0; i < strlen(s); i++) {
int c = (int)s[i] - 96;
sum += a[c];
ans += m[c][sum - a[c]];
m[c][sum]++;
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void umax(T &a, T b) {
if (a < b) a = b;
}
template <class T>
inline void umin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
inline T min(T a, T b, T c) {
return min(a, min(b, c));
}
int main(int argc, char *argv[]) {
int values[26];
for (int i = 0; i < 26; i++) cin >> values[i];
string str;
cin >> str;
long long sum = 0;
vector<vector<long long> > mat(26, vector<long long>());
for (int i = 0; i < (int)str.size(); i++) {
sum += values[str[i] - 'a'];
mat[str[i] - 'a'].push_back(sum);
}
long long ans = 0;
map<long long, long long> HASH;
for (int i = 0; i < 26; i++) {
int len = mat[i].size();
for (int j = 0; j < len; j++) {
long long required = (mat[i][j] - values[i]);
ans += HASH[required];
HASH[mat[i][j]]++;
}
HASH.clear();
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[30], ans, sum;
map<long long, int> mp;
vector<long long> vec[30];
string s;
int main() {
ios::sync_with_stdio(false), cin.tie(0);
for (int i = 0; i < 26; i++) cin >> a[i];
cin >> s;
for (int i = 0; i < s.size(); i++) {
sum += a[s[i] - 'a'];
vec[s[i] - 'a'].push_back(sum);
}
for (int i = 0; i < 26; i++) {
mp.clear();
for (long long v : vec[i]) {
ans += mp[v - a[i]];
mp[v]++;
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double PI = 2 * acos(0.0);
void print(vector<int> &a) {
for (int i : a) {
cout << i << " ";
}
cout << "\n";
}
void print(vector<long long> &a) {
for (long long i : a) {
cout << i << " ";
}
cout << "\n";
}
void print(vector<long double> &a) {
for (long double i : a) {
cout << i << " ";
}
cout << "\n";
}
void print(vector<pair<long long, long long> > &a) {
for (pair<long long, long long> i : a) {
cout << i.first << " " << i.second << "\n";
}
cout << "\n";
}
long long dist_sq(pair<long long, long long> a, pair<long long, long long> b) {
return ((a.first - b.first) * (a.first - b.first) +
(a.second - b.second) * (a.second - b.second));
}
long long po(long long a, long long b) {
if (b <= 0)
return 1;
else if (b == 1)
return a;
long long vl = po((a * a), b / 2);
if (b % 2 == 0)
return vl;
else
return (vl)*a;
}
int main(void) {
ios_base::sync_with_stdio(false);
string second;
vector<long long> vl(26, 0);
for (long long i = (0); i <= (25); i++) cin >> vl[i];
cin >> second;
int sz = second.length();
vector<long long> sum(sz, 0);
sum[0] = vl[second[0] - 'a'];
for (long long i = (1); i <= (sz - 1); i++) {
char c = second[i];
sum[i] = vl[c - 'a'] + sum[i - 1];
}
long long ans = 0;
for (long long i = (0); i <= (25); i++) {
map<long long, int> m;
char c = 'a' + i;
if (second[0] == c) {
m[sum[0]]++;
}
for (long long j = (1); j <= (sz - 1); j++) {
if (second[j] == c) {
ans = ans + m[sum[j - 1]];
m[sum[j]]++;
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, mas[30], summ[100005];
long long sum, countt;
string s;
map<pair<char, long long>, int> matr;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
for (int i = 0; i < 26; ++i) cin >> mas[i];
cin >> s;
for (int i = 0; i < s.size(); ++i) {
if (matr.count(make_pair(s[i], sum))) countt += matr[make_pair(s[i], sum)];
sum += mas[s[i] - 'a'];
matr[make_pair(s[i], sum)]++;
}
cout << countt;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1000000000")
using namespace std;
map<long long, int> m[26];
int c[26];
long long sum[100005];
string s;
int main() {
for (int(i) = (0); (i) < int(26); ++(i)) scanf("%d", c + i);
cin >> s;
int len = s.length();
long long ans = 0;
for (int(i) = (1); (i) < int(len + 1); ++(i))
sum[i] = sum[i - 1] + c[s[i - 1] - 'a'];
for (int(i) = (0); (i) < int(len); ++(i)) {
ans += m[s[i] - 'a'][sum[i]];
m[s[i] - 'a'][sum[i + 1]]++;
}
cout << ans << endl;
cin.sync();
cin.get();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
vector<int> v_x(26);
for (int i = 0; i < 26; i++) {
cin >> v_x[i];
}
string s;
cin >> s;
vector<long long> prefix_s(s.size());
vector<vector<int>> occur(26);
prefix_s[0] = v_x[(int)s[0] - 97];
occur[(int)s[0] - 97].push_back(0);
for (int i = 1; i < s.size(); i++) {
int val = (int)s[i] - 97;
prefix_s[i] = prefix_s[i - 1] + v_x[val];
occur[val].push_back(i);
}
long long ans = 0;
for (vector<int> a : occur) {
map<long long, int> Map;
for (int m : a) {
ans += Map[prefix_s[m - 1]];
Map[prefix_s[m]]++;
}
Map.clear();
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
vector<int> x;
for (int i = 0; i < 26; i++) {
int v;
cin >> v;
x.push_back(v);
}
cin >> s;
map<long long, vector<int> > prefix2pos[26];
vector<long long> prefix;
long long psum = 0;
int i = 0;
for (string::iterator it = s.begin(); it != s.end(); ++it, ++i) {
char c = *it - 'a';
if (i > 0) prefix2pos[c][psum].push_back(i - 1);
psum += x[c];
prefix.push_back(psum);
}
long long answer = 0;
i = 0;
for (string::iterator si = s.begin(); si != s.end(); si++, i++) {
int c = *si - 'a';
vector<int>& p = prefix2pos[c][prefix[i]];
vector<int>::iterator where = lower_bound(p.begin(), p.end(), i);
answer += distance(where, p.end());
}
cout << answer << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int sz, cost[26];
string s;
map<pair<char, long long int>, int> mp;
int main() {
for (int i = 0; i < 26; i++) scanf("%d", &cost[i]);
cin >> s;
sz = s.size();
long long int sum = 0, ans = 0;
for (int i = 0; i < sz - 1; i++) {
sum += cost[s[i] - 'a'];
ans += mp[make_pair(s[i + 1], sum)];
mp[make_pair(s[i], sum)]++;
}
for (int i = 0; i < sz - 1; i++)
if (s[i] == s[i + 1]) ans++;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 2147483647;
const double PI = acos(-1.0);
const double e = 2.718281828459;
const int mod = 1000000007;
int a[30];
char s[100005];
vector<int> vc[30];
long long v[100005];
map<long long, long long> mp[30];
int main() {
int i, j;
for (i = 0; i < 26; ++i) scanf("%d", &a[i]);
scanf("%s", s + 1);
long long ans = 0;
for (i = 1; s[i]; ++i) {
v[i] = v[i - 1] + a[s[i] - 'a'];
ans += mp[s[i] - 'a'][v[i - 1]];
mp[s[i] - 'a'][v[i]]++;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<char, long long>, int> m1;
int val[26];
int main() {
string str1;
for (int i = 0; i < 26; i++) cin >> val[i];
cin >> str1;
long long s = 0, sum = 0;
for (int i = 0; i < str1.size(); i++) {
char c = str1[i];
int cc = c - 'a';
s += val[cc];
sum += m1[make_pair(c, s - val[cc])];
m1[make_pair(c, s)]++;
}
cout << sum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = (const int)(1e5 + 11);
int A[33];
int64_t P[MAX];
map<int64_t, int> M[33];
vector<int> all[33];
static void solve(std::int32_t test) {
memset(P, 0, sizeof(P));
for (int i = 0; i < 33; ++i) {
M[i].clear();
all[i].clear();
}
for (int i = 0; i < 26; ++i) cin >> A[i];
string S;
cin >> S;
for (int i = 0; i < S.length(); ++i) all[S[i] - 'a'].push_back(i);
for (int i = 0; i < S.length(); ++i) P[i + 1] = P[i] + A[S[i] - 'a'];
int64_t res = 0;
for (int i = 0; i < 26; ++i) {
auto &m = M[i];
for (const auto &j : all[i]) {
res += m[P[j] - A[i]];
m[P[j]]++;
}
}
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;
map<long long, int> save[26];
int val[26];
char str[100010];
int main() {
long long tmp, cnt, ans;
ans = tmp = cnt = 0;
for (int i = 0; i < 26; i++) {
scanf("%d", &val[i]);
}
scanf("%s", str);
int len;
len = strlen(str);
for (int i = 0; i < len; i++) {
ans += save[str[i] - 'a'][cnt];
cnt += val[str[i] - 'a'];
save[str[i] - 'a'][cnt]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
template <typename T, typename TT>
inline ostream &operator<<(ostream &os, const pair<T, TT> &t) {
return os << t.first << " " << t.second;
}
template <typename T>
inline ostream &operator<<(ostream &os, const vector<T> &t) {
for (auto i : t) os << i << " ";
return os;
}
template <typename T>
inline ostream &operator<<(ostream &os, const set<T> &t) {
for (auto i : t) os << i << " ";
return os;
}
template <typename T1, typename T2>
inline ostream &operator<<(ostream &os, const map<T1, T2> &t) {
for (auto i : t) os << i.first << " : " << i.second << '\n';
return os;
}
template <typename T>
inline istream &operator>>(istream &is, vector<T> &v) {
for (T &t : v) is >> t;
return is;
}
template <typename T1, typename T2>
inline istream &operator>>(istream &is, vector<pair<T1, T2>> &v) {
for (pair<T1, T2> &t : v) is >> t.first >> t.second;
return is;
}
const long long mod = 1e9 + 7;
void solve() {
vector<long long> v(26);
cin >> v;
string s;
cin >> s;
vector<map<long long, long long>> m(26);
long long pre = 0, ans = 0;
for (int i = 0; i < s.size(); i++) {
ans += m[s[i] - 'a'][pre];
pre += v[s[i] - 'a'];
m[s[i] - 'a'][pre]++;
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long T = 1;
while (T--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e6 + 7;
const long long INF = (long long)1e9 + 7;
char st[N];
map<long long, long long> s[200];
long long c[N];
int main() {
int n;
long long t, ans = 0, x = 0;
for (char i = 'a'; i <= 'z'; i++) cin >> c[i];
gets(st);
gets(st);
n = strlen(st);
for (int i = 0; i < n; i++) {
x += c[st[i]];
ans += s[st[i]][x - c[st[i]]];
s[st[i]][x]++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, char>, int> mp;
long long val[50], ary[100010];
int n;
char ch[100010];
int main() {
pair<long long, char> tmp;
long long ans;
int i;
for (i = 0; i < 26; i++) scanf("%lld", &val[i]);
scanf("%s", ch);
n = strlen(ch);
for (i = 0; i < n; i++) ary[i + 1] = ary[i] + val[ch[i] - 'a'];
ans = 0;
for (i = 1; i + 1 <= n; i++) {
tmp = make_pair(ary[i], ch[i - 1]);
mp[tmp]++;
tmp = make_pair(ary[i], ch[i]);
ans += mp[tmp];
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long p;
map<long long, int> m[123];
int main() {
int characters_value[26], i;
for (i = 0; i < 26; i++) cin >> characters_value[i];
string s;
cin >> s;
long long ans = 0;
for (i = 0; i < s.size(); i++) {
ans += m[s[i]][p];
p += characters_value[s[i] - 'a'];
m[s[i]][p]++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long TESTS = 1;
while (TESTS--) {
vector<long long> val(30, 0);
for (long long i = 0; i < 26; i++) cin >> val[i];
string s;
cin >> s;
long long n = (long long)s.size();
vector<long long> pre(n, 0);
pre[0] = val[s[0] - 'a'];
for (long long i = 1; i < n; i++) pre[i] = pre[i - 1] + val[s[i] - 'a'];
unordered_map<long long, long long> k[30];
long long ans = 0;
for (long long i = 0; i < n; i++) {
ans += k[s[i] - 'a'][pre[i] - val[s[i] - 'a']];
k[s[i] - 'a'][pre[i]]++;
}
cout << ans;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int maxn = 100005;
vector<pair<long long, long long> > s[30];
char str[maxn];
long long a[30];
long long sum[maxn];
int main() {
for (int i = 0; i < 26; i++) cin >> a[i];
scanf("%s", str);
int n = strlen(str);
for (int i = 0; i < n; i++) {
sum[i + 1] = sum[i] + a[str[i] - 'a'];
s[str[i] - 'a'].push_back(pair<long long, long long>(sum[i + 1], i));
}
long long ans = 0;
for (int i = 0; i < 26; i++) {
if (s[i].size()) {
sort(s[i].begin(), s[i].end());
int sz = s[i].size();
for (int j = 0; j < sz; j++) {
int l =
lower_bound(s[i].begin(), s[i].end(),
pair<long long, long long>(
s[i][j].first - a[str[s[i][j].second] - 'a'], -1)) -
s[i].begin();
int r = upper_bound(s[i].begin(), s[i].end(),
pair<long long, long long>(
s[i][j].first - a[str[s[i][j].second] - 'a'],
s[i][j].second - 1)) -
s[i].begin();
ans += r - l;
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> M[30];
int values[100010];
char str[100010];
int N;
int counts[30];
long long sums[30];
inline void ReadInput(void) {
for (int i = 0; i < 26; i++) scanf("%d", &values[i]);
scanf("%s", str);
}
long long ans = 0;
inline void solve(void) {
N = strlen(str);
for (int i = 1; i <= N; i++) {
int pos = str[i - 1] - 'a';
ans += (M[pos][0 - sums[pos]]);
for (int j = 0; j < 26; j++) {
if (counts[j] > 0) {
sums[j] += values[pos];
}
}
M[pos][0 - sums[pos]]++;
counts[pos]++;
}
cout << ans;
}
inline void Refresh(void) {}
int main() {
ReadInput();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int wt[27], dp[100001], res = 0;
string s;
vector<int> g[27];
for (int i = 0; i < 26; i++) cin >> wt[i];
cin >> s;
int n = s.size();
for (int i = 0; i < n; i++) {
dp[i] = wt[s[i] - 'a'];
if (i != 0) dp[i] += dp[i - 1];
g[s[i] - 'a'].push_back(i);
}
for (int i = 0; i < 26; i++) {
map<long long int, int> val;
int idx = 0;
for (auto a : g[i]) {
if (idx != 0 and val[dp[a - 1]] != 0) res += val[dp[a - 1]];
val[dp[a]]++;
idx++;
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long val[30] = {0}, sum[100000 + 8] = {0};
vector<long long> pos[30];
int main() {
long long i, j, k, s, d, r, m, n;
for (i = 0; i < 26; i++) {
cin >> m;
val[i] = m;
}
string line;
cin >> line;
for (i = 0; i < line.size(); i++) {
m = line[i] - 'a';
sum[i + 1] = val[m];
sum[i + 1] += sum[i];
pos[m].push_back(i + 1);
}
long long ans = 0;
for (i = 0; i < 26; i++) {
map<long long, long long> Map;
for (j = 0; j < pos[i].size(); j++) {
long long p = pos[i][j];
ans += Map[sum[p - 1]];
Map[sum[p]]++;
}
Map.clear();
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int like[256];
int main() {
for (int i = 'a'; i <= 'z'; ++i) cin >> like[i];
string s;
cin >> s;
long long res = 0;
for (int c = 'a'; c <= 'z'; ++c) {
long long cur = 0;
map<long long, long long> cnt;
for (int i = 0; i < s.size(); ++i) {
if (s[i] == c) {
res += cnt[cur];
cur += like[s[i]];
cnt[cur] += 1;
} else {
cur += like[s[i]];
}
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long int, long long int> v[125];
long int a[100];
int main() {
ios_base::sync_with_stdio(0);
string s;
long long int i, j, l, ct = 0, sum = 0;
for (i = 0; i < 26; i++) cin >> a[i];
cin >> s;
l = s.length();
for (i = 0; i < l; i++) {
ct += v[s[i] - 'a'][sum];
v[s[i] - 'a'][sum += a[s[i] - 'a']]++;
}
cout << ct << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100010;
int n, m, a[maxN], f[30][maxN];
long long res, S[maxN];
char s[maxN];
struct ioi {
long long v, p;
};
ioi c[maxN];
bool cmp(ioi i, ioi j) { return i.v < j.v; }
int main() {
for (int i = 0; i <= 25; ++i) scanf("%d", &a[i]);
scanf("\n");
scanf("%s\n", &s);
int len = strlen(s), num = 0;
for (int i = 1; i <= len; ++i) {
S[i] = S[i - 1] + a[s[i - 1] - 'a'];
c[++num].v = S[i];
c[num].p = i;
}
sort(c + 1, c + num + 1, cmp);
int val = 1;
S[c[1].p] = val;
for (int i = 2; i <= num; ++i) {
val += (c[i].v != c[i - 1].v);
S[c[i].p] = val;
}
f[s[0] - 'a'][S[1]] = 1;
for (int i = 2; i <= len; ++i) {
res += (f[s[i - 1] - 'a'][S[i - 1]]);
f[s[i - 1] - 'a'][S[i]]++;
}
cout << res;
fclose(stdin);
fclose(stdout);
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int ddx[] = {1, 0};
int ddy[] = {1, 1};
vector<int> pos[30];
string s;
long long int pre[100001];
int n;
long long int value[100001];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
for (int i = 0; i < 26; i++) cin >> value[i];
cin >> s;
for (int i = 0; i < int(s.size()); i++) {
pre[i + 1] = pre[i] + value[s[i] - 'a'];
pos[s[i] - 'a'].push_back(i);
}
long long int ans = 0;
for (int i = 0; i < 26; i++) {
map<long long int, int> sum;
char aux = i + 'a';
for (int j = 0; j < int(pos[i].size()); j++) {
int atual = pos[i][j];
ans += sum[pre[atual]];
sum[pre[atual + 1]]++;
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long cul[100005];
int main() {
map<long long, long long> hit;
map<long long, map<char, long long> > mark;
for (int i = 0; i < 26; i++) {
int in;
cin >> in;
hit['a' + i] = in;
}
string s;
cin >> s;
cul[0] = hit[s[0]];
for (int i = 1; i < s.size(); i++) {
cul[i] = cul[i - 1] + hit[s[i]];
}
long long res = 0;
for (int i = 0; i < s.size() - 1; i++) {
if (s[i] == s[i + 1]) res++;
res += mark[cul[i]][s[i + 1]];
mark[cul[i]][s[i]]++;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream& operator>>(istream& I, vector<T>& v) {
for (auto& i : v) I >> i;
return I;
}
template <typename T>
ostream& operator<<(ostream& O, vector<T>& v) {
for (auto& i : v) O << i << ' ';
return O;
}
template <typename T>
istream& operator>>(istream& I, vector<vector<T>>& v) {
for (auto& i : v)
for (auto& x : i) I >> x;
return I;
}
template <typename T>
ostream& operator<<(ostream& O, vector<vector<T>>& v) {
for (auto& i : v) {
for (auto& x : i) O << x << ' ';
O << '\n';
}
return O;
}
template <typename T, typename U>
istream& operator>>(istream& I, pair<T, U>& p) {
I >> p.first >> p.second;
return I;
}
template <typename T, typename U>
ostream& operator<<(ostream& O, pair<T, U>& p) {
O << p.first << ' ' << p.second;
return O;
}
const int maxn = 1e6 + 3;
const int mod = 1e9 + 7;
using namespace std;
void solve() {
vector<int> x(26, 0);
for (long long i = 0; i < 26; i++) cin >> x[i];
string s;
cin >> s;
long long n = s.length();
vector<long long> a(n, 0);
for (long long i = 0; i < n; i++) {
if (i == 0)
a[i] = x[s[i] - 'a'];
else
a[i] = a[i - 1] + x[s[i] - 'a'];
}
map<long long, map<char, long long>> y;
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long val = a[i];
long long count = 0;
if (i != 0) count = y[a[i - 1]][s[i]];
if (i != n - 1) y[a[i]][s[i]]++;
ans += count;
}
cout << ans << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<long long, int> m[26];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int sc[26];
string s;
for (int i = 0; i < 26; i++) cin >> sc[i];
cin >> s;
int n = s.size();
long long ans = 0;
long long score[n];
score[0] = sc[s[0] - 'a'];
for (int i = 1; i < n; i++) {
score[i] = score[i - 1] + (long long)sc[s[i] - 'a'];
}
for (int i = 0; i < n; i++) {
ans += m[s[i] - 'a'][score[i] - sc[s[i] - 'a']];
m[s[i] - 'a'][score[i]]++;
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Debugger {
public:
Debugger(const std::string& _separator = " | ")
: first(true), separator(_separator) {}
template <typename ObjectType>
Debugger& operator,(const ObjectType& v) {
if (!first) std::cerr << separator;
std::cerr << v;
first = false;
return *this;
}
~Debugger() { std::cerr << std::endl; }
private:
bool first;
std::string separator;
};
long long value[26];
std::vector<long long> seg[26];
void solve() {
for (long long i = 0; i < 26; ++i) cin >> value[i];
string s;
cin >> s;
long long n = s.size();
std::vector<long long> pre(n + 1, 0);
for (long long i = 0; i < n; ++i) {
seg[s[i] - 'a'].push_back(i);
pre[i] = pre[i - 1] + value[s[i] - 'a'];
}
long long ans = 0;
map<long long, long long> mp;
for (long long i = 0; i < 26; ++i) {
if (seg[i].size() < 2) continue;
mp.clear();
mp[0] = 1;
for (long long j = 1; j < seg[i].size(); ++j) {
long long temp = pre[seg[i][j] - 1] - pre[seg[i][0]];
if (mp.count(temp)) {
ans += mp[temp];
}
mp[pre[seg[i][j]] - pre[seg[i][0]]]++;
}
}
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0),
cout << fixed << setprecision(10);
;
long long T;
T = 1;
while (T--) {
solve();
}
return 0;
};
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T max2(T a, T b) {
return a < b ? b : a;
}
template <class T>
T min2(T a, T b) {
return a < b ? a : b;
}
template <class T>
T max3(T a, T b, T c) {
return max2(max2(a, b), c);
}
template <class T>
T min3(T a, T b, T c) {
return min2(min2(a, b), c);
}
template <class T>
T max4(T a, T b, T c, T d) {
return max2(max2(a, b), max2(c, d));
}
template <class T>
T min4(T a, T b, T c, T d) {
return min2(min2(a, b), max2(c, d));
}
const long long int mod = 1000000007ll;
const long long int MOD = 1000000009ll;
long long int bit_count(long long int _x) {
long long int _ret = 0;
while (_x) {
if (_x % 2 == 1) _ret++;
_x /= 2;
}
return _ret;
}
long long int bit(long long int _mask, long long int _i) {
long long int x = 1;
return (_mask & (x << _i)) == 0 ? 0 : 1;
}
long long int powermod(long long int _a, long long int _b,
long long int _m = mod) {
long long int _r = 1;
while (_b) {
if (_b % 2 == 1) _r = (_r * _a) % _m;
_b /= 2;
_a = (_a * _a) % _m;
}
return _r;
}
long long int power(long long int _a, long long int _b) {
long long int _r = 1;
while (_b) {
if (_b % 2 == 1) _r = (_r * _a);
_b /= 2;
_a = (_a * _a);
}
return _r;
}
long long int add(long long int a, long long int b, long long int m = mod) {
long long int x = a + b;
while (x >= m) x -= m;
return x;
}
long long int sub(long long int a, long long int b, long long int m = mod) {
long long int x = a - b;
while (x < 0) x += m;
return x;
}
long long int mul(long long int a, long long int b, long long int m = mod) {
long long int x = a * b;
x %= m;
return x;
}
long long int gcd(long long int a, long long int b) {
if (a < b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
if (b == 0) return a;
long long int t;
while (b) {
t = b;
b = a % b;
a = t;
}
return a;
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
pair<int, int> operator+(const pair<int, int>& l, const pair<int, int>& r) {
pair<int, int> ret;
ret.first = l.first + r.first;
ret.second = l.second + r.second;
return ret;
}
struct cmp {
bool operator()(int const& l, int const& r) { return l < r; }
} myobject;
int a[26];
string second;
vector<int> v[26];
long long int pre[100010];
long long int ans = 0;
int main() {
for (int i = 0; i < 26; i++) cin >> a[i];
cin >> second;
int l = second.size();
second = 'a' + second;
pre[0] = 0;
for (int i = 1; i <= l; i++) {
v[second[i] - 'a'].push_back(i);
pre[i] = pre[i - 1] + a[second[i] - 'a'];
}
for (int i = 0; i < 26; i++) {
map<long long int, int> m;
for (int idx : v[i]) {
ans += m[pre[idx - 1]];
m[pre[idx]]++;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5 + 10;
int val[30];
string s;
long long int sol;
long long sum[maxN];
map<long long, int> m[30];
int main() {
for (int i = 0; i < 26; i++) cin >> val[i];
cin >> s;
sum[0] = val[s[0] - 'a'];
for (int i = 1; i < s.size(); i++) sum[i] = sum[i - 1] + val[s[i] - 'a'];
for (int i = 0; i < s.size(); i++) {
sol += m[s[i] - 'a'][sum[i - 1]];
m[s[i] - 'a'][sum[i]]++;
}
cout << sol << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long cul[100005];
int main() {
map<long long, long long> hit;
map<long long, map<char, long long> > mark;
for (int i = 0; i < 26; i++) {
int in;
cin >> in;
hit['a' + i] = in;
}
string s;
cin >> s;
cul[0] = hit[s[0]];
for (int i = 1; i < s.size(); i++) {
cul[i] = cul[i - 1] + hit[s[i]];
}
long long res = 0;
for (int i = 0; i < s.size(); i++) {
res += mark[cul[i - 1]][s[i]];
mark[cul[i]][s[i]]++;
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long a, long long b, long long m) {
long long ans = 1;
while (b) {
if (b & 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans;
}
int main() {
long long t = 1, b = 1;
while (t--) {
map<long long, long long> m[26];
long long x[26];
for (char i = 'a'; i <= 'z'; ++i) {
cin >> x[i - 'a'];
}
string s;
cin >> s;
long long pre[s.size()];
pre[0] = x[s[0] - 'a'];
m[s[0] - 'a'][pre[0]]++;
long long c = 0;
for (long long int i = 1; i < s.size(); i++) {
long long y = s[i] - 'a';
c += m[y][pre[i - 1]];
pre[i] = pre[i - 1] + x[y];
m[y][pre[i]]++;
}
cout << c << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int val[27];
long long sum[100005];
vector<int> pos[27];
int main() {
for (int i = 0; i < 26; i++) {
cin >> val[i];
}
char ch = getchar();
char str[1000005];
gets(str + 1);
int len = strlen(str + 1);
for (int i = 1; i <= len; i++) {
sum[i] = sum[i - 1] + val[str[i] - 'a'];
pos[str[i] - 'a'].push_back(i);
}
long long ans = 0;
for (int i = 0; i < 26; i++) {
map<long long, int> mymap;
int siz = pos[i].size();
for (int j = 0; j < siz; j++) {
int curr_pos = pos[i][j];
ans += mymap[sum[curr_pos - 1]];
mymap[sum[curr_pos]]++;
}
mymap.clear();
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[27];
char s[100005];
long long pre1[100005];
map<long long, int> temp;
int main() {
for (int i = 1; i <= 26; i++) scanf("%d", &a[i]);
scanf("%s", s + 1);
memset(pre1, 0, sizeof(pre1));
int len = strlen(s + 1);
for (int i = 1; i <= len; i++) {
pre1[i] = a[s[i] - 'a' + 1] + pre1[i - 1];
}
long long ans = 0;
for (char ch = 'a'; ch <= 'z'; ch++) {
temp.clear();
for (int i = 1; i <= len; i++) {
if (s[i] == ch) {
ans += temp[pre1[i - 1]];
temp[pre1[i]]++;
}
}
}
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1e5 + 100;
char str[maxn];
int num[30];
map<long long, int> mp[30];
int main() {
while (~scanf("%d", &num[0])) {
for (int i = 1; i <= 25; ++i) scanf("%d", &num[i]);
for (int i = 0; i < 26; ++i) mp[i].clear();
scanf("%s", str);
int len = strlen(str);
long long ans = 0, sum = 0;
for (int i = 0; i < len; ++i) {
int x = str[i] - 'a';
if (mp[x][sum]) ans += mp[x][sum];
sum += (long long)num[x];
mp[x][sum]++;
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N[300];
int CH[256];
map<long long, int> M[256];
long long sum[100000];
bool used[30000];
int main() {
for (int i = 0; i < 26; i++) {
int k;
cin >> k;
CH['a' + i] = k;
}
string str;
cin >> str;
long long s = 0;
long long ans = 0;
for (int i = 0; i < str.size(); i++) {
ans += M[str[i]][s];
s += CH[str[i]];
sum[i] = s;
M[str[i]][s]++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, char>, long long> mp;
char ch[200000];
long long s, x[200000];
int main() {
long long ans = 0;
for (int i = 0; i < 26; i++) scanf("%I64d", &x[i]);
scanf("%s", ch + 1);
long long len = strlen(ch + 1);
for (int i = 1; i <= len; i++) {
ans += mp[make_pair(s, ch[i])];
s += x[ch[i] - 'a'];
mp[make_pair(s, ch[i])]++;
}
printf(
"%I64d"
"\n",
ans);
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.