Question

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

即3 + 7 + 4 + 9 = 23。

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

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

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

我的代码有点混乱

a="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"
b=a.split(", ")
d=[]
ans=0
for x in range(len(b)):
    b[x]= b[x].split(" ")
    c= [int(i) for i in b[x]]
    d.append(c)
index= d[0].index(max(d[0]))
print index
for y in range(len(d)):
    ans+= d[y][index]
    if y+1==len(d):
        break
    else:
        index= d[y+1].index(max(d[y+1][index], d[y+1][index+1]))
print ans

所以我得到了1063作为答案，而实际的答案是1074.我猜我的方法是正确的但是有一些我仍然无法弄清楚的错误。

Answer 1

您的方法不正确。你不能只做一个贪婪的算法。考虑一下这个例子：

In function double* uptri(double (*)[17],int):cannot convert 'double (*)[17]' to 'double*' in assignment

显然：

#include<stdio.h>
#include<math.h>

main()
{
    double prob[16][17], GE[16][17],soln[16];
    double *q,*r;
    q=&GE[0][0];
    r=&soln[0];

    double* uptri(double[16][17], int);
    double* solve(double[16][17], int);
    int n,i,j;

    n=2;

    prob[0][0]=2;
    prob[0][1]=3;
    prob[0][2]=1;
    prob[1][0]=1;
    prob[1][1]=4;
    prob[1][2]=2;

    q=uptri(prob,n);

    for(i=0;i<n;i++)
        for(j=0;j<=n;j++)
            printf("%lf\n",GE[i][j]);

    r=solve(GE,n);

    printf("Soln\n");

    for(i=0;i<n;i++)
        printf("%lf\n",soln[i]);

}

double* uptri(double A[16][17],int n)
{
    int i,j,k;
    double *p,temp;
    p=&A[16][17];

    for(i=0;i<n;i++)
        for(k=i+1;k<n;k++)
        {
            temp=A[k][i]/A[i][i];
            for(j=i;j<=n;j++)
                A[k][j]=A[k][j]-temp*A[i][j];
        }

        for(i=0;i<n;i++)
            for(j=0;j<=n;j++)
                printf("%lf\n",A[i][j]);

        return p;   
}

double* solve(double A[16][17], int n)
{
    int i,j,k;
    double soln[16],*p,sum;
    p=&soln[0];
    soln[n-1]=A[n-1][n]/A[n-1][n-1];

    for(i=n-2;i>=0;i--)
    {
        sum=0;
        for(j=n-1;j>i;j--)
            sum=sum+A[i][j]*soln[j];
            soln[i]=(A[i][n]-sum)/A[i][i];
    }

    return p;
}

然而你遵循这个算法。

但是，如果三角形只是：

贪婪的方法有效，换句话说，我们需要将问题简化为一种“3号”三角形。因此，假设您遵循的路径到达3 + 7 + 4 + 9 = 23 < 500 + (other terms here)，应该做出什么选择？转到3 7 4。（如果apath进入6会怎样？？500怎么办？）

我们如何使用这些结果制作一个较小的三角形？

Answer 2

看起来您总是在下一行中选择较大的数字（左和右）（这称为greedy algorithm。）但是可能先选择较小的数字，您可以在后续选择较大的数字线。（事实上，通过这样做，可以实现1074。）

评论中的提示很有用：

回溯方法会给出正确的结果。
动态编程方法可以提供正确的结果，并且比回溯更快，因此它也适用于问题67.

Answer 3

您只能从顶行的相邻（最多）三个单元格到达每个单元格，其中最有利的单元格最多，您不需要跟踪其他。

我举了一个代码的例子。这适用于问题中左边对齐的金字塔（原始问题是中心金字塔，但至少我不能完全破坏问题）。我案件的最大总数是1116：

d="""
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
"""

ll=[line.split() for line in d.split('\n')][1:-1]
topline=ll[0]
for line in ll[1:]:
    newline=[]
    for i,cell in enumerate(line):
        newline.append(int(cell)+max(map(int,topline[max([0,i-1]):min([len(line),i+2])])))
    topline=newline
    print newline
print "final results is %i"%max(newline)

Answer 4

对您的代码做一点评论。这个三角形的最大总和确实是1074.你的数字是正确的，只需从

更改你的循环代码

    for i,cell in enumerate(line):
    newline.append(int(cell)+max(map(int,topline[max([0,i-1]):min([len(line),i+2])])))

到

    for i,cell in enumerate(line):
    newline.append(int(cell)+max(map(int,topline[max([0,i-1]):min([len(line),i+1])])))

（＆＃34; 1＆＃34;而不是＆＃34; 2＆＃34;）

请

Answer 5

我日夜思考这个问题。这是我的解决方案：

# Maximum path sum I
import time
def e18():
    start = time.time()
    f=open("num_triangle.txt")
    summ=[75]
    for s in f:
        slst=s.split()
        lst=[int(item) for item in slst]
        for i in range(len(lst)):
            if i==0:
                lst[i]+=summ[i]
            elif i==len(lst)-1:
                lst[i]+=summ[i-1]
            elif (lst[i]+summ[i-1])>(lst[i]+summ[i]):
                lst[i]+=summ[i-1]
            else:
                lst[i]+=summ[i]
        summ=lst
    end = time.time() - start
    print("Runtime =", end)
    f.close()
    return max(summ)
print(e18()) #1074

附言num_triangle.txt 没有第一个字符串 '75'

项目Euler＃18在Python-初学者

5 个答案: