给出两个字符串S和T,长度相等,由小写字母‘a’、‘b’、‘c’组成。每次操作,你可以对字符串S进行如下操作之一:
1、 选择S的一个字符‘a’,把该字符变成字符‘b’,费用是cost[0]。
2、 选择S的一个字符‘b’,把该字符变成字符‘c’,费用是cost[1]。
3、 选择S的一个字符‘c’,把该字符变成字符‘a’,费用是cost[2]。
你的目标是把字符串S变成T,但是总费用不能超过给定的maxCost,有多少种不同的操作方式?答案模1000000007。 不同的操作方式为:在第某轮操作时,操作方式A和B选择不同位置的字符进行变化。
1 <= cost[0]、cost[1]、cost[2] <= 1000000000。
0 <= maxCost <= 1000000000。
粗看题目,比较敏感的就是字符串的长度很短,最多只有3的11次方种状态。还有就是MaxCost很大,所以要快速求解,这自然就想到矩阵乘法。
我们不能记录下当前用了多少Cost,所以我们要去掉这个限制。想想,若要从S变成T,最多能走多少步。首先可以算出从S变成T至少需要多少步,然后在剩下的步数里,S一定要回到原来的样子,也就是说某些字符刚好转了一圈(比如'a' -> 'b' -> 'c' -> 'a'),而这个花费刚好是cost[0] + cost[1] + cost[2]。所以,最多只能走(maxCost - minCost(从S变成T的最少费用)) / (cost[0] + cost[1] + cost[2]) * 3 + minStep(从S变成T至少需要多少步)。
接着就是矩阵乘法的经典问题了:在一个图内,从A点出发经过K部到达B点有多少种方案。
我们就把每种状态看作一个结点,然后再加边。
然而,点数实在太多了,我们得换一种方法记录状态。
设f(i, j, k) 为有i个字符已经是对应的目标状态,有j个字符要旋转一次才能到目标状态,有k个字符要旋转两次到目标状态。
例如:S = "abc", T = "aab", 那么就是 f(1, 0, 2),可以发现i + j + k = n,所以只需要记下i, j,k也能计算出来。状态数有: 12 * 13 / 2 = 78种。
设该矩阵为A, 原矩阵为B, 一种做法就是算出 BA + BA^2 + BA^3 + ... + BA^maxStep(最大步数) = B (A + A^2 + A^3 + ... + A^maxStep)
= B (A + A^2 + A^3 + .. + A^(maxStep/2) * (A + A^2 + A^3 + ..)) 大概是这个样子,时间复杂度为 (m ^ 3) * ( (log 2 maxStep)^2 ) (m为矩阵边长)。
另外一种是多加一个点设为Succ,然后再图中在目标状态f(n, 0) 和 Succ 加一条单向边,进入Succ即表示操作结束。
然后在Succ加一条回边,用于累加答案,问题就为 A B' ^ maxStep, 时间少了一个log,而且方便快捷。
贴上代码:
#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
#define maxn 13
#define maxt 80
int n, step;
string source, target;
int MaxCost, cost[3], Count[3];
void Init() {
cin >> source >> target;
for (int i = 0; i < 3; i ++) cin >> cost[i];
cin >> MaxCost;
n = source.size(); // The length of string
}
void ComputeStep() {
int res = 0;
for (int i = 0; i < n; i ++) {
char ch = source[i];
int cnt = 0;
while (ch != target[i]) {
cnt ++;
if (ch == 'a') {
ch = 'b';
MaxCost -= cost[0];
}
else if (ch == 'b') {
ch = 'c';
MaxCost -= cost[1];
}
else if (ch == 'c') {
ch = 'a';
MaxCost -= cost[2];
}
}
if (MaxCost <= 0) return; //no solution
res += cnt;
Count[cnt] ++;
}
// MaxCost - MinCost
step = (MaxCost / (cost[0] + cost[1] + cost[2])) * 3 + res;
}
int pos[maxn][maxn];
struct Matrice {
ll G[maxt+1][maxt+1];
}Start, Result, tmp;
int m;
void Graph() {
for (int i = 0; i <= n; i ++)
for (int j = 0; j + i <= n; j ++)
pos[i][j] = ++ m;
memset(Start.G, 0, sizeof(Start.G));
for (int i = 0; i <= n; i ++)
for (int j = 0; j + i <= n; j ++) {
int k = n - i - j;
if (i > 0) Start.G[ pos[i][j] ][ pos[i-1][j] ] = (ll) i;
if (j > 0) Start.G[ pos[i][j] ][ pos[i+1][j-1] ] = (ll) j;
if (k > 0) Start.G[ pos[i][j] ][ pos[i][j+1] ] = (ll) k;
}
Start.G[ pos[n][0] ][0] = (ll) 1;
Start.G[0][0] = 1LL;
}
int stack[37], top = -1; // log 2 mod
void Mul(Matrice &a, Matrice &b, Matrice &c) {
memset(tmp.G, 0, sizeof(tmp.G));
for (int i = 0; i <= m; i ++)
for (int j = 0; j <= m; j ++)
for (int k = 0; k <= m; k ++) {
tmp.G[i][j] += a.G[i][k] * b.G[k][j];
tmp.G[i][j] %= mod;
}
memcpy(c.G, tmp.G, sizeof(c.G));
}
void Solve() {
step ++;
while (step > 0) {
stack[++ top] = step;
step >>= 1;
}
top --;
memcpy(Result.G, Start.G, sizeof(Result.G));
while (top >= 0) {
Mul(Result, Result, Result);
if (stack[top] & 1) Mul(Result, Start, Result);
top --;
}
int line = pos[ Count[0] ][ Count[1] ];
cout << Result.G[line][0] << endl;
}
int main() {
freopen("vert.in", "r", stdin);
freopen("vert.out", "w", stdout);
Init();
ComputeStep();
if (step == 0)
if (source == target) cout << (int) 1 << endl;
else cout << (int) 0 << endl;
else {
Graph();
Solve();
}
return 0;
}