C,可以推出，k个连续的字符串是满足等比数列的关系的。
    所以我们只需求出a1 和比例q就可以了。
    首相就是只有一个字符串的时候，所有的删除的总和。
    q就是pow（2 , l），l是字符串的长度。
    等比数列求和公式 （a1 * （q ^ n - 1）） / （q - 1）%MOD .先将a1 拿到外面去，不参与计算。我们设q ^ n - 1为a ,q - 1 为b .那么式子就变成a / b %MOD .这就变成很熟悉的拓展欧几里德了，先求出b % MOD的逆元x . x * b % MOD  = 1 ,那么 （a / b ） %MOD * （x * b） % MOD 的值不变，那么可以将式子化简成（a * x） % MOD .
    最后再将a1乘上即可。
    #define MOD 1000000007
    char a[111111] ;
    inline ll extend_gcd（ll a ,ll b , ll& x , ll& y）{
    ll ans , t ;
    if（b == 0）{
    x = 1 ;
    y = 0 ;
    return a ;
    }
    ans = extend_gcd（b , a % b ,x ,y ） ;
    t = x ;
    x = y ;
    y = t - （a / b） * y ;
    return ans ;
    }
    ll quick_pow（ll a ,ll b , ll M）{
    ll ret = 1 ;
    ll temp = a ;
    while（b）{
    if（b & 1）{
    ret = （ret * temp） % M ;
    }
    temp = （temp * temp） % M  ;
    b 》= 1 ;
    }
    return ret ;
    }
    int main（）{
    cin 》 a ;
    int k ;
    cin 》 k ;
    int l = strlen（a） ;
    ll a1 = 0 ;
    REP（i , 0 ,l - 1 ）{
    if（a[i] == '0' || a[i] == '5'）{
    a1 = （a1 + quick_pow（2 ,i ,MOD）） % MOD ;
    }
    }
    ll a = quick_pow（2 , l ,MOD） ;
    ll aa = （a - 1 + MOD） % MOD ;
    ll x , y ;
    extend_gcd（aa ,MOD , x ,y） ;
    x = （x + MOD） % MOD ;
    ll c = （quick_pow（a , k  ,MOD） - 1） * x % MOD ;
    ll ans = c * a1 % MOD ;
    cout 《 ans 《 endl;
    return 0 ;
    }
    D,DFS,每次进入一个空地，先将他建成蓝色的，然后向四个方向DFS,最后回溯的时候将这个蓝色的建筑拆掉建成红色的，当然第一个进入的点是不能建成红色的。
    这个很容易证明，一个联通块里面，肯定有一个是蓝色的，其他都是红色的。
    int n , m ;
    char op[11111111] ;
    int xx[11111111] ;
    int yy[11111111] ;
    int ss[555][555] ;
    char Map[555][555] ;
    int num = 0 ;
    void dfs（int x ,int y ,int first ） {
    if（x < 1 || x > n || y < 1 || y > m）return ;
    op[num] = 'B' ;
    xx[num] =  x ;
    yy[num] = y ;
    num ++ ;
    ss[x][y] = 0 ;
    if（ss[x - 1][y]）dfs（x - 1 ,y , 1） ;
    if（ss[x][y - 1]）dfs（x ,y - 1 ,1 ） ;
    if（ss[x + 1][y]）dfs（x + 1 ,y , 1） ;
    if（ss[x][y + 1]）dfs（x ,y + 1 ,1 ） ;
    if（first） {
    op[num] = 'D' ;
    xx[num] = x ;
    yy[num] = y ;
    num ++ ;
    op[num] = 'R' ;
    xx[num] = x ;
    yy[num] = y ;
    num ++ ;
    }
    }
    int main（） {
    cin 》 n 》 m ;
    for （int i = 1 ; i <= n ; i ++ ） {
    for （int j = 1 ; j <= m ; j ++ ） {
    cin 》 Map[i][j] ;
    if（Map[i][j] == '.'） {
    ss[i][j] = 1 ;
    }
    }
    }
    for （int i = 1 ; i <= n ; i ++ ） {
    for （int j = 1 ; j <= m ; j ++ ） {
    if（ss[i][j]） {
    dfs（i ,j , 0 ） ;
    }
    }
    }
    cout 《 num 《 endl;
    for （int i = 0 ; i < num ; i ++ ） {
    cout 《 op[i] 《 " " 《 xx[i] 《 " " 《 yy[i] 《 endl;
    }
    return 0 ;
    }
    E.状态压缩DP.
    枚举1《 24的状态。
    #include <iostream>
    #include <cstdio>
    #include <algorithm>
    #include <string>
    #include <cmath>
    #include <cstring>
    #include <queue>
    #include <set>
    #include <vector>
    #include <stack>
    #include <map>
    #include <iomanip>
    #define PI acos（-1.0）
    #define Max 2505
    #define inf 1《28
    #define LL（x） （ x 《 1 ）
    #define RR（x） （ x 《 1 | 1 ）
    #define REP（i,s,t） for（ int i = （ s ） ; i <= （ t ） ; ++ i ）
    #define ll long long
    #define mem（a,b） memset（a,b,sizeof（a））
    #define mp（a,b） make_pair（a,b）
    #define PII pair<int,int>
    using namespace std;
    #define MOD 1000000007
    inline void RD（int &ret） {
    char c;
    do {
    c = getchar（）；
    } while（c < '0' || c > '9'） ;
    ret = c - '0';
    while（（c=getchar（）） >= '0' && c <= '9'）
    ret = ret * 10 + （ c - '0' ）；
    }
    int a[111111] ;
    int sum[1 《 24] ;
    int dp[1 《 24] ;
    int k[11] ;
    int main（）{
    int n ;
    cin 》 n  ;
    for （int i = 0 ;i < n ; i ++ ）{
    RD（a[i]） ;
    }
    int m ;
    cin 》 m ;
    for （int i = 0 ;i < m ;i ++ ）{
    RD（k[i]） ;
    }
    dp[0] = 1 ;
    for （int i = 1 ;i < （1 《 n） ; ++ i）{//枚举当前路径
    int pos ;
    bool flag = 0 ;
    sum[i] = 0 ;
    for （int j = 0 ;j < n ;j ++ ）{
    if（i & （1 《 j））{//i 在 j 这点为1 ,直接在这里找出sum[i]的值会T.O（2 ^ 24 *  n）
    pos = j ;//一开始我直接写sum[i] += a[j] ;就T了
    break ;
    }
    }
    sum[i] = sum[i ^ （1 《 pos）] + a[pos] ;//i 状态的所有步数。
    for （int j = 0 ; j < m ;j ++ ）{//i状态的步数是否不能走。
    if（sum[i] == k[j]）{
    dp[i] = 0 ;
    flag = 1 ;
    break ;
    }
    }
    if（flag）continue ;
    dp[i] = 0 ;
    for （int j = 0 ;j < n ;j ++ ）{
    if（i & （1 《 j））{//i 这位可以由i ^ （1 《 j ）这一状态过来。
    dp[i] = （dp[i] + dp[i ^ （1 《 j）]） ;
    if（dp[i] >= MOD）dp[i] -= MOD ;
    }
    }
    }
    cout 《 dp[（1 《 n） - 1] 《 endl;
    return 0 ;
    }