P1005 [NOIP2007 提高组] 矩阵取数游戏

已于 2023-12-07 15:23:59 修改
阅读量694 收藏 8
点赞数 9
文章标签： 算法 动态规划 c语言
于 2023-12-06 23:31:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fool256353/article/details/134843676
版权

网址：P1005 [NOIP2007 提高组] 矩阵取数游戏 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

动态规划和高精度的组合，使我的滨州旋转

最后只得了80，两个测试点超时了

看题解有人是用了int128来做的，明天学一下

我的递归思路和常规的不同，但也能做就是了，明天参考一下他们的

垃圾代码如下：

#include<stdio.h>
#include<string.h>
#define MAXN 30
void multiply_constant(int a[], int b);
void add_constant(int a[], int b);
void add_array(int a[], int b[]);
int digcmp(int a[], int b[]);
int diglen(int a[]);
int dp[81][81][MAXN], num[81], result[MAXN];
int n, m;//result的长度

int main(void)
{
    scanf("%d%d", &n, &m);
    for(int i = 0; i < n; i++)
    {
        memset(dp, 0, sizeof(dp));
        for(int j = 1; j <= m; j++)
            scanf("%d", &num[j]);
        for(int j = 1; j <= m; j++)
        {
            add_constant(dp[0][j], num[m + 1 - j]), add_constant(dp[j][0], num[j]);
            for(int k = 0; k < j; k++)
                multiply_constant(dp[0][j], 2), multiply_constant(dp[j][0], 2);
            add_array(dp[0][j], dp[0][j - 1]), add_array(dp[j][0], dp[j - 1][0]);
        }//处理一直从左边取和一直从右边取的情况
        for(int j = 2; j <= m; j++)//j代表取了多少数
        {
            for(int x = 1; x < j; x++)
            {
                int y = j - x;
                int tmp1[MAXN] = {0}, tmp2[MAXN] = {0};
                add_constant(tmp1, num[x]), add_constant(tmp2, num[m + 1 - y]);
                for(int k = 0; k < j; k++)
                    multiply_constant(tmp1, 2), multiply_constant(tmp2, 2);
                add_array(tmp1, dp[x - 1][y]), add_array(tmp2, dp[x][y - 1]);
                if(digcmp(tmp1, tmp2) >= 0)
                    memcpy(dp[x][y], tmp1, sizeof(tmp1));
                else
                    memcpy(dp[x][y], tmp2, sizeof(tmp2));
            }
            //dp[x][y] = max{dp[x - 1][y] + num[x] * 2 ^ j, dp[x][y - 1] + num[m + 1 - y] * 2 ^ j}
            //x代表左边取了多少数，y代表右边取了多少数
        }
        //得到取完的数中的最大的数
        int tmp[MAXN] = {0};
        for(int x = 0; x <= m; x++)
        {
            int y = m - x;
            if(digcmp(tmp, dp[x][y]) < 0)
                memcpy(tmp, dp[x][y], sizeof(dp[x][y]));
        }
        //result加上最大的数
        add_array(result, tmp);
    }
    //输出result
    for(int i = diglen(result) - 1; i >= 0; i--)
        printf("%d", result[i]);

    return 0;
}
void multiply_constant(int a[], int b)
{
    int ext = 0, i;
    for(i = 0; i < diglen(a); i++)
    {
        ext += b * a[i];
        a[i] = ext % 10;
        ext /= 10;
    }
    while(ext)
    {
        a[i++] = ext % 10;
        ext /= 10;
    }
    return;
}
void add_constant(int a[], int b)
{
    int ext = 0, i = 0;
    while(b)
    {
        ext += a[i] + b % 10;
        a[i++] = ext % 10;
        ext /= 10, b /= 10;
    }
    return;
}
void add_array(int a[], int b[])
{
    int ext = 0;
    for(int i = 0; i < MAXN; i++)
    {
        ext += a[i] + b[i];
        a[i] = ext % 10;
        ext /= 10;
    }
    return;
}//m加到n上
int digcmp(int a[], int b[])
{
    for(int i = MAXN - 1; i >= 0; i--)
        if(a[i] != b[i])
            return a[i] - b[i];
    return 0;
}//n更大时返回整数
int diglen(int a[])
{
    int i;
    for(i = MAXN; i >= 0; i--)
        if(a[i])  break;
    if(i < 0) return 1;
    return i + 1;
}//得到n数组的长度

累了累了，洗洗睡

题解就先不写了

补充：

先试了一下之前讲过的提高高精度效率的方法，对比我下面的代码就可以看出来，很明显的变化

代码如下：

#include<stdio.h>
#include<string.h>
#define MAXN 25
void multiply_constant(int a[], int b);
void add_constant(int a[], int b);
void add_array(int a[], int b[]);
int digcmp(int a[], int b[]);
int diglen(int a[]);
int dp[81][81][MAXN], num[81], result[MAXN];
int n, m;//result的长度

int main(void)
{
    scanf("%d%d", &n, &m);
    for(int i = 0; i < n; i++)
    {
        memset(dp, 0, sizeof(dp));
        for(int j = 1; j <= m; j++)
            scanf("%d", &num[j]);
        for(int j = 1; j <= m; j++)
        {
            add_constant(dp[0][j], num[m + 1 - j]), add_constant(dp[j][0], num[j]);
            for(int k = 0; k < j; k++)
                multiply_constant(dp[0][j], 2) , multiply_constant(dp[j][0], 2);
            add_array(dp[0][j], dp[0][j - 1]), add_array(dp[j][0], dp[j - 1][0]);
        }//处理一直从左边取和一直从右边取的情况
        for(int j = 2; j <= m; j++)//j代表取了多少数
        {
            for(int x = 1; x < j; x++)
            {
                int y = j - x;
                int tmp1[MAXN] = {0}, tmp2[MAXN] = {0};
                add_constant(tmp1, num[x]), add_constant(tmp2, num[m + 1 - y]);
                for(int k = 0; k < j; k++)
                    multiply_constant(tmp1, 2), multiply_constant(tmp2, 2);
                add_array(tmp1, dp[x - 1][y]), add_array(tmp2, dp[x][y - 1]);
                if(digcmp(tmp1, tmp2) >= 0)
                    memcpy(dp[x][y], tmp1, sizeof(tmp1));
                else
                    memcpy(dp[x][y], tmp2, sizeof(tmp2));
            }
            //dp[x][y] = max{dp[x - 1][y] + num[x] * 2 ^ j, dp[x][y - 1] + num[m + 1 - y] * 2 ^ j}
            //x代表左边取了多少数，y代表右边取了多少数
        }
        //得到取完的数中的最大的数
        int tmp[MAXN] = {0};
        for(int x = 0; x <= m; x++)
        {
            int y = m - x;
            if(digcmp(tmp, dp[x][y]) < 0)
                memcpy(tmp, dp[x][y], sizeof(dp[x][y]));
        }
        //result加上最大的数
        add_array(result, tmp);
    }
    //输出result
    for(int i = diglen(result) - 1, first = 1; i >= 0; i--)
        if(first)
            {printf("%d", result[i]);  first = 0;}
        else
            printf("%09d", result[i]);

    return 0;
}
void multiply_constant(int a[], int b)
{
    int ext = 0, i;
    for(i = 0; i < diglen(a); i++)
    {
        ext += b * a[i];
        a[i] = ext % 1000000000;
        ext /= 1000000000;
    }
    while(ext)
    {
        a[i++] = ext % 1000000000;
        ext /= 1000000000;
    }
    return;
}
void add_constant(int a[], int b)
{
    int ext = 0, i = 0;
    while(b)
    {
        ext += a[i] + b % 1000000000;
        a[i++] = ext % 1000000000;
        ext /= 1000000000, b /= 1000000000;
    }
    return;
}
void add_array(int a[], int b[])
{
    int ext = 0;
    for(int i = 0; i < MAXN; i++)
    {
        ext += a[i] + b[i];
        a[i] = ext % 1000000000;
        ext /= 1000000000;
    }
    return;
}//m加到n上
int digcmp(int a[], int b[])
{
    for(int i = MAXN - 1; i >= 0; i--)
        if(a[i] != b[i])
            return a[i] - b[i];
    return 0;
}//n更大时返回整数
int diglen(int a[])
{
    int i;
    for(i = MAXN - 1; i >= 0; i--)
        if(a[i])  break;
    if(i < 0) return 1;
    return i + 1;
}//得到n数组的长度

这样得了90分，最后一个测评点就超了一点时

只要把long long换成int，然后改一下一格储存的数据上限就可以拿到满分了

这是最简单的高精度优化方式

还有一个优化方式，就是不要一次一次地乘2，在不会溢出的情况下，改成一次乘2^n，然后满足需要求的数，如要乘2^80次方，可以先乘2^20次方，然后乘下去

但是要注意，因为我已经尽量地利用int储存的空间了，所以可以乘的2^n的n是相对较小的，两个方法算是鱼和熊掌不可兼得

然后是其他的dp方法：

一般的是区间dp法：即当剩余数的区间在[ai, aj]的时候的最大值

还有另一个方法：先从中间开始取，每dp一次就将数加上新的数乘2，这样计算会比较简单（在用到高精度数组的情况下）

最后是int128的实现：我会专门写一篇博客来讲

Fool256353
关注
  • 9
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
NOIP 2007 矩阵取数游戏 源代码
03-23
NOIP 2007 的题目矩阵取数游戏的pascal源代码，测试数据全部通过。
P1005专属代码
07-25
P1005专属代码，欢迎大家下载，不知道能不能用
Luogu P1005 [NOIP2007 提高组] 矩阵取数游戏
yanzicheng1的博客
03-02 523
帅帅经常跟同学玩一个矩阵取数游戏：对于一个给定的 $n \times m$ 的矩阵($1\le n,m\le 80$)，矩阵中的每个元素 $a_{i,j}$ 均为非负整数（$0\le a_{i,j}\le1000$）。$，$1\le n,m\le 80$，$0\le a_{i,j}\le1000$，最多要计算到$2^{80}$，所以现有的unsigned long long是无法解决这个问题的，摆在我们眼前的是两条路：高精度和__int128。
洛谷P1005 [NOIP2007 提高组] 矩阵取数游戏
jim_hfz的博客
07-18 184
帅帅经常跟同学玩一个矩阵取数游戏对于一个给定的n×m的矩阵，矩阵中的每个元素ai,j​均为非负整数。nm×2iii1m帅帅想请你帮忙写一个程序，对于任意矩阵，可以求出取数后的最大得分。
洛谷P1005 [NOIP2007 提高组] 矩阵取数游戏题解
zzsaghjk的博客
08-27 350
帅帅经常跟同学玩一个矩阵取数游戏：对于一个给定的 n \times mn×m 的矩阵，矩阵中的每个元素 a_{i,j}ai,j​ 均为非负整数。对于 100\%100% 的数据，满足 1\le n,m\le 801≤n,m≤80，0\le a_{i,j}\le10000≤ai,j​≤1000。对于 60\%60% 的数据，满足 1\le n,m\le 301≤n,m≤30，答案不超过 10^{16}1016。有一个n \times mn×m的矩阵，对于第ii行，每次。，求nn行的最大得分总和。...
NOIP2007 提高组] 矩阵取数游戏
最新发布
CC
04-23 573
P1005 [NOIP2007 提高组] 矩阵取数游戏。
P1005 [NOIP2007 提高组] 矩阵取数游戏（区间dp）
Ghostttttttiii的博客
05-01 1364
P1005[NOIP2007 提高组] 矩阵取数游戏https://www.luogu.com.cn/problem/P1005 #include <iostream> #include <cstdio> #include <string> #include <algorithm> #include <vector> #include <queue> #include <stack> #include <cstr.
P1005 [NOIP2007 提高组] 矩阵取数游戏 c++题解
kekedeLa的博客
03-26 366
帅帅经常跟同学玩一个矩阵取数游戏：对于一个给定的 n×m 的矩阵，矩阵中的每个元素 ai,j​ 均为非负整数。对于 100%100% 的数据，满足 1≤n,m≤80，0≤ai,j​≤1000。第 2∼n+1 行为 n×m 矩阵，其中每行有 m 个用单个空格隔开的非负整数。对于 60%60% 的数据，满足1≤n,m≤30，答案不超过 10161016。帅帅想请你帮忙写一个程序，对于任意矩阵，可以求出取数后的最大得分。输出文件仅包含 1 行，为一个整数，即输入矩阵取数后的最大得分。
P1005 [NOIP2007 提高组] 矩阵取数游戏 day28
qq_23852555的博客
07-13 522
训练记录
洛谷P1005 [NOIP2007 提高组] 矩阵取数游戏 题解
q779的博客
07-09 769
区间dp+高精度
P1005 最大公约数.cpp
11-29
P1005 最大公约数.cpp
c#调试程序一例（p1005）
03-20
有效的调试技巧可以提高开发效率，减少bug，并最终提升用户体验。 ### 知识点二：C#中的日志记录 日志记录是调试程序的一个非常有用的工具。通过分析日志文件，开发者可以追踪到程序运行时的状态变化，这对于理解...
TYVJ题库P1005题 滑雪问题源代码
11-21
标题中的“TYVJ题库P1005题 滑雪问题源代码”指的是一个编程竞赛题目，来源于TYVJ（可能是一个在线编程竞赛平台）的题库，编号为P1005，主题是“滑雪”。这个问题显然需要参赛者编写程序来解决，而提供的“解”表明...
基于SPLC与变频器的风机节能自动控制分解PPT学习教案.pptx
10-02
这个系统主要用于解决类似电锯工作时的吸尘风机控制问题，旨在提高能效并优化工作环境。 一、项目说明 在传统方案中，风机采用电位器调节风量，工人需要手动操作电位器以适应不同设备的工作需求。但实际操作中，...
FANUC系统四种返回参考点方法.pdf
11-13
- 参数设置：P1002(1)=0 和 P1005(1)=0 表示有减速开关。P1006(5)用于设定回零方向。P3003(5)决定减速开关的有效状态，而P1424、P1425分别设定回零的快速和低速速度。P1850定义栅格偏移量，P1240设定第一参考点的...
HP1007维修手册
09-27
"看了就能修"表达了手册的实用性，旨在让不具备专业知识的用户也能快速上手，提高问题解决效率。 【标签】"维修手册"进一步强调了本文件的核心内容，即提供有关如何修理HP1007打印机的指导。这类手册通常会包括故障...
FANUC系统四种返回点方法.doc
10-07
1. 参数设置：P1002(1)=1 或 P1005(1)=1 表示无减速开关，其他参数如P1006(5)、P1425、P1850和P1240依然重要。 2. 回零过程：没有减速开关的情况下，系统直接以设定的回零低速找寻MARK点，然后偏移栅格距离停止，...
HP_ljP1000_P1500HBpnpwin32sc.zip
06-29
HP LaserJet P1000系列打印机主要包括P1005、P1006、P1007和P1008等型号，这些打印机以其小巧的体积、经济的成本和可靠的打印质量受到用户欢迎。此驱动程序兼容P1007型号，且根据描述，也适用于P1007之外的其他P1000...
p1005最大公约数c语言
08-25
否则，递归调用求取两个数的余数和较小数的最大公约数。 在`main`函数中，首先定义了两个整数变量`n`和`m`，用于存储输入的两个数。然后使用`scanf`函数从标准输入中读取两个数的值。接下来，调用`gcd`函数求取最大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值