phanre의 tistory

[DB] - DB의 특징 및 트랜잭션

phanre — Wed, 10 May 2023 22:03:31 +0900

DB의 4가지 특징

1. 실시간 접근성

데이터베이스는 비정형적인 질의에 대해 실시간 처리에 의한 응답이 가능해야 합니다.

2. 지속적인 변화

데이터베이스의 상태는 동적으로, 즉 새로운 데이터의 삽입, 삭제, 갱신으로 항상 최신의 데이터를 유지해야 합니다.

3. 동시 공용

데이터베이스는 서로 다른 목적을 가진 여러 사용자들을 위한 것이므로, 다수의 사용자가 동시에 같은 내용의 데이터를 이용할 수 있어야 합니다.

4. 내용에 의한 참조

데이터베이스에 있는 데이터를 참조할 때, 데이터 레코드의 주소나 위치에 의해서가 아니라, 사용자가 요구하는 데이터 내용으로 찾아야 합니다.

SQL 4가지 데이터 언어

1. DDL (Data Definition Language)

데이터베이스 구조를 정의, 수정, 삭제하는 언어입니다.

create(생성), alter(수정), drop(삭제), truncate(초기화), rename(이름 변경)이 있습니다.

2. DML (Data Manipulation Language)

데이터베이스 내 자료 조회, 삽입, 수정, 삭제하는 언어입니다

select(조회), insert(삽입), update(수정), delete(삭제)가 있습니다.

3. DCL (Data Control Language)

데이터베이스에 대한 접근 권한 제어에 사용하는 언어입니다.

grant(권한 부여), revoke(권한 회수)가 있습니다.

4. TCL (Transaction Control Language)

DCL에서 트랜잭션을 컨트롤 하는 명령어로, DCL로 분류하는 경우도 있습니다.

commit(영구 반영), rollback(복구), savepoint(복구 위한 저장점 지정)이 있습니다.

트랜잭션

트랜잭션이란, 여러 개의 작업을 하나로 묵은 실행 유닛이며 작업의 완전성을 보장해 주는 것입니다.

하나의 특정 작업으로 시작해서 묶여있는 모든 작업들을 다 완료해야 정상적으로 종료됩니다.

작업이 하나라도 실패하면 트랜잭션은 실패합니다.

트랜잭션의 종류로는 3가지가 있습니다.

1. 자동 커밋 트랜잭션

데이터 변경이 성공적으로 끝나면 자동으로 commit, 실패하면 자동 rollback 처리 됩니다.

2. 묵시적 트랜잭션

자동 커밋 트랜잭션과 정 반대되는 개념으로, 사용자가 commit 혹은 rollback을 입력하기 전까지의 명령어들을 하나의 트랜잭션으로 간주합니다.

3. 명시적 트랜잭션

사용자가 트랜잭션의 시작과 끝을 결정 짓습니다.

트랜잭션의 4가지 특성 (ACID)

1. Atomic (원자성)

트랜잭션이 부분적으로 성공 또는 실패하지 않는 것입니다.

작업이 모두 반영되거나, 모두 반영되지 않음으로써 결과를 예측할 수 있어야 합니다.

ex) 계좌이체에서 A의 통장에서 출금만 되고 B의 통장에 입금이 안되는 경우, 롤백시켜 데이터를 보호합니다.

2. Consistency (일관성)

트랜잭션 이후 DB의 무결성이 유지되어야 하는 것입니다.

다시 말해, 트랜잭션이 일어난 이후의 데이터베이스는 데이터베이스의 제약이나 규칙을 만족해야 합니다.

ex) 모든 고객은 반드시 이름을 가져야 한다는 제약이 있을 때, 기존 고객의 이름을 삭제하는 쿼리나 이름 없는 새로운 고객을 추가하는 쿼리는 일관성에 위반됩니다.

3. Isolation (고립성)

하나의 트랜잭션 사이에 다른 트랜잭션이 끼어들 수 없는 것입니다.

모든 트랜잭션은 다른 트랜잭션으로부터 독립되어야 한다는 뜻입니다.

각 트랜잭션은 철저히 독립적이기 때문에, 다른 트랜잭션의 작업 내용을 알 수 없습니다.

ex) 만원이 있는 계좌에서 동시에 B와 C에게 8천원을 송금할 때, B에게 먼저 송금한 뒤 C에게 송금하여, B, C 모두에게 송금하는 것을 실패하게 해야 합니다.

4. Durability (지속성)

트랜잭션이 영구히 데이터베이스에 반영되어야 하는 것입니다.

하나의 트랜잭션이 성공적으로 수행되었다면, 해당 트랜잭션에 대한 로그가 남아야 합니다.

만약 런타임 오류나 시스템 오류가 발생하더라도, 해당 기록은 영구적이어야 합니다.

ex) 은행에서 계좌이체를 성공적으로 실행한 뒤에, 해당 은행 데이터베이스에 오류가 발생해 종료되더라도 계좌이체 내역은 기록으로 남아야 합니다. 마찬가지로 계좌이체를 기록하기 전에 오류로 종료가 된다면, 이체는 실패 처리하고 각 계좌들은 이체 이전 상태로 롤백해야 합니다.

[Python/파이썬] - 백준(BOJ) 3221번 : 개미의 이동

phanre — Tue, 12 Jul 2022 08:24:15 +0900

https://www.acmicpc.net/problem/3221

3221번: 개미의 이동

첫째 줄에 줄의 길이 L과 T가 주어진다. (2 ≤ L ≤ 200,000, 1 ≤ T ≤ 1,000,000) T의 단위는 초이다. 둘째 줄에는 개미의 수 N이 주어진다. (1 ≤ N ≤ 70,000, N < L) 다음 N개 줄에는 개미의 처음 위치 (줄의

www.acmicpc.net

개미 여러마리가 일직선상을 이동하는데 서로 부딪히거나 벽에 부딪히면 방향을 바꿉니다.

1초 마다 1씩 이동하는데 T초 후의 개미의 위치를 파악하는 문제입니다.

처음에는 개미끼리 부딪힐 때 어떻게 처리를 해야하나 고민했으나

생각해보니 개미끼리 부딪힐 경우 부딪힌 다른 개미가 이동하는 방향으로 움직였습니다.

여기까지는 금방 생각하였으나 개미별 위치를 알아내야 되기 때문에 고민하던 도중

어차피 처음의 개미가 왼쪽부터 오른쪽까지 1번 ~ N번 이고 그 상대적인 위치는 변하지 않는다는 것을 알게되었습니다.

왜냐면 부딪히면 방향을 바꾸기 때문에 서로 스쳐 지나갈 수 없기 때문입니다.

따라서 개미끼리 부딪히는 것은 신경쓰지 않고 벽에만 부딪히는 경우를 생각하여

개미의 위치를 sort하여 나타내었습니다.

import sys
input = sys.stdin.readline

l, t = map(int,input().split())
n = int(input())
loc = []
vec = []

for _ in range(n):
    a, b = map(str, input().split())
    loc.append(int(a))
    if b == 'L':
        vec.append(-1)
    else:
        vec.append(1)

for i in range(n):
    loc[i] += vec[i] * t
    while loc[i] > l or loc[i] < 0:
        if loc[i] > l:
            loc[i] = 2*l - loc[i]
        elif loc[i] < 0:
            loc[i] = -loc[i]
        vec[i] = -vec[i]

print(*sorted(loc),sep=' ')

[Python/파이썬] - 백준(BOJ) 14500번 : 테트로미노

phanre — Mon, 11 Jul 2022 08:55:20 +0900

https://www.acmicpc.net/problem/14500

14500번: 테트로미노

폴리오미노란 크기가 1×1인 정사각형을 여러 개 이어서 붙인 도형이며, 다음과 같은 조건을 만족해야 한다. 정사각형은 서로 겹치면 안 된다. 도형은 모두 연결되어 있어야 한다. 정사각형의 변

www.acmicpc.net

구현 문제입니다.

정사각형 네칸으로 만든 테트로미노의 모양으로 탐색을 하여 answer값을 max로 만드는 문제입니다.

우선 처음에 모든 테트로미노가 네칸이므로 dy, dx 배열을 만들어 만들어질 수 있는 경우의 수를 DFS로 탐색하였습니다.

DFS로 네 방향 모두 탐색을 하며 탐색을 시작할 때 visit 배열의 값을 1로 만들어 중복을 피하고

탐색이 끝난 경우 visit을 다시 0으로 전환하여 모든 경우의 수를 탐색하도록 하였습니다.

네칸을 탐색하였다면 저장해둔 값과 answer값을 max함수를 이용하여 비교하여 최대값으로 저장해줍니다.

이 알고리즘을 통하여 모두 탐색할 수 있을 줄 알았는데 T자 모양은 DFS로 탐색이 불가능하여 따로 함수를 생성해주었습니다.

첫번째 칸 근처의 세칸을 탐색하도록 만들었습니다.

import sys
input = sys.stdin.readline

answer = 0
def DFS(y, x, s, v):
    global answer
    if v == 4:
        answer = max(answer, s)
        return
    visit[y][x] = 1
    for i in range(4):
        yy = y + dy[i]
        xx = x + dx[i]
        if 0 <= yy < n and 0 <= xx < m and visit[yy][xx] == 0:
            DFS(yy, xx, s+arr[yy][xx], v+1)
    visit[y][x] = 0
def T(y, x):
    global answer
    for k in range(4):
        s = arr[y][x]
        b = 1
        for i in range(4):
            if i == k:
                continue
            yy = y + dy[i]
            xx = x + dx[i]
            if yy < 0 or xx < 0 or yy >= n or xx >= m:
                b = 0
                break
            s += arr[yy][xx]
        if b:
            answer = max(answer, s)
n, m = map(int,input().split())
arr = [list(map(int,input().split())) for _ in range(n)]
visit = [[0 for _ in range(m)] for _ in range(n)]
dy = [0,1,0,-1]
dx = [1,0,-1,0]
for i in range(n):
    for j in range(m):
        DFS(i, j, 0, 0)
        T(i, j)
print(answer)

[Python/파이썬] - 백준(BOJ) 2583번 : 영역 구하기

phanre — Sun, 10 Jul 2022 22:47:33 +0900

https://www.acmicpc.net/problem/2583

2583번: 영역 구하기

첫째 줄에 M과 N, 그리고 K가 빈칸을 사이에 두고 차례로 주어진다. M, N, K는 모두 100 이하의 자연수이다. 둘째 줄부터 K개의 줄에는 한 줄에 하나씩 직사각형의 왼쪽 아래 꼭짓점의 x, y좌표값과 오

www.acmicpc.net

간단한 BFS를 이용하는 문제입니다.

arr 배열에 영역의 정보를 저장하고 이미 탐색한 지역인지를 확인하는 visit 배열을 만듭니다.

이후 arr 전체 탐색을 하며 arr[i][j] == 0인 경우 queue에 넣은 뒤 visit을 1로 하고 s값을 0으로 세팅합니다.

BFS로 탐색하여 arr 정보가 0이고 visit 정보가 0인 경우 queue에 추가하고 visit을 1로 합니다.

queue에서 popleft 할 때마다 s값을 1씩 증가시키며 queue가 빌 때까지 반복합니다.

queue가 비면 answer 배열에 s 값을 추가하고 arr 다음값 탐색을 반복합니다.

모든 탐색이 끝나면 answer를 출력합니다.

import sys
from collections import deque
input = sys.stdin.readline

m, n, k = map(int,input().split())
arr = [[0 for _ in range(n)] for _ in range(m)]
dy = [0,-1,0,1]
dx = [1,0,-1,0]
for _ in range(k):
    x1, y1, x2, y2 = map(int,input().split())
    for i in range(y1, y2):
        for j in range(x1, x2):
            arr[i][j] = 1
queue = deque([])
answer = []
for i in range(m):
    for j in range(n):
        if arr[i][j] == 0:
            queue.append([i, j])
            arr[i][j] = 1
            s = 0
            while queue:
                y, x = queue.popleft()
                s += 1
                for k in range(4):
                    yy = y + dy[k]
                    xx = x + dx[k]
                    if 0 <= yy < m and 0 <= xx < n and arr[yy][xx] == 0:
                        queue.append([yy, xx])
                        arr[yy][xx] = 1
            answer.append(s)
print(len(answer))
print(*sorted(answer),sep=' ')

[Python/파이썬] - 백준(BOJ) 11559번 : Puyo Puyo

phanre — Thu, 16 Jun 2022 05:27:42 +0900

https://www.acmicpc.net/problem/11559

11559번: Puyo Puyo

총 12개의 줄에 필드의 정보가 주어지며, 각 줄에는 6개의 문자가 있다. 이때 .은 빈공간이고 .이 아닌것은 각각의 색깔의 뿌요를 나타낸다. R은 빨강, G는 초록, B는 파랑, P는 보라, Y는 노랑이다.

www.acmicpc.net

주어진 조건에 맞게 구현하는 문제입니다.

같은 색깔이 4개 이상 확인 하는 코드를 Check 함수로 만들었고

Check한 원소들을 '.'으로 바꿔주는 코드를 Pop 함수로 만들었고

빈칸을 채우는 코드를 Gravity로 만들었습니다.

우선 Check 함수에서는 DFS로 탐색하며 같은 색깔의 원소를 q라는 배열에 담아둡니다.

이후 함수가 종료되면 q 배열을 Puyo라는 dict에 넣어서 색깔별, 인접해있는 원소끼리 분류해줍니다.

그리고 Pop 함수를 실행하여 Puyo를 for문으로 색깔별로 4개 이상 있으면 그 좌표의 원소를 '.'으로 바꿔줍니다

Pop을 한번도 하지 않는다면 종료를 시켜야 하기 때문에 종료 조건인 p를 return 해줍니다.

이후 Gravity 함수를 실행하여 아래에서부터 '.'을 체크하고 가장 가까운 같은 열의 원소와 바꿔줍니다.

만약 맨 위까지 탐색했는데 '.'만 있는 경우 윗칸에 있는원소를 탐색하지 않아도 되기 때문에 0을 return 해줍니다.

이 사이클을 Pop이 더이상 되지 않을때까지 반복한 후 반복한 회수를 print 해줍니다.

코드 :

def Check(y, x, q):
    visit[y][x] = 1
    q.append([y, x])
    for i in range(4):
        yy = y + dy[i]
        xx = x + dx[i]
        if 0 <= yy < 12 and 0 <= xx < 6 and visit[yy][xx] == 0 and arr[yy][xx] == arr[y][x]:
            Check(yy, xx, q)

def Pop():
    p = 0
    for i in Puyo:
        for j in Puyo[i]:
            if len(j) < 4:
                continue
            for yy, xx in j:
                arr[yy][xx] = '.'
            p = 1
        Puyo[i] = []
    return p

def Gravity(y, x):
    for yy in range(y-1, -1, -1):
        if arr[yy][x] != '.':
            arr[y][x] = arr[yy][x]
            arr[yy][x] = '.'
            return 1
    return 0

arr = [list(map(str,input())) for _ in range(12)]
Puyo = {'R' : [], 'G' : [], 'B' : [], 'P' : [], 'Y' : []}

dy = [0,1,0,-1]
dx = [1,0,-1,0]
answer = 0
while True:
    visit = [[0 for _ in range(6)] for _ in range(12)]
    for j in range(6):
        for i in range(11, -1, -1):
            if arr[i][j] == '.':
                break
            if visit[i][j] == 0:
                temp = []
                Check(i, j, temp)
                Puyo[arr[i][j]].append(temp)
    if not Pop():
        break
    answer += 1
    for j in range(6):
        for i in range(11, -1, -1):
            if arr[i][j] == '.':
                if not Gravity(i, j):
                    break
print(answer)

[Python/파이썬] - 백준(BOJ) 14500번 : 테트로미노

phanre — Wed, 15 Jun 2022 03:00:25 +0900

https://www.acmicpc.net/problem/14500

14500번: 테트로미노

www.acmicpc.net

DFS를 이용하여 4칸 탐색을 하면 T자 모양 테트로미노 제외한 모든 모양을 확인할 수 있다.

DFS를 이용해 T자 제외 테트로미노의 최대합을 max함수를 이용하여 전역변수 answer에 저장해둔 후

T자 테트로미노를 탐색하여 answer의 최댓값을 조정한다.

이후에 answer값을 출력하면 된다.

DFS를 이용할 때는 중복 체크를 위해 함수 시작부분에 visit[y][x] = 1을 하였고

다른 모양의 테트로미노를 사용할 때 잘못된 중복체크를 막기 위해 종료 전 visit[y][x] = 0을 하였다.

코드 :

import sys
input = sys.stdin.readline

answer = 0
def DFS(y, x, s, v):
    global answer
    if v == 4:
        answer = max(answer, s)
        return
    visit[y][x] = 1
    for i in range(4):
        yy = y + dy[i]
        xx = x + dx[i]
        if 0 <= yy < n and 0 <= xx < m and visit[yy][xx] == 0:
            DFS(yy, xx, s+arr[yy][xx], v+1)
    visit[y][x] = 0
def T(y, x):
    global answer
    for k in range(4):
        s = arr[y][x]
        b = 1
        for i in range(4):
            if i == k:
                continue
            yy = y + dy[i]
            xx = x + dx[i]
            if yy < 0 or xx < 0 or yy >= n or xx >= m:
                b = 0
                break
            s += arr[yy][xx]
        if b:
            answer = max(answer, s)
n, m = map(int,input().split())
arr = [list(map(int,input().split())) for _ in range(n)]
visit = [[0 for _ in range(m)] for _ in range(n)]
dy = [0,1,0,-1]
dx = [1,0,-1,0]
for i in range(n):
    for j in range(m):
        DFS(i, j, 0, 0)
        T(i, j)
print(answer)

[Python/파이썬] - 백준(BOJ) 1806번 : 부분합

phanre — Mon, 6 Jun 2022 08:50:42 +0900

https://www.acmicpc.net/problem/1806

1806번: 부분합

첫째 줄에 N (10 ≤ N < 100,000)과 S (0 < S ≤ 100,000,000)가 주어진다. 둘째 줄에는 수열이 주어진다. 수열의 각 원소는 공백으로 구분되어져 있으며, 10,000이하의 자연수이다.

www.acmicpc.net

누적합을 이용하지 않으면 시간초과가 나는 문제이다.

처음에 1 2 3 4 5 를 받는다면 누적합을 구하여 1 3 6 10 15 를 배열에 저장한다

이후 포인터를 두개 생성하여 왼쪽 포인터는 0, 오른쪽 포인터는 1을 가리키게 한다.

그리고 오른쪽 포인터가 가리키는 누적합에서 왼쪽 포인터가 가리키는 누적합을 빼면 사이의 합이 구해진다.

이 방식으로 왼쪽 포인터가 배열의 크기를 넘어가지 않을때까지 반복하는데

사이의 합이 m(문제에서는 S)을 넘지 않았을 때 오른쪽 포인터가 배열의 크기를 넘어가지 않으면 오른쪽 포인터를 한칸 증가시키고

넘어간다면 왼쪽 포인터를 한칸 증가시킨다.

그리고 만약 사이의 합이 m을 넘어간다면 answer에 정보를 저장하고 왼쪽 포인터를 한칸 증가시킨다.

반복하며 한번도 answer에 정보를 저장하지 않으면 0을 출력하고, 정보를 저장했다면 answer를 출력한다.

import sys
input = sys.stdin.readline
n, m = map(int,input().split())
arr = list(map(int,input().split()))
s = [0]
for i in range(n):
    s.append(s[i] + arr[i])
answer = sys.maxsize
l = 0
r = 1
while l < n:
    if s[r] - s[l] < m:
        if r < n:
            r += 1
        else:
            l += 1
    else:
        answer = min(answer, r-l)
        l += 1

if answer == sys.maxsize:
    print(0)
else:
    print(answer)

[Python/파이썬] - 백준(BOJ) 17499번 : 수열과 시프트 쿼리

phanre — Mon, 6 Jun 2022 00:52:01 +0900

https://www.acmicpc.net/problem/17499

17499번: 수열과 시프트 쿼리

첫 번째 줄에 Q개의 연산을 차례대로 수행한 후 a1, a2, …, aN 을 공백을 사이에 두고 출력합니다.

www.acmicpc.net

주어진 쿼리에 맞게 배열에 더하기를 하거나 시프트를 하는 문제이다.

단순 append, pop을 이용하면 시간초과가 나오므로 포인터를 활용해야 한다.

처음 p를 index 0으로 잡고 오른쪽으로 시프트하면 -, 왼쪽으로 시프트하면 + 하고

그 p값을 배열의 첫번째 인덱스라고 생각하고 더하고, 프린트하면 된다.

처음에 시간초과가 떠서 문제를 확인해보니 input에서 시간을 너무 잡아먹는 것 같아

sys 라이브러리의 sys.stdin.readline을 이용해서 input에 시간을 줄였더니 AC를 받았다.

import sys
input = sys.stdin.readline
n, q = map(int,input().split())
arr = list(map(int,input().split()))
p = 0

for i in range(q):
    query = list(map(int,input().split()))
    if query[0] == 1:
        arr[(p+query[1]-1)%n] += query[2]
    elif query[0] == 2:
        p -= query[1]
    else:
        p += query[1]
        
for i in range(p, p+n):
    print(arr[i%n], end=' ')

[Python/파이썬] - 백준(BOJ) 2467번 : 용액

phanre — Sun, 5 Jun 2022 02:37:57 +0900

https://www.acmicpc.net/problem/2467

2467번: 용액

첫째 줄에는 전체 용액의 수 N이 입력된다. N은 2 이상 100,000 이하의 정수이다. 둘째 줄에는 용액의 특성값을 나타내는 N개의 정수가 빈칸을 사이에 두고 오름차순으로 입력되며, 이 수들은 모두 -

www.acmicpc.net

투 포인터를 이용하는 문제이다.

첫번째 인덱스와 마지막 인덱스를 가리키는 포인터를 두개 만들고 조건에 따라 포인터를 옮겨주면 된다.

오름차순으로 입력이 주어지기 때문에 포인터끼리의 합이 음수이면 왼쪽 포인터를 오른쪽으로 한칸 옮기고,

포인터값이 양수이면 오른쪽 포인터를 왼쪽으로 한칸 옮기면 된다.

그리고 포인터가 가리키는 값끼리의 합의 절대값을 min값과 비교하여 더 작다면 변경해준다.

이를 왼쪽 포인터가 가리키는 인덱스가 오른쪽 포인터를 가리키는 인덱스보다 작다면 계속 반복한다.

합이 0이면 더이상 작아 질 수 없기 때문에 바로 프린트하고 종료하며 while문을 탈출하면 저장해둔 값을 프린트한다.

import sys
input = sys.stdin.readline
n = int(input())
arr = list(map(int,input().split()))
l, r = 0, n-1
m = sys.maxsize
while l < r:
    s = arr[l] + arr[r]
    if m > abs(s):
        answer = [arr[l], arr[r]]
        m = abs(s)
    if s < 0:
        l += 1
    elif s > 0:
        r -= 1
    else:
        break
print(*answer,sep=' ')

[Python/파이썬] - 백준(BOJ) 14442번 : 벽 부수고 이동하기 2

phanre — Sat, 4 Jun 2022 21:14:25 +0900

https://www.acmicpc.net/problem/14442

14442번: 벽 부수고 이동하기 2

첫째 줄에 N(1 ≤ N ≤ 1,000), M(1 ≤ M ≤ 1,000), K(1 ≤ K ≤ 10)이 주어진다. 다음 N개의 줄에 M개의 숫자로 맵이 주어진다. (1, 1)과 (N, M)은 항상 0이라고 가정하자.

www.acmicpc.net

BFS로 (0,0)에서 시작하여 (n-1, m-1)에 도착할 때 까지 K개 이하의 벽을 부수고 진행하면 된다.

vst, brk 배열을 생성하여 각각 이동 블록 개수와 부순 벽 개수를 저장하고 brk가 k를 넘으면 멈추게 한다.

시간을 줄이기 위해 이동할 블록이 현재 블록보다 부순 벽 개수가 적고 이동 거리도 적으면 탐색하지 않도록 하였다.

import sys
from collections import deque
input = sys.stdin.readline

def bfs():
    while queue:
        y, x = queue.popleft()
        for i in range(4):
            yy = y + dy[i]
            xx = x + dx[i]
            if 0 <= yy < n and 0 <= xx < m:
                if yy == n-1 and xx == m-1:
                    print(vst[y][x]+1)
                    return
                if arr[yy][xx] == 1:
                    if brk[yy][xx] <= brk[y][x]+1 and vst[yy][xx] <= vst[y][x]+1:
                        continue
                    if brk[y][x]+1 > k:
                        continue
                    vst[yy][xx] = vst[y][x]+1
                    brk[yy][xx] = brk[y][x]+1
                    queue.append([yy, xx])

                else:
                    if brk[yy][xx] <= brk[y][x] and vst[yy][xx] <= vst[y][x]+1:
                        continue
                    vst[yy][xx] = vst[y][x]+1
                    brk[yy][xx] = brk[y][x]
                    queue.append([yy, xx])
    print(-1)

n, m, k = map(int,input().split())
arr = [list(map(int, input().strip())) for _ in range(n)]
vst = [[sys.maxsize for _ in range(m)] for _ in range(n)]
brk = [[0 for _ in range(m)] for _ in range(n)]
dy = [0,1,0,-1]
dx = [1,0,-1,0]
queue = deque([[0, 0]])
vst[0][0] = 1
if n == 1 and m == 1:
    print(1)
else:
    bfs()