思路：模拟

数据很小，直接模拟就能通过。

代码

C++

#include <bits/stdc++.h>
using namespace std;
#define ll long long

int n,m,k;
int a[105][105];

void get(char c,int x,int y){
	int dx,dy;
	if(c=='l'){
		dx=0;
		dy=-1;
	}else if(c=='r'){
		dx=0;
		dy=1;
	}else if(c=='u'){
		dx=-1;
		dy=0;
	}else{
		dx=1;
		dy=0;
	}
	bool flag=false;
	x+=dx;
	y+=dy;
	while(x>=1&&x<=n&&y>=1&&y<=m){
		if(a[x][y]==0){
			cout<<x<<" "<<y<<endl;
			flag=true;
			break;
		}
		x+=dx;
		y+=dy;
	}
	if(!flag){
		cout<<-1<<endl;
	}
}

int main() {
    std::ios::sync_with_stdio(false); // 关闭同步，提高C++输入输出效率
    cin>>n>>m>>k;
    for(int i=1;i<=k;++i){
    	char c;
		int x,y;
    	cin>>c>>x>>y;
    	if(c=='c'){
    		a[x][y]=1;
		}else{
			get(c,x,y);
		}
	}
    
    return 0;
}

Python

import sys

def find(grid,mode,xi,yi):
    n = len(grid)-1
    m = len(grid[0])-1
    if xi >= 1 and xi <= n and yi >= 1 and yi <= m:
        if mode == 'l':
            for i in range(yi-1,0,-1):
                if grid[xi][i] == 0:
                    return xi,i
            return -1,-1
        elif mode == 'r':
            for i in range(yi+1,m+1):
                if grid[xi][i] == 0:
                    return xi,i
            return -1,-1
        elif mode == 'u':
            for i in range(xi-1,0,-1):
                if grid[i][yi] == 0:
                    return i,yi
            return -1,-1
        elif mode == 'd':
            for i in range(xi+1,n+1):
                if grid[i][yi] == 0:
                    return i,yi
            return -1,-1
n,m,k = map(int,input().split())
#0:white,1:black,-1:out
grid = [[0]*(m+1) for _ in range(n+1)]
# grid[0][:] = -1
# grid[:][0] = -1
for i in range(n+1):
    grid[i][0] = -1
for i in range(m+1):
    grid[0][i] = -1

for i in range(k):
    ini = input().split()
    xi = int(ini[1])
    yi = int(ini[2])
    mode = ini[0]
    if mode == 'c':
        grid[xi][yi] = 1
    else:
        x,y = find(grid,mode,xi,yi)
        if x == -1:
            print(-1)
        else:
            print(x,y)

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(),m=sc.nextInt(),k=sc.nextInt();
        int[][] visited = new int[n+1][m+1];
        while(sc.hasNext()){
            String str = sc.next();
            int i = sc.nextInt(),j = sc.nextInt();
            if(str.equals("c")){
                visited[i][j] = 1;
            }else if(str.equals("1")||str.equals("l")){
                int number = j-1;
                while(number>=1 && visited[i][number]==1) number--;
                if(number==0) System.out.println(-1);
                else System.out.println(i+" "+number);
            }else if(str.equals("r")){
                int number = j+1;
                while(number<=m && visited[i][number]==1) number++;
                if(number==m+1) System.out.println(-1);
                else System.out.println(i+" "+number);
            }else if(str.equals("u")){
                int number = i-1;
                while(number>=1 && visited[number][j]==1) number--;
                if(number==0) System.out.println(-1);
                else System.out.println(number+" "+j);
            }else{
                int number = i+1;
                while(number<=n && visited[number][j]==1) number++;
                if(number==n+1) System.out.println(-1);
                else System.out.println(number+" "+j);
            }

        }
    }
}

题目内容

给定一个大小为$x×m$的网格板，网格板是由$n×m$个$1$×1的单元格组成，最初所有的单位格是白色的；现在给出$k$个操作：

$c x y$将位置为$(x,y)$的单元格涂成黑色

$lxy$从位置为$(x,y)$的单元格向左寻找最先出现的白色单元格(不包含($x$,$y$)),并输出其坐标；

$rxy$从位置为$(x,y)$的单元格向右寻找最先出现的白色单元格(不包含($x$,$y$)),并输出其坐标；

$uxy$从位置为$(x,y)$的单元格向上寻找最先出现的白色单元格(不包含($x$,$y$))，并输出其坐标；

$dxy$从位置为$(x,y)$的单元格向下寻找最先出现的白色单元格(不包含($x$,$y$)),并输出其坐标；

注：网格板的左上角的单元格坐标为$(1,1)$

输入描述

第一行给出正整数$n,m,k$;代表网格板的大小以及操作的次数；

随后$k$行，每行一个操作命令格式为$s_i x_iy_i$。

$1≤n,m≤100$

$1≤k≤10^4$

$1≤x_i≤n$

$1≤y_i≤m$

$s_i$中包含$l r u d c$

输出描述

对于以$lrud$的命令，每行输出对应的操作后的坐标。

若没有这样的坐标，输出$-1$

样例1

输入

5 5 20
c 2 4
c 4 2
r 3 5
c 4 4 
c 5 2
u 5 2
c 3 2 
c 1 4
1 4 4 
c 3 5 
c 5 3 
c 3 3
c 3 1
u 1 4
c 3 4 
r 1 1 
d 3 3
d 3 4
c 1 1
c 5 4

输出

-1
3 2
4 3
-1 
1 2
4 3
5 4