Codeforces Round #292 (Div. 1)

B. Drazil and Tiles

 

Drazil created a following problem about putting 1 × 2 tiles into an n × m grid:

"There is a grid with some cells that are empty and some cells that are occupied. You should use 1 × 2 tiles to cover all empty cells and no two tiles should cover each other. And you should print a solution about how to do it."

But Drazil doesn't like to write special checking program for this task. His friend, Varda advised him: "how about asking contestant only to print the solution when it exists and it is unique? Otherwise contestant may print 'Not unique' ".

Drazil found that the constraints for this task may be much larger than for the original task!

Can you solve this new problem?

Note that you should print 'Not unique' either when there exists no solution or when there exists several different solutions for the original task.

Input

The first line contains two integers n and m (1 ≤ n, m ≤ 2000).

The following n lines describe the grid rows. Character '.' denotes an empty cell, and the character '*' denotes a cell that is occupied.

Output

If there is no solution or the solution is not unique, you should print the string "Not unique".

Otherwise you should print how to cover all empty cells with 1 × 2 tiles. Use characters "<>" to denote horizontal tiles and characters "^v" to denote vertical tiles. Refer to the sample test for the output format example.

Sample test(s)

Input

3 3
...
.*.
...

Output

Not unique

Input

4 4
..**
*...
*.**
....

Output

<>**
*^<>
*v**
<><>

Input

2 4
*..*
....

Output

*<>*
<><>

Input

1 1
.

Output

Not unique

Input

1 1
*

Output

*

Note

In the first case, there are indeed two solutions:

<>^
^*v
v<>

and

^<>
v*^
<>v

so the answer is "Not unique".

---

题意：用一些1*2的瓷砖覆盖m*n的网格（有障碍），问方案是否唯一，是则输出覆盖的方案。(1 ≤ n, m ≤ 2000).

这题像极了某次cf的一道题（判断网格中是否有环），不过那题数据比较小，直接暴力的拓扑排序即可。

而这题为了在o(m*n)内构造出解，需要维护一个保存所有度为1的点的队列，以及一个保存所有点的度数的数组，每次将一个点出队，同时将唯一的那个与该点相邻的点删掉，然后更改删掉的点的相邻的点的度数（常数时间），度为1的话即入队。

当发现队列空的时候，表明找不到度为1的点了，这时要不是全部覆盖完了，就是存在环或者单独的点（这种情况显然是无解或者多解），再循环判断一遍即可。

---

#include <iostream>
#include <stdio.h>
#include <queue>
using namespace std;
#define MAXN 2010

struct Point
{
    int x,y;
};
char G[MAXN][MAXN];
int degree[MAXN][MAXN]={0};
int m,n;
bool isin(int x,int y)
{
    return x>=0 && x<m && y>=0 && y<n;
}

int dx[]={1,0,-1, 0};
int dy[]={0,1, 0,-1};
int getDegree(int x,int y)
{
    if(G[x][y]=='*')
        return 0;
    int sum=0;
    for(int i=0;i<4;i++)
    {
        int newx=x+dx[i];
        int newy=y+dy[i];
        sum+=(isin(newx,newy) && G[newx][newy]!='*');
    }
    return sum;
}

int main()
{
    cin>>m>>n;
    for(int i=0;i<m;i++)
        scanf("%s",G[i]);

    queue<Point> Q;
    for(int i=0;i<m;i++)
        for(int j=0;j<n;j++)
        {
            degree[i][j]=getDegree(i,j);
            if(degree[i][j] == 1)
                Q.push(Point{i,j});
        }

//    int dx[]={1,0,-1, 0};
//    int dy[]={0,1, 0,-1};
    char oldtype[]={'^','<','v','>'};
    char newtype[]={'v','>','^','<'};
    while(!Q.empty())
    {
        Point x=Q.front();
        Q.pop();
        degree[x.x][x.y]=0;
        for(int i=0;i<4;i++)
        {
            int newx=x.x+dx[i];
            int newy=x.y+dy[i];
            if(isin(newx, newy) && degree[newx][newy])
            {
                degree[newx][newy]=0;
                G[x.x][x.y]=oldtype[i];
                G[newx][newy]=newtype[i];
                // 更新与(newx, newy)相邻的点的度数
                for(int j=0;j<4;j++)
                {
                    int curx=newx+dx[j];
                    int cury=newy+dy[j];
                    if(isin(curx, cury) && degree[curx][cury])
                    {
                        degree[curx][cury]--;
                        if(degree[curx][cury]==1)
                            Q.push(Point{curx, cury});
                    }
                }
                break;
            }
        }
    }

    for(int i=0;i<m;i++)
        for(int j=0;j<n;j++)
        {
            if(G[i][j]=='.')
            {
                puts("Not unique");
                return 0;
            }
        }

    for(int i=0;i<m;i++)
        puts(G[i]);

    return 0;
}