Cozy coding

[JAVA] 백준 16638 괄호 추가하기 2

valid_ming — Tue, 16 Nov 2021 20:48:53 +0900

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

16638번: 괄호 추가하기 2

첫째 줄에 수식의 길이 N(1 ≤ N ≤ 19)가 주어진다. 둘째 줄에는 수식이 주어진다. 수식에 포함된 정수는 모두 0보다 크거나 같고, 9보다 작거나 같다. 문자열은 정수로 시작하고, 연산자와 정수가

www.acmicpc.net

괄호 추가하기 문제와 다른 것은 연산자들의 우선순위가 생겼다는 점!

이전 문제에서는 바로바로 값을 구해서 넘겨주었지만,

이번 문제에서는 괄호를 넣어준 스트링을 구하고 그 스트링을 후위표기법으로 바꾸면서 계산하는 방법으로 하였다

주어지는 식에 괄호를 추가하는 식의 String 연산을 진행하기 때문에 StringBuilder를 이용했다.

살짝 후위표기법으로 변환하는 코드가 마음에 안 들긴 하지만.. 구현 문제이니 그냥 놔뒀다

비트를 이용해서 풀이하는 코드도 봤는데 아직까지 비트 관련 연산자가 어렵다 ㅠ

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        N = Integer.parseInt(sc.nextLine());
        exp = sc.nextLine().toCharArray();
        op = N/2;

        if(N==1) System.out.println(exp[0]);
        else{
            solve(0, "");
            System.out.println(ans);
        }
    }

    static int N, op, ans = Integer.MIN_VALUE;
    static char[] exp;

    public static void solve(int n, String str){
        if(n>=op){
            char c = str.charAt(str.length()-1);
            if(c!=')') str += exp[N-1];

            int val = calc(str.toCharArray());
            if(ans < val) ans = val;

            return;
        }

        //선택 안한 경우
        StringBuilder tmp1 = new StringBuilder(str);
        tmp1.append(exp[2*n]).append(exp[2*n+1]);
        solve(n+1, tmp1.toString());

        //선택한 경우
        StringBuilder tmp2 = new StringBuilder(str);
        tmp2.append('(');
        tmp2.append(exp[2*n]).append(exp[2*n+1]).append(exp[2*n+2]);
        tmp2.append(')');
        if(n+1<op) tmp2.append(exp[2*n+3]);
        solve(n+2, tmp2.toString());
    }

    public static int calc(char[] str){
        Stack<Character> op = new Stack<>();
        Stack<Integer> num = new Stack<>();

        loop : for(int i=0;i<str.length;i++){

            if('0'<= str[i] && str[i]<='9'){
                num.push(str[i]-'0');
            }
            else {
                if(str[i]=='(') op.push(str[i]);
                else if(str[i]==')'){
                    while(op.peek()!='('){
                        int n1 = num.pop();
                        int n2 = num.pop();
                        num.push(calc(n2, n1, op.pop()));
                    }
                    op.pop();
                } else {
                    boolean in = false;

                    while (!in) {
                        if(op.size()==0){
                            op.push(str[i]);
                            continue loop;
                        }
                        char c = op.peek();
                        if (c == '(' || (c != '*' && str[i] == '*')){
                            op.push(str[i]);
                            in = true;
                        }
                        else {
                            int n1 = num.pop();
                            int n2 = num.pop();
                            num.push(calc(n2, n1, op.pop()));
                        }
                    }
                }
            }
        }

        while(op.size()>0){
            int n1 = num.pop();
            int n2 = num.pop();
            num.push(calc(n2, n1, op.pop()));
        }

        return num.pop();
    }

    public static int calc(int n1, int n2, char op){
        switch(op){
            case '+':
                return n1+n2;
            case '-':
                return n1-n2;
            case '*':
                return n1*n2;
            default: return 0;
        }
    }

}

[JAVA] 백준 3020 개똥벌레

valid_ming — Sun, 14 Nov 2021 13:51:10 +0900

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

3020번: 개똥벌레

개똥벌레 한 마리가 장애물(석순과 종유석)로 가득찬 동굴에 들어갔다. 동굴의 길이는 N미터이고, 높이는 H미터이다. (N은 짝수) 첫 번째 장애물은 항상 석순이고, 그 다음에는 종유석과 석순이

www.acmicpc.net

처음에는 단순히 이중 포문을 생각했고, 시간초과가 날 것 같아서 어떻게 풀어야 할까 고민을 했다..

누적합을 이용해야 하는 문제임을 알았음에도! (문제 유형 훔쳐봄) 어떻게 이용해야 할지 감이 오지 않았다...

결국,, 블로그 참고 (요즘 혼자 해결하는 문제가 많이 적어진 것 같다 흑흑)

내가 처음 생각한 이중 포문은 높이 크기의 배열을 만들어서 높이가 h인 장애물이 들어온다 => 1~h 까지 반복문을 돌며 해당하는 배열의 값을 1씩 증가 시킨다. 하여 h에 해당하는 값을 찾는다!

누적합을 이용하게 되면, 높이가 h인 장애물에 대한 접근을 전체 장애물수에서 h-1 이하의 장애물의 개수를 빼어서 풀이!! (석순과 종유석의 배열을 다르게 한다)

따라서 h 이하의 장애물에 수에 대한 정보가 필요함!

bot_sum[i]: i이하의 석순의 수

bot_sum[h]: h이하의 석순의 수 == 전체 석순의 개수

crush = bot_sum[H] - bot_sum[h-1] //h로 지나갔을 때 충돌하게 될 석순의 수

그렇다면 bot_sum[i]는 어떻게 구할까? 이때 누적합을 이용!

i-1 길이 이하의 석순의 수에서 i 길이의 석순을 합하면 i 이하의 석순의 수가 나온다

bot_sum[i] = bot_sum[i-1] + bot[i];

반대의 종유석은 전체 개수에서 H-i 이하의 종유석의 수를 빼주면 된다.

crush += bot_sum[H] - top_sum[H-i];

전체코드

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        H = Integer.parseInt(st.nextToken());
        bot = new int[H+1];
        top = new int[H+1];
        min = N; cnt = 0;

        for(int i=0;i<N/2;i++){
            bot[Integer.parseInt(br.readLine())]++;
            top[Integer.parseInt(br.readLine())]++;
        }

        process();

        System.out.println(min+" "+cnt);

    }

    static int N, H;
    static int[] bot, top;
    static int min, cnt;

    public static void process(){
        int[] bot_sum = new int[H+1]; // 높이가 h 이하인 석순의 수
        int[] top_sum = new int[H+1];

        for(int i=1;i<=H;i++){
            bot_sum[i] = bot_sum[i-1] + bot[i];
            top_sum[i] = top_sum[i-1] + top[i];
        }

        for(int i=1;i<H+1;i++){
            int crush = 0;

            crush += bot_sum[H] - bot_sum[i-1];
            crush += bot_sum[H] - top_sum[H-i];

            if(min>crush){
                cnt = 1;
                min = crush;
            } else if(min==crush){
                cnt++;
            }
        }
    }

}

[JAVA] 백준 1941 소문난 칠공주

valid_ming — Fri, 12 Nov 2021 22:29:50 +0900

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

1941번: 소문난 칠공주

총 25명의 여학생들로 이루어진 여학생반은 5×5의 정사각형 격자 형태로 자리가 배치되었고, 얼마 지나지 않아 이다솜과 임도연이라는 두 학생이 두각을 나타내며 다른 학생들을 휘어잡기 시작

www.acmicpc.net

[JAVA] 백준 2213 트리의 독립집합

valid_ming — Tue, 9 Nov 2021 21:32:29 +0900

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

2213번: 트리의 독립집합

첫째 줄에 트리의 정점의 수 n이 주어진다. n은 10,000이하인 양의 정수이다. 1부터 n사이의 정수가 트리의 정점이라고 가정한다. 둘째 줄에는 n개의 정수 w1, w2, ..., wn이 주어지는데, wi는 정점 i의

www.acmicpc.net

- 어려웠다.. 결국 블로그의 도움을 받아 해결하였다

- 트리의 구조 -> 어느 정점이든 루트가 될 수 있다 -> 편의상 1번 정점을 루트로 생각하고 1번 노드부터 dfs 탐색을 진행한다

- 현재 접근한 노드를 포함할 때/포함하지 않을 때의 최대 독립 집합의 가중치를 구해본다 => memo[N][2]

- 현재 노드를 집합에 포함한다면, 인접한 다음 노드는 포함되지 않아야 한다.

- 현재 노드를 집합에 포함하지 않는다면, 인접한 다음 노드를 포함되도 되고, 포함하지 않아도 된다 => 둘 중 더 큰 값을 선택한다

- 이렇게 dfs를 통해 memo 배열을 모두 채우고, memo[1][0]과 memo[1][1] 중의 큰값을 선택한다

- 이제 다시 루트 노드에서 최대 독립 집합을 구성하는 노드들을 찾을 trace 메서드를 호출한다

- trace(int cur, int inc): 현재 접근한 노드 cur, 접근한 노드를 포함하는지(1), 포함하지 않는지(0)

- 포함한다면 정답 배열에 넣고, 인접한 노드들은 포함하지 않는 버전으로 호출 => trace(next, 0)

- 포함하지 않는다면, 이전에 구했던 memo를 이용하여 더 큰 값을 가진 경우로 호출 => trace(next, ?)

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine());
        W = new int[N+1];
        visit = new boolean[N+1];
        memo = new int[N+1][2]; //i 번째 노드를 선택한 경우와 선택하지 않은 경우
        tree = new ArrayList[N+1];

        StringTokenizer st = new StringTokenizer(br.readLine());
        for(int i=1;i<=N;i++){
            tree[i] = new ArrayList<>();
            W[i] = Integer.parseInt(st.nextToken());
        }

        for(int i=1;i<N;i++){
            st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            tree[a].add(b);
            tree[b].add(a);
        }

        dfs(1);

        visit = new boolean[N+1];
        if(memo[1][0] > memo[1][1]){
            System.out.println(memo[1][0]);
            trace(1, 0);
        } else{
            System.out.println(memo[1][1]);
            trace(1, 1);
        }

        Collections.sort(res);
        for(int num : res ) {
            System.out.print(num+" ");
        }

    }

    static int N;
    static int[] W;
    static boolean[] visit;
    static int[][] memo;
    static ArrayList<Integer>[] tree;
    static ArrayList<Integer> res = new ArrayList<>();

    public static void dfs(int cur){
        int child_size = tree[cur].size();

        memo[cur][0] = 0;
        memo[cur][1] = W[cur];
        visit[cur] = true;

        for(int i=0;i<child_size;i++){
            int next = tree[cur].get(i);
            if(!visit[next]){
                dfs(next);

                memo[cur][0] += Math.max(memo[next][0], memo[next][1]);
                memo[cur][1] += memo[next][0];
            }
        }
    }

    public static void trace(int cur, int inc){
        visit[cur] = true;

        if(inc==1){
            res.add(cur);
            for(int next:tree[cur]){
                if(!visit[next]) trace(next, 0);
            }
        } else {
            for(int next:tree[cur]){
                if(!visit[next]){
                    if(memo[next][1] > memo[next][0]){
                        trace(next, 1);
                    } else trace(next, 0);
                }
            }
        }
    }
}

[JAVA] 백준 16637 괄호 추가하기

valid_ming — Fri, 5 Nov 2021 23:34:37 +0900

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

16637번: 괄호 추가하기

길이가 N인 수식이 있다. 수식은 0보다 크거나 같고, 9보다 작거나 같은 정수와 연산자(+, -, ×)로 이루어져 있다. 연산자 우선순위는 모두 동일하기 때문에, 수식을 계산할 때는 왼쪽에서부터 순

www.acmicpc.net

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        N = Integer.parseInt(sc.nextLine());
        str = sc.nextLine().toCharArray();
        op = N/2;

        choice(0, str[0]-'0');
        System.out.println(ans);
    }

    static int N, op;
    static char[] str;
    static int ans = Integer.MIN_VALUE;

    public static void choice(int idx, int val){
//        System.out.println(idx+" "+val);
        boolean leftOne = false;
        if(idx>=N-1){
            if(val > ans) ans = val;
            return;
        }
        if(idx>=N-3) leftOne = true;

        //선택안한경우
        int res1 = calc(val, str[idx+2]-'0', str[idx+1]);
        choice(idx+2, res1);
        //선택한 경우
        if(!leftOne){
            int temp = calc(str[idx+2]-'0', str[idx+4]-'0', str[idx+3]);
            int res2 = calc(val, temp, str[idx+1]);
            choice(idx+2*2, res2);
        }
    }

    public static int calc(int n1, int n2, char op){
        switch(op){
            case '+':
                return n1+n2;
            case '-':
                return n1-n2;
            case '*':
                return n1*n2;
            default: return 0;
        }
    }
}

[JAVA] 백준 2473 세 용액

valid_ming — Thu, 4 Nov 2021 22:40:00 +0900

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

2473번: 세 용액

첫째 줄에는 전체 용액의 수 N이 입력된다. N은 3 이상 5,000 이하의 정수이다. 둘째 줄에는 용액의 특성값을 나타내는 N개의 정수가 빈칸을 사이에 두고 주어진다. 이 수들은 모두 -1,000,000,000 이상

www.acmicpc.net

- 처음에는 조합이나 백트래킹을 떠올렸는데 5000이라는 범위가 시간초과가 날 것 같았다.

- 투포인터는 O(N)으로 두 가지를 고를 수 있다는 것을 알고, 한가지 용액과 나머지 두 용액을 고르는 것으로 문제를 해결하였다.

- 처음에는 투 포인터를 전체 범위에 대해 진행하였지만, i+1 ~ N-1에 대해서만 두 용액을 찾으면 된다는 것을 뒤늦게 깨달았다. 왜냐하면 이미 한 용액을 고르는 순간에 그 한 용액을 포함한 모든 조합을 살펴본 것이고, 이후에는 그 한 용액을 제외하고 조합해도 된다.

- 입력 범위는 int 범위이기 때문에 int로 값을 받아왔는데, 세 값을 더해주는 연산에서 int 범위가 벗어나 계속 틀렸습니다가 나는 것 같아 입력 배열 타입을 long으로 바꿔서 풀이했다.

- 투 포인터를 연습하기에 좋은 문제였다.

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int N = Integer.parseInt(sc.nextLine());
        long[] arr = new long[N];
        StringTokenizer st = new StringTokenizer(sc.nextLine());
        for(int i=0;i<N;i++){
            arr[i] = Long.valueOf(st.nextToken());
        }

        Arrays.sort(arr);
        long abs = 3000000000L;
        long[] ans = new long[3];
        for(int i=0;i<N;i++){
            long ch = arr[i];
            int left = i+1;
            int right = N-1;

            while(left<right){
                long val = arr[left] + arr[right] + ch;
                if(Math.abs(val) < abs){
                    abs = Math.abs(val);
                    ans[0] = ch;
                    ans[1] = arr[left];
                    ans[2] = arr[right];
                }
                if(val > 0) right--;
                else if(val<=0) left++;
            }
        }

        System.out.println(ans[0]+" "+ans[1]+" "+ans[2]);
    }
}

[JAVA] 백준 16168 퍼레이드

valid_ming — Tue, 2 Nov 2021 10:08:02 +0900

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

16168번: 퍼레이드

첫 번째 줄에 지점의 개수 V, 연결 구간의 개수 E가 주어진다. (1 ≤ V ≤ E ≤ 3000) 이후 E개의 줄에 걸쳐 각 연결 구간이 연결하는 두 지점의 번호 Va, Vb가 공백을 사이에 두고 주어진다. (1 ≤ Va,

www.acmicpc.net

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        V = Integer.parseInt(st.nextToken());
        E = Integer.parseInt(st.nextToken());
        graph = new ArrayList[V+1];
        visit = new boolean[V+1];

        for(int i=1;i<=V;i++){
            graph[i] = new ArrayList<>();
        }

        int[] degrees = new int[V+1];
        for(int i=0;i<E;i++){
            st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            graph[a].add(b);
            graph[b].add(a);
            degrees[a]++;
            degrees[b]++;
        }

        int cnt = 0;
        for(int i=1;i<=V;i++){
            if(!visit[i]){
                dfs(i);
                cnt ++;
            }
        }

        if(cnt!=1) System.out.println("NO");
        else {
            int odd = 0;
            for(int i=1;i<=V;i++){
                if(degrees[i]%2==1) odd++;
            }

            if(odd==0 || odd==2) System.out.println("YES");
            else System.out.println("NO");
        }
    }

    static ArrayList<Integer>[] graph;
    static boolean[] visit;
    static int V, E;

    public static void dfs(int i){
        if(visit[i]) return;
        visit[i] = true;

        for(int j: graph[i]){
            dfs(j);
        }
    }
}

[JAVA] 백준 1944 복제 로봇

valid_ming — Sun, 31 Oct 2021 13:24:14 +0900

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

1944번: 복제 로봇

첫째 줄에 미로의 크기 N(4 ≤ N ≤ 50)과 열쇠의 개수 M(1 ≤ M ≤ 250) 이 공백을 사이에 두고 주어진다. 그리고 둘째 줄부터 N+1째 줄까지 미로의 정보가 주어진다. 미로는 1과 0, 그리고 S와 K로 주어

www.acmicpc.net

import java.util.*;
import java.io.*;

public class Main {

    public static class Node implements Comparable<Node>{
        int row, col;
        int dist;

        public Node(int r, int c, int d){
            row = r; col = c;
            dist = d;
        }

        public int compareTo(Node o){
            return dist - o.dist;
        }
    }

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        map = new char[N][N];
        include = new boolean[N][N];
        int row = 0, col = 0;
        left = M;

        for(int i=0;i<N;i++){
            String str = br.readLine();
            for(int j=0;j<N;j++){
                char c = str.charAt(j);
                map[i][j] = c;
                if(c=='S'){
                    row = i;
                    col = j;
                }
            }
        }

        boolean find = true;
        int sum = 0;
        while(left>0){
            if(find) findDist(row, col);
            Node node = pq.poll();
            row = node.row;
            col = node.col;

            if(include[row][col]){
                find = false;
                continue;
            }
            include[row][col] = true;
            left--;
            sum += node.dist;
            find = true;
        }

        System.out.println(sum);
    }

    static PriorityQueue<Node> pq = new PriorityQueue<>();
    static int N, M, left;
    static char[][] map;
    static boolean[][] include;
    static int[][] d = {{-1, 1, 0, 0}, {0, 0, -1, 1}};

    public static void findDist(int r, int c){
        Queue<Node> q = new LinkedList<>();
        boolean[][] visit = new boolean[N][N];
        q.add(new Node(r, c, 0));
        visit[r][c] = true;
        int cnt = 0;

        while(!q.isEmpty()){
            Node cur = q.poll();

            for(int i=0;i<4;i++){
                int nr = cur.row + d[0][i];
                int nc = cur.col + d[1][i];

                if(!visit[nr][nc]){
                    if(map[nr][nc]!='1'){
                        q.add(new Node(nr, nc, cur.dist+1));
                        visit[nr][nc] = true;
                    }
                    if(map[nr][nc]=='K' && !include[nr][nc]){
                        pq.add(new Node(nr, nc, cur.dist+1));
                        cnt++;
                        if(cnt==left) return;
                    }
                }
            }
        }

        if(cnt<left){
            System.out.println(-1);
            System.exit(0);
        }
    }
}

[JAVA] 백준 15684 사다리 조작

valid_ming — Wed, 27 Oct 2021 12:10:31 +0900

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

15684번: 사다리 조작

사다리 게임은 N개의 세로선과 M개의 가로선으로 이루어져 있다. 인접한 세로선 사이에는 가로선을 놓을 수 있는데, 각각의 세로선마다 가로선을 놓을 수 있는 위치의 개수는 H이고, 모든 세로선

www.acmicpc.net

풀이 후기

- 인덱스 처리가 힘들었다. 원래는 사다리 크기에 딱 맞는 배열을 생성하여 범위 체크해가며 풀이했는데 코드가 복잡해져서 좌우로 마진을 한칸씩 주고, 범위 체크 없이 좌우에 사다리가 있는지 없는지를 확인했다

- 나는 boolean 배열로 해당 칸에 사다리가 있다 없다를 체크했는데, 다른 코드를 보니 오른쪽으로 뻗은 사다리는 1로 왼쪽으로 뻗은 사다리는 -1로 한 코드가 많았다. 더 직관적일 것 같다

- 사다리를 2차원 배열로 생각하는게 힘들었다..

import java.util.*;
import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        H = Integer.parseInt(st.nextToken());
        map = new boolean[H+1][N+1];
        while(M-->0){
            st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            map[a][b] = true;
        }

        for(int i=0;i<=3;i++){
            comb(0, 0, i);
        }

        System.out.println(-1);
    }

    static int N,M,H;
    static boolean[][] map;

    public static void comb(int idx, int cnt, int n){
        if(cnt==n){
            if(start()){
                System.out.println(n);
                System.exit(0);
            }
            return;
        }

        for (int i = idx; i < (N - 1) * H; i++) {
            int r = i/(N-1)+1;
            int c = i%(N-1)+1;
            if(!map[r][c] && !map[r][c+1] && !map[r][c-1]){
                map[r][c] = true;
                comb(i+1, cnt+1, n);
                map[r][c] = false;
            }
        }
    }

    public static boolean start(){
        for(int i=1;i<=N;i++){
            int line = i;
            for(int j=1;j<=H;j++){
                boolean move = false;
                if(line<N && map[j][line]){
                    line++;
                    move = true;
                }
                if(!move && 0<=line-1 && map[j][line-1]) line--;
            }
            if(line!=i) return false;
        }
        return true;
    }
}

[JAVA] 백준 21610 마법사 상어와 비바라기

valid_ming — Tue, 26 Oct 2021 20:19:55 +0900

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

21610번: 마법사 상어와 비바라기

마법사 상어는 파이어볼, 토네이도, 파이어스톰, 물복사버그 마법을 할 수 있다. 오늘 새로 배운 마법은 비바라기이다. 비바라기를 시전하면 하늘에 비구름을 만들 수 있다. 오늘은 비바라기

www.acmicpc.net

import java.util.*;
import java.io.*;

public class Main {

    public static class Pos{
        int row, col;
        public Pos(int r, int c){
            row = r; col = c;
        }
    }

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());
        map = new int[N][N];

        for(int i=0;i<N;i++){
            st = new StringTokenizer(br.readLine());
            for(int j=0;j<N;j++){
                map[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        q.add(new Pos(N-1,0));
        q.add(new Pos(N-1,1));
        q.add(new Pos(N-2,0));
        q.add(new Pos(N-2,1));


        while(M-->0){
            st = new StringTokenizer(br.readLine());
            int d = Integer.parseInt(st.nextToken())-1;
            int s = Integer.parseInt(st.nextToken())%N;
            int size = q.size();

            for(int i=0;i<size;i++){
                Pos pos = q.poll();
                move(pos, d, s);
            }

            boolean[][] check = new boolean[N][N];
            while(!q.isEmpty()){
                Pos pos = q.poll();
                check[pos.row][pos.col] = true;
                copy(pos);
            }

            for(int i=0;i<N;i++){
                for(int j=0;j<N;j++){
                    if(map[i][j] >=2 && !check[i][j]){
                        map[i][j] -= 2;
                        q.add(new Pos(i, j));
                    }
                }
            }
        }

        int sum = 0;
        for(int i=0;i<N;i++){
            for(int j=0;j <N;j++){
                sum += map[i][j];
            }
        }

        System.out.println(sum);
    }

    static int N;
    static int[][] map;
    static Queue<Pos> q = new LinkedList<>();
    static int[][] dir = {{0, -1, -1, -1, 0, 1, 1, 1}, {-1, -1, 0, 1, 1, 1, 0 ,-1}};

    public static void move(Pos pos, int d, int s){
        int row = ((pos.row + N) + dir[0][d]*s)%N;
        int col = ((pos.col + N) + dir[1][d]*s)%N;
        map[row][col]++;
        q.add(new Pos(row,col));
    }

    public static void copy(Pos pos){
        int cnt = 0;

        for(int i=1; i<8; i+=2){
            int r = pos.row + dir[0][i];
            int c = pos.col + dir[1][i];

            if(0<=r && r<N && 0<=c && c<N && map[r][c]>0) cnt++;
        }

        map[pos.row][pos.col] += cnt;
    }
}