poj 2111 Millenium Leapcow(记忆化搜索）

Description

The cows have revised their game of leapcow. They now play in the middle of a huge pasture upon which they have marked a grid that bears a remarkable resemblance to a chessboard of N rows and N columns (3 <= N <= 365). 

Here's how they set up the board for the new leapcow game: 

* First, the cows obtain N x N squares of paper. They write the integers from 1 through N x N, one number on each piece of paper. 

* Second, the 'number cow' places the papers on the N x N squares in an order of her choosing. 

Each of the remaining cows then tries to maximize her score in the game. 

* First, she chooses a starting square and notes its number. 

* Then, she makes a 'knight' move (like the knight on a chess board) to a square with a higher number. If she's particularly strong, she leaps to the that square; otherwise she walks. 

* She continues to make 'knight' moves to higher numbered squares until no more moves are possible. 

Each square visited by the 'knight' earns the competitor a single point. The cow with the most points wins the game. 

Help the cows figure out the best possible way to play the game.

Input

* Line 1: A single integer: the size of the board 

* Lines 2.. ...: These lines contain space-separated integers that tell the contents of the chessboard. The first set of lines (starting at the second line of the input file) represents the first row on the chessboard; the next set of lines represents the next row, and so on. To keep the input lines of reasonable length, when N > 15, a row is broken into successive lines of 15 numbers and a potentially shorter line to finish up a row. Each new row begins on its own line. 

Output

* Line 1: A single integer that is the winning cow's score; call it W. 

* Lines 2..W+1: Output, one per line, the integers that are the starting square, the next square the winning cow visits, and so on through the last square. If a winning cow can choose more than one path, show the path that would be the 'smallest' if the paths were sorted by comparing their respective 'square numbers'. 

Sample Input

4
1 3 2 16
4 10 6 7
8 11 5 12
9 13 14 15

Sample Output

7
2
4
5
9
10
12
13

题意：给你一个矩阵，问你按照象棋马的走法，下一步比上一步的数大，问长度最长的序列是多长，然后输出序列。如果有多个最长序列输出字典序最小的那个。
这是看到的一个代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <vector>
#include <algorithm>
#include <map>
using namespace std;
typedef pair<int,int>P;
const double eps=1e-9;
const int maxn=200100;
const int mod=1e9+7;
const int INF=1e9;
int M[370][370],dp[370][370];
int N;
int dx[8]= {1,1,2,2,-1,-1,-2,-2};
int dy[8]= {2,-2,1,-1,2,-2,1,-1};
P path[370][370];
vector<P>res;
int DP(int x,int y)
{
    int &m=dp[x][y];
    if(m) return m;
    m=1;
    for(int i=0; i<8; i++)
    {
        int nx=x+dx[i];
        int ny=y+dy[i];
        if(1<=nx&&nx<=N&&1<=ny&&ny<=N&&M[nx][ny]>M[x][y])
        {
            if(m<DP(nx,ny)+1)
            {
                m=DP(nx,ny)+1;
                path[x][y]=make_pair(nx,ny);
            }
            else if(DP(nx,ny)+1==m)
            {
                if(M[path[x][y].first][path[x][y].second]>M[nx][ny])
                {
                    path[x][y]=make_pair(nx,ny);
                }
            }
        }
    }
    return m;
}
int main()
{
    while(~scanf("%d",&N))
    {
        for(int i=1; i<=N; i++)
        {
            for(int j=1; j<=N; j++)
            {
                scanf("%d",&M[i][j]);
            }
        }
        int MAX=1,cnt;
        for(int i=1; i<=N; i++)
        {
            for(int j=1; j<=N; j++)
            {
                cnt=DP(i,j);
                if(MAX<cnt)
                {
                    MAX=cnt;
                    res.clear();
                    res.push_back(make_pair(i,j));
                }
                else if(MAX==cnt)
                {
                    res.push_back(make_pair(i,j));
                }
            }
        }
        int keyx,keyy,key;
        key=INF;
        for(int i=0; i<res.size(); i++)
            if(M[res[i].first][res[i].second]<key)
            {
                key=M[res[i].first][res[i].second];
                keyx=res[i].first;
                keyy=res[i].second;
            }
        printf("%d\n",MAX);
        while(1)
        {
            printf("%d\n",M[keyx][keyy]);
            int t=path[keyx][keyy].second;
            keyx=path[keyx][keyy].first;
            keyy=t;
            if(!keyx)
                break;
        }
    }
    return 0;
}

知识点：

这个代码的主要想法是，如同最短路一样，path中储存的是当前节点的下一步应该走的位置，然后进行搜索直到遍历了所有的点。