UVa:10564 Paths through the Hourglass

dp[i][j][k]는 i층에 도달한 j개의 칸 값이 k일 때의 경로 개수를 나타낸다.
이미 알고 있는 dp[i][j][k]는 새로운 층의 dp를 내보낼 수 있는데, 가장 왼쪽에 있는 경로를 출력해야 하기 때문에 아래에서 위로 밀어내는 것이 좋다.
상층의 dp[][][]는 다음 층에서 이미 구한 두 개의 인접한 dp[][][]로 구할 수 있다.
 
이렇게 경로 그룹 path[i][j][k]는 i층의 j번째 칸 값이 k인 것을 나타낸다. 왼쪽 아래 또는 오른쪽 아래 방향에서 온다.
또한 왼쪽 아래나 오른쪽 아래에서 (i, j) 값이 k일 때 path [i] [j] [k] 는 왼쪽 아래 방향을 저장합니다.
일부 세부 사항에 주의하면 역삼각형과 정삼각형의 이동 방식(즉 점차적인 방식)은 다르다.
dp[i][j][k+a[i][j]]=dp[i+1][j][k]+dp[i+1][j+1][k];(정삼각형)
dp[i][j][k+a[i][j]]=dp[i+1][j-1][k]+dp[i+1][j][k];(역삼각형)
마지막으로 출력 경로도 다르다.
 
어젯밤에 밤새 생각했는데 오늘 아침에 한 시간 더 썼어요. 결과적으로 WA는 디스커스를 보고 론롱을 써야 한다는 걸 알게 됐어요. 고친 후에 AC를 썼어요.
 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#define MAXS 500
using namespace std;
int a[45][25];
long long dp[45][25][505];
int path[45][25][505];
int main()
{
   int N,S;
    while(scanf("%d%d",&N,&S)&&!(!N&&!S))
    {
        memset(a,-1,sizeof(a));
        memset(dp,0,sizeof(dp));
        memset(path,0,sizeof(path));
        for(int i=1; i<=N; ++i)
            for(int j=1; j<=N+1-i; ++j)
                scanf("%d",&a[i][j]);
        for(int i=2; i<=N; ++i)
            for(int j=1; j<=i; ++j)
                scanf("%d",&a[i+N-1][j]);
        for(int i=1; i<=N; ++i)
            dp[2*N-1][i][a[2*N-1][i]]=1;
        for(int i=2*N-2; i>=N; --i)
            for(int j=1; j<=i-N+1; ++j)
                for(int k=0; k<=MAXS; ++k)
                {
                    if(a[i+1][j+1]!=-1&&dp[i+1][j+1][k])
                    {
                        dp[i][j][k+a[i][j]]+=dp[i+1][j+1][k];
                        path[i][j][k+a[i][j]]=1;
                    }
                    if(a[i+1][j]!=-1&&dp[i+1][j][k])
                    {
                        dp[i][j][k+a[i][j]]+=dp[i+1][j][k];
                        path[i][j][k+a[i][j]]=-1;
                    }
                }
        for(int i=N-1; i>=1; --i)
            for(int j=1; j<=N-i+1; ++j)
                for(int k=0; k<=MAXS; ++k)
                {
                    if(a[i+1][j]!=-1&&dp[i+1][j][k])
                    {
                        dp[i][j][k+a[i][j]]+=dp[i+1][j][k];
                        path[i][j][k+a[i][j]]=1;
                    }
                    if(a[i+1][j-1]!=-1&&dp[i+1][j-1][k])
                    {
                        dp[i][j][k+a[i][j]]+=dp[i+1][j-1][k];
                        path[i][j][k+a[i][j]]=-1;
                    }
                }
        long long ans=0;
        for(int i=1; i<=N; ++i)
            ans+=dp[1][i][S];
        printf("%lld
",ans);
        if(!ans)printf("
");
        else
        {
            int pos,res=S;
            for(int i=1; i<=N; ++i)
                if(dp[1][i][S])
                {
                    printf("%d ",i-1);
                    pos=i;
                    break;
                }
            for(int i=1; i<2*N-1; ++i)
            {
                if(path[i][pos][res]==1) putchar('R');
                else  if(path[i][pos][res]==-1) putchar('L');
                int temp=res;
                res-=a[i][pos];
                if(i<N)
                {
                    if(path[i][pos][temp]==-1)  pos-=1;
                    else if(path[i][pos][temp]==1)  pos+=0;
                }
                else
                {
                    if(path[i][pos][temp]==-1)   pos-=0;
                    else if(path[i][pos][temp]==1) pos+=1;
                }
            }
            printf("
");
        }
    }
    return 0;
}