#Codeforces Round #341 (Div. 2)

@(E ACMer)

C. Wet Shark and Flowers（概率+容斥）

题意：先给一个素数 p ，有 n 个人，围成一圈，每个人有会等概率的取自己区间中的一个数，如果两个相邻的人的数的乘积能被p整除，那么这两个人就会一人获得1000元，问你整个圈的人期望得到的钱是多少？
分析：首先，根据素数的性质：两个数的乘积要能被 p 整除，等价于两个数中至少一个数能被 p 整除。
那么对于第 i 个人我们就开始研究，它为能被 p 整除的概率:

Pi=r/p−(l−1)/p

那么根据容斥原理两个相邻的人获得的钱的期望就是：

(Pi+Pi+1−Pi∗Pi+1)∗2000

比赛的时候比较慌，连每个人的概率都没有分析清楚=——=，直接YY了一个方法，下来才想到正解。比赛的时候应该冷静地想清楚思路。
我的Code如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
#include <map>
#include <stack>
#include <vector>
#include <string>
#include <queue>
#include <cstdlib>
#include <cmath>
#include <algorithm>
using namespace std;
typedef pair<int, int> pii;
typedef unsigned long long ull;
typedef long long ll;
typedef vector<int> vi;
#define xx first
#define yy second
#define rep(i, a, n) for (int i = a; i < n; i++)
#define sa(n) scanf("%d", &(n))
#define vep(c) for(decltype((c).begin()) it = (c).begin(); it != (c).end(); it++)
const int mod = int(1e9) + 7, INF = 0x3fffffff, maxn = 1e5 + 12;
int a[maxn], b[maxn];
int n, p;

int doit(int l, int r) {
    return r / p - (l - 1) / p;
}

int main(void)
{
    cin >> n >> p;
    double temp = 0;
    double ans = 0, q = 0;
    for (int i = 0; i < n; i++) {
        int x, y;
        sa(x), sa(y);
        a[i] = doit(x, y);
        b[i] = y - x + 1;
        // cout << a[i] << " " << b[i] << endl;
        // temp *= (y - x + 1);
    }
    for (int i = 0; i < n; i++) {
        ans = double(a[i]) * b[i + 1 == n ? 0 : i + 1] + double(a[i + 1 == n ? 0 : i + 1]) * (b[i] - a[i]);
        temp = double(b[i]) * b[i + 1 == n ? 0 : i + 1];
        //if (ans > temp) cout << i << ": " << a[i] << " " << b[i] << endl;
        q += ans / temp * 2000;
    }

    printf("%.14f\n", q);
    return 0;
}

E. Wet Shark and Blocks（dp + 矩阵快速幂）

题意：有一个长度为 n 的数列，有 b 组相同的这样的数列，从每组数列中选取一个数，串成的一个长数字，问取余 x 等于 k 的数字有多少个？
分析：
很容易想到状态定义: dp[i][k] 表示前 i 组数列构成的取余x余数为 k 的数字的个数.
那么根据大数取余的性质容易有:

dp[i][k]=∑dp[i−1][j]∗cnt[a] (其中(j∗10+a)%x=j 且a∈[0,9])

这样就是求 dp[b][k] ,直接暴力dp显然不能, 109 的数据范围,会想到矩阵快速幂来优化,直接是初始状态乘以转移矩阵的 b 次方.
那么如何构造这个转移矩阵?
首先根据矩阵乘法的性质,转移矩阵 move[k][j]=x ,代表的意思是把原矩阵的 i 列的 x 倍加到新矩阵的第 j 列上.
这时观察状态转移方程,我们需要的是将原矩阵的第 j 列的 cnt[a] 倍加到新矩阵的第 k 列上 (其中(j∗10+a)%x=j 且a∈[0,9]) ,这样令:

move[k][j]=cnt[a], (其中(j∗10+a)%x=j 且a∈[0,9])

就构造好了转移矩阵.
Code如下:

#include <iostream>
#include <cstdio>
#include <cstring>
#include <set>
#include <map>
#include <stack>
#include <vector>
#include <string>
#include <queue>
#include <cstdlib>
#include <cmath>
#include <algorithm>
using namespace std;
typedef pair<int, int> pii;
typedef long long ull;
typedef long long ll;
typedef vector<int> vi;
#define xx first
#define yy second
#define rep(i, a, n) for (int i = a; i < n; i++)
#define sa(n) scanf("%d", &(n))
#define vep(c) for(decltype((c).begin()) it = (c).begin(); it != (c).end(); it++)
const int mod = int(1e9) + 7, INF = 0x3fffffff, maxn = 1e5 + 12;
int x;

//建立一个矩阵类
class matrix
{
public:
    ll v[100][100];

    matrix(int y) {
        for (int i = 0; i < 100; i++) {
            for (int j = 0; j < 100; j++) {
                v[i][j] = i == j ? y : 0;
            }
        }
    }

    //矩阵乘法,操作符重载
    matrix operator*(matrix& temp) {
        matrix ret(0);
        for (int i = 0; i < x; i++) {
            for (int j = 0; j < x; j++) {
                for (int k = 0; k < x; k++) {
                    ret.v[i][j] = (ret.v[i][j] + 1ll * v[i][k] * temp.v[k][j]) % mod;
                }
            }
        }
        return ret;
    }

    //矩阵乘方,操作符重载
    matrix operator^(int n) {
        matrix ret(1), b = *this;
        while (n) {
            if (n & 1) ret = ret * b;
            b = b * b;
            n >>= 1;
        }
        return ret;
    }
};


int main(void)
{
    //freopen("in.txt", "r", stdin);
   // freopen("out.txt", "w", stdout);
    int n, b, k;
    cin >> n >> b >> k >> x;

    int cnt[10];//对于每组数列,我们只关心每个数的个数 
    memset(cnt, 0, sizeof(cnt));
    for (int i = 0; i < n; i++) {
        int x;
        sa(x);
        cnt[x]++;
    }


    matrix move(0);

    //构造转移矩阵
    for (int i = 0; i < x; i++) {
        for (int j = 0; j < 10; j++) {
            move.v[i][(i * 10 + j) % x] += cnt[j];
        }
    }

    move = move ^ b;
    cout << move.v[0][k] << endl;
}