HDU 2084数塔

 

这道题目的核心点是：自顶向下分析，自底向上计算。

从顶点出发时到底向左走还是向右走应取决于是从左走能取到最大值还是从右走能取到最大值， 
只要左右两道路径上的最大值求出来了才能作出决策。 
同样的道理下一层的走向又要取决于再下一层上的最大值是否已经求出才能决策。 
这样一层一层推下去，直到倒数第二层时就非常明了。 
如数字2，只要选择它下面较大值的结点19前进就可以了。 
所以实际求解时，可从底层开始，层层递进，最后得到最大值。 

从最底层开始与倒数第二层开始相加，比如最底层的第N个只能与倒数第二层的第N-1个和第N个相加。
这时问题出来了，倒数第二层有些数字最多被加了两次，所以就必须选择其中最大的一个选项，来达到问题的最优解。
这是写代码过程中的一个关键点。刚开始我的思路卡在了————每层的第一个与最后一个，只能与一个数字相加
。其实这里的想法是多余的，下面的优化过程中会提到。

下面展示我的第一个代码：

#include <stdio.h>
#include <string.h>
int main(void)
{
    int C, N;
    int a[101][101];
    int b[101];
    int flag[101];

    scanf("%d", &C);
    while(C--)
    {
        scanf("%d", &N);
        memset(a, 0, sizeof(a));
        memset(b, 0, sizeof(b));
        
        for(int i = 1; i <= N; i++)
        {
            for(int j = 1; j <= i; j++)
            scanf("%d", &a[i][j]);
        }
        for(int i = 1; i <= N ; i++)
        b[i] = a[N][i];
        for(int i = N; i > 1; i--)
        {
            memset(flag, 0, sizeof(flag));
            for(int j = 1; j <= i; j++)
            {
                if(j == 1)
                {
                    b[1] = b[1]+ a[i-1][1];
                    flag[1]++;
                }
                else if(j > 1 && j < i)
                {
                    if(a[i-1][j] > a[i-1][j-1])
                    {
                        b[j] = b[j] + a[i-1][j];
                        flag[j]++;
                    }
                    else
                    {
                        b[j] = b[j] + a[i-1][j-1];    
                        flag[j-1]++;
                    }
                    
                }
                else
                {
                    b[j] = b[j] + a[i-1][j-1];
                    flag[j-1]++;
                }
            }
            for(int k = 1; k <= i; k++)
            {
                if(flag[k] == 2)
                {
                    if(b[k] < b[k+1])
                    b[k] = b[k+1];
                    for(k = k + 1; k < i; k++)
                    b[k] = b[k + 1];
                    break;
                }
            }
        }
        if(b[1] > b[2])
        printf("%d", b[1]);
        else
        printf("%d", b[2]);
        if(C != 0)
        printf("\n");
    }
    return 0;
}

结果WA了，还请大家指点下哪里错误了。谢谢
下面写优化的过程。和上面一样，从键盘录入数组，用了一个二维数组，每个数组从a[i][1]开始录入，所以上面提到的比如最底层的第N个只能与倒数第二层的第N-1个和第N个相加。这个想法是可以优化的，比如a[i][1],可以与a[i-1][0]和a[i-1][1]相加。还有这里可以使用max函数。另外一个优化的关键点就是使用了max函数每次相加直接选出最大值。上面的代码过程可以说是当进行相加步骤时是出现当第N行的两个数字都选择与第N-1中某个数字相加的时候，还要删除其中的较小数，还使用了数组前移等步骤，比较麻烦。而优化过的步骤，是采用了从第N-1行，与第N行相加。直接采用第N行中可以相加的最大值，不存在上述过程中的麻烦了。
下面是AC的代码：

#include <stdio.h>
#include <string.h>
#define max(a,b) a>b?a:b
int main(void)
{
	int C, N;
	int a[101][101];
	int b[101];


	scanf("%d", &C);
	while(C--)
	{
		scanf("%d", &N);
		memset(a, 0, sizeof(a));
		memset(b, 0, sizeof(b));
		
		for(int i = 1; i <= N; i++)
		{
			for(int j = 1; j <= i; j++)
			scanf("%d", &a[i][j]);
		}
		for(int i = 1; i <= N ; i++)
		b[i] = a[N][i];
		for(int i = N - 1; i >=1; i--)
		{
			for(int j = 1; j <= i; j++)
			{
				b[j] = max(b[j]+a[i][j], b[j+1]+a[i][j]);
			}
		}
		printf("%d\n", b[1]);
		
	}
	return 0;
}