【USACO】numtri

给一颗数字树，让找一条数字和最大的路径。一下子就想起刚学不久的回溯法了。照着写了个代码，调了调搞通了。在小数据的情况下是对的，但是在test 6 树有199层的时候溢出了。

#include <stdio.h>
int BackTrack(int n, int (*num)[], int * summax) //回溯法
{
    *summax = ;
    int sum = ;
    int k = ;
    int S[] = {};
    int sign[] = {};
    int sumn[] = {};  //保存算到第k行的和
    S[k] = ;
    sign[k] = ;
    do{
        while(S[k] != )
        {
            if(S[k] ==  && k != )
            {
                sign[k]++; //选择右边的数
            }
            if(k == )
            {
                sumn[k] = num[k][sign[k]];
            }
            else
            {
                sumn[k] = sumn[k - ] + num[k][sign[k]];
            }
            S[k]--;
            if(k < n - )
            {
                k++;
                S[k] = ; //新到一行时 共有两个选择
                sign[k] = sign[k - ] +  - S[k];  //选择左边的数
            }
            else
            {
                if(sumn[k] > *summax)
                {
                    *summax = sumn[k];
                }

            }
        }
        k--;
    }while(k > );
    return ;
}

int main()
{
    FILE *in, *out;
    in = fopen("numtri.in", "r");
    out = fopen("numtri.out", "w");

    int N;
    int num[][];
    int summax;
    int i, j;
    fscanf(in, "%d", &N);
    for(i = ; i < N; i++)
    {
        for(j = ; j <= i; j++)
        {
            fscanf(in, "%d", &num[i][j]);
        }
    }

    BackTrack(N, num, &summax);
    fprintf(out, "%d\n", summax);

    return ;
}

-------------------------------------------------------------

针对回溯法溢出，很容易想到的是计算有冗余。举例来说： 在计算5的分支时，其实下面7的情况已经在之前都算过了的，只要知道7 和 8哪个数对应的下面的和最大就好了。

3

4 5

6 7 8

9 10 11 12

于是可以换成从下到上的解法，从最底下开始计算在每一层对应位置上和最大的数，最下面一层就是数本身，再往上每次都是 数本身 + max(下一行左边最大求和数， 下一行右边最大求和数)， 在最高层时输出最大值。写完代码后很奇怪，自己的电脑上跑总是溢出，但在测评系统上却AC了。

#include <stdio.h>

int max(int a, int b)
{
    return a > b ? a : b;
}

int tmp[] = {}; //每层用同一个tmp存储最大值就好了，因为在计算出高层的最大值后，低层的最大值就没有用了。
int downtotop(int c, int N, int (*num)[])
{
    int i;
    if(c == N)
    {
        if(c != )
        {
            for(i = ; i < c; i++)
            {
                tmp[i] = num[c - ][i];
            }
            downtotop(c-, N, num);
        }
        else //针对只有一个数的情况
        {
            return num[][];
        }
    }
    else
    {
        for(i = ; i < c; i++)
        {
            tmp[i] = num[c - ][i] + max(tmp[i], tmp[i + ]);
        }
        if(c == )
        {
            return tmp[];
        }
        else
        {
            downtotop(c-, N, num);
        }
    }
}

int main()
{
    FILE *in, *out;
    in = fopen("numtri.in", "r");
    out = fopen("numtri.out", "w");

    int N;
    int num[][];
    int summax;
    int i, j;
    fscanf(in, "%d", &N);
    for(i = ; i < N; i++)
    {
        for(j = ; j <= i; j++)
        {
            fscanf(in, "%d", &num[i][j]);
        }
    }

    summax = downtotop(N, N, num);
    fprintf(out, "%d\n", summax);

    return ;
}

-------------------------------------------

经过好友点拨，发现是int num[1000][1000]太大了，超过了栈内存，必须动态分配。改好后自己在电脑上也跑通了。在测评系统上消耗的内存也小了。

    int i;
    int N;
    fscanf(in, "%d", &N);

    int **num = (int **)malloc( * sizeof(int *));
    for(i = ; i < N; i++)
    {
        num[i] = (int *)malloc( * sizeof(int));
    }

--------------------------------------

看了答案还是想复杂了 不需要递归的 直接for循环就好

　for (i = ; i < rows; i++)
    res[i] = tri[rows-][i];

  for (i = rows-; i > ; i--)
    for (j = ; j <= i; j++)
      res[j] = tri[i-][j] + max(res[j],res[j+]);

-----------------------------------

答案还有一种从上到下的思路，不用先把数字存下来，可以取一个计算一步。如同从上到下，每次有两个选择，从下到上每次也是两个选择（边上的只有一个选择），从上往下加时可以只选择两个上方已有数字钟最大的，最后可以得到最下方N个最大值，选出其中最大的一个即可。

    for(i=; i<=r; i++) {
        memmove(oldbest, best, sizeof oldbest);
        for(j=; j<i; j++) {
            fscanf(fin, "%d", &n);
            if(j == )
                best[j] = oldbest[j] + n;
            else
                best[j] = max(oldbest[j], oldbest[j-]) + n;
        }
    }