codeforces #271D Good Substrings

原题链接：http://codeforces.com/problemset/problem/271/D

题目原文：

D. Good Substrings

time limit per test

2 seconds

memory limit per test

512 megabytes

input

standard input

output

standard output

You've got string s, consisting of small English letters. Some of the English letters are good, the rest are bad.

A substring s[l...r] (1 ≤ l ≤ r ≤ |s|) of string s  =  s1s2...s|s| (where |s| is the length of string s) is string  slsl + 1...sr.

The substring s[l...r] is good, if among the letters  sl, sl + 1, ..., sr there are at most k bad ones (look at the sample's explanation to understand it more clear).

Your task is to find the number of distinct good substrings of the given string s. Two substrings s[x...y] and s[p...q] are considered distinct if their content is different, i.e. s[x...y] ≠ s[p...q].

Input

The first line of the input is the non-empty string s, consisting of small English letters, the string's length is at most 1500 characters.

The second line of the input is the string of characters "0" and "1", the length is exactly 26 characters. If the i-th character of this string equals "1", then the i-th English letter is good, otherwise it's bad. That is, the first character of this string corresponds to letter "a", the second one corresponds to letter "b" and so on.

The third line of the input consists a single integer k (0 ≤ k ≤ |s|) — the maximum acceptable number of bad characters in a good substring.

Output

Print a single integer — the number of distinct good substrings of string s.

Examples

input

Copy

ababab
01000000000000000000000000
1

output

5

input

Copy

acbacbacaa
00000000000000000000000000
2

output

8

Note

In the first example there are following good substrings: "a", "ab", "b", "ba", "bab".

In the second example there are following good substrings: "a", "aa", "ac", "b", "ba", "c", "ca", "cb".

题意：

这种题目没什么好讲的，就是让你从一个字符串 s 找出有多少个不同字串并且字串中包含的所有字符是坏的总数不超过k；

解题方法：

NO.1   hash+map

我开始就想用map去solve它，不过当时没想到map的复杂度那么大，就直接把字串放map里面比较，所以就超时了。今天加个hash就可以了，不过时间复杂度还是很大。不建议使用。

unordered_map  无序map，比map时间复杂度低效果差不多就是这样子。不过用法都是一样的。

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <queue>
 4 #include <algorithm>
 5 #include <stack>
 6 #include <cmath>
 7 #include <map>
 8 #include <cstring>
 9 #include <bits/stdc++.h>
10 using namespace std;
11 #define mod 1000000007
12 #define PI acos(-1.0)
13 typedef long long ll;
14 //const int INF=0x3f3f3f3f;
15 //const ll INF=1000000000000000000;
16 //priority_queue<int, vector<int>, greater<int> >p;
17 int main()
18 {
19     unordered_map<ll,int>m;
20     char s[2000];
21     char a[30];
22     ll k,sum=0;
23     scanf("%s",s);
24     scanf("%s",a);
25     scanf("%lld",&k);
26     int b[2000]={0};
27     int l=strlen(s);
28     for(int i=1;i<=l;i++)
29         b[i]=b[i-1]+((a[s[i-1]-'a']-'0'+1)%2);
30     for(int i=1;i<=l;i++)
31     {
32         ll temp=0;
33         for(int j=i;j<=l;j++)
34         {
35             if(b[j]-b[i-1]<=k)
36             {
37                 temp=temp*mod+s[j-1];
38                 if(m.find(temp)==m.end())
39                 {
40                     sum++;
41                     m[temp]=1;
42                 }
43             }
44             else break;
45         }
46     }
47     printf("%lld\n",sum);
48     return 0;
49 }

NO.2 hash+数组

把字串hash的数值放到数组里面，然后先排序，用unique查重。时间复杂度低了很多了，内存也好了一半。

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <queue>
 4 #include <algorithm>
 5 #include <stack>
 6 #include <cmath>
 7 #include <map>
 8 #include <cstring>
 9 using namespace std;
10 #define mod 1000000007
11 #define PI acos(-1.0)
12 typedef long long ll;
13 //const int INF=0x3f3f3f3f;
14 //const ll INF=1000000000000000000;
15 //priority_queue<int, vector<int>, greater<int> >p;
16 ll ha[2250005];
17 int main()
18 {
19     map<string,int>m;
20     char s[2000];
21     char a[30];
22     ll k,sum=0;
23     scanf("%s",s);
24     scanf("%s",a);
25     scanf("%lld",&k);
26     int b[2000]={0};
27     int l=strlen(s);
28     for(int i=1;i<=l;i++)
29         b[i]=b[i-1]+((a[s[i-1]-'a']-'0'+1)%2);
30     ll next=0;
31     for(int i=1;i<=l;i++)
32     {
33         ll temp=0;
34         for(int j=i;j<=l;j++)
35         {
36            if(b[j]-b[i-1]>k)break;
37            temp=temp*mod+s[j-1];
38            ha[next++]=temp;
39         }
40     }
41     sort(ha,ha+next);
42     sum=unique(ha,ha+next)-ha;
43     printf("%lld\n",sum);
44     return 0;
45 }

NO.3 hash+set

set直接把重复的数去掉了。。。

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <queue>
 4 #include <algorithm>
 5 #include <stack>
 6 #include <cmath>
 7 #include <map>
 8 #include <cstring>
 9 #include <bits/stdc++.h>
10 using namespace std;
11 #define mod 1000000007
12 #define PI acos(-1.0)
13 typedef long long ll;
14 //const int INF=0x3f3f3f3f;
15 //const ll INF=1000000000000000000;
16 int main()
17 {
18     set<ll>m;
19     char s[2000];
20     char a[30];
21     ll k,sum=0;
22     scanf("%s",s);
23     scanf("%s",a);
24     scanf("%lld",&k);
25     int b[2000]={0};
26     int l=strlen(s);
27     for(int i=1;i<=l;i++)
28         b[i]=b[i-1]+((a[s[i-1]-'a']-'0'+1)%2);
29     for(int i=1;i<=l;i++)
30     {
31         ll temp=0;
32         for(int j=i;j<=l;j++)
33         {
34             if(b[j]-b[i-1]<=k)
35             {
36                 temp=temp*mod+s[j-1];
37                 m.insert(temp);
38             }
39             else break;
40         }
41     }
42     sum=m.size();
43     printf("%lld\n",sum);
44     return 0;
45 }

NO.4 hash+字典树

懒得写了，实现起来原理都是一样的。

好了，这个题就讲到这里，我去看下哪个队需要喊666的队友。