hdu5015 233 Matrix(构造矩阵)

本文深入探讨了233矩阵的构造方法及其与快速幂算法的结合应用,详细解释了如何通过矩阵运算求解特定问题,并提供了代码实现的详细步骤。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

233 Matrix

Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 1215    Accepted Submission(s): 714


Problem Description
In our daily life we often use 233 to express our feelings. Actually, we may say 2333, 23333, or 233333 ... in the same meaning. And here is the question: Suppose we have a matrix called 233 matrix. In the first line, it would be 233, 2333, 23333... (it means a 0,1 = 233,a 0,2 = 2333,a 0,3 = 23333...) Besides, in 233 matrix, we got a i,j = a i-1,j +a i,j-1( i,j ≠ 0). Now you have known a 1,0,a 2,0,...,a n,0, could you tell me a n,m in the 233 matrix?
 

Input
There are multiple test cases. Please process till EOF.

For each case, the first line contains two postive integers n,m(n ≤ 10,m ≤ 10 9). The second line contains n integers, a 1,0,a 2,0,...,a n,0(0 ≤ a i,0 < 2 31).
 

Output
For each case, output a n,m mod 10000007.
 

Sample Input
  
1 1 1 2 2 0 0 3 7 23 47 16
 

Sample Output
  
234 2799 72937
Hint
 

Source
注第二个代码的构造方法:
矩阵为(233   a0  a1  a2  1),转移矩阵为
|10 1 11 0|
|0 1 11 0|
|01 1 0|
|00 1 0|
|0 0 01|
/*
另一种构造方法。加油!!!
Time:2015-4-10 18:36
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

typedef long long LL;
const LL mod=10000007;
struct Matrix{
    LL mat[15][15];
    int n;
    void Init(int _n){
        n=_n;
        memset(mat,0,sizeof(mat));
    }
    Matrix operator *(const Matrix &b) const{
        Matrix ret; ret.Init(n);
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                for(int k=0;k<n;k++){
                    ret.mat[i][j]+=mat[i][k]*b.mat[k][j];
                    ret.mat[i][j]%=mod;
                    //if(ret.mat[i][j]>=mod)ret.mat[i][j]-=mod;//不能用-mod,有可能是mod的好几倍
                }
            }
        }
        return ret;
    }
};
Matrix pow_mat(Matrix a,int k){
    Matrix ret; ret.Init(a.n);
    for(int i=0;i<ret.n;i++)ret.mat[i][i]=1;
    while(k>0){
        if(k&1)ret=ret*a;

        a=a*a;
        k>>=1;
    }
    return ret;
}
int main(){
    int n,m;
    Matrix trans,ans;
    while(scanf("%d%d",&n,&m)!=EOF){
        trans.Init(n+2);ans.Init(n+2);
        for(int i=0;i<n;i++){
            scanf("%lld",&ans.mat[0][i]);
        }ans.mat[0][n]=233;ans.mat[0][n+1]=3;

        for(int i=0;i<n;i++){
            for(int j=i;j<n;j++){
                trans.mat[i][j]=1;
            }
            trans.mat[n][i]=1;
        }
        trans.mat[n][n]=10;trans.mat[n+1][n]=1;
        trans.mat[n+1][n+1]=1;

        trans=pow_mat(trans,m);
        ans=ans*trans;
        /*
        for(int i=0;i<n+2;i++){
            printf("%d ",ans.mat[0][i]);
            for(int j=0;j<n+2;j++){
         //       printf("%d ",trans.mat[i][j]);
            }puts("");
        }*/

        printf("%lld\n",ans.mat[0][n-1]);
    }
return 0;
}


/*
每一列相当于前一列和该列的最上边的和,所以构造转移矩阵
矩阵构造,,快速幂
加油!!!
Time:2015-3-30 9:48
*/
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<map>
using namespace std;
typedef long long LL;
const int mod=10000007;
struct Matrix{
    int n;
    int mat[15][15];
    void Init(int _n){
        n=_n; memset(mat,0,sizeof(mat));
    }
    Matrix operator *(const Matrix &b)const{
        Matrix ret;
        ret.Init(n);

        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                    ret.mat[i][j]=0;
                for(int k=0;k<n;k++){
                    ret.mat[i][j]+=(LL)mat[i][k]*b.mat[k][j]%mod;
                    if(ret.mat[i][j]>=mod)ret.mat[i][j]-=mod;
                }
            }
        }
        return ret;
    }
};
Matrix quick_power(Matrix a,LL b){
    Matrix ret;
    ret.Init(a.n);
    for(int i=0;i<ret.n;i++){ret.mat[i][i]=1;}
    while(b>0){
        if(b&1) ret=ret*a;
        a=a*a;
        b>>=1;
    }
    return ret;
}
int main(){
    int n,m;
    Matrix a,b;
    while(scanf("%d%d",&n,&m)!=EOF){
        a.Init(n+2); b.Init(n+2);
        a.mat[0][0]=233;a.mat[0][n+1]=1;
        for(int i=1;i<n+1;i++){
            scanf("%d",&a.mat[0][i]);
        }
        b.mat[0][0]=10;b.mat[n+1][0]=3;
        for(int j=1;j<n+1;j++){
            for(int i=0;i<=j;i++){
                b.mat[i][j]=1;
            }
        }
        b.mat[n+1][n+1]=1;
        b=quick_power(b,m);
        a=a*b;
        /*
        for(int i=0;i<n+2;i++){
            for(int j=0;j<n+2;j++){
                printf("%d ",b.mat[i][j]);
            }puts("");
        }

        for(int i=0;i<n+2;i++){
            printf("%d ",a.mat[0][i]);
        }puts("");
        */
        printf("%d\n",a.mat[0][n]);
    }
return 0;
}

### HDU 2544 题目分析 HDU 2544 是关于最短路径的经典问题,可以通过多种方法解决,其中包括基于邻接矩阵的 Floyd-Warshall 算法。以下是针对该问题的具体解答。 --- #### 基于邻接矩阵的 Floyd-Warshall 实现 Floyd-Warshall 算法是一种动态规划算法,适用于计算任意两点之间的最短路径。它的时间复杂度为 \( O(V^3) \),其中 \( V \) 表示节点的数量。对于本题中的数据规模 (\( N \leq 100 \)),此算法完全适用。 下面是具体的实现方式: ```cpp #include <iostream> #include <algorithm> using namespace std; const int INF = 0x3f3f3f3f; int dist[105][105]; int n, m; void floyd() { for (int k = 1; k <= n; ++k) { // 中间节点 for (int i = 1; i <= n; ++i) { // 起始节点 for (int j = 1; j <= n; ++j) { // 结束节点 if (dist[i][k] != INF && dist[k][j] != INF) { dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]); } } } } } int main() { while (cin >> n >> m && (n || m)) { // 初始化邻接矩阵 for (int i = 1; i <= n; ++i) { for (int j = 1; j <= n; ++j) { if (i == j) dist[i][j] = 0; else dist[i][j] = INF; } } // 输入边的信息并更新邻接矩阵 for (int i = 0; i < m; ++i) { int u, v, w; cin >> u >> v >> w; dist[u][v] = min(dist[u][v], w); dist[v][u] = min(dist[v][u], w); // 如果是有向图,则去掉这一行 } // 执行 Floyd-Warshall 算法 floyd(); // 输出起点到终点的最短距离 cout << (dist[1][n] >= INF ? -1 : dist[1][n]) << endl; } return 0; } ``` --- #### 关键点解析 1. **邻接矩阵初始化** 使用二维数组 `dist` 存储每一对节点间的最小距离。初始状态下,设所有节点对的距离为无穷大 (`INF`),而同一节点自身的距离为零[^4]。 2. **输入处理** 对于每条边 `(u, v)` 权重 `w`,将其存储至邻接矩阵中,并取较小值以防止重边的影响[^4]。 3. **核心逻辑** Floyd-Warshall 的核心在于三重循环:依次尝试通过中间节点优化其他两节点间的距离关系。具体而言,若从节点 \( i \) 到 \( j \) 可经由 \( k \) 达成更优解,则更新对应位置的值[^4]。 4. **边界条件** 若最终得到的结果仍为无穷大(即无法连通),则返回 `-1`;否则输出实际距离[^4]。 --- #### 性能评估 由于题目限定 \( N \leq 100 \),因此 \( O(N^3) \) 的时间复杂度完全可以接受。此外,空间需求也较低,适合此场景下的应用。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值