강지안

구름톤 챌린지: 4주차(230906~230908)

강지안 — Wed, 6 Sep 2023 11:53:22 +0900

230906

Day18 문제풀이

코드

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

class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer tk = new StringTokenizer(br.readLine(), " ");
        int N = Integer.parseInt(tk.nextToken());
        int M = Integer.parseInt(tk.nextToken());

        long[][][] board = new long[N][N][2]; // 보드Y 보드X 가로세로

        for(int i=0; i<M; i++) {
            tk = new StringTokenizer(br.readLine(), " ");
            int y = Integer.parseInt(tk.nextToken()) - 1;
            int x = Integer.parseInt(tk.nextToken()) - 1;
            String direction = tk.nextToken();

            switch(direction) {
                case "U" :
                    for(int a=y; a>=0; a--) board[a][x][1]++;
                    break;
                case "D" :
                    for(int a=y; a<N; a++) board[a][x][1]++;
                    break;
                case "L" :
                    for(int a=x; a>=0; a--) board[y][a][0]++;
                    break;
                case "R" :
                    for(int a=x; a<N; a++) board[y][a][0]++;
            }
        }

        long count = 0;
        for(int i=0; i<N; i++) {
            for(int j=0; j<N; j++) {
                count += (board[i][j][0] * board[i][j][1]);
            }
        }
        System.out.print(count);
    }
}

중요

마지막 테스트케이스만 자꾸 실패하였는데 board와 count의 자료형을 int에서 long으로 바꿈으로써 성공하였다.
오버플로우에 주의하자.

230907

Day19 문제풀이

코드

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

class Main {
    static ArrayList<ArrayList<Integer>> graph = new ArrayList<>();
    static int N, S, E;

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer tk = new StringTokenizer(br.readLine(), " ");
        N = Integer.parseInt(tk.nextToken()); // 도시의 수
        int M = Integer.parseInt(tk.nextToken()); // 도로의 수
        S = Integer.parseInt(tk.nextToken()) - 1; // 출발 도시
        E = Integer.parseInt(tk.nextToken()) - 1; // 도착 도시

        for(int i=0; i<N; i++) graph.add(new ArrayList<Integer>());

        for(int i=0; i<M; i++) {
            tk = new StringTokenizer(br.readLine(), " ");

            int u = Integer.parseInt(tk.nextToken()) - 1;
            int v = Integer.parseInt(tk.nextToken()) - 1;

            graph.get(u).add(v);
            graph.get(v).add(u);
        }

        for(int i=0; i<N; i++) System.out.println(bfs(i));
    }

    public static int bfs(int R) {
        // 시작 도시나 도착 도시가 공사중일 경우 -1 반환
        if(S == R || E == R) return -1;

        int[] visited = new int[N];
        visited[S] = 1;

        Queue<Integer> queue = new LinkedList();
        queue.offer(S);

        while(!queue.isEmpty()) {
            int u = queue.poll();

            for(int v : graph.get(u)) {
                // 공사중일 경우 지나갈 수 없음
                if(v == R) continue;

                if(visited[v] == 0 || (visited[v] != 0 && visited[v] > visited[u] + 1)) {
                    visited[v] = visited[u] + 1;
                    queue.offer(v);
                }
            }
        }

        if(visited[E] == 0) return -1;
        else return visited[E];
    }
}

중요

시작도시에서 도착도시로 가는 최단 거리를 찾아야 하기 때문에, 이미 방문했더라도 기존의 거리보다 가까울 경우 재방문하는 경우도 체크해주어야 한다. ( visited[v] != 0 && visited[v] > visited[u] + 1) )

230908

Day20 문제풀이

코드

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

class Main {
    static class Node {
        int y;
        int x;

        Node(int y, int x) {
            this.y = y;
            this.x = x;
        }
    }

    static int N, K;
    static String[] board;

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

        StringTokenizer tk = new StringTokenizer(br.readLine(), " ");
        N = Integer.parseInt(tk.nextToken());
        K = Integer.parseInt(tk.nextToken());
        int Q = Integer.parseInt(tk.nextToken());

        board = new String[N*N];
        for(int i=0; i<N; i++) {
            String[] split = br.readLine().split("");
            for(int j=0; j<N; j++) {
                board[i*N + j] = split[j];
            }
        }

        for(int i=0; i<Q; i++) {
            tk = new StringTokenizer(br.readLine(), " ");
            int y = Integer.parseInt(tk.nextToken()) - 1;
            int x = Integer.parseInt(tk.nextToken()) - 1;
            String d = tk.nextToken();

            board[y*N+ x] = d;

            bfs(y, x);
        }

        StringBuilder sb = new StringBuilder();
        for(int i=0; i<N; i++) {
            for(int j=0; j<N; j++) {
                sb.append(board[i*N + j]);
            }
            sb.append("\n");
        }

        bw.write(sb.toString());

        bw.flush();
        bw.close();
    }

    public static void bfs(int y, int x) {
        int[][] direction = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
        boolean[] visited = new boolean[N*N];
        String[] origBoard = board.clone();

        int count = 1;
        Queue<Node> queue = new LinkedList();
        queue.offer(new Node(y, x));
        board[y*N + x] = ".";
        visited[y*N + x] = true;

        while(!queue.isEmpty()) {
            Node u = queue.poll();

            for(int i=0; i<direction.length; i++) {
                int Y = u.y + direction[i][0];
                int X = u.x + direction[i][1];
                if(Y < 0 || Y >= N || X < 0 || X >= N) continue;
                if(visited[Y*N + X]) continue;

                if(origBoard[Y*N + X].equals(origBoard[u.y*N + u.x])) {
                    board[Y*N + X] = ".";
                    visited[Y*N + X] = true;
                    queue.offer(new Node(Y, X));
                    count++;
                }
            }
        }

        if(count < K) board = origBoard;
    }
}

중요

한 번 접근한 인덱스에 방문 처리를 해주지 않아 시간초과의 늪에 빠졌었다. 방문 처리를 해주지 않으면 시간적인 면에서 굉장히 불리하니 절대 잊지 않도록 해야 한다.
StringBuilder를 사용하면 속도와 메모리 측면 모두 효율적으로 문자열을 만들 수 있다.

구름톤 챌린지: 4주차(230904~230905)

강지안 — Mon, 4 Sep 2023 13:03:26 +0900

230904

Day16 문제풀이

코드

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

class Main {
    static ArrayList<ArrayList<Integer>> graph = new ArrayList<>();
    static int N;
    static int count = 0;
    static int[] visited;

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer tk = new StringTokenizer(br.readLine(), " ");
        N = Integer.parseInt(tk.nextToken());
        int M = Integer.parseInt(tk.nextToken());

        for(int i=0; i<N; i++) graph.add(new ArrayList<Integer>());
        visited = new int[N];

        for(int i=0; i<M; i++) {
            tk = new StringTokenizer(br.readLine(), " ");
            int u = Integer.parseInt(tk.nextToken()) - 1;
            int v = Integer.parseInt(tk.nextToken()) - 1;

            graph.get(u).add(v);
        }

        for(int i=0; i<N; i++) bfs(i);

        System.out.print(count);
    }

    public static void bfs(int R) {
        if(visited[R] == 0) visited[R] = ++count;
        else return;

        Queue<Integer> queue = new LinkedList();
        queue.offer(R);

        while(!queue.isEmpty()) {
            int u = queue.poll();

            for(int v : graph.get(u)) {
                if(visited[v] == 0 && graph.get(v).contains(u)) {
                    visited[v] = visited[R];
                    queue.offer(v);
                }
            }
        }
    }
}

중요

해당 문제에서는 단방향이 아닌 양방향일 경우에만 연합으로 치기 때문에 기존의 bfs에서 방문 여부 외에도 graph.get(v).contains(u)로 양방향 조건을 추가해주어야 한다.
bfs에서 queue에 v를 offer하는 걸 잊지 말자. v를 offer하지 않으면 다음 이웃 노드로 넘어갈 수 없다

230905

Day17 문제풀이

코드

import java.io.*;
import java.util.*;
class Main {
    static ArrayList<ArrayList<Integer>> graph = new ArrayList<>();
    static ArrayList<ArrayList<Integer>> component = new ArrayList<>();
    static HashMap<ArrayList<Integer>, Integer> map = new HashMap<>();

    static int N;
    static int[] visited;
    static int count = 0;

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer tk = new StringTokenizer(br.readLine(), " ");
        N = Integer.parseInt(tk.nextToken());
        int M = Integer.parseInt(tk.nextToken());

        int[] countU = new int[N];
        visited = new int[N];

        for(int i=0; i<N; i++) graph.add(new ArrayList<Integer>());

        for(int i=0; i<M; i++) {
            tk = new StringTokenizer(br.readLine(), " ");
            int u = Integer.parseInt(tk.nextToken()) - 1;
            int v = Integer.parseInt(tk.nextToken()) - 1;

            countU[u]++;

            graph.get(u).add(v);
            graph.get(v).add(u);
        }

        for(int i=0; i<N; i++) bfs(i);

        // 밀도가 높은 컴포넌트
        Collections.sort(component, (o1, o2) -> {
            // 컴퓨터의 수가 가장 작은 컴포넌트
            if(map.get(o1) == map.get(o2)) {
                // 더 작은 번호 컴퓨터 컴포넌트
                if(o1.size() == o2.size()) {
                    return Collections.min(o1) - Collections.min(o2);
                } else {
                    return o1.size() - o2.size();
                }
            } else {
                return map.get(o2) - map.get(o1);
            }
        });

        Collections.sort(component.get(0));
        for(int i : component.get(0)) System.out.print((i+1) + " ");
    }

    public static void bfs(int R) {
        if(graph.get(R).size() == 0 || visited[R] != 0) return;

        visited[R] = ++count;
        int countComponentTemp = 0; // 통신 회선 개수 카운트
        component.add(new ArrayList<Integer>());
        component.get(component.size()-1).add(R);

        Queue<Integer> queue = new LinkedList();
        queue.offer(R);

        while(!queue.isEmpty()) {
            int u = queue.poll();

            for(int v : graph.get(u)) {
                countComponentTemp++;
                if(visited[v] == 0) {
                    visited[v] = visited[R];
                    component.get(component.size()-1).add(v);
                    queue.offer(v);
                }
            }
        }

        map.put(component.get(component.size()-1), countComponentTemp / 2);
    }
}

중요

HashMap에서 키 값을 단일값만 줄 수 있다고 생각했는데, 배열 전체도 키 값으로 줄 수 있다는 것을 알게 되었다.
(1 뿐만 아니라 {1,3,6} 도 key로 사용할 수 있다는 의미)

구름톤 챌린지: 3주차(230830~230901)

강지안 — Wed, 30 Aug 2023 10:47:11 +0900

230830

Day13 문제풀이

코드

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

class Main {
    static int[][] building;
    static boolean[] visit;
    static int N;

    static Queue<Integer> queue = new LinkedList<>();
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer tk = new StringTokenizer(br.readLine());
        N = Integer.parseInt(tk.nextToken());
        int K = Integer.parseInt(tk.nextToken());

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

        visit = new boolean[N*N];
        HashMap<Integer, Integer> map = new HashMap<>();
        for(int i=0; i<N*N; i++) {
            int count = bfs(i);
            if(count < K) continue;

            if(map.containsKey(building[i/N][i%N])) map.put(building[i/N][i%N], map.get(building[i/N][i%N]) + 1);
            else map.put(building[i/N][i%N], 1);
        }

        int maxKey = 0, maxCount = 0;
        for(int key : map.keySet()) {
            if(maxCount < map.get(key) || (maxCount == map.get(key) && maxKey < key)) {
                maxKey = key;
                maxCount = map.get(key);
            }
        }
        System.out.print(maxKey);
    }

    public static int bfs(int R) {
        int count = 0;

        if(visit[R]) return count;
        visit[R] = true;
        count++;

        int[][] list = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

        queue.offer(R);

        while(!queue.isEmpty()) {
            int u = queue.poll();

            for(int i=0; i<list.length; i++) {
                int v = (u/N + list[i][0]) * N + (u%N + list[i][1]);
                try {
                    if(visit[v] || building[u/N][u%N] != building[u/N + list[i][0]][u%N + list[i][1]]) continue;

                    count++;
                    visit[v] = true;
                    queue.offer(v);
                } catch(Exception e) {} // 인덱스 범위 초과
            }
        }

        return count;
    }
}

중요

최대 단지수가 같을 경우 유형 번호가 더 큰 쪽을 우선한다는 조건을 빠뜨려 한 번 fail이 떴었다. 문제를 파악하는 것도 중요하지만, 조건 하나하나도 모두 읽고 문제를 풀이하는 습관을 들여야겠다.
근접리스트를 {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}가 아닌 {-1*N, N, -1, 1}로 두었을 경우 인덱스 범위에서 벗어나는 경우를 잡을 수 없으니 주의해야 한다.

230831

Day14 문제풀이

코드

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

class Main {
    static ArrayList<ArrayList<Integer>> graph = new ArrayList<>();
    static int[] visited;
    static int count = 0;

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer tk = new StringTokenizer(br.readLine(), " ");
        int N = Integer.parseInt(tk.nextToken());
        int M = Integer.parseInt(tk.nextToken());
        int K = Integer.parseInt(tk.nextToken());

        visited = new int[N];

        for(int i=0; i<N; i++) graph.add(new ArrayList<Integer>());
        for(int i=0; i<M; i++) {
            tk = new StringTokenizer(br.readLine(), " ");

            int u = Integer.parseInt(tk.nextToken()) - 1;
            int v = Integer.parseInt(tk.nextToken()) - 1;

            graph.get(u).add(v);
            graph.get(v).add(u);
        }
        for(int i=0; i<N; i++) Collections.sort(graph.get(i));

        dfs(K - 1);

        int countNode = 0;
        int maxIndex = 0;
        int maxCount = 0;

        for(int i=0; i<visited.length; i++) {
            if(visited[i] == 0) continue;
            countNode++;
            if(maxCount < visited[i]) {
                maxCount = visited[i];
                maxIndex = i;
            }
        }

        System.out.print(countNode + " " + (maxIndex+1));
    }

    public static void dfs(int R) {
        visited[R] = ++count;

        for(int v : graph.get(R)) {
            if(visited[v] == 0) {
                dfs(v);
                break;
            }
        }
    }
}

중요

이 문제의 핵심은 각 노드에서 갈 수 있는 노드 중 최솟값의 노드로만 이동한다는 것이다.
기존 dfs랑 비슷하지만 처음으로 갈 수 있는 노드로 이동 후 다른 노드로 뻗어가지 않도록 break로 중간에 반복을 끊어주는 것이 중요하다.

230901

Day15 문제풀이

코드

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

class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer tk = new StringTokenizer(br.readLine(), " ");
        int N = Integer.parseInt(tk.nextToken());
        int K = Integer.parseInt(tk.nextToken());

        int[][] Cs = new int[N][2]; // P C
        for(int i=0; i<N; i++) {
            tk = new StringTokenizer(br.readLine(), " ");

            Cs[i][0] = Integer.parseInt(tk.nextToken());
            Cs[i][1] = Integer.parseInt(tk.nextToken());
        }

        Arrays.sort(Cs, (o1, o2) -> {
            if(o2[1]/o2[0] == o1[1]/o1[0]) return o1[0] - o2[0];
            else return o2[1]/o2[0] - o1[1]/o1[0];
        });

        long result = 0;
        for(int i=0; i<Cs.length; i++) {
            // 하나 사기
            if(Cs[i][0] <= K) {
                result += Cs[i][1];
                K -= Cs[i][0];
            }
            // 나누어 사기
            else {
                int CP = Cs[i][1] / Cs[i][0];
                result += (K * CP);
                K -= K;
            }
            if(K == 0) break;
        }

        System.out.print(result);
    }
}

중요

최대 포만감을 위해선 Ci / Pi 값이 큰 값부터 구매하는 것이 포인트이다. 이를 위해 Ci/Pi 값을 기준으로 배열을 정렬해주었다.

구름톤 챌린지: 3주차(230828~230829)

강지안 — Mon, 28 Aug 2023 10:41:05 +0900

230828

Day11 문제풀이

코드

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

class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int N = Integer.parseInt(br.readLine());
        String[] split = br.readLine().split(" ");
        int A = Math.max(Integer.parseInt(split[0]), Integer.parseInt(split[1]));
        int B = Math.min(Integer.parseInt(split[0]), Integer.parseInt(split[1]));

        int count = Integer.MAX_VALUE;
        for(int i=N/A; i>=0; i--) {
            if((N - i*A) % B != 0) continue;

            for(int j=0; j<N/B+1; j++) {
                if(i * A + j * B == N) {
                    System.out.print(i+j);
                    return;
                }
            }
        }
        System.out.print(-1);
    }
}

중요

이번 풀이의 중심은 시간초과를 잡는 것이었다. 아이템의 개수를 최소화하기 위해선 치유력이 높은 것을 많이 사용하고, 남은 부분을 치유력이 비교적 낮은 것으로 채워넣어야 한다.
치유력이 높은 것을 A, 치유력이 낮은 것을 B라고 가정하였을 때, for문에서 A는 최댓값부터 시작하는 것이 중요하다.

230829

Day12 문제풀이

코드

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

class Main {
    static boolean[] visit;
    static boolean[][] house;
    static Queue<Integer> queue = new LinkedList<>();
    static int N;
    static int[][] neighbor = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        N = Integer.parseInt(br.readLine());

        visit = new boolean[N*N];
        house = new boolean[N][N];
        for(int i=0; i<N; i++) {
            StringTokenizer tk = new StringTokenizer(br.readLine());
            for(int j=0; j<N; j++) {
                if(Integer.parseInt(tk.nextToken()) == 1) house[i][j] = true;
            }
        }

        int count = 0;
        for(int i=0; i<N*N; i++) {
            if(!house[i/N][i%N]) continue;
            if(bfs(i)) count++;
        }

        System.out.print(count);
    }

    public static boolean bfs(int R) {
        if(visit[R]) return false; // 처음부터 이미 visit인 경우 -> 이미 전기 공급 받음
        visit[R] = true;
        queue.offer(R);

        while(!queue.isEmpty()) {
            int u = queue.poll();
            int i = u/N;
            int j = u%N;

            for(int k=0; k<neighbor.length; k++) {
                try {
                    int v = (i + neighbor[k][0]) * N + (j + neighbor[k][1]);
                    if(!visit[v] && house[i + neighbor[k][0]][j + neighbor[k][1]]) {
                        visit[v] = true;
                        if(!queue.contains(v)) queue.offer(v);
                    }
                } catch(Exception e) {}
            }
        }

        return true;
    }
}

중요

이번 문제는 메모리 관리가 핵심이었다. 계속 메모리초과로 인해 런타임에러가 발생했는데, 인접리스트가 문제였다.
인접리스트를 없애고 매번 이웃을 찾아주었더니 메모리초과 문제를 해결할 수 있었다.
인접리스트를 미리 만들어두는 편이 훨씬 보기 좋다고 생각하였는데(재사용성 또한..), 메모리초과 문제도 생각해봐야 한다는 것을 알게 되었다.

구름톤 챌린지: 2주차(230823~230825)

강지안 — Thu, 24 Aug 2023 13:48:01 +0900

230823

Day8 문제풀이

코드

import java.io.*;
class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int N = Integer.parseInt(br.readLine());

        int countItem = 0;
        countItem += (N / 14);
        N %= 14;
        countItem += (N / 7);
        countItem += N % 7;

        System.out.println(countItem);
    }
}

중요

그리디 알고리즘 : 선택을 해야 할 때마다 눈앞의 최선의 선택을 하는 알고리즘. 너무 많은 반복이 필요한 동적 프로그래밍을 보완하기 위한 알고리즘.

230824

Day9 문제풀이

코드

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

class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer tk = new StringTokenizer(br.readLine());
        int N = Integer.parseInt(tk.nextToken());
        int K = Integer.parseInt(tk.nextToken());

        String[][] ground = new String[N][N];
        int[][] point = new int[N][N];
        for(int i=0; i<N; i++) {
            tk = new StringTokenizer(br.readLine());
            for(int j=0; j<N; j++) {
                ground[i][j] = tk.nextToken();
            }
        }

        int max = 0;
        int[][] area = {{1,0}, {0,-1}, {0,0}, {0,1}, {-1,0}};
        for(int k=0; k<K; k++) {
            tk = new StringTokenizer(br.readLine());
            int Y = Integer.parseInt(tk.nextToken()) - 1;
            int X = Integer.parseInt(tk.nextToken()) - 1;

            for(int l=0; l<area.length; l++) {
                try {
                    if(ground[Y+area[l][0]][X+area[l][1]].equals("0")) point[Y+area[l][0]][X+area[l][1]]++;
                    else if(ground[Y+area[l][0]][X+area[l][1]].equals("@")) point[Y+area[l][0]][X+area[l][1]] += 2;

                    if(max < point[Y+area[l][0]][X+area[l][1]]) max = point[Y+area[l][0]][X+area[l][1]];
                } catch(Exception e) {} 
            }
        }

        System.out.print(max);
    }
}

중요

완전 탐색 알고리즘 : 모든 경우의 수를 체크하는 방법
코드 자체의 가독성만 본다면 이차원 배열이 낫지만, 일차원 배열을 사용하면 속도와 성능 면에서 조금 더 개선될 수 있다고 한다.
지금은 데이터의 양이 적지만 방대한 양의 자료를 사용해야 할 땐 일차원 배열을 고려해봐도 좋을 듯 하다.

230825

Day10 문제풀이

코드

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

class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int N = Integer.parseInt(br.readLine());
        String[] temp = br.readLine().split(" ");
        int[] goorm = {Integer.parseInt(temp[0]) - 1, Integer.parseInt(temp[1]) - 1};
        temp = br.readLine().split(" ");
        int[] player = {Integer.parseInt(temp[0]) - 1, Integer.parseInt(temp[1]) - 1};

        boolean[][] visitGoorm = new boolean[N][N];
        boolean[][] visitPlayer = new boolean[N][N];

        String[][] board = new String[N][N];
        for(int i=0; i<N; i++) {
            StringTokenizer tk = new StringTokenizer(br.readLine());
            for(int j=0; j<N; j++) {
                board[i][j] = tk.nextToken();
            }
        }

        visitGoorm[goorm[0]][goorm[1]] = true;
        visitPlayer[player[0]][player[1]] = true;
        int pointGoorm = playGame(board, visitGoorm, goorm, N);
        int pointPlayer = playGame(board, visitPlayer, player, N);

        if(pointGoorm > pointPlayer) System.out.print("goorm " + pointGoorm);
        else System.out.print("player " + pointPlayer);
    }

    public static int playGame(String[][] board, boolean[][] visit, int[] user, int N) {
        boolean isBreak = false;
        while(true) {
            if(isBreak) break;

            String[] go = new String[2];
            go[0] = board[user[0]][user[1]].substring(0, board[user[0]][user[1]].length()-1);
            go[1] = String.valueOf(board[user[0]][user[1]].charAt(board[user[0]][user[1]].length()-1));

            if(go[1].equals("L")) {
                for(int i=0; i<Integer.parseInt(go[0]); i++) {
                    user[1]--;
                    if(user[1] < 0) user[1] = N-1;

                    if(visit[user[0]][user[1]]) {
                        isBreak = true;
                        break;
                    }

                    //방문처리
                    if(!visit[user[0]][user[1]]) visit[user[0]][user[1]] = true;
                }
            } else if(go[1].equals("R")) {
                for(int i=0; i<Integer.parseInt(go[0]); i++) {
                    user[1]++;
                    if(user[1] > N-1) user[1] = 0;

                    if(visit[user[0]][user[1]]) {
                        isBreak = true;
                        break;
                    }

                    //방문처리
                    if(!visit[user[0]][user[1]]) visit[user[0]][user[1]] = true;
                }
            } else if(go[1].equals("U")) {
                for(int i=0; i<Integer.parseInt(go[0]); i++) {
                    user[0]--;
                    if(user[0] < 0) user[0] = N-1;

                    if(visit[user[0]][user[1]]) {
                        isBreak = true;
                        break;
                    }

                    //방문처리
                    if(!visit[user[0]][user[1]]) visit[user[0]][user[1]] = true;
                }
            } else {
                for(int i=0; i<Integer.parseInt(go[0]); i++) {
                    user[0]++;
                    if(user[0] > N-1) user[0] = 0;

                    if(visit[user[0]][user[1]]) {
                        isBreak = true;
                        break;
                    }

                    //방문처리
                    if(!visit[user[0]][user[1]]) visit[user[0]][user[1]] = true;
                }
            }
        }

        int point = 0;
        for(int i=0; i<N; i++) {
            for(int j=0; j<N; j++) {
                if(visit[i][j]) point++;
            }
        }
        return point;
    }
}

중요

1L을 1 L 로 분할하는 것은 좋았으나, 무턱대고 글자대로 자르다보니 103L이 103 L 이 아닌 1 0 3 L로 분할되는 문제가 발생하였고 이를 파악하는 것이 늦어 시간을 많이 잡아먹었다.
앞으로 split으로 분할할 때 내가 원하는 대로 분할한 것이 맞는지 다시 한 번 생각해봐야겠다.

구름톤 챌린지: 2주차(230821~230822)

강지안 — Mon, 21 Aug 2023 13:29:26 +0900

230821

Day6 문제풀이

코드

첫번째 방법 : S를 매번 substring 하기

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

class Main {  
public static void main(String\[\] args) throws Exception {  
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    ArrayList<String> list = new ArrayList<>(); // 중복 없는 모든 부분 문자열

    int N = Integer.parseInt(br.readLine());
    String[][] input = new String[N][3]; // 각 문자열의 부분 문자열

    String S = br.readLine();

    // 부분문자열을 list에 추가 후 정렬
    for(int a=1; a<S.length()-1; a++) {
        for(int b=a+1; b<S.length(); b++) {
            String temp1 = S.substring(0, a);
            String temp2 = S.substring(a, b);
            String temp3 = S.substring(b, S.length());

            if(!list.contains(temp1)) list.add(temp1);
            if(!list.contains(temp2)) list.add(temp2);
            if(!list.contains(temp3)) list.add(temp3);
        }
    }
    Collections.sort(list);

    // 정렬 후 문자에 대한 점수 부여
    HashMap<String, Integer> map = new HashMap<>();
    for(int i=0; i<list.size(); i++) {
        map.put(list.get(i), i+1);
    }

    // 부분문자열의 최댓값 구하기
    int max = 0;
    for(int a=1; a<S.length()-1; a++) {
        for(int b=a+1; b<S.length(); b++) {
            String temp1 = S.substring(0, a);
            String temp2 = S.substring(a, b);
            String temp3 = S.substring(b, S.length());

            int sum = map.get(temp1) + map.get(temp2) + map.get(temp3);
            if(max < sum) max = sum;
        }
    }

    // 결과 출력
    System.out.print(max);
    }
}

두번째 방법 : S를 substring한 결과를 저장해서 사용하기

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

class Main {  
public static void main(String\[\] args) throws Exception {  
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

    ArrayList<String> list = new ArrayList<>(); // 중복 없는 모든 부분 문자열

    int N = Integer.parseInt(br.readLine());
    ArrayList<String[]> input = new ArrayList<String[]>(); // 각 문자열의 부분 문자열

    String S = br.readLine();

    // 부분문자열을 list에 추가 후 정렬
    int index = 0;
    for(int a=1; a<S.length()-1; a++) {
        for(int b=a+1; b<S.length(); b++) {                
            String temp1 = S.substring(0, a);
            String temp2 = S.substring(a, b);
            String temp3 = S.substring(b, S.length());
            String[] temp = {temp1, temp2, temp3};
            input.add(temp);    

            if(!list.contains(input.get(index)[0])) list.add(input.get(index)[0]);
            if(!list.contains(input.get(index)[1])) list.add(input.get(index)[1]);
            if(!list.contains(input.get(index)[2])) list.add(input.get(index)[2]);

            index++;
        }
    }
    Collections.sort(list);

    // 정렬 후 문자에 대한 점수 부여
    HashMap<String, Integer> map = new HashMap<>();
    for(int i=0; i<list.size(); i++) {
        map.put(list.get(i), i+1);
    }

    // 부분문자열의 최댓값 구하기
    int max = 0;
    for(int i=0; i<input.size(); i++) {
        String temp1 = input.get(i)[0];
        String temp2 = input.get(i)[1];
        String temp3 = input.get(i)[2];

        int sum = map.get(temp1) + map.get(temp2) + map.get(temp3);
            if(max < sum) max = sum;
    }

    // 결과 출력
    System.out.print(max);
    }
}

중요

문제를 풀이하는 도중 문자열 S를 substring해야하는 일이 두 번 발생한다. 이 때 java7 업데이트 이후 substring의 시간 복잡도가 O(n)이라는 것을 알게 되었고, S를 매번 substring 하지 않고 분할한 S를 미리 arraylist에 저장해두는 방법을 떠올려보았다.
substring의 시간 복잡도가 O(n)인 것에 비해 arraylist의 시간 복잡도는 add와 get 모두 O(1)이다. 비록 arraylist 저장을 위한 index 변수와 arraylist 때문에 공간복잡도는 좀 늘어났지만, 시간복잡도는 줄었을 것이라 예상한다.

time-complexity-of-javas-substring : https://stackoverflow.com/questions/4679746/time-complexity-of-javas-substring
Runtime Complexity of Java Collections : https://gist.github.com/psayre23/c30a821239f4818b0709

230822

Day7 문제풀이

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

class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer tk = new StringTokenizer(br.readLine(), " ");
        int N = Integer.parseInt(tk.nextToken());
        int K = Integer.parseInt(tk.nextToken());

        // 게임판 구성
        boolean[][] board = new boolean[N][N];
        for(int i=0; i<N; i++) {
            tk = new StringTokenizer(br.readLine(), " ");
            for(int j=0; j<N; j++) {
                board[i][j] = tk.nextToken().equals("1") ? true : false;
            }
        }

        // 깃발 개수 카운트
        int countK = 0;
        int[][] search = {{-1, -1}, {-1, 0}, {-1, 1}, {0, -1}, {0, 1}, {1, -1}, {1, 0}, {1, 1}};
        for(int i=0; i<N; i++) {
            for(int j=0; j<N; j++) {
                // 구름이 없는 칸일 경우
                if(!board[i][j]) {
                    int countCloud = 0;
                    for(int k=0; k<search.length; k++) {
                        try {
                            if(board[i+search[k][0]][j+search[k][1]]) countCloud++;
                        } catch(Exception e) {}
                    }
                    if(countCloud == K) countK++;
                }
            }
        }

        System.out.print(countK);
    }
}

중요

board의 boolean값을 넣는데 사용하였다. 평소에는 가독성의 이유로 if-else문을 사용했지만, 이번 경우에는 오히려 삼항연산자의 가독성이 더 높았다. 학부 시절 삼항연산자는 가독성이 좋지 않으니 사용하는 것을 지양하라는 말을 들었지만, 이렇게 되려 가독성이 높아지는 곳이 있다면 사용하는 것이 좋을 것 같다.

구름톤 챌린지 1주차(230816~230818)

강지안 — Wed, 16 Aug 2023 11:34:49 +0900

230816

Day3 문제풀이

코드

import java.io.*;

class Day3 {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        int sum = 0;

        int T = Integer.parseInt(br.readLine());
        for(int i=0; i<T; i++) {
            String[] fomula = br.readLine().split(" ");

            int a = Integer.parseInt(fomula[0]);
            String operator = fomula[1];
            int b = Integer.parseInt(fomula[2]);

            switch(operator) {
                case "+" :
                    sum += (a + b);
                    break;
                case "-" :
                    sum += (a - b);
                    break;
                case "*" :
                    sum += (a * b);
                    break;
                case "/" :
                    sum += (a / b);    
            }
        }

        System.out.print(sum);
    }
}

중요

한 문장을 나누는 방법에는 split()으로 분할하는 방법이 있지만. StringTokenizer를 사용하는 방법도 있다.
이번 문제에서는 나누어 저장하는 값이 적어 split()을 사용하였지만,
반복적으로 나누어 저장해야 하는 값일 경우 for문에 StringTokenizer의 nextToken()을 사용하면 좀 더 효율적으로 코드를 작성할 수 있다.

230817

Day4 문제풀이

코드

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

class Main {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();
        Integer[] array = new Integer[N];

        int target = 0;
        for(int i=0; i<N; i++) {
            array[i] = sc.nextInt();
            if(array[i] > target) target = array[i];
        }

        int sum = array[0];
        boolean up = true;
        int pre = array[0];

        // N이 1일 경우 return
        if(N == 1) {
            System.out.println(sum);
            return;
        }

        // 처음부터 내림차순일 경우
        if(pre == target) {
            pre = Integer.MAX_VALUE;
            up = false;
        }

        // 햄버거 확인
        for(int i=1; i<N; i++) {
            sum += array[i];

            // 오름차순이어야 함
            if(up) {

                // 오름차순에 맞지 않을 경우 return
                if(array[i] < pre) {
                    System.out.print(0);
                    return;
                }

                pre = array[i];

                // 가장 높은 재료일 시 내림차순으로 전환
                if(array[i] == target) {
                    pre = Integer.MAX_VALUE;
                    up = false;
                }
            }

            // 내림차순이어야 함
            else {

                // 내림차순에 맞지 않을 경우 return
                if(array[i] > pre) {
                    System.out.print(0);
                    return;
                }

                pre = array[i];
            }
        }
        System.out.println(sum);
    }
}

중요

문제에서는 정렬을 활용하여 문제를 풀이하라고 나와있는데, 나는 최댓값을 사용하여 풀이하였다. 내가 생각한 정렬을 이용한 풀이는 우선 최댓값의 인덱스를 알아내야 하고 젇렬 여부를 확인하기 위해 슬라이싱을 이용한 추가 변수가 필요했다. 이처럼 풀이하면 코드가 더 복잡해진다. 정렬을 이용한 문제의 풀이에 대해 좀 더 생각해 볼 필요가 있다.
처음부터 내림차순으로 진행되어야 하는 경우를 놓쳐 마지막 테스트 케이스를 계속 실패했다. 나올 수 있는 경우의 종류를 잘 생각해보고 이에 맞는 테스트케이스를 작성하는 연습을 해야겠다.
처음에 문제를 제대로 이해하지 못해 중간값을 기준으로 오름차순/내림차순을 해야 하는 코드를 작성하였다. 이후 다시 읽어보니 중간값이 아닌 최대값을 기준으로 오름차순/내림차순을 하는 것이었다. 문제를 제대로 읽고 이해하는 자세가 필요하다.

230818

Day5 문제풀이

코드

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

class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer tk = new StringTokenizer(br.readLine(), " ");
        int N = Integer.parseInt(tk.nextToken());
        int K = Integer.parseInt(tk.nextToken());

        tk = new StringTokenizer(br.readLine(), " ");
        int[][] list = new int[N][2];
        for(int i=0; i<N; i++) {
            list[i][0] = Integer.parseInt(tk.nextToken());
            list[i][1] = countBinary(list[i][0]);
        }

        Arrays.sort(list, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if(o1[1] == o2[1])
                    return o2[0] - o1[0];
                else
                    return o2[1] - o1[1];
            }
        });

        System.out.print(list[K-1][0]);
    }

    public static int countBinary(int num) {
        int count = 0;

        while(num != 0 && num != 1) {
            if(num % 2 == 1) count++;
            num /= 2;
        }
        if(num == 1) count++;

        return count;
    }
}

중요

new Comparator를 사용하여 이중 배열을 정렬하는 것은 자주 해왔지만, 자동완성 없이 작성하는 것은 어려웠다. 시험장에서는 자동완성을 사용하지 못하니 자동완성을 사용하지 않고도 코드를 작성할 수 있는 능력을 길러야 한다.
이번 문제에서는 2진수에서 1의 개수만 체크하면 되었지만, 2진수의 경우 나머지 연산을 한 후 그 값을 거꾸로 뒤집어야 해당 수의 2진수가 됨을 잊지 말자.
내림차순의 경우 o2-o1, 오름차순의 경우 o1-o2 이다

구름톤 챌린지: 1주차(230814~230815)

강지안 — Mon, 14 Aug 2023 14:11:30 +0900

230814

구름 컨테이너, github 세팅

구름 컨테이너 생성 및 실행

구름톤 챌린지를 위한 구름 컨테이너를 생성해주었다.(깃허브 연동)

프로젝트 폴더는 이렇게 구성해주었다.
새로 생성한 Solution.java를 구동하는데 꽤 애를 먹었는데 위처럼 프로젝트 속성 또한 수정해주어야 한다.
(나또한 구름 컨테이너는 처음 사용해보는 것이기에 더 좋은 방법이 있을 수도 있다!)

깃허브 토큰 생성

구름에서 깃허브를 연동하기 위해선 깃허브에서 토큰을 발행해주어야 한다
Github의 Settings > Developer Settings > Personal access tokens > Fine-grained tokens > Generate new tokens 버튼

토큰의 정보를 입력해주고 사용 범위 또한 사용할 레포지토리 하나로 지정해주었다.

Permission 설정이 정말 중요하다. 이거 빼먹어서 고생했다
commit, push 등 구름톤 컨테이너에서 사용해줄 것들의 권한을 read&write로 부여해주었다.

이후 토큰이 생성되면 반드시 복사하여 다른 곳에 저장해둔다.
토큰은 딱 한 번만 보여주기 때문에 해당 토큰을 잃어버렸다면 토큰을 재발행 받아야한다.

구름 컨테이너에 토큰 적용

아까 발행받은 토큰을 이곳에 입력해준다.

구름에서 git 설정하기

git 초기화
git init
구름 컨테이너 git 창에 들어가보면 저장소 연결 버튼이 나올텐데
그걸 누르지 말고 git init을 입력하여 초기화 후 새로고침 해주면 정상적으로 git 창이 표시된다.
git 계정 정보 입력
git config --global user.name [사용자 이름] git config --global user.password [발행받은 토큰]
add, commit
git add . git commit -m "커밋할 내용"
push
git push -u origin master
만약 여기에서 403오류가 발생할 경우!
403오류 > fatal: unable to access ... The requested URL returned error: 403
git remote set-url https://github.com/사용자 이름/레포지토리 주소
를 입력하여 remote를 다시 세팅해준다.

github 확인

여기까지 했다면 정상적으로 github에도 push 되어있는 것을 확인할 수 있다.

만약 들어갔는데 아무것도 보이지 않는다면 branch가 달라서 그럴 수도 있다.

그럴 땐 branch를 클릭하여 master로 가보면 정상적으로 push 된 걸 확인할 수 있다.

Day1 문제풀이

코드

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

class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer tk = new StringTokenizer(br.readLine(), " ");
        int W = Integer.parseInt(tk.nextToken());
        int R = Integer.parseInt(tk.nextToken());

        System.out.print((int)(W * (1+R/30.0)));
    }
}

중요

정수끼리 연산할 경우 결과값은 정수이지만, 정수와 실수를 연산할 경우 결과값은 실수가 된다.
BufferedWriter를 사용할 경우 마지막에 반드시 bw.flush()와 bw.close()로 버퍼를 닫아주어야 한다.

230815

Day2 문제풀이

코드

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

class Main {
    public static void main(String[] args) throws Exception {
        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();
        int T = sc.nextInt();
        int M = sc.nextInt();

        for(int i=0; i<N; i++) {
            int c = sc.nextInt();
            M += c;
        }

        T = (T + M / 60) % 24;
        M %= 60;

        System.out.print(T + " " + M);
    }
}

중요

60, 24는 절대 변하지 않는 상수이기 때문에 이번에는 저렇게 숫자로 기재하였지만, 상수가 변할 수 있다면(프로그램 내부가 아닌 프로그램 자체적으로) 하드코딩 보다는 final로 상수를 따로 선언하여 작성하는 편이 좋다.