欧拉计划 18

Question

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

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

3

7 4

2 4 6

8 5 9 3

即 3 + 7 + 4 + 9 = 23。

找出下面三角形从上到下的最大值：

...

注意：由于只有 16384 条路线，因此可以通过尝试每条路线来解决此问题。然而，第 67 题是同样的挑战，包含 100 行的三角形；不能靠蛮力解决，需要巧妙的方法！ ;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

这是一个图形描述：

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

这是一个基于动态规划的好问题。您需要创建一个二维数据结构（如 c++ 中的向量），然后按照 dp 的自下而上的方法。

公式为dp[i][j] += max(dp[i + 1][j], dp[i + 1][j + 1])。尝试自己编写代码，如果遇到困难，请查看我的解决方案。

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));
    }