【矩阵树】BZOJ1002轮状病毒

最新推荐文章于 2019-01-26 21:17:44 发布

616156

最新推荐文章于 2019-01-26 21:17:44 发布

阅读量212

点赞数

分类专栏：矩阵树图论高斯消元

本文链接：https://blog.csdn.net/qq_34454069/article/details/80962831

版权

图论同时被 3 个专栏收录

50 篇文章 2 订阅

订阅专栏

高斯消元

11 篇文章 0 订阅

订阅专栏

矩阵树

2 篇文章 0 订阅

订阅专栏

分析：

矩阵树定理，参见https://blog.csdn.net/qq_34454069/article/details/78035152

但这道题要用到高精度，如果一昧地使用矩阵树，可能会被卡精度，而且代码极其复杂。

所以观察一下性质，设 $F(n)$ 为n个点的生成树总数，满足 $F(n)=3*F(n-1)-F(n-2)+2$
其证明就是手算矩阵的过程：
首先根据矩阵树定理，删去任意一行任意一列（即第一行与第一列）

3 - 1 0 \dots \dots - 1 - 1 3 - 1 0 \dots \dots - 1 3 \dots \dots \dots \dots \dots \dots - 1 - 1 - 1 \dots \dots \dots \dots 3

$\begin{matrix} 3 & -1 & ……&…… & -1\\ -1 & 3 & -1 &……&…… \\ 0 & -1 & 3 &-1 & ……\\ ……\\ -1 & 0 & …… & -1 & 3 \end{matrix}$
现在根据行列式的性质，我们交换1、2行，2、3行，3、4行……
于是变成了这个样子：

- 1 0 \dots \dots - 1 3 3 - 1 0 - 1 - 1 3 \dots \dots \dots \dots \dots \dots - 1 - 1 \dots \dots \dots \dots \dots \dots 3 - 1

$\begin{matrix} -1 & 3 & -1 &……&…… \\ 0 & -1 & 3 &-1 & ……\\ ……\\ -1 & 0 & …… & -1 & 3\\ 3 & -1 & ……&…… & -1 \end{matrix}$
现在我们发现，除了最后两行，其余的只剩下上弦三角形了。
所以要消去这两行。
尝试去模拟一下消的过程，你就会得到这个递推式了。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#include<cmath>
#include<iomanip>
#include<vector>
#define SF scanf
#define PF printf
#define MAXN 110
using namespace std;
int n;
typedef long long ll;
struct big {
    static const int BASE = 10000;   // µ±Ö»Ê¹ÓÃ¼Ó¼õ·¨Ê±¿ÉÒÔ½ÚÊ¡¿Õ¼ä£¬°Ñ
    static const int WIDTH = 4;      // BASE ¸Ä³É 100000000£¬WIDTH ¸Ä³É 8
    std::vector<int> s;

    big(long long num = 0) { *this = num; }
    big(const std::string& str) { *this = str; }
    big operator = (long long num) {
        s.clear();
        do {
            s.push_back(num % BASE);
            num /= BASE;
        } while (num > 0);
        return *this;
    }
    big operator = (const std::string& str) {
        s.clear();
        int x, len = (str.length() - 1) / WIDTH + 1;
        for (int i = 0; i < len; i++) {
            int end = str.length() - i * WIDTH;
            int start = std::max(0, end - WIDTH);
            sscanf(str.substr(start, end - start).c_str(), "%d", &x);
            s.push_back(x);
        }
        return *this;
    }

    bool operator < (const big& b) const {
        if (s.size() != b.s.size()) return s.size() < b.s.size();
        for (int i = s.size() - 1; i >= 0; i--)
            if (s[i] != b.s[i]) return s[i] < b.s[i];
        return false;
    }
    bool operator > (const big& b) const { return b < *this; }
    bool operator <= (const big& b) const { return !(b < *this); }
    bool operator >= (const big& b) const { return !(*this < b); }
    bool operator != (const big& b) const { return b < *this || *this < b; }
    bool operator == (const big& b) const { return !(b < *this) && !(*this < b); }

    big operator + (const big& b) const {
        big c;
        c.s.clear();
        for (int i = 0, g = 0; ; i++) {
            if (g == 0 && i >= s.size() && i >= b.s.size()) break;
            int x = g;
            if (i < s.size()) x += s[i];
            if (i < b.s.size()) x += b.s[i];
            c.s.push_back(x % BASE);
            g = x / BASE;
        }
        return c;
    }
    big operator - (const big& b) const {
        big c;
        c.s.clear();
        if (*this == b) {
            c.s.push_back(0);
        } else if (*this < b) {
            for (int i = 0, g = 0; ; i++) {
                if (g == 0 && i >= b.s.size() && i >= s.size()) {
                    c.s[i - 1] = -c.s[i - 1]; break;
                }
                int x = g;
                if (i < b.s.size()) x += b.s[i];
                if (i < s.size()) x -= s[i];
                if (x < 0) {
                    c.s.push_back(BASE + x % BASE);
                    g = x / BASE - 1;
                } else {
                    c.s.push_back(x % BASE);
                    g = x / BASE;
                }
            }
        } else {
            for (int i = 0, g = 0; ; i++) {
                if (g == 0 && i >= s.size() && i >= b.s.size()) break;
                int x = g;
                if (i < s.size()) x += s[i];
                if (i < b.s.size()) x -= b.s[i];
                if (x < 0) {
                    c.s.push_back(BASE + x % BASE);
                    g = x / BASE - 1;
                } else {
                    c.s.push_back(x % BASE);
                    g = x / BASE;
                }
            }
        }
        return c;
    }

    big operator * (const big& b) const {
        big c; int len = s.size() + b.s.size(); bool flag = false;
        c.s.clear();
        if (*this == 0 || b == 0) {c.s.push_back(0); return 0;}
        if (*this < 0 && b > 0) flag = true;
        if (*this > 0 && b < 0) flag = true;
        for (int i = 0, g = 0; ; i++) {
            if (g == 0 && i >= len) break;
            int x = g;
            for (int u = 0, v = i, temp; v >= 0; u++, v--)
                if (u < s.size() && v < b.s.size()) {
                    temp = s[u] * b.s[v];
                    if (temp < 0) temp = -temp;
                    x += temp;
                }
            c.s.push_back(x % BASE);
            g = x / BASE;
        }
        for (int i = c.s.size() - 1; i >= 0 && c.s[i] == 0; i--)
            c.s.pop_back();
        if (flag) c.s[c.s.size() - 1] = -c.s[c.s.size() - 1];
        return c;
    }

    inline void killzero() {
        while (s.back() == 0 && s.size() > 1) s.pop_back();
    }
    inline void reverse() {
        int len = s.size();
        for (int i = 0; i < len >> 1; ++i) swap(s[i], s[len - i - 1]);
    }

    big operator / (const big &b) const {
        big c, t;
        c.s.clear(); t.s.clear();
        for (int i = s.size() - 1; i >= 0; --i) {
            t.s.push_back(s[i]);
            int x = 0;
            while (b <= t) { t -= b; x++; }
            c.s.push_back(x);
        }
        c.reverse();
        c.killzero();
        return c;
    }

    big operator += (const big& b) {
        *this = *this + b; return *this;
    }
    big operator ++ (int) {
        *this = *this + 1; return *this;
    }
    big operator ++ () {
        *this = *this + 1; return *this;
    }
    big operator -= (const big& b) {
        *this = *this - b; return *this;
    }
    big operator -- (int) {
        *this = *this - 1; return *this;
    }
    big operator -- () {
        *this = *this - 1; return *this;
    }
    big operator *= (const big& b) {
        *this = *this * b; return *this;
    }
    big operator /= (const big& b) {
        *this = *this / b; return *this;
    }
    // big operator %= (const big& b) {
    //     *this = *this % b; return *this;
    // }
};

std::ostream& operator << (std::ostream& out, const big& x) {
    out << x.s.back();
    for (int i = x.s.size() - 2; i >= 0; i--) {
        char buf[20];
        sprintf(buf, "%04d", x.s[i]);
        for (int j = 0; j < strlen(buf); j++) out << buf[j];
    }
    return out;
}
big a[MAXN];
int main(){
    SF("%d",&n);
    a[1]=1;
    a[0]=0;
    for(int i=2;i<=n;i++){
        a[i]=a[i-1]*3-a[i-2]+2;
    }
    cout<<a[n];
}

616156

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【矩阵树】BZOJ1002轮状病毒

分析：矩阵树定理，参见https://blog.csdn.net/qq_34454069/article/details/78035152但这道题要用到高精度，如果一昧地使用矩阵树，可能会被卡精度，而且代码极其复杂。所以观察一下性质，设F(n)F(n)F(n)为n个点的生成树总数，满足F(n)=3∗F(n−1)−F(n−2)+2F(n)=3∗F(n−1)−F(n−2)+2F(n)=3*...
复制链接

扫一扫

专栏目录