The Triangle

最新推荐文章于 2020-07-18 13:59:15 发布

原创最新推荐文章于 2020-07-18 13:59:15 发布 · 349 阅读

0 ·

CC 4.0 BY-SA版权

C++ 同时被 2 个专栏收录

76 篇文章

订阅专栏

算法总结

49 篇文章

订阅专栏

本文介绍了一种通过动态规划求解三角形路径中最大数值和的问题。利用递归方法会因重复计算导致效率低下，而动态规划则能有效避免重复计算，显著提高计算速度。文章提供了两种不同的C++实现方案，帮助读者理解算法细节。

Description

7
3 8
8 1 0
2 7 4 4
4 5 2 6 5

(Figure 1)
Figure 1 shows a number triangle. Write a program that calculates the highest sum of numbers passed on a route that starts at the top and ends somewhere on the base. Each step can go either diagonally down to the left or diagonally down to the right.
Input

Your program is to read from standard input. The first line contains one integer N: the number of rows in the triangle. The following N lines describe the data of the triangle. The number of rows in the triangle is > 1 but <= 100. The numbers in the triangle, all integers, are between 0 and 99.
Output

Your program is to write to standard output. The highest sum is written as an integer.
Sample Input

5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
Sample Output

算法思路：
如果把本题看成一个递归的题目其实可以解出答案来，但是解出答案时间太长，几乎说是不科学的，原因就是有大量的没必要计算。2^100是有多少次计算。
所以，我们将换一种思维：动态规划，来解决这个问题，把每次计算出来的结果进行记录下来，这样就解决了不用重复计算的时间，从而我们将我们的无效的计算全部省去。

#include <iostream>
#include <algorithm>

using namespace std;

#define MAX 101
int D[MAX][MAX];
int n;
int maxSum[MAX][MAX];
int MaxSum(int i,int j)
{
    if( maxSum[i][j] != -1)
        return maxSum[i][j];
    if(i == n)
        maxSum[i][j] = D[i][j];
    else{
        int x = MaxSum(i + 1,j);
        int y = MaxSum(i + 1,j + 1);
        maxSum[i][j] = max(x,y) + D[i][j];
    }
    return maxSum[i][j];
}
int main()
{
    int i , j;
    cin >> n;
    for(i = 1; i <= n; i++)
    {
        for(j = 1; j <= i; j++)
        {
            cin >> D[i][j];
            maxSum[i][j] = -1;
        }
    }
    cout << MaxSum(1,1) <<endl;
}

值得学习的代码

//Memory Time 
//232K    0MS 

#include<iostream>
using namespace std;

int max(int a,int b)
{
    return a>b?a:b;
}

int main(int i,int j)
{
    int n;
    while(cin>>n)
    {
        int **way=new int*[n+1];   //动态申请二维数组的第一维，每个元素都是一个一维数组的指针

        /*Input & Initial*/

        for(i=0;i<=n;i++)
        {
            way[i]=new int[i+2]; //动态申请二维数组的第二维，每一行的空间
            for(j=0;j<=i+1;j++)
                way[i][j]=0;   //不能用memset初始化

            if(i!=0)
                for(j=1;j<=i;j++)
                    cin>>way[i][j];
        }

        /*Dp*/

        int max_weight=0;
        for(i=1;i<=n;i++)
            for(j=1;j<=i;j++)
            {
                way[i][j] += max(way[i-1][j-1],way[i-1][j]);

                if(i==n && max_weight<way[i][j])
                    max_weight=way[i][j];
            }

        cout<<max_weight<<endl;

        delete[] way;
    }
    return 0;
}