Question

嘿，一直在Project Euler工作，这个问题给了我一些问题

从下方三角形的顶部开始，移动到下面一行的相邻数字，从上到下的最大总数为23。

3

7 4

2 4 6

8 5 9 3

即3 + 7 + 4 + 9 = 23。

查找下方三角形从上到下的最大总数：

...

注意：由于只有16384条路线，因此可以通过尝试每条路线来解决此问题。然而，问题67，对于包含一百行的三角形来说是同样的挑战;它无法通过蛮力解决，需要一种聪明的方法！ ; O）

这是我用来解决它的算法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Problem18
{
    class Program
    {
        static void Main(string[] args)
        {
            string triangle = @"75
95 64
17 47 82
18 35 87 10
20 04 82 47 65
19 01 23 75 03 34
88 02 77 73 07 63 67
99 65 04 28 06 16 70 92
41 41 26 56 83 40 80 70 33
41 48 72 33 47 32 37 16 94 29
53 71 44 65 25 43 91 52 97 51 14
70 11 33 28 77 73 17 78 39 68 17 57
91 71 52 38 17 14 91 43 58 50 27 29 48
63 66 04 68 89 53 67 30 73 16 69 87 40 31
04 62 98 27 23 09 70 98 73 93 38 53 60 04 23";
            string[] rows = triangle.Split('\n');
            int currindex = 1;
            int total = int.Parse(rows[0]);
            Console.WriteLine(rows[0]);
            for (int i = 1; i < rows.Length; i++)
            {
                string[] array1 = rows[i].Split(' ');
                if (array1.Length > 1)
                {
                    if (int.Parse(array1[currindex - 1]) > int.Parse(array1[currindex]))
                    {
                        Console.WriteLine(array1[currindex - 1]);
                        total += int.Parse(array1[currindex - 1]);
                    }
                    else
                    {
                        Console.WriteLine(array1[currindex]);
                        total += int.Parse(array1[currindex]);
                        currindex++;
                    }
                }
            }
            Console.WriteLine("Total: " + total);
            Console.ReadKey();
        }
    }
}

现在每当我运行它时，它会出现1064，只比解决方案少10个 - 1074

我没有发现算法存在任何问题，我手工完成了问题并提出了1064，任何人都知道解决方案是错误的，我正在解释错误的问题，或者是否存在缺陷算法？

Answer 1

以下是图形说明：

enter image description here

Answer 2

以下是belisarius描述的自下而上的方法 - 使用问题18中给出的平凡三角形 - 看起来像是，以防他的帖子中的图像混淆了其他任何人。

      03
    07  04
  02  04  06
08  05  09  03

      03
    07  04
  02  04  06
08  05  09  03
^^^^^^

      03
    07  04
  10  04  06
08  05  09  03
    ^^^^^^

      03
    07  04
  10  13  06
08  05  09  03
        ^^^^^^

      03
    07  04
  10  13  15
  ^^^^^^
08  05  09  03

      03
    20  04
  10  13  15
      ^^^^^^
08  05  09  03

      03
    20  04
  10  13  15
      ^^^^^^
08  05  09  03

      03
    20  19
    ^^^^^^
  10  13  15
08  05  09  03

      23
      ^^
    20  19
  10  13  15
08  05  09  03

Answer 3

你的问题是你的算法是一个贪婪的算法，总是找到局部最大值。不幸的是，它导致它错过了更低的数字，因为它们直接低于较低的数字。例如，如果三角形仅为3级，则算法将选择75 + 95 + 47 = 217，而正确答案为75 + 64 + 82 = 221。

正确的算法将尝试每个路径并选择总数最高的路径，或从下往上计算路径（这样可以避免尝试每个路径，因此速度更快）。我应该补充说，自下而上工作不仅更快（O（n ^ 2）而不是O（2 ^ n）！），而且更容易编写（我在约3行代码中完成）

Answer 4

你写过greedy algorithm，我觉得这不符合要求。这是一个快速举例说明这一点：

  1
 2 1
1 1 100

使用您的算法，您将达到4的总和，尽管最佳解是102。

Answer 5

这是一个基于动态编程的好问题。您需要创建2d数据结构（如c ++中的矢量），然后按照从下到上的方法处理dp。

公式为 dp [i] [j] + = max（dp [i + 1] [j]，dp [i + 1] [j + 1]） < / em>。尝试自行编码，如果遇到困难，请参阅我的解决方案。

vector< vector<int> > dp(n); // n is the number of rows for (int i = 0 ; i < n; i++){ for (int j = 0; j <= i; j++){ cin >> val; dp[i].push_back(val); } } for (int i = n - 2 ; i >= 0; i--) { for (int j = 0; j <= i; j++) dp[i][j] += max(dp[i + 1][j], dp[i + 1][j + 1]); } cout << dp[0][0] << endl; return 0; }

输入：3 2 4 5 6 8 9

输出：16

Answer 6

递归（不一定是最好的）方法：

    static int q18(){
        int matrix[][] = // BIG MATRIX;
        return getMaxPath(matrix, 0, 0, 0);
    }
    static int getMaxPath(int matrix[][], int sum, int row, int col){
        if(row==matrix.length) return sum;
        return Math.max(getMaxPath(matrix, sum+matrix[row][col], row+1, col),
                        getMaxPath(matrix, sum+matrix[row][col], row+1, col+1));
    }

项目欧拉18

6 个答案: