2020暑期训练5

最新推荐文章于 2020-09-14 09:40:14 发布

「已注销」

最新推荐文章于 2020-09-14 09:40:14 发布

阅读量100

点赞数

分类专栏：其他

本文链接：https://blog.csdn.net/Pastafarian/article/details/107620694

版权

其他专栏收录该内容

10 篇文章 0 订阅

订阅专栏

DP优化

矩阵快速幂
矩阵加速
单调队列优化

矩阵快速幂

矩阵乘法和数的乘法一样都满足结合律，所以可以像写普通快速幂一样写矩阵快速幂。
例题：P3390 【模板】矩阵快速幂

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int INF = 0x3f3f3f3f;
const int maxn = 1e5 + 9;
const ll mod = (ll)1000000007;
inline ll read()
{
    ll data = 0, f = 1;
    char ch = getchar();
    while (!isdigit(ch))
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (isdigit(ch))
    {
        data = (data << 3) + (data << 1) + ch - '0';
        ch = getchar();
    }
    return f * data;
}
struct matrix
{
    ll mat[105][105];
    int size;
    matrix()//这是必要的
    {
        memset(mat, 0, sizeof(mat));
        size = 0;
    }
    void create_unit(int s)
    {
        size = s;
        for (int i = 1; i <= s; ++i)
            mat[i][i] = 1;
    }
    void init()
    {
        for (int i = 1; i <= size; ++i)
            for (int j = 1; j <= size; ++j)
                mat[i][j] = read();
    }
    matrix operator*(const matrix &b)
    {
        matrix ans;
        for (int i = 1; i <= size; ++i)
            for (int j = 1; j <= size; ++j)
                for (int k = 1; k <= size; ++k)
                    ans.mat[j][k] = (ans.mat[j][k] + mat[j][i] * b.mat[i][k] % mod) % mod;
        ans.size = size;
        return ans;
    }
    /*这个没必要重载
    void operator=(const matrix &b)
    {
        size = b.size;
        for (int i = 1; i <= size; ++i)
            for (int j = 1; j <= size; ++j)
                mat[i][j] = b.mat[i][j];
    }
    */
    void print()
    {
        for (int i = 1; i <= size; ++i)
        {
            for (int j = 1; j <= size; ++j)
                cout << mat[i][j] << ' ';
            cout << '\n';
        }
    }
};
matrix a, ans;

int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("data.txt","w",stdout);
    //std::ios::sync_with_stdio(false);
    //std::cin.tie(0);
    a.size = read();
    ll k = read();
    a.init();
    ans.create_unit(a.size);
    while (k)
    {
        if (k & 1)
            ans = ans * a;
        a = a * a, k /= 2;
    }
    ans.print();
    //fclose(stdin);
    //fclose(stdout);
    return 0;
}

矩阵加速

推导数列的时候用矩阵快速幂加速
例题：P1939 【模板】矩阵加速（数列）
递推式：
$\begin{bmatrix} a _n \\ a_{n-1}\\ a_{n-2} \end{bmatrix}=\begin{bmatrix} 1&0&1 \\ 1&0&0\\ 0&1&0 \end{bmatrix}\times \begin{bmatrix} a _{n-1} \\ a_{n-2}\\ a_{n-3} \end{bmatrix}$
那么只要对系数矩阵用快速幂就可以了，然后这样得到的 $m a t [1] [1]$ 是 $a_{n+1}$ ，所以输出 $m a t [2] [1]$ 。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int INF = 0x3f3f3f3f;
const int maxn = 1e5 + 9;
const ll mod = (ll)1000000007;
inline ll read()
{
    ll data = 0, f = 1;
    char ch = getchar();
    while (!isdigit(ch))
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (isdigit(ch))
    {
        data = (data << 3) + (data << 1) + ch - '0';
        ch = getchar();
    }
    return f * data;
}
struct matrix
{
    ll mat[105][105];
    int size;
    matrix()
    {
        memset(mat, 0, sizeof(mat));
        size = 0;
    }
    void create_unit(int s)
    {
        size = s;
        for (int i = 1; i <= s; ++i)
            mat[i][i] = 1;
    }
    void init()
    {
        for (int i = 1; i <= size; ++i)
            for (int j = 1; j <= size; ++j)
                mat[i][j] = read();
    }
    matrix operator*(const matrix &b)
    {
        matrix ans;
        for (int i = 1; i <= size; ++i)
            for (int j = 1; j <= size; ++j)
                for (int k = 1; k <= size; ++k)
                    ans.mat[j][k] = (ans.mat[j][k] + mat[j][i] * b.mat[i][k] % mod) % mod;
        ans.size = size;
        return ans;
    }
    void print()
    {
        for (int i = 1; i <= size; ++i)
        {
            for (int j = 1; j <= size; ++j)
                cout << mat[i][j] << ' ';
            cout << '\n';
        }
    }
};

int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("data.txt","w",stdout);
    //std::ios::sync_with_stdio(false);
    //std::cin.tie(0);
    int T = read();
    while (T--)
    {
        int n = read();
        if (n <= 3)
        {
            puts("1");
            continue;
        }
        matrix a, ans;
        a.size = 3, a.mat[1][1] = 1, a.mat[1][3] = 1, a.mat[2][1] = 1, a.mat[3][2] = 1;
        ans.create_unit(3);
        while (n)
        {
            if (n & 1)
                ans = ans * a;
            a = a * a, n /= 2;
        }
        cout << ans.mat[2][1] << '\n';
    }
    //fclose(stdin);
    //fclose(stdout);
    return 0;
}

单调队列优化

例题：P3800 Power收集
数据比较大，复杂度多一个log恐怕都会T，只能用单调队列。做法显然是从第二行开始给每个格子加上上一行对应的 $2\times v$ 长度的区间内最大值，一直到最后一行。

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
const int INF = 0x3f3f3f3f;
const int maxn = 4001;
inline int read()
{
    int data = 0, f = 1;
    char ch = getchar();
    while (!isdigit(ch))
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (isdigit(ch))
    {
        data = (data << 3) + (data << 1) + ch - '0';
        ch = getchar();
    }
    return f * data;
}
deque<int> dq;
int n, m, v, k, dp[maxn][maxn];
void ins(int d, int pos)
{
    while (!dq.empty() && dp[d][pos] > dp[d][dq.back()])
        dq.pop_back();
    dq.push_back(pos);
}
int find(int d, int pos)
{
    if (pos + v <= m)
        ins(d, pos + v);
    while (dq.front() + v < pos)
        dq.pop_front();
    return dq.front();
}
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("data.txt","w",stdout);
    //std::ios::sync_with_stdio(false);
    //std::cin.tie(0);
    n = read(), m = read(), k = read(), v = read();
    for (int i = 1; i <= k; ++i)
    {
        int x = read(), y = read();
        dp[x][y] = read();
    }
    for (int i = 2; i <= n; ++i)
    {
        for (int j = 1; j <= v; ++j)
            ins(i - 1, j);
        for (int j = 1; j <= m; ++j)
            dp[i][j] += dp[i - 1][find(i - 1, j)];
        dq.clear();
    }
    cout << *max_element(dp[n] + 1, dp[n] + m + 1) << '\n';
    //fclose(stdin);
    //fclose(stdout);
    return 0;
}