矩阵取数 码蹄集

最新推荐文章于 2024-06-01 12:25:46 发布
最新推荐文章于 2024-06-01 12:25:46 发布
阅读量168 收藏
点赞数
分类专栏： 算法题 文章标签： 矩阵 算法 python c++ java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44052621/article/details/131022776
版权

题目来源：码蹄集

题目描述：

在这里插入图片描述
在这里插入图片描述

Python代码实现：

m, n, k = map(int, input().split())
M = []
for i in range(m):
    row = list(map(int, input().split()))
    M.append(row)

mx = [[0] * k for _ in range(m)]
dp = [[[0] * k for _ in range(n // 2 + 1)] for _ in range(n)]

def pre_process():
    for line in range(m):
        arr = M[line]
        for ii in range(n):
            if ii == 0:
                for jj in range(n // 2 + 1):
                    for mod in range(k):
                        if jj == 0:
                            if mod == 0:
                                dp[ii][jj][mod] = 0
                            else:
                                dp[ii][jj][mod] = -0x3fffffff
                        else:
                            if mod == 0:
                                if arr[0] % k == 0:
                                    dp[ii][jj][mod] = max(0, arr[0])
                                else:
                                    dp[ii][jj][mod] = 0
                            else:
                                if arr[0] % k == mod:
                                    dp[ii][jj][mod] = arr[0]
                                else:
                                    dp[ii][jj][mod] = -0x3fffffff
                continue

            for jj in range(n // 2 + 1):
                for mod in range(k):
                    if jj == 0:
                        if mod == 0:
                            dp[ii][jj][mod] = 0
                        else:
                            dp[ii][jj][mod] = -0x3fffffff
                    else:
                        dp[ii][jj][mod] = dp[ii - 1][jj][mod]
                        new_mod = (((mod - arr[ii]) % k) + k) % k
                        dp[ii][jj][mod] = max(dp[ii][jj][mod], arr[ii] + dp[ii - 1][jj - 1][new_mod])

        for mod in range(k):
            mx[line][mod] = dp[n - 1][n // 2][mod]

D = [[0] * k for _ in range(m)]

pre_process()

for ii in range(m):
    if ii == 0:
        for mod in range(k):
            D[ii][mod] = mx[ii][mod]
        continue

    for mod in range(k):
        D[ii][mod] = D[ii - 1][mod]
        for v in range(k):
            new_mod = (((mod - v) % k) + k) % k
            D[ii][mod] = max(D[ii][mod], mx[ii][v] + D[ii - 1][new_mod])

print(D[m - 1][0])

C++代码实现：

参考链接：https://blog.csdn.net/m0_54754302/article/details/128209412

#include<bits/stdc++.h> 

using namespace std;
typedef long long ull;
typedef long long LL;

const int MAX_N = 80;

int m,n,k;
int M[80][80];
ull mx[80][80];
ull dp[80][80][80];

void pre_process(){
    for(int line = 0;line<m;line++){
        int* arr = M[line];
        for(int ii=0;ii<n;ii++){
            if(ii==0){
                for(int jj=0;jj<=(n>>1);jj++){
                    for(int mod=0;mod<k;mod++){
                        if(jj==0){
                            if(mod==0) dp[ii][jj][mod]=0;
                            else dp[ii][jj][mod] = -0x3fffffff;
                        }else{
                            if(mod==0){
                                if(arr[0]%k==0)
                                    dp[ii][jj][mod] = max(0,arr[0]);
                                else
                                    dp[ii][jj][mod]=0;
                            }else{
                                if(arr[0]%k == mod)
                                    dp[ii][jj][mod] = arr[0];
                                else
                                    dp[ii][jj][mod] = -0x3fffffff;
                            }
                        }
                    }
                }
                continue;
            }

            for(int jj=0;jj<=(n>>1);jj++){
                for(int mod=0;mod<k;mod++){
                    if(jj==0){
                        if(mod==0) dp[ii][jj][mod] = 0;
                        else dp[ii][jj][mod] = -0x3fffffff;
                    }else{
                        dp[ii][jj][mod] = dp[ii-1][jj][mod];
                        int new_mod = (((mod-arr[ii])%k)+k)%k;
                        dp[ii][jj][mod] = max(dp[ii][jj][mod],arr[ii]+dp[ii-1][jj-1][new_mod]);
                    }
                }
            }
        }
        for(int mod=0;mod<k;mod++){
            mx[line][mod] = dp[n-1][n>>1][mod];
        }
    }
}

ull D[80][80];

int main( )
{
#ifdef TEST
    freopen("/Users/grh/Programming/ClionProjects/AlgoCoding/input.txt","r",stdin);
#endif

    scanf("%d %d %d",&m,&n,&k);
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++) scanf("%d",&(M[i][j]));
    }
    pre_process();

    for(int ii=0;ii<m;ii++){
        if(ii==0){
            for(int mod=0;mod<k;mod++){
                D[ii][mod] = mx[ii][mod];
            }
            continue;
        }

        for(int mod=0;mod<k;mod++){
            D[ii][mod] = D[ii-1][mod];
            for(int v=0;v<k;v++){
                int new_mod = (((mod-v)%k)+k)%k;
                D[ii][mod] = max(D[ii][mod],mx[ii][v]+D[ii-1][new_mod]);
            }
        }
    }

    printf("%lld",D[m-1][0]);
    return 0;
}

Java代码实现：

import java.util.Scanner;

public class Main {
    private static final int MAX_N = 80;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int m = scanner.nextInt();
        int n = scanner.nextInt();
        int k = scanner.nextInt();
        int[][] M = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                M[i][j] = scanner.nextInt();
            }
        }

        long[][] mx = new long[m][k];
        long[][][] dp = new long[n][n / 2 + 1][k];

        preProcess(m, n, k, M, mx, dp);

        long[][] D = new long[m][k];

        for (int ii = 0; ii < m; ii++) {
            if (ii == 0) {
                for (int mod = 0; mod < k; mod++) {
                    D[ii][mod] = mx[ii][mod];
                }
                continue;
            }

            for (int mod = 0; mod < k; mod++) {
                D[ii][mod] = D[ii - 1][mod];
                for (int v = 0; v < k; v++) {
                    int newMod = (((mod - v) % k) + k) % k;
                    D[ii][mod] = Math.max(D[ii][mod], mx[ii][v] + D[ii - 1][newMod]);
                }
            }
        }

        System.out.println(D[m - 1][0]);
    }

    private static void preProcess(int m, int n, int k, int[][] M, long[][] mx, long[][][] dp) {
        for (int line = 0; line < m; line++) {
            int[] arr = M[line];
            for (int ii = 0; ii < n; ii++) {
                if (ii == 0) {
                    for (int jj = 0; jj <= (n >> 1); jj++) {
                        for (int mod = 0; mod < k; mod++) {
                            if (jj == 0) {
                                if (mod == 0)
                                    dp[ii][jj][mod] = 0;
                                else
                                    dp[ii][jj][mod] = -0x3fffffff;
                            } else {
                                if (mod == 0) {
                                    if (arr[0] % k == 0)
                                        dp[ii][jj][mod] = Math.max(0, arr[0]);
                                    else
                                        dp[ii][jj][mod] = 0;
                                } else {
                                    if (arr[0] % k == mod)
                                        dp[ii][jj][mod] = arr[0];
                                    else
                                        dp[ii][jj][mod] = -0x3fffffff;
                                }
                            }
                        }
                    }
                    continue;
                }

                for (int jj = 0; jj <= (n >> 1); jj++) {
                    for (int mod = 0; mod < k; mod++) {
                        if (jj == 0) {
                            if (mod == 0)
                                dp[ii][jj][mod] = 0;
                            else
                                dp[ii][jj][mod] = -0x3fffffff;
                        } else {
                            dp[ii][jj][mod] = dp[ii - 1][jj][mod];
                            int newMod = (((mod - arr[ii]) % k) + k) % k;
                            dp[ii][jj][mod] = Math.max(dp[ii][jj][mod], arr[ii] + dp[ii - 1][jj - 1][newMod]);
                        }
                    }
                }
            }
            for (int mod = 0; mod < k; mod++) {
                mx[line][mod] = dp[n - 1][n >> 1][mod];
            }
        }
    }
}

代码提交测试结果：

在这里插入图片描述
附B站老师讲解链接，可供参考：https://www.bilibili.com/video/BV1ck4y1s7s8/?t=1818.9

Magneto_万磁王
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
1083 矩阵取数问题
NaCl__的博客
07-20 635
基准时间限制：1 秒 空间限制：131072 KB 分值: 5 难度：1级算法题收藏关注一个N*N矩阵中有不同的正整数，经过这个格子，就能获得相应价值的奖励，从左上走到右下，只能向下向右走，求能够获得的最大价值。例如：3 * 3的方格。1 3 32 1 32 2 1能够获得的最大价值为：11。Input 第1行：N，N为矩阵的大小。(2 <= N <= 500) 第2 - N + 1行：每行N个
[NOIP2007]矩阵取数游戏（详细题解、含多种思路）
weixin_51000954的博客
09-26 2832
题目 帅帅经常跟同学玩一个矩阵取数游戏：对于一个给定的 n×m 的矩阵，矩阵中的每个元素 ai,j​ 均为非负整数。游戏规则如下： 每次取数时须从每行各取走一个元素，共 n 个。经过 m 次后取完矩阵内所有元素； 每次取走的各个元素只能是该元素所在行的行首或行尾； 每次取数都有一个得分值，为每行取数的得分之和，每行取数的得分 = 被取走的元素值 ×2i，其中 i 表示第 i 次取数（从 1 开始编号）； 游戏结束总得分为 m 次取数得分之和。 帅帅想请你帮忙写一个程序，对于任意矩阵，可以求出取数后的最大
码题集 填矩阵
ZZR2631574030的博客
08-24 223
有一个1xn的矩阵，现在往里面填方块，一共有三种方块：1×1的白块，1×1的黑块，1×k的黑块，方块放置时，必须是黑白交替的，矩阵不用填满，但要求最下面的块和最上面的块必须是黑色的，问有多少种放置方法。
码蹄集24周周赛（史莱姆融合，求逆矩阵，矩阵游戏，矩阵计数，比较器）
s1050712899的博客
11-11 1372
马蹄疾
算法竞赛入门【码蹄集进阶塔335题】(MT2281-2285）
m0_54754302的博客
11-30 3378
算法竞赛入门【码蹄集进阶塔335题】（MT2281、MT2282、MT2283、MT2284、MT2285）
算法竞赛入门【码蹄集进阶塔335题】(MT2291-2295）
m0_54754302的博客
11-30 2333
算法竞赛入门【码蹄集进阶塔335题】（MT2291、MT2292、MT2293、MT2294、MT2295）
码蹄集部分题目（2024OJ赛15期；前缀和+栈+堆+队列）
qq_63349644的博客
05-17 2077
码蹄集部分题目（2024OJ赛15期；前缀和+栈+堆+队列）
算法竞赛入门【码蹄集新手村600题】(MT1201-1250）
m0_54754302的博客
07-29 2073
算法竞赛入门【码蹄集新手村600题】（MT1201、MT1202、MT1203、MT1204、MT1205......MT1250）
32*32矩阵手写数字集合数据集
07-04
32*32数字矩阵集合数据集
NOIP 2007 矩阵取数游戏 源代码
03-23
NOIP 2007 的题目矩阵取数游戏的pascal源代码，测试数据全部通过。
病态矩阵条件数估算方法
07-11
对于一个方程组的求解问题，通常会考虑到条件数，条件数太大，计算机求解会出现极大的误差，影响到后续工作的进行，需要对条件数进行预估。
区县邻近矩阵数据集.xlsx
05-01
详细介绍及样例数据参见文章：https://blog.csdn.net/m0_65541699/article/details/138376874
C#实现矩阵加法、取负、数乘、乘法的方法
09-03
主要介绍了C#实现矩阵加法、取负、数乘、乘法的方法,涉及C#针对矩阵的数学运算相关实现技巧,需要的朋友可以参考下
【线性表 - 数组和矩阵】
abclyq的博客
05-31 1040
数组是一种连续存储线性结构，元素类型相同，大小相等，数组是多维的，通过使用整型索引值来访问他们的元素，数组尺寸不能改变。
数组和矩阵
m0_50846237的博客
05-28 916
数组可以方便的通过获取到下标下对应的数据。正是。
每日刷题——杭电2156.分数矩阵和杭电2024.C语言合法标识符
u014114223的博客
06-01 934
这个函数接收一个字符串作为输入，根据C语言标识符的规则判断该字符串是否合法。规则包括：首字符必须是字母或下划线，之后的字符可以是字母、数字或下划线。Input：输入数据包含多个测试实例，数据的第一行是一个整数n,表示测试实例的个数，然后是n行输入数据，每行是一个长度不超过50的字符串。如果输入数据是C的合法标识符，则输出"yes"，否则，输出“no”。Input：每行给定整数N (N
傅立叶变换矩阵的频谱响应
最新发布
weixin_45827703的博客
06-01 733
线性变换可以用矩阵表示，傅立叶变换是一种线性变换，因此也可以使用矩阵表示。
matlab从矩阵中取数
06-01
在 Matlab 中，可以使用下标索引的方式从矩阵中取数。下标索引是用方括号括起来的数字或数字向量，它们代表了要取的矩阵中的元素的位置。 例如，假设有一个大小为 3x3 的矩阵 A，我们可以使用下标索引来取出第二行...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Magneto_万磁王

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值