矩阵快速幂专题 HDU1757 HDU1575 HDU2604 HDU2256 CF185A HDU2276 HDU2842

最新推荐文章于 2019-07-10 15:22:54 发布
最新推荐文章于 2019-07-10 15:22:54 发布
阅读量287 收藏
点赞数 1
分类专栏： 快速幂 组合数学-矩阵快速幂 数学-公式
本文为博主原创文章，未经博主允许也可以转载。
本文链接：https://blog.csdn.net/FrankAx/article/details/81603870
版权

HDU1757
递推式给了，入门裸题。
Code：

#include <bits/stdc++.h>
#pragma comment(linker, “/STACK:1024000000,1024000000”)
#define INF 0x3f3f3f3f
#define LL long long
using namespace std;
LL k ;
int m ;
int b[15];
struct Matrix{
    LL a[12][12];
};
Matrix Mul( Matrix x , Matrix y ){
    Matrix res ;
    memset( res.a , 0 , sizeof(res.a) );
    for( int i = 0 ; i < 10 ; i++ ){
        for( int j = 0 ; j < 10 ; j++ ){
            for( int k = 0 ; k < 10; k++ ){
                res.a[i][j] = ( res.a[i][j] + x.a[i][k] * y.a[k][j] % m ) % m;
            }
        }
    }   
    return res ;
}

Matrix quick( Matrix x , int b ){
    Matrix ans ;
    memset( ans.a , 0 , sizeof(ans.a) );
    for( int i = 0 ; i < 10 ; i++ ) ans.a[i][i] = 1 ;
    while( b ){
        if( b & 1 ){
            ans = Mul( ans , x );
        }
        b >>= 1 ;
        x = Mul( x , x ) ;
    }
    return ans ;
}

int main(){
    while( ~scanf("%lld%d",&k,&m) ){
        if( k < 10 ){
            printf("%d\n",k%m);
            continue ; 
        }
        Matrix mat ;
        memset( mat.a , 0 , sizeof(mat.a) );
        for( int i = 0 ; i < 10 ; i++ ){
            scanf("%d",&mat.a[0][i]);
        }
        for( int i = 1 ; i < 10 ; i++ ){
            mat.a[i][i-1] = 1;
        }
        Matrix s = quick( mat , k - 9 );

        Matrix ans ;
        memset( ans.a , 0 , sizeof(ans.a) );
        for( int i = 0 ; i < 10 ; i++ ) ans.a[i][0] = 9 - i ; 

        LL res = 0;
        for( int i = 0 ; i < 10 ; i++ ){
            res = ( res + s.a[0][i] * ans.a[i][0] ) % m;
        }
        printf("%d\n",res);
    }
    return 0 ;
}

HDU1575
更裸。。
Code:

#include <bits/stdc++.h>
#pragma comment(linker, “/STACK:1024000000,1024000000”)
#define INF 0x3f3f3f3f
#define LL long long
using namespace std;
const int MOD = 9973 ;
struct Matrix{
    LL a[12][12];
};
int n , k ;
Matrix Mul( Matrix x , Matrix y ){
    Matrix ans ;
    memset( ans.a , 0 , sizeof(ans.a) );
    for( int i = 0 ; i < n ; i++ ){
        for( int j = 0 ; j < n ; j++ ){
            for( int k = 0 ; k < n ; k++ ){
                ans.a[i][j] = ( ans.a[i][j] + x.a[i][k] * y.a[k][j] % MOD ) % MOD;
            }
        }
    }
    return ans ;
}

Matrix quick( Matrix a , int b ){
    Matrix ans ;
    memset( ans.a , 0 ,sizeof(ans.a) );
    for( int i = 0 ; i < n ; i++ ) ans.a[i][i] = 1 ;    
    while( b ){
        if( b & 1 ) ans = Mul( ans , a );
        b >>= 1 ;
        a = Mul( a , a );
    } 
    return ans ;
}

int main(){
    int T;
    scanf("%d",&T);
    while( T-- ){
        scanf("%d%d",&n,&k);
        Matrix Mat; 
        memset( Mat.a , 0 , sizeof(Mat.a) );
        for( int i = 0 ; i < n ; i++ ){
            for( int j = 0 ; j < n ; j++ ){
                scanf("%d",&Mat.a[i][j]);
            }
        }
        Matrix res = quick( Mat , k ) ;
        int ans = 0 ;
        for( int i = 0 ; i < n ; i++ ){
            ans = ( ans + res.a[i][i] ) % MOD ;
        }
        printf("%d\n",ans);
    }   
    return 0 ;
}

HDU2604
题意：对于只由数字1和0构成的字符串，给出长度为n的，不含子串101且不含子串111的字符串的个数对m取模的值。
推公式：f[n] 为满足条件的长度n的串的个数
如果最后一个为0，那么结果就是f(n-1) 后面加0，肯定不会出现101，111
如果最后一个为1，还要考虑前面2位必须为00 （f[n-3]）， 01（前面必须为0）所以就是f[n-4]
得到：f[n] = f [n-1] + f[n-3] + f[n-4]

Code：

#include <bits/stdc++.h>
#pragma comment(linker, “/STACK:1024000000,1024000000”)
#define INF 0x3f3f3f3f
#define LL long long
using namespace std;
int n , m ;
struct Matrix{
    int a[4][4];
};

Matrix Mul( Matrix x , Matrix y ){
    Matrix ans ;
    memset( ans.a , 0 , sizeof(ans) );
    for( int i = 0 ; i < 4 ; i++ ){
        for( int j = 0 ; j < 4 ; j++ ){
            for( int k = 0 ; k < 4 ; k++ ){
                ans.a[i][j] = ( ans.a[i][j] + x.a[i][k] * y.a[k][j] % m ) % m ;
            }
        }
    }
    return ans ;
}

Matrix quick( Matrix x , int b ){
    Matrix ans;
    memset( ans.a , 0 , sizeof(ans) );
    for( int i = 0 ; i < 4 ; i++ ) ans.a[i][i] = 1 ;
        while( b ){
            if( b & 1 ) ans = Mul( ans , x );
            x = Mul(x,x);
            b >>= 1 ;
        }
        return ans ;
    }

    int main(){
        while( ~scanf("%d%d",&n,&m) ){
            if( n == 0 )      printf("0\n");
            else if( n == 1 ) printf("%d\n",2%m);
            else if( n == 2 ) printf("%d\n",4%m);
            else if( n == 3 ) printf("%d\n",6%m);
            else if( n == 4 ) printf("%d\n",9%m);
            else{
                Matrix ans ;
                memset( ans.a , 0 , sizeof(ans.a) );
                ans.a[0][0] = 1 ; ans.a[0][1] = 0 ; ans.a[0][2] = 1 ; ans.a[0][3] = 1 ;
                ans.a[1][0] = 1 ; ans.a[1][1] = 0 ; ans.a[1][2] = 0 ; ans.a[1][3] = 0 ;
                ans.a[2][0] = 0 ; ans.a[2][1] = 1 ; ans.a[2][2] = 0 ; ans.a[2][3] = 0 ;
                ans.a[3][0] = 0 ; ans.a[3][1] = 0 ; ans.a[3][2] = 1 ; ans.a[3][3] = 0 ;
                Matrix tmp ;
                memset( tmp.a , 0 ,sizeof(tmp.a) );
                tmp.a[0][0] = 9 ; tmp.a[1][0] = 6; tmp.a[2][0] = 4 ; tmp.a[3][0] = 2;
                Matrix t = quick( ans , n - 4 );
                int res = 0 ;
                for( int i = 0 ; i < 4 ; i++ ){
                    res = ( res + t.a[0][i] * tmp.a[i][0] ) % m ;
                }
                printf("%d\n",res);
            }
        }
        return 0 ;
    }

HDU2256

思路：
这里写图片描述
Code：

#include <bits/stdc++.h>
#pragma comment(linker, “/STACK:1024000000,1024000000”)
#define INF 0x3f3f3f3f
#define LL long long
using namespace std;
const int MOD = 1024 ;
struct Matrix{
    int a[3][3];
};
int n ;
Matrix Mul( Matrix x , Matrix y ){
    Matrix ans ;
    memset( ans.a , 0 , sizeof(ans.a) );
    for( int i = 0 ; i < 2 ; i++ ){
        for( int j = 0 ; j < 2 ; j++ ){
            for( int k = 0 ; k < 2 ; k++ ){
                ans.a[i][j] = ( ans.a[i][j] + x.a[i][k] * y.a[k][j] % MOD ) % MOD;
            }
        }
    }
    return ans ;
}

Matrix quick( Matrix a , int b ){
    Matrix ans ;
    memset( ans.a , 0 ,sizeof(ans.a) );
    for( int i = 0 ; i < 2 ; i++ ) ans.a[i][i] = 1 ;    
        while( b ){
            if( b & 1 ) ans = Mul( ans , a );
            b >>= 1 ;
            a = Mul( a , a );
        } 
        return ans ;
    }

    int main(){
        int T;
        scanf("%d",&T);
        while( T-- ){
            scanf("%d",&n);
            Matrix Mat ;
            Mat.a[0][0] = 5 ; Mat.a[0][1] = 12;
            Mat.a[1][0] = 2 ; Mat.a[1][1] = 5;
            Matrix ans = quick( Mat , n - 1 );
            int A1 = 5 ;
            int B1 = 2 ;
            int An = ( 5 * ans.a[0][0] + 2 * ans.a[0][1] )  % MOD;
            printf("%d\n",(An*2-1+MOD)%MOD);
        }   
        return 0 ;
    }

CF185A
公式：F(n上) = 2F(n-1上) + 4 ^(n-2)
推导：F(n上) = F(n-1下) + 3 * F(n-1上)
F(n-1 下) + F (n - 1上) = F (n-1)
上面两个式子可以得出F(n上) = F(n-1) + 2*F(n-1上)
所以F(n上) = 4^(n-2) + 2 * F(n-1上)
其中，上下表示上三角下三角，没有上下的为其总和。
Code：

#include <bits/stdc++.h>
#pragma comment(linker, “/STACK:1024000000,1024000000”)
#define INF 0x3f3f3f3f
#define LL long long
using namespace std;
const LL MOD = 1e9+7;
struct Matrix{
    LL a[4][4];
};

Matrix Mul( Matrix x , Matrix y ){
    Matrix res ;
    memset( res.a , 0 , sizeof(res.a) );
    for( int i = 0 ; i < 3 ; i++ ){
        for( int k = 0 ; k < 3 ; k++ ){
            if( x.a[i][k] ){
                for( int j = 0 ; j < 3 ; j++ ){
                    if( y.a[k][j] )
                        res.a[i][j] = ( res.a[i][j] + x.a[i][k] * y.a[k][j] ) % MOD;
                }
            }
        }
    }
    return res ;
}

Matrix quick( Matrix a , LL b ){
    Matrix res ; 
    memset( res.a , 0 , sizeof(res.a) );
    for( int i = 0 ; i < 3 ; i++ ) res.a[i][i] = 1 ;
        while( b ){
            if( b & 1 ){
                res = Mul( res , a );
            }
            b >>= 1;
            a = Mul( a , a );
        }
        return res ; 
    }

    int main(){
        LL n ;
        scanf("%I64d",&n);
        if( !n ) printf("1\n");
        else if( n == 1 ) printf("3\n");
        else{
            Matrix Mat ;
            Mat.a[0][0] = 2 ; Mat.a[0][1] = 0 ; Mat.a[0][2] = 4;
            Mat.a[1][0] = 1 ; Mat.a[1][1] = 0 ; Mat.a[1][2] = 0;
            Mat.a[2][0] = 0 ; Mat.a[2][1] = 0 ; Mat.a[2][2] = 4;
            Matrix ans;
            ans.a[0][0] = 3 ; ans.a[1][0] = 1 ; ans.a[2][0] = 1 ;
            Matrix tmp = quick( Mat , n - 1 );
            LL res = 0 ;
            for( int i = 0 ; i < 3 ; i++ ){
                res = ( res + tmp.a[0][i] * ans.a[i][0] % MOD ) % MOD;
            }
            printf("%I64d\n",res);
        }
        return 0 ;
    }

HDU2276
题意：每次操作如果i-1是1就将i反转（1变0，0变1），0的位置看n-1
思路：构造的矩阵是n*n的，除了第一列是0和n-1位置为1外，其他每列都是i和i-1位置为1.
m次方，对2取余。
Code：

#include <bits/stdc++.h>
#pragma comment(linker, “/STACK:1024000000,1024000000”)
#define INF 0x3f3f3f3f
#define LL long long
using namespace std;
const int AX = 1e2+6;
char s[AX];
int val[AX];
int m , n ; 

struct Matrix{
    int a[AX][AX];
};

Matrix Mul( Matrix x , Matrix y ){
    Matrix res ;
    memset( res.a , 0 , sizeof(res.a) );
    for( int i = 0 ; i < n ; i++ ){
        for( int j = 0 ; j < n ; j++ ){
            for( int k = 0 ; k < n ; k++ ){
                res.a[i][j] = ( res.a[i][j] + x.a[i][k] * y.a[k][j] % 2 ) % 2 ;
            }
        }
    }
    return res ;
}

Matrix quick( Matrix a , int b ){
    Matrix res ;
    memset( res.a , 0 , sizeof(res.a) ) ;
    for( int i = 0 ; i < n ; i++ ) res.a[i][i] = 1 ;
    while( b ){
        if( b & 1 ) res = Mul( res , a ) ;
        b >>= 1 ;
        a = Mul( a , a ) ;
    }
    return res ;
}

int main(){
    while( ~scanf("%d",&m) ){
        scanf("%s",s);
        n = strlen(s);
        for( int i = 0 ; i < n ; i++ ){
            val[i] = s[i] - '0';
        }
        Matrix Mat;
        memset( Mat.a , 0 , sizeof(Mat.a) );
        Mat.a[n-1][0] = 1 ;
        Mat.a[0][0] = 1 ;
        for( int i = 1 ; i < n ; i++ ){
            Mat.a[i][i] = 1 ;
            Mat.a[i-1][i] = 1 ;
        }
        Matrix ans = quick( Mat , m ) ;
        for( int i = 0 ; i < n ; i++ ){
            int tmp = 0 ;
            for( int j = 0 ; j < n ; j ++ ){
                tmp = ( tmp + val[j] * ans.a[j][i] ) % 2 ;
            }
            printf("%d",tmp);
        }printf("\n");
    }
    return 0 ;
}

HDU2842
公式：F(n) = 2*F( n - 2 ) + F(n-1) + 1
思路：i前面都为0，且i为1时，i+1才能变成0，
当使位置为n的字符为0时，需要满足n-2前面都变成0,步数就是F(n-2) , 且n-1为1，
然后变n-1，因为要从后往前变，所以先要+F(n-2)（变n时将前n-2项改变，此时要变回去） ,再加上F(n-1)
利用F(n-2)的步数，再加一步，将n-2变成1，才能改变n-1，就是F(n-1)
Code：

#include <bits/stdc++.h>
#pragma comment(linker, “/STACK:1024000000,1024000000”)
#define INF 0x3f3f3f3f
#define LL long long
using namespace std;
const int MOD = 200907;
int n ;
struct Matrix{
    LL a[4][4];
};

Matrix Mul( Matrix x , Matrix y ){
    Matrix ans ;
    memset( ans.a , 0 , sizeof(ans) );
    for( int i = 0 ; i < 3 ; i++ ){
        for( int j = 0 ; j < 3 ; j++ ){
            for( int k = 0 ; k < 3 ; k++ ){
                ans.a[i][j] = ( ans.a[i][j] + x.a[i][k] * y.a[k][j] % MOD ) % MOD ;
            }
        }
    }
    return ans ;
}

Matrix quick( Matrix x , int b ){
    Matrix ans;
    memset( ans.a , 0 , sizeof(ans) );
    for( int i = 0 ; i < 3 ; i++ ) ans.a[i][i] = 1 ;
        while( b ){
            if( b & 1 ) ans = Mul( ans , x );
            x = Mul(x,x);
            b >>= 1 ;
        }
        return ans ;
    }

    int main(){
        while( scanf("%d",&n) && n ){
            if( n == 1 ) printf("1\n");
            else if( n == 2 ) printf("2\n");
            else{
                Matrix ans ;
                memset( ans.a , 0 , sizeof(ans.a) );
                ans.a[0][0] = 1 ; ans.a[0][1] = 2 ; ans.a[0][2] = 1 ; 
                ans.a[1][0] = 1 ; ans.a[1][1] = 0 ; ans.a[1][2] = 0 ; 
                ans.a[2][0] = 0 ; ans.a[2][1] = 0 ; ans.a[2][2] = 1 ; 
                Matrix tmp ;
                memset( tmp.a , 0 ,sizeof(tmp.a) );
                tmp.a[0][0] = 2 ; tmp.a[1][0] = 1 ; tmp.a[2][0] = 1 ;
                Matrix t = quick( ans , n - 2 );
                int res = 0 ;
                for( int i = 0 ; i < 3 ; i++ ){
                    res = ( res + t.a[0][i] * tmp.a[i][0] ) % MOD ;
                }
                printf("%d\n",res);
            }
        }
        return 0 ;
    }
Dave_L
关注
专栏目录
矩阵快速幂专题（一）
shengtao96的专栏
03-25 2627
最近闲来无事，准备集中精力刷一波数论与图论。矩阵快速幂是数论里面的重要组成部分，值得我好好学习一下。因为题目比较多，分析也比较多，所以将此专题分成几个部分。做完这一专题，可能会暂时转向图论部分，然后等我组合数学学得差不多了，再回过头来继续做数论题。 矩阵快速幂算法的核心思想是将问题建模转化为数学模型（有一些简单题目是裸的矩阵模型，但是大部分难题就是难在要构造矩阵，用矩阵方法解决问题），推倒递推式
HDU1757 - A Simple Math Problem - 矩阵快速幂
终有绿洲摇曳在沙漠
03-05 352
1.题目描述 A Simple Math Problem Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 4507    Accepted Submission(s): 2716 Problem Descripti
[矩阵快速幂专题]
aiyuneng5167的博客
05-12 99
http://acm.hdu.edu.cn/showproblem.php?pid=2604 Queuing Time Limit: 10000/5000 MS (Java/Others)Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 8168Accepted Submission(s): 3...
矩阵快速幂专题
10-02 259
模板：51nod1113 矩阵快速幂 传送门：SWPU 2017暑假专题训练-矩阵快速幂 A.HDU 5950  直接将大佬的题解粘过来~     #include&lt;iostream&gt; #include&lt;cstdio&gt; using namespace std; typedef unsigned long long ll; const ll MOD=21...
矩阵快速幂专题（矩阵快速幂入门、矩阵构造法、数论规律题）
林下的码路
08-04 2332
Link1：http://acm.hdu.edu.cn/showproblem.php?pid=1575 Tr A Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 3628    Accepted Submissio
【矩阵专题】——矩阵快速幂
weixin_30537451的博客
07-08 137
今天来讲矩阵快速幂： 先卖个关子，对于一般的快速幂，我们是这样解决的： eg：n19 mod k 我们知道，根据二进制 19(10)=10011(2)=(10000+10+1)(2) 所以可以将19二进制分解 这里引入res和ans和N三个变量。 令N=19，res=n，ans=1 10011末尾为1，所以将这个单独放入ans：ans=res*ans=n，接着将res平方：res=...
HDU_2010.rar_hdu 2010_hdu 20_hdu acm20
09-14
【标题】"HDU_2010.rar"是一个压缩包文件，其中包含了与"HDU 2010"相关的资源，特别是针对"HDU ACM20"比赛的编程题目。"hdu 2010"和"hdu 20"可能是该比赛的不同简称或分类，而"hdu acm20"可能指的是该赛事的第20届...
hdu.rar_hdu
最新发布
09-23
7. **模板代码**：如快速幂、二分查找、DFS/BFS等常用算法的通用实现。 8. **问题解决策略**：理解题目需求、设计合适的数据结构、分析时间复杂度和空间复杂度、调试和优化代码。 9. **调试技巧**：使用调试工具...
hdu-api:A simple SDK for HDU. 一个提供一卡通服务、考试、课表、选课和公共信息等 API 的 SDK
05-04
A simple SDK for HDU. hdu-api 是一个集结 HDU 所有教务管理服务的 SDK，提供了一卡通服务、考试、课表、选课和一些公共信息如空闲教室、上课时间等信息的 API。 hdu-api 主要基于 Requests 库和 Beautiful Soup 库...
HDU.rar_hdu_hdu07_com_shownv9b_www.563hdu.
09-23
【标题】"HDU.rar_hdu_hdu07_com_shownv9b_www.563hdu." 暗示这是一个与HDU（杭州电子科技大学在线编程平台）相关的压缩包，其中可能包含了该平台上的编程竞赛题目或练习题目的源代码。"hdu07"可能是某个特定题目的...
矩阵快速幂专题（二）
shengtao96的专栏
04-02 896
久等了，第二弹来了，这次的九道题大部分都非常简单，但是最后一题特别坑爹，不太好想到而且有个让人吐血的坑点。建议以后刷Light oj的朋友们做好心理准备，那上面的题目都非常坑，我以前做过一道最小生成树，就TLE了我整整一下午，没想到这次一道矩阵快速幂又是一下午，唉~~~，心累。 第一题
矩阵快速幂题集
wangtao的博客
07-10 643
矩阵快速幂 矩阵必须全部初始化,注意矩阵大小 POJ - 3070 最简单的矩阵快速幂 f[n]=f[n-1]+f[n-2] ac: #include <iostream> #include <cstdio> #include <cstring> #define ll long long using namespace std; /* (f(n-...
矩阵快速幂&快速幂
DeathYmz的博客
07-17 406
矩阵快速幂&amp;快速幂 一、快速幂 typedef long long ll; ll quic_power(ll x,ll n,ll mod) { ll result=1; while(n) { if(n&amp;1) { result*=x; result%=mod; ...
51nod 巨大的斐波那契数列（矩阵快速幂），递推式优化的好模板！！！！！！！
AK_HuangYC的博客
10-24 1799
斐波那契数列的定义如下： F(0) = 0 F(1) = 1 F(n) = F(n - 1) + F(n - 2) (n >= 2) (1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, ...) 给出n，求F(n)，由于结果很大，输出F(n) % 1000000009的结果即可。 Input
矩阵快速幂专题【完结】
caobihole
08-25 423
第一题 hdu 1757 A Simple Math Problem 点击打开链接 思路：矩阵快速幂 分析: 1 最简单的矩阵快速幂的题目，直接利用矩阵求解即可 点击打开查看代码 第二题 hdu 1575Tr A 点击打开hdu 1575 思路: 矩阵快速幂 分析: 1 题目给定一个n*n的矩阵要求矩阵的k次幂之后的矩阵的对角线的和 2 矩阵快速幂的裸题 点...
矩阵快速幂总结
Linux猿
09-11 3131
矩阵快速幂总结
矩阵 快速幂
weixin_30407099的博客
11-29 826
矩阵的快速幂是用来高效地计算矩阵的高次方的。将朴素的o（n）的时间复杂度，降到log（n）。 这里先对原理（主要运用了矩阵乘法的结合律）做下简单形象的介绍： 一般一个矩阵的n次方，我们会通过连乘n-1次来得到它的n次幂。 但做下简单的改进就能减少连乘的次数，方法如下： 把n个矩阵进行两两分组，比如：A*A*A*A*A*A => (A*A)*(A*A)*(A*A) 这...
专题训练1 矩阵快速幂 题目清单
qq_39898877的博客
09-10 987
一些简单的递推式 1.f(n)=a*f(n-1)+b*f(n-2)+c；（a,b,c是常数） (图源网络) 2.f(n)=c^n-f(n-1) ；（c是常数） （图源网络） 3.求等比矩阵的和 求 S=A^1+A^2+..A^n |A  E| |0  E| 其中的A为m阶矩阵，E是单位矩阵，0是零矩阵。                                        ...
杨辉三角重要性质
热门推荐
Dave_lzw的博客
10-14 1万+
前提：每行端点与结尾的数为1. 每个数等于它上方两数之和。 每行数字左右对称，由1开始逐渐变大。 第n行的数字有n项。 第n行数字和为2n-1。 第n行的m个数可表示为 C(n-1，m-1)，即为从n-1个不同元素中取m-1个元素的组合数。 第n行的第m个数和第n-m+1个数相等 ，为组合数性质之一。 每个数字等于上一行的左右两个数字之和。可用此性质写
2013年HDU专题：最短路径与背包问题训练
"HDU 专题分类（2013年8月）"是一场由webDIY和DIY组织的线上编程竞赛，针对ACM（Adaptive Computation and Machine Learning）问题提供了一系列的题目，旨在提升参赛者的算法设计和问题解决能力。这个专题训练涵盖了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值