ZOJ 3690 Choosing number(dp矩阵优化)

Choosing number


Time Limit: 2 Seconds      Memory Limit: 65536 KB



There are n people standing in a row. And There are m numbers, 1.2...m. Every one should choose a number. But if two persons standing adjacent to each other choose
the same number, the number shouldn‘t equal or less than k. Apart from this rule, there are no more limiting conditions.

And you need to calculate how many ways they can choose the numbers obeying the rule.

Input

There are multiple test cases. Each case contain a line, containing three integer n (2 ≤ n ≤ 108), m (2 ≤ m ≤ 30000), k(0 ≤ k ≤ m).

Output

One line for each case. The number of ways module 1000000007.

Sample Input

4 4 1

Sample Output

216

题意:有n个人,1到m个数,这n个人,每人选一个数字,要求相邻的两个人选择的数要么不相等,要么相等时大于k

题解:dp[i][0]:第i个人选大于k的数的最优解,dp[i][1]:第i个人选小于等于k的数的最优解。

则  dp[i][0]=(m-k)*dp[i-1][0]+(m-k)*dp[i-1][1]

dp[i][1]=k*dp[i-1][0]+(k-1)*dp[i-1][1].

构造矩阵:  |  dp[i][0]     |           |  m-k ,m-k |         |  dp[i-1][0]  |

=                           *

|  dp[i][1]     |          |   k     ,k-1  |          |   dp[i-1][1]  |

#include<cstring>
#include<cstdio>
#include<algorithm>
#include<iostream>
#include<vector>
#define ll long long
#define mod 1000000007
using namespace std;

typedef vector<ll>vec;
typedef vector<vec>mat;

ll n,m,k;

mat mul(mat &A,mat &B) {
    mat C(A.size(),vec(B[0].size()));
    for(int i=0; i<A.size(); i++) {
        for(int k=0; k<B.size(); k++) {
            for(int j=0; j<B[0].size(); j++) {
                C[i][j]=(C[i][j]+A[i][k]*B[k][j])%mod;
            }
        }
    }
    return C;
}

mat pow_mod(mat A,ll x) {
    mat B(A.size(),vec(A.size()));
    for(int i=0; i<A.size(); i++) {
        B[i][i]=1;
    }
    while(x>0) {
        if(x&1)B=mul(B,A);
        A=mul(A,A);
        x>>=1;
    }
    return B;
}

int main() {
    //freopen("test.in","r",stdin);
    while(~scanf("%lld%lld%lld",&n,&m,&k)) {
        mat A(2,vec(2));
        A[0][0]=m-k,A[0][1]=m-k;
        A[1][0]=k,A[1][1]=k-1;
        A=pow_mod(A,n-1);
        ll ans=(A[0][0]+A[1][0])*(m-k)%mod+(A[0][1]+A[1][1])*k%mod;
        printf("%lld\n",ans%mod);
    }
    return 0;
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-08-25 16:30:42

ZOJ 3690 Choosing number(dp矩阵优化)的相关文章

ZOJ 3690 Choosing number(矩阵快速幂)

题目地址:ZOJ 3690 假设F(n)表示前n个人第n个人选择的数大于k的个数,G(n)表示的是前n个人第n个人选择的数小于等于k的个数 那么F(n) = F(n-1)*(m-k)+G(n-1)*(m-k) , G(n) = F(n-1)*k+G(n-1)*(k-1) , 那么最后的结果就是F(n)+G(n); 那么我们可以构造出矩阵 | m-k m-k|   | F(n-1) |       | F(n) | | k      k-1| * | G(n-1) | => | G(n) | 那么

ZOJ - 3690 Choosing number 矩阵快速幂

题目大意:有n个人排成一行,有m个数字,每个人可以选择1 – m的任一个数字,但有一个限制,如果相邻的两个人选择相同的数字的话,这个数字必须大于k 问有多少种选择方法 解题思路:变化矩阵为(m-k, k, m - k, k - 1),按行的写 设前一个数为j 如果j大于k的话,那么j后面可以跟上任一个数 如果j小于等于k,那么j后面只能跟上不等于k的数 如果有p种情况为前一个数大于k的,q种情况为前一个数小于等于k的,由上面可得,当前这个数大于k的情况有 p * (n -k) + q * (n

zoj3690--Choosing number(dp,矩阵快速幂)

Choosing number Time Limit:2000MS     Memory Limit:65536KB     64bit IO Format:%lld & %llu Submit Status Description There are n people standing in a row. And There are m numbers, 1.2...m. Every one should choose a number. But if two persons standing

ZOJ 3690 &amp; HDU 3658 (矩阵快速幂+公式递推)

ZOJ 3690 题意: 有n个人和m个数和一个k,现在每个人可以选择一个数,如果相邻的两个人选择相同的数,那么这个数要大于k 求选择方案数. 思路: 打表推了很久的公式都没推出来什么可行解,好不容易有了想法结果WA到天荒地老也无法AC.. 于是学习了下正规的做法,恍然大悟. 这道题应该用递推 + 矩阵快速幂. 我们设F(n) = 有n个人,第n个人选择的数大于k的方案数: G(n) = 有n个人,第n个人选择的数小于等于k的方案数: 那么递推关系式即是: F(1)=m?k,G(1)=k F(n

[Vijos1067]Warcraft III 守望者的烦恼(DP + 矩阵优化)

传送门 可知 f[i] = f[i - 1] + f[i - 2] + ... + f[i - k] 直接矩阵优化就好了 #include <cstdio> #include <cstring> #define p 7777777 #define LL long long int n, k; struct Matrix { int n, m; LL a[11][11]; Matrix() { n = m = 0; memset(a, 0, sizeof(a)); } }; inli

POJ3744 Scout YYF I (概率DP + 矩阵优化)

题目链接: http://poj.org/problem?id=3744 题意: 有一段路,路上有n个陷阱,每一次只能向前走一步或者两步,求安全走过这段路的改路 分析: 设dp[i]表示安全走过第i个陷阱的概率 那么dp[i+1]=dp[i]*(1-p(走到第i+1个陷阱)) 因为每次只能走一步或者两步,所有安全走过第i个陷阱后的位置一定在a[i]+1;\ 其中a[i]表示第i个陷阱的位置 求从a[i]+1,走到a[i+1]的概率的时候我们需要用到矩阵来经行优化 ans[i]表示走到位置i的概率

bzoj 1009 DP 矩阵优化

原来的DP: dp[i][j]表示长度为i的合法串,并且它的长度为j的后缀是给定串的长度为j的前缀. 转移: i==0 dp[0][0] = 1 dp[0][1~m-1] = 0 i>=1 dp[i][0] = dp[i-1][0]*10-dp[i-1][m-1] dp[i][1] = dp[i-1][0]-(a[m]==a[1])*dp[i-1][m-1] dp[i][2] = dp[i-1][1]-(a[m-1~m]==a[1~2])*dp[i-1][m-1] dp[i][3] = dp[i

[POJ2778]DNA Sequence(AC自动机 + DP + 矩阵优化)

传送门 AC自动机加DP就不说了 注意到 m <= 10,所以模式串很少. 而 n 很大就需要 log 的算法,很容易想到矩阵. 但是该怎么构建? 还是矩阵 A(i,j) = ∑A(i,k) * A(k,j),那么i到j的方案数就是j到k的方案数称k到j的方案数,那么直接矩阵快速幂即可 #include <queue> #include <cstdio> #include <cstring> #define N 100001 #define p 100000 #d

[HDU2157]How many ways??(DP + 矩阵优化)

传送门 k < 20 k这么小,随便dp一下就好了... dp[i][j][k]表示从i到j经过k个点的方案数 4重循环.. 但是如果k很大就不好弄了 把给定的图转为邻接矩阵,即A(i,j)=1当且仅当存在一条边i->j.令C=A*A,那么C(i,j)=ΣA(i,k)*A(k,j),实际上就等于从点i到点j恰好经过1个点的路径数(枚举k为中转点).类似地,C*A的第i行第j列就表示从i到j经过2个点的路径数.同理,如果要求经过k步的路径数,我们只需要二分求出A^k即可. #include &l