[报告]ZJU 3651 Cipher Lock

Abstract

ZJU 3651 Cipher Lock

组合计数 DP 矩阵乘法

Body

Source

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3651

Description

N个点围成一个环，每个点有两个属性(u, v)，取值范围分别是[1, p]和[1, q]。已知其中8个点的属性，问有多少个环，满足相邻两点至少有一个属性值相同。

Solution

很明显的用矩阵加速的dp统计题。

一开始想错状态，把起点的情况也考虑进去，弄了个3x3({us,ut,其他}x{vs,vt,其他})=9维的矩阵，然后还要考虑vs,vt相等或者us,ut相等之类的情况，写了一下午，一脸血。

后来观察了下，发现合并后，其实跟起点的情况没有关系。

首先把点按照坐标排序，算相邻点之间的方案数，最后乘起来即可。

对于相邻的点，记f(n,{0,1},{0,1})表示从起点开始走n个点，u和终点的u是否相等，v和终点的v是否相等的方案数。转移比较容易。由于n很大所以要用矩阵乘法加速。

注意有点坐标相同的情况，特殊判断一下。

Code

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

typedef long long ll;

const ll mod = 1234567890ll;

struct sm {
    ll m[4][4];
    void init() {memset(m, 0, sizeof m);}
    sm() {init();}
    void eye() {for (int i = 0; i < 4; ++i) m[i][i] = 1;}
};

sm operator*(const sm &a, const sm &b) {
    sm res;
    for (int i = 0; i < 4; ++i)
        for (int j = 0; j < 4; ++j)
            for (int k = 0; k < 4; ++k)
                if (a.m[i][k] && b.m[k][j])
                    res.m[i][j] = (res.m[i][j]+a.m[i][k]*b.m[k][j])%mod;
    return res;
}

sm operator^(sm x, ll p) {
    sm res;
    res.eye();
    for (; p; p>>=1) {
        if (p&1) res = res*x;
        x = x*x;
    }
    return res;
}

struct snode {
    ll x, u, v;
    void read() {cin>>x>>u>>v; x--; u--; v--;}
    bool operator<(const snode &rhs) const {
        return x < rhs.x;
    }
}node[10];

ll N, p, q;

ll solve() {
    int i, j, k;
    ll res = 1;
    sort(node, node+8);
    node[8] = node[0];
    node[8].x += N;
    sm m;
    m.m[0][0]=m.m[0][1]=m.m[0][2]=m.m[1][3]=m.m[2][3] = 1;
    m.m[1][0]=m.m[1][1]=m.m[3][2] = (q-1)%mod;
    m.m[2][0]=m.m[2][2]=m.m[3][1] = (p-1)%mod;
    m.m[3][3] = p>1&&q>1?(p+q-3)%mod:0;
    //from i to i+1
    for (i = 0; i < 8; ++i) {
        if (node[i].x==node[i+1].x) {
            if (node[i].u^node[i+1].u || node[i].v^node[i+1].v) return 0;
            else continue;
        }
        sm now = m^(node[i+1].x-node[i].x);
        j = ((node[i].u!=node[i+1].u)<<1)|(node[i].v!=node[i+1].v);
        res = (res*now.m[0][j])%mod;
    }
    res %= mod;
    if (res<0) res += mod;
    return res;
}

int main() {
    int i, j, k;
    while (cin>>N>>p>>q) {
        for (i = 0; i < 8; ++i)
            node[i].read();
        cout<<solve()<<endl;
    }
    return 0;
}