LightOJ 1052 String Growth && uva 12045 Fun with Strings （矩阵快速幂）

Jan's LightOJ :: Problem 1052 - String Growth

uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=3196

　　很好的一题，也是我的队友xdp给我的题。

　　题意是根据字符串的变化规律，给出第n次和第m次变化的时候的长度，求出第k次变化时的长度。

　　开始的时候感觉这是难题，不过仔细想了一下，发现只需要高斯消元（其实在我这里只是一个简单的解二元一次方程组罢了。。囧）解出起始的时候a和b的个数，然后套上矩阵快速幂就可以得到第k项了。这题搞了整整一天，WA的地方居然是一个int没有改成LL。开始的时候，以为高斯消元做除法的过程中不会溢出，结果不知道为什么的，被我搞了好多数据之后，发现了一个会导致溢出的数据，改过来之后就过了！

代码如下：

#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <iostream>

using namespace std;

#define REP(i, n) for (int i = 0; i < (n); i++)
#define REP_1(i, n) for (int i = 1; i <= (n); i++)

typedef long long LL;

LL fab[60];
void preFab() {
    fab[0] = 0ll;
    fab[1] = 1ll;
    REP_1(i, 58) {
        fab[i + 1] = fab[i] + fab[i - 1];
//        cout << i + 1 << ' ' << fab[i + 1] << endl;
    }
}

LL mat[2][3];

void swapRow() {
    REP(i, 3) swap(mat[0][i], mat[1][i]);
}

bool test(int n, LL x, int m, LL y, int &a, int &b) {
    if (n > 50 || m > 50) return false;
    if (fab[n - 1] > x) return false;
    if (fab[m - 1] > y) return false;
    REP(i, 2) {
        mat[0][i] = fab[n + i];
        mat[1][i] = fab[m + i];
    }
    mat[0][2] = x;
    mat[1][2] = y;
    while (true) {
        if (mat[0][0] > mat[1][0]) swapRow();
        if (mat[0][0]) {
            LL tmp = mat[1][0] / mat[0][0];
            REP(i, 3) mat[1][i] -= tmp * mat[0][i];
        } else {
            break;
        }
    }
    swapRow();
//    REP(i, 2) {
//        REP(j, 3) {
//            cout << mat[i][j] << ' ';
//        }
//        cout << endl;
//    }

    LL ans[2];
    for (int i = 1; i >= 0; i--) {
        if (mat[i][i]) {
            if (mat[i][2] % mat[i][i]) return false;
            ans[i] = mat[i][2] / mat[i][i];
            if (ans[i] < 0) return false;
            for (int j = i - 1; j >= 0; j--) {
                mat[j][2] -= mat[j][i] * ans[i];
                mat[j][i] = 0ll;
            }
        } else {
            if (mat[i][2]) return false;
            ans[i] = 0ll;
        }
    }
    a = ans[0], b = ans[1];

//    REP(i, 2) {
//        REP(j, 3) {
//            cout << mat[i][j] << ' ';
//        }
//        cout << endl;
//    }
//    cout << a << "~~" << b << endl;
    return true;
}

const int matSize = 2;
const LL mod = 1000000007;
struct Mat {
    LL val[matSize][matSize];
    Mat(LL one = 0ll) {
        REP(i, matSize) {
            REP(j, matSize) {
                val[i][j] = 0ll;
            }
            val[i][i] = one;
        }
    }
    void print() {
        REP(i, 2) {
            REP(j, 2) {
                cout << val[i][j] << ' ';
            }
            cout << endl;
        }
        cout << "~~~" << endl;
    }
} ;

Mat operator * (Mat &a, Mat &b) {
    Mat ret = Mat();
    REP(i, matSize) {
        REP(k, matSize) {
            REP(j, matSize) {
                ret.val[i][j] += a.val[i][k] * b.val[k][j] % mod;
            }
        }
    }
    return ret;
}

Mat operator ^ (Mat &a, int p) {
    Mat ret = Mat(1);
    Mat _a = a;
    while (p > 0) {
        if (p & 1) {
            ret = ret * _a;
        }
        _a = _a * _a;
        p >>= 1;
    }
    return ret;
}

LL work(int k, int a, int b) {
    Mat Base = Mat();
    Mat op = Mat();
    op.val[0][1] = op.val[1][0] = op.val[1][1] = 1ll;
    Base.val[0][0] = (LL) a;
    Base.val[0][1] = (LL) b;
    op = op ^ (k - 1);
//    op.print();
    Base = Base * op;
//    Base.print();
    return (Base.val[0][0] + Base.val[0][1]) % mod;
}

LL bruceForce(int k, int a, int b) {
    LL na = (LL) a, nb = (LL) b;
    REP(i, k - 1) {
        nb += na;
        na = nb - na;
        nb %= mod;
    }
    return (na + nb) % mod;
}

int main() {
//    freopen("in", "r", stdin);
    preFab();
    int n, m, k, na, nb, T;
    LL x, y;
    cin >> T;
    REP_1(cas, T) {
        cin >> n >> x >> m >> y >> k;
        printf("Case %d: ", cas);
        if (test(n, x, m, y, na, nb)) {
//            cout << na << ' ' << nb << endl;
            cout << work(k, na, nb) << endl;
//            cout << "~~~~~~~~ " << bruceForce(k, na, nb) << endl;
        } else {
            puts("Impossible");
        }
    }
    return 0;
}

测试数据是：

Sample in:

4
1 1 2 1 10
7 277 8 448 1
39 842831057 38 321932817 1 （错在这个数据了）
1 1003 7 16343 9000000

Sample out:

Case 1: 55
Case 2: 17
Case 3: Impossible
Case 4: 147991426

——written by Lyon