#Codeforces Round #341 (Div. 2)

@(E ACMer)

C Wet Shark and Flowers概率容斥

E Wet Shark and Blocksdp 矩阵快速幂

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[k],直接暴力dp显然不能,109的数据范围,会想到矩阵快速幂来优化,直接是初始状态乘以转移矩阵的b次方.

[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;
}