"字串转换vert" 矩阵乘法 巧妙加点

给出两个字符串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;
}