Output longest common subsequence template (Compromise)

poj-2250
n a few months the European Currency Union will become a reality. However, to join the club, the Maastricht criteria must be fulfilled, and this is not a trivial task for the countries (maybe except for Luxembourg). To enforce that Germany will fulfill the criteria, our government has so many wonderful options (raise taxes, sell stocks, revalue the gold reserves,...) that it is really hard to choose what to do.

Therefore the German government requires a program for the following task:
Two politicians each enter their proposal of what to do. The computer then outputs the longest common subsequence of words that occurs in both proposals. As you can see, this is a totally fair compromise (after all, a common sequence of words is something what both people have in mind).

Your country needs this program, so your job is to write it for us.
Input
The input will contain several test cases.
Each test case consists of two texts. Each text is given as a sequence of lower-case words, separated by whitespace, but with no punctuation. Words will be less than 30 characters long. Both texts will contain less than 100 words and will be terminated by a line containing a single '#'.
Input is terminated by end of file.
Output
For each test case, print the longest common subsequence of words occuring in the two texts. If there is more than one such sequence, any one is acceptable. Separate the words by one blank. After the last word, output a newline character.
Sample Input
die einkommen der landwirte
are for seconded seal a closed book
to remedy the situation
must urgently all subsidy law improves
#
the taxes on property and income
should look for opinion seconded
levied emphatically
to have to the powers of control of the tax authorities
to be improved urgently
#
Sample Output
must-income seconded to be improved urgently

The meaning of problems

Two words are given, separated by spaces between words, each section by #, then the output of the two longest common subsequence.
Each word is not more than 30 letters, each case not more than 100 words.
Output longest common subsequence, if the same length of the longest common subsequence, to any output. Note that there is no space behind the last word.

Code

#include <algorithm>
#include <iostream>
#include <cstdio>
#include <cstring>
#define N 103
using namespace std;

char pa[N][32], pb[N][32];
int d[N][N];
int path[N][N];
int lena = 0, lenb = 0;

void pri(int i, int j)
{
    if (i == 0 || j == 0)
        return;
    if (path[i][j] == 1)
    {
        pri(i - 1, j - 1);
        if (d[i][j] != 1)
        {
            printf(" ");
        }
        printf("%s", pa[i - 1]);
    }
    else if (path[i][j] == 2)
        pri(i - 1, j);
    else
        pri(i, j - 1);
}

int main()
{

    char tem[32];
    while (scanf("%s", tem) != EOF)
    {
        memset(d, 0, sizeof(d));
        lena=0,lenb=0;
        strcpy(pa[lena++], tem);
        while (scanf("%s", tem), tem[0] != '#')
        {
            strcpy(pa[lena++], tem);
        }
        while (scanf("%s", tem), tem[0] != '#')
        {
            strcpy(pb[lenb++], tem);
        }

        for (int i = 1; i <= lena; i++)
        {
            for (int j = 1; j <= lenb; j++)
            {
                if (strcmp(pa[i - 1], pb[j - 1]) == 0)
                {
                    d[i][j] = d[i - 1][j - 1] + 1;
                    path[i][j] = 1;
                }
                else if (d[i - 1][j] > d[i][j - 1])
                {
                    d[i][j] = d[i - 1][j];
                    path[i][j] = 2;
                }
                else
                {
                    d[i][j] = d[i][j - 1];
                    path[i][j] = 3;
                }
            }
        }
        pri(lena, lenb);
        cout << endl;
    }
}