数字金字塔（C++）

最新推荐文章于 2024-05-04 17:15:56 发布
最新推荐文章于 2024-05-04 17:15:56 发布
阅读量6.5k 收藏 21
点赞数 9
文章标签： c++ 学习 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59850318/article/details/125884610
版权

观察下面的数字金字塔。写一个程序查找从最高点到底部任意处结束的路径，使路径经过数字的和最大。每一步可以从当前点走到左下方的点也可以到达右下方的点。

输入：

       第一个行包含R(1<= R<=1000)，表示行的数目。

       后面每行为这个数字金字塔特定行包含的整数。

       所有的被供应的整数是非负的且不大于100。

输出：

      单独的一行，包含那个可能得到的最大的和。

方法1：搜索

问题要求的是从最高点按照规则走到最低点的路径的最大的权值和，路径起点终点固定，走法规则明确，可以考虑用搜索来解决。

定义递归函数void Dfs(int x,int y,int Curr)，其中x,y表示当前已从(1,1)走到(x,y)，目前已走路径上的权值和为Curr。

当x=N时，到达递归出口，如果Curr比Ans大，则把Ans更新为Curr；否则向下一行两个位置行走，即递归执行Dfs(x+1,y,Curr+A[x+1][y])和Dfs(x+1,y+1,Curr+A[x+1][y+1])

#include <iostream>
using namespace std;
const int MAXN = 1005;
int A[MAXN][MAXN],F[MAXN][MAXN],N,Ans;
void Dfs(int x,int y,int Curr)
{
	  if (x==N)
	  {
	      if (Curr>Ans)Ans=Curr;
	      return;
	  }
	  Dfs(x+1,y,Curr+A[x+1][y]);
	  Dfs(x+1,y+1,Curr+A[x+1][y+1]);
}
int main()
{
     cin >> N;
     for(int i = 1;i <= N;i ++)
       for(int j = 1;j <= i;j ++)
	 cin >> A[i][j];
     Ans =0;
     Dfs(1,1,A[1][1]);
     cout<<Ans<<endl;
     return 0;
}

 该方法实际上是把所有路径都走了一遍，由于每一条路径都是由N-1步组成，每一步有“左”、“右”两种选择，因此路径总数为2N-1，所以该方法的时间复杂度为O(2N-1)，超时。

方法2：记忆法搜索

        方法1之所以会超时，是因为进行了重复搜索，如样例中从(1,1)到(3,2)有“左右”和“右左”两种不同的路径，也就是说搜索过程中两次到达(3,2)这个位置，那么从(3,2)走到终点的每一条路径就被搜索了两次，我们完全可以在第一次搜索(3,2)到终点的路径时就记录下(3,2)到终点的最大权值和，下次再次来到(3,2)时就可以直接调用这个权值避免重复搜索。我们把这种方法称为记忆化搜索。

记忆化搜索需要对方法一中的搜索进行改装。由于需要记录从一个点开始到终点的路径的最大权值和，因此我们重新定义递归函数Dfs。

定义Dfs(x,y)表示从(x,y)出发到终点的路径的最大权值和，答案就是Dfs(1,1)。计算Dfs(x,y)时考虑第一步是向左还是向右，我们把所有路径分成两大类：

①第一步向左：那么从(x,y)出发到终点的这类路径就被分成两个部分，先从(x,y)到(x+1,y)再从(x+1,y)到终点，第一部分固定权值就是A[x][y]，要使得这种情况的路径权值和最大，那么第二部分从(x+1,y)到终点的路径的权值和也要最大，这一部分与前面的Dfs(x,y)的定义十分相似，仅仅是参数不同，因此这一部分可以表示成Dfs(x+1,y)。综上，第一步向左的路径最大权值和为A[x][y]+Dfs(x+1,y)；

②第一步向右：这类路径要求先从(x,y)到(x+1,y+1)再从(x+1,y+1)到终点，分析方法与上面一样，这类路径最大权值和为A[x][y]+Dfs(x+1,y+1)；

为了避免重复搜索，我们开设全局数组F[x][y]记录从(x,y)出发到终点路径的最大权值和，一开始全部初始化为-1表示未被计算过。在计算Dfs(x,y)时，首先查询F[x][y]，如果F[x][y]不等于-1，说明Dfs(x,y)之前已经被计算过，直接返回 F[x][y]即可，否则计算出Dfs(x,y)的值并存储在F[x][y]中。

  #include <iostream>
  #include <algorithm>
  using namespace std;
  const int MAXN = 505;
  int A[MAXN][MAXN],F[MAXN][MAXN],N;
  int Dfs(int x,int y)
  {
  	if (F[x][y]==-1)
  	{
             if (x==N)F[x][y]=A[x][y];
             else F[x][y]=A[x][y]+max(Dfs(x+1,y),Dfs(x+1,y+1));
    }
    return F[x][y];
  }
  int main()
  {
  	cin >> N;
  	for(int i = 1;i <= N;i ++)
  		for(int j = 1;j <= i;j ++)
  			cin >> A[i][j];
  	for(int i = 1;i <= N;i ++)
  		for(int j = 1;j <= i;j ++)
  			F[i][j] = -1;
  	Dfs(1,1);
  	cout << F[1][1] << endl;
  	return 0;
  }

由于F[x][y]对于每个合法的(x,y)都只计算过一次，而且计算是在O(1)内完成的，因此时间复杂度为O(n^{2})。

方法3：顺推法

方法2通过分析搜索的状态重复调用自然过渡到记忆化搜索，而记忆化搜索本质上已经是动态规划了。下面我们完全从动态规划的算法出发换一个角度给大家展示一下动态规划的解题过程，并提供动态规划的迭代实现法。
①确定状态：

题目要求从(1,1)出发到最底层路径最大权值和，路径中是各个点串联而成，路径起点固定，终点和中间点相对不固定。因此定义F[x][y]表示从(1,1)出发到达(x,y)的路径最大权值和。最终答案Ans=max{F[N][1],F[N][2],...,F[N][N]}。
②确定状态转移方程和边界条件：

不去考虑(1,1)到(x,y)的每一步是如何走的，只考虑最后一步是如何走，根据最后一步是向左还是向右分成以下两种情况：

向左：最后一步是从(x-1,y)走到(x,y),此类路径被分割成两部分，第一部分是从(1,1)走到(x-1,y)，第二部分是从(x-1,y)走到(x,y)，要计算此类路径的最大权值和，必须用到第一部分的最大权值和，此部分问题的性质与F[x][y]的定义一样，就是F[x-1,y]，第二部分就是A[x][y]，两部分相加即得到此类路径的最大权值和为F[x-1,y]+A[x,y]；

向右：最后一步是从(x-1,y-1)走到(x,y),此类路径被分割成两部分，第一部分是从(1,1)走到(x-1,y)，第二部分是从(x-1,y)走到(x,y)，分析方法如上。此类路径的最大权值和为F[x-1,y-1]+A[x,y]；

F[x][y]的计算需要求出上面两种情况的最大值。综上，得到状态转移方程如下：

F[x][y]=max{F[x-1,y-1],F[x-1][y]}+A[x,y]

与递归关系式还需要递归终止条件一样，这里我们需要对边界进行处理以防无限递归下去。观察发现计算F[x][y]时需要用到F[x-1][y-1]和F[x-1,y]，是上一行的元素，随着递归的深入，最终都要用到第一行的元素F[1][1],F[1][1]的计算不能再使用状态转移方程来求，而是应该直接赋予一个特值A[1][1]。这就是边界条件。

综上得：

状态转移方程：F[x][y]=max{F[x-1][y-1],F[x-1][y]}+A[x,y]

边界条件：F[1][1]=A[1][1]

现在让我们来分析一下该动态规划的正确性，分析该解法是否满足使用动态规划的两个前提：

最优化原理：这个在分析状态转移方程时已经分析得比较透彻，明显是符合最优化原理的；

无后效性：状态转移方程中，我们只关心F[x-1][y-1]与F[x-1][y]的值，计算F[x-1][y-1]时可能有多种不同的决策对应着最优值，选哪种决策对计算F[x][y]的决策没有影响，F[x-1][y-1]也是一样。这就是无后效性。 
③程序实现：

由于状态转移方程就是递归关系式，边界条件就是递归终止条件，所以可以用递归来完成，递归存在重复调用，利用记忆化可以解决重复调用的问题，方法二已经讲过。记忆化实现比较简单，而且不会计算无用状态，但递归也会受到“栈的大小”和“递推+回归执行方式”的约束，另外记忆化实现调用状态的顺序是按照实际需求而展开，没有大局规划，不利于进一步优化。

这里介绍一种迭代法。与分析边界条件方法相似，计算F[x][y]用到状态F[x-1][y-1]与F[x-1][y]，这些元素在F[x][y]的上一行，也就是说要计算第x行的状态的值，必须要先把第x-1行元素的值计算出来，因此我们可以先把第一行元素F[1][1]赋为 A[1][1]，再从第二行开始按照行递增的顺序计算出每一行的有效状态即可。时间复杂度为O(n^{2})。

#include <iostream>
#include <algorithm>
using namespace std;
const int MAXN = 1005;
int A[MAXN][MAXN],F[MAXN][MAXN],N;
int main(){
  	cin >> N;
  	for(int i = 1;i <= N;i ++)
  	    for(int j = 1;j <= i;j ++)
  	        cin >> A[i][j];
  	F[1][1] = A[1][1];
  	for(int i = 2;i <= N;i ++)
                  for(int j = 1;j <= i;j ++)
  	       F[i][j]=max(F[i-1][j-1],F[i-1][j])+A[i][j];
  	int ans =0;
  	for(int i = 1;i <= N;i ++)
  	    ans = max(ans,F[N][i]);
  	cout << ans << endl;
  	return 0;
  }

方法4：逆推法

①贪心法往往得不到最优解：本题若采用贪心法则：13-11-12-14-13，其和为63,但存在另一条路：13-8-26-15-24，其和为86。

②动态规划求解：动态规划求解问题的过程归纳为：自顶向下的分析，自底向上计算。

其基本方法是：

划分阶段：按三角形的行，划分阶段，若有n行，则有n-1个阶段。

A．从根结点13出发，选取它的两个方向中的一条支路，当到倒数第二层时，每个结点其后继仅有两个结点，可以直接比较，选择最大值为前进方向，从而求得从根结点开始到底端的最大路径。

B．自底向上计算：（给出递推式和终止条件）

①从底层开始，本身数即为最大数；

②倒数第二层的计算，取决于底层的数据：12+6=18，13+14=27，24+15=39，24+8=32；

③倒数第三层的计算，取决于底二层计算的数据：27+12=39，39+7=46，39+26=65

④倒数第四层的计算，取决于底三层计算的数据：46+11=57，65+8=73

⑤最后的路径：13——8——26——15——24

 C．数据结构及算法设计

①图形转化：直角三角形，便于搜索：向下、向右

②用三维数组表示数塔：a[x][y][1]表示行、列及结点本身数据,a[x][y][2]能够取得最大值,a[x][y][3]表示前进的方向——0向下，1向右；

③算法：

数组初始化，输入每个结点值及初始的最大路径、前进方向为0；从倒数第二层开始向上一层求最大路径，共循环N-1次；从顶向下，输出路径：究竟向下还是向右取决于列的值，若列的值比原先多1则向右，否则向下。

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
	int n,x,y;
	int a[51][51][3];
	cout<<"please input the number of rows:";
	cin>>n;
	memset(a,0,sizeof(0));
	for (x=1;x<=n;x++)                         //输入数塔的初始值
     	for (y=1;y<=x;y++)
	     	{
			cin>>a[x][y][1];
			a[x][y][2]=a[x][y][1];
			a[x][y][3]=0;                          //路径走向，默认向下
		} 
      for (x=n-1;x>=1;x--)
            for (y=1;y<=x;y++)
                  if (a[x+1][y][2]>a[x+1][y+1][2])     //选择路径，保留最大路径值
                  { a[x][y][2]=a[x][y][2]+a[x+1][y][2]; a[x][y][3]=0; }
                  else { a[x][y][2]=a[x][y][2]+a[x+1][y+1][2]; a[x][y][3]=1; }
      cout<<"max="<<a[1][1][2]<<endl;           //输出数塔最大值
      y=1;
      for (x=1;x<=n-1;x++)                      //输出数塔最大值的路径
      {
             cout<<a[x][y][1]<<"->";
             y=y+a[x][y][3];                         //下一行的列数
      }
     cout<<a[n][y][1]<<endl;
}

输入：

5               //数塔层数

13

11   8

12   7    26

6   14    15    8

12   7    13   24    11

输出结果：

 max=86

 13->8->26->15->24

a'ゞfan
关注
  • 9
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
金字塔C++
weixin_51516247的博客
06-19 1161
基础版 #include <iostream.h> void main() { int n,i,j; cin>>n; for(i=1;i<=n;i++) { for(j=1;j<=n-i;j++) cout<<" "; for(j=1;j<=2*i-1;j++) cout<<"*"; cout<<endl; }}
7-1数字三角形
m0_58339622的博客
05-13 257
观察下面的数字金字塔。写一个程序查找从最高点到底部任意处结束的路径，使路径经过数字的和最大。每一步可以从当前点走到左下方的点也可以到达右下方的点。 在上面的样例中,从13到8到26到15到24的路径产生了最大的和86。 输入格式: 第一个行包含R(1≤ R≤1000)，表示行的数目。 后面每行为这个数字金字塔特定行包含的整数。 所有的被供应的整数是非负的且不大于100。 输出格式: 单独的一行，包含那个可能得到的最大的和。 输入样例: 5 13 11 8 12 7 26 6 14
数字金字塔（动态规划）
_BOSS_的博客
08-17 3356
问题描述： 观察下面的数字金字塔，查找从最高点到底部任意结束的路径，使路径经过的数字之和最大。每一步可以从当前点走到左下方的点或者右下方的点。                          13                    11         8              12          7          26        6          14    
C++数塔问题
SYC20110120的博客
03-29 637
用于存储从底部到当前位置的最大路径和。通过逆向遍历数塔，从倒数第二层开始，每一层的每个位置的最大路径和可以通过其下一层相邻的两个位置的最大路径和来计算。首先读取输入的数塔，将数塔表示为一个二维数组。，创建一个大小与数塔相同的二维数组。，即为从顶部到底部的最大路径和。
C++递推算法典例：数塔问题
最新发布
m0_67249626的博客
05-04 355
【代码】C++递推算法典例：数塔问题。
C++金字塔图案
qinglong_zhan的博客
10-14 7162
C++用星号输出金字塔图案 输入输出样例 #include<iostream> using namespace std; int main() { int n; cin >> n; for (int i = n - 1; i >= 0; i--) //大循环执行n次，即共有几行执行几次。i也可设成其他数字，执行n次即可 { for (int p =...
C++系统性学习之金字塔图案打印
2301_82137722的博客
12-22 648
在本篇博客中，我们将学习如何使用C++编写一个程序，根据给定的金字塔边长，打印出由"*"组成的金字塔图案。
数塔问题及变形
c0re的博客
04-29 309
数塔问题及变形数塔问题及变形数塔问题及变形数塔问题及变形数塔问题及变形数塔问题及变形
数塔问题
★探梦少年☆的博客
05-15 350
考虑在下面被显示的数字金字塔。 写一个程序来计算从最高点开始在底部任意处结束的路径经过数字的和的最大。 每一步可以走到左下方的点也可以到达右下方的点。 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5 在上面的样例中,从7 到 3 到 8 到 7 到 5 的路径产生了最大和:30 Input 第一个行包含 R(1<= R<=1000) ,表示行的数目。 后面每行为这个数字金字塔特定行包含...
数字塔C++
weixin_51188609的博客
07-31 1941
数字塔 题目描述 输入一个整数n，输出n行数字金字塔。如n=3时，则输出如下图形： 输入 1个整数n（1≤n≤9） 输出 n行，第1行1，第2行121，以此类推，直到n行2*n+1个数字，从1递增到n，再由n-1递减到1。 样例输入 3 样例输出 1 121 12321 代码 #include<bits/stdc++.h> using namespace std; int main(){ int n; cin>>n; for(int i=1;i<=n;i++) { for(i
数塔问题的算法c++实现
06-27
要找到最大和的前提条件是，要能看到数塔的全貌。在此基础之上，不难发现，该问题应从下而上逐层解决。从倒数第二层开始考虑，对该层的每一个数取其下一层中与其相邻的两个数的较大者。然后把二者相加，结果存储到一个位置。依次倒退到第一层时就可得到最佳结果。 下一个问题是如何解决存储问题，如果把每一次累加的和存储到原表的话，当输出路径时将找不到数塔的原始数据。因此要另辟一个表存储从倒数第二层开始没个数的累加和。为了方便，我们可以开辟一个与原表相同的数组来存储相应位置上的累加和。 还有一个问题是，如何根据累加和与原始数塔数据找到相应的路径。我们来分析一下，对于从倒数第二层开始的每一个数，与其对应的下一个数无非在其左边或右边，只有这两种可能。因此，可以把这两个数区分出左和右，进而，可以用标志量来标识我们取左还是取右。同样，我们再开辟一个与原表相同的数组来存储相应是标识量。我们可以用0表示取左，1表示取右。 最后，总结一下，我们可以把这三张表同时申请出来——用三维数组。
c++输出正倒金字塔
12-20
#include void main() {int i,j,k; for(i=1;i<=7;i++) {if(i<=4) {for(j=1;j<=4-i;j++) cout<<" "; for(k=1;k<=2*i-1;k++) {cout<<"*";} cout<<"\n"; } else { for(j=1;j<=i-4;j++) {cout<<" ";} for(k=1;k<=15-2*i;k++) {cout<<"*";} cout<<"\n"; } } }
数塔问题解决方案
05-24
经典算法数塔问题解决方案 自己思路编写 没有什么难点 仔细阅读就可以看懂
绘制金字塔
06-04
计算机图形学绘制三维图形，金字塔 核心View显示部分CPP
(C语言)数字金字塔
热门推荐
xycg0529的博客
04-08 1万+
本题来自pintia.cn题目要求题目分析代码测试结果图PTA测试图 题目要求 本题要求实现函数输出n行数字金字塔。 函数接口定义： void pyramid( int n ); 其中n是用户传入的参数，为[1, 9]的正整数。要求函数按照如样例所示的格式打印出n行数字金字塔。注意每个数字后面跟一个空格。 裁判测试程序样例： #include <stdio.h> void pyram...
C语言：数字金字塔
lalala_dxf的博客
07-13 8412
题目： 输出n行数字金字塔。 要求 1、使用下面的函数 void pyramid(int n); //说明：n是用户传入的参数。 2、每个数字后面跟一个空格 3、最后一行的第一个数字前无空格 输入输出样例 ----------------------------------------------------------------分割线----------------------------------------------------------------------------- 解题： 解
洛谷 1216——USACO 1.5 数字金字塔（递推与递归二分）
weixin_30587927的博客
01-27 206
题目描述 观察下面的数字金字塔。 写一个程序来查找从最高点到底部任意处结束的路径，使路径经过数字的和最大。每一步可以走到左下方的点也可以到达右下方的点。 7 3 8 8 1 0 2 7 4 4 4 5 2 6 5 在上面的样例中,从7 到 3 到 8 到 7 到 5 的路径产生了最大 输入输出格式 输入格式： 第一个行包含 R(1<= R<=1000...
实现函数输出n行数字金字塔（C/Python/C++）
naturly的博客
07-27 5448
编程语言练习
数字金字塔c++代码
10-28
引用和引用[2]都提供了数字金字塔的C++代码示例，它们的实现方式略有不同。引用使用了二维数组来存储数字金字塔，通过两层循环来计算每个数字的最大路径和。而引用则使用了vector嵌套vector的方式来存储数字金字塔，同样通过两层循环来计算最大路径和。以下是两个示例代码： 引用[1]示例代码： ```cpp #include <iostream> using namespace std; int main() { int numRows; cout << "请输入数字金字塔的行数："; cin >> numRows; int pyramid[numRows][numRows]; cout << "请输入数字金字塔的每个数字（按行输入）：" << endl; for (int i = 0; i < numRows; i++) { for (int j = 0; j <= i; j++) { cin >> pyramid[i][j]; } } for (int i = numRows - 2; i >= 0; i--) { for (int j = 0; j <= i; j++) { pyramid[i][j] += max(pyramid[i+1][j], pyramid[i+1][j+1]); } } cout << "数字金字塔的最大路径和为：" << pyramid[0][0] << endl; return 0; } ``` 引用示例代码： ```cpp #include <iostream> #include <vector> using namespace std; int main() { int t; cin >> t; for (int i = 0; i < t; i++) { int r; cin >> r; vector<vector<int>> matrix(r); for (int j = 0; j < r; j++) { for (int k = 0; k < j + 1; k++) { int temp; cin >> temp; matrix[j].push_back(temp); } } for (int j = r - 1; j > 0; j--) { for (int k = 0; k < j; k++) { matrix[j][k] > matrix[j][k + 1] ? matrix[j - 1][k] += matrix[j][k] : matrix[j - 1][k] += matrix[j][k + 1]; } } cout << matrix[0][0] << endl; } return 0; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值