Codeforces Round #294 (Div. 2) D （模拟）

最新推荐文章于 2015-08-15 00:58:53 发布

原创最新推荐文章于 2015-08-15 00:58:53 发布 · 763 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

YY题专栏收录该内容

12 篇文章

订阅专栏

本文探讨了一个在编程竞赛中出现的问题，即如何计算一个字符串中满足特定条件的子串数量。条件包括子串首尾字符相同且除首尾外所有字符的赋值之和为零。通过引入每个字母的赋值来解决问题，并采用离散化技术和线性复杂度方法进行求解。

A and B are preparing themselves for programming contests.

After several years of doing sports programming and solving many problems that require calculating all sorts of abstract objects, A and B also developed rather peculiar tastes.

A likes lowercase letters of the Latin alphabet. He has assigned to each letter a number that shows how much he likes that letter (he has assigned negative numbers to the letters he dislikes).

B likes substrings. He especially likes the ones that start and end with the same letter (their length must exceed one).

Also, A and B have a string s. Now they are trying to find out how many substrings t of a string s are interesting to B (that is, t starts and ends with the same letter and its length is larger than one), and also the sum of values of all letters (assigned by A), except for the first and the last one is equal to zero.

Naturally, A and B have quickly found the number of substrings t that are interesting to them. Can you do it?

Input

The first line contains 26 integers xa, xb, ..., xz ( - 105 ≤ xi ≤ 105) — the value assigned to letters a, b, c, ..., z respectively.

The second line contains string s of length between 1 and 105 characters, consisting of Lating lowercase letters— the string for which you need to calculate the answer.

Output

Print the answer to the problem.

Sample test(s)

input
1 1 -1 1 1 1 1 1 1 1 1 1 1 1 1 7 1 1 1 8 1 1 1 1 1 1
xabcab

output
2

input
1 1 -1 1 1 1 1 1 1 1 1 1 1 1 1 7 1 1 1 8 1 1 1 1 1 1
aaa

output
2

Note

In the first sample test strings satisfying the condition above are abca and bcab.

In the second sample test strings satisfying the condition above are two occurences of aa.

题意：第一行给出每个字母的价值val，第二行是一个字符串，在字符串中找到满足如下条件的子串的个数：

1.首尾字母相同

2.除首尾外其他字母价值总和为0

有两个条件而且数据量是10^5 ，所以要找一个接近线性复杂度的方法

所以可以想到以前i项价值和建数组，每个价值和对应的26个字母分别有多少个即可

这样会超内存的所以我用了离散化，就ac了...也正因为2在这里...直接用map处理就相当于离散化了....

我的代码：

//Memory: 12600 KB		Time: 31 MS
#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
#define M 100010
#define ll long long
int val[30];
struct node {
    int tab;
    ll a;
}sum[M];
char s[M];
ll tmp;
int Hash[M];
int cnt[M][27];
ll ans;
bool cmp(const node&a,const node&b){
    return a.a<b.a;
}
int main(){
    for(int i=0;i<26;i++){
        scanf("%d",&val[i]);
    }
    scanf("%s",s);
    int len =strlen(s);
    for(int i=0;i<len;i++){
        tmp+=val[s[i]-'a' ];
        sum[i].tab=i;
        sum[i].a=tmp;
    }
    sort(sum,sum+len,cmp);
    int l=0;
    Hash[sum[0].tab ]=l;
    for(int i=1;i<len;i++){//离散化...
        if(sum[i].a==sum[i-1].a){
            Hash[sum[i].tab ]=l;
        }
        else Hash[sum[i].tab ]=++l;
    }
    cnt[Hash[0]][s[0]-'a']++;
    for(int i=1;i<len;i++){
        ans+=cnt[Hash[i-1]  ][s[i]-'a' ];
        cnt[Hash[i]  ][s[i]-'a']++;
    }
    printf("%I64d\n",ans);
    return 0;
}

大神的代码：

// 75ms
#include<iostream>
#include<fstream>
#include<cstdio>
#include<vector>
#include<string>
#include<cstring>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
#include<iomanip>
#include<bitset>
using namespace std;

const int N = 100100;

int val[27];
char a[N];
int n;
map<long long, int> h[26];

int main() {
    int i;
   
    for(i = 0; i < 26; ++i) {
        cin >> val[i];
    }
    cin >> (a + 1);
        n = strlen(a + 1);

    long long sc = 0, rez = 0;

    for(i = 1; i <= n; ++i) {
        a[i] -= 'a';
        sc += val[a[i]];

        rez += h[a[i]][sc - val[a[i]]];
        h[a[i]][sc]++;
    }

    cout << rez;

    return 0;
}