URAL 1920 Titan Ruins: the Infinite Power of Magic

            搜索。首先很显然，当L是奇数的时候是不可求的，当n是奇数的时候，L最大为n*n-1，这样的话不满足的情况就很容易得出了。对于满足的情况，我们只要，按图中所示的方法搜，因为最终只需要一遍左右的遍历就可以得出结果，所以时间复杂度大概是O（L）的，关键是注意搜的方向。

           1，   当n是偶数时，可以直接这样画图，然后对于p点，看其到（1,1）点的距离，当距离够L的时候，就可以停止dfs，然后把p点和（1，1）点连起来了。                                                                                                                                                

               2，但是对于n是奇数时，当L大于n*（n- 1）+ 2 的时候，上述方法就不可以了，这样的话我们需要这样画图，以n=5，L=24为例:

                                                                                  这样的话到达（3,2）点的时候我们需要换一下方向数组的先后顺序，达到画成上述图形的效果。

             然后方向数组的定义就需要我们按上述两种方法定义，使得最后能用近似O（L）的方法解决问题。

#include<functional>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<cmath>
#include<map>
#include<set>
#define REP(i, n) for(int i=0; i<n; i++)
#define PB push_back
#define CLR(a, b) memset(a, b, sizeof(a))
using namespace std;
const int N = 110;

bool vis[N][N];
int dx[5] = {1, 0, 0, -1};
int dy[5] = {0, 1, -1, 0};
int p[N * N * 10];
int n, l, mod = 1000, gx, gy;

void dlt(int x, int y)
{
    for(int i = x; i > 1; i --)
    {
        p[i * mod + y] = (i - 1) * mod + y;
    }
    for(int i = y; i > 1; i --)
    {
        p[mod + i] = mod + i - 1;
    }
}

bool inside(int x, int y)
{
    return x >= 2 && x <= n && y >= 2 && y <= n;
}

bool flag;

bool dfs(int x, int y, int st)
{
    if(x + y - 3 + st == l)
    {
        gx = x, gy = y;
        return true;
    }
    if(x == 3 && y == 2)
    {
        if(st + 2 * (n - 1) < l)
        {
            dx[0] = -1;dx[1] = 1; dx[2] = dx[3] = 0;
            dy[0] = 0;dy[1] = 0; dy[2] = 1; dy[3] = -1;
        }
    }
    for(int i = 0; i < 4; i ++)
    {
        int xx = x + dx[i], yy = y + dy[i];
        p[x * mod + y] = xx * mod + yy;
        if(!inside(xx, yy) || vis[xx][yy]) continue;
        vis[xx][yy] = true;
        if(dfs(xx, yy, st + 1)) return true;
        vis[xx][yy] = false;
    }
    return false;
}

int main()
{
    scanf("%d%d", &n, &l);
    if(l & 1 || ((n & 1) && (l > n * n - 1) || l > n * n))
    {
        puts("Unsuitable device");
        return 0;
    }
    CLR(vis, false);
    vis[1][1] = true;
    puts("Overwhelming power of magic");
    puts("1 1");
    if(n * 2 >= l)
    {
        int t = 0;
        for(int i = 1; i <= n; i ++)
        {
            if(i * 2 == l)
            {
                p[i * mod + 1] = i * mod + 2;
                t = i;
                break;
            }
            p[i * mod + 1] = (i + 1) * mod + 1;
        }
        dlt(t, 2);
    }
    else
    {
        for(int i = 1; i < n; i ++)
        {
            p[i * mod + 1] = (i + 1) * mod + 1;
        }
        p[n * mod + 1] = n * mod + 2;
        vis[n][2] = true;flag = false;
        if(!dfs(n, 2, n + 1))
        {
            puts("Unsuitable device");
            return 0;
        }
        dlt(gx, gy);
    }
    for(int i = p[1*mod + 1]; i != 1*mod + 1; i = p[i])
    {
        printf("%d %d\n", i / mod, i % mod);
    }
}