POJ1163 The Triangle&&POJ3176 Cow Bowling

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

30

Description

The cows don’t use actual bowling balls when they go bowling. They each take a number (in the range 0..99), though, and line up in a standard bowling-pin-like triangle like this:

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

Then the other cows traverse the triangle starting from its tip and moving “down” to one of the two diagonally adjacent cows until the “bottom” row is reached. The cow’s score is the sum of the numbers of the cows visited along the way. The cow with the highest score wins that frame.

Given a triangle with N (1 <= N <= 350) rows, determine the highest possible sum achievable.

Input

Line 1: A single integer, N

Lines 2..N+1: Line i+1 contains i space-separated integers that represent row i of the triangle.

Output

Line 1: The largest sum achievable using the traversal rules

Sample Input

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

Sample Output

30

题解：从第一层到最后一层总权值最大是多少，可以看成打保龄球求倒下的过程。

CODE:

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
int main()
{
    int sum[400][400],a[400][400];
    int n,i,j;
    scanf("%d",&n);
    memset(sum,0,sizeof(sum));
    for( i=0;i<n;i++)
        for( j=0;j<=i;j++)
            scanf("%d",&a[i][j]);
    for(i=0;i<n;i++)
    {
        for( j=0;j<=i;j++)
        {
            int y1=j-1;
            int y2=j;
            if(j==0)//简单画图可知道，如果是最左边的球则只能被上一行最左边的球撞倒
            {
                y1=0;
                y2=0;
            }

            if(j==i)//同上最右边的球也只能被上一行最右边的球撞倒
            {
                y2=i-1;
                y1=i-1;
            }
            //当前碰完后有两种情况，一是被左上碰倒，二是被右上碰倒
            int t1=sum[i-1][y1]+a[i][j];
            int t2=sum[i-1][y2]+a[i][j];
            sum[i][j]=max(t1,t2);
        }
    }
    sort(sum[n-1],sum[n-1]+n);
    printf("%d\n",sum[n-1][n-1] );
}

看了题解后发现了更好的更正宗的动态规划用法

如果从后往前遍历就无需担心边界问题，就可以一个状态转移方程就可以求出。
循环是从倒数第二行开始的，比如倒数第二行第一个元素，求的是它碰倒下一行它可以碰倒的两个球之一（倒数第一行第一个或第二个）后的最大值，此时dp数组中存的是，倒数第二行碰倒倒数第一行的某个球后的最大值，这样往上遍历，我们便可以得到解。

CODE：

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
typedef long long LL;
const int MAX =  1100;
int a[400][400];
int n;
int main()
{
    while(~scanf("%d",&n))
    {
        for(int i=1;i<=n;i++)
            for(int j=1;j<=i;j++)
                scanf("%d",&a[i][j]);
        for(int i=n-1;i>=1;i--)
            for(int j=1;j<=i;j++)
                a[i][j]+=max(a[i+1][j],a[i+1][j+1]);
        printf("%d\n",a[1][1]);
    }

    return 0;
}