# 유형 : 다익스트라, 그래프

# 난이도 : 골드 V

# 맨 처음에는 인접리스트, 우선순위큐 대신 2차원 배열과 반복문을 사용해서 메모리 초과가 났다. 그 이유는 Vertex 최대 개수는 20000, 따라서 20000*20000*4Byte가 필요한 가중치 그래프, 20000*4Byte 의 Dist 그래프, 20000 * 1Byte boolean그래프 때문이었다. 검색해보니 다익스트라를 풀 때는 우선순위큐와 ArrayList를 사용하는게 좋다고한다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
package bj;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
 
public class p1753 {
    static int V,E,Start,INF=Integer.MAX_VALUE;
    static int dist[];
    static ArrayList<Point> arrList[];
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        V = Integer.parseInt(st.nextToken());
        E = Integer.parseInt(st.nextToken());
        
        arrList = new ArrayList[V+1];
        dist = new int[V+1];
        for(int i=1; i<=V; i++)
            arrList[i] = new ArrayList<>();
        for(int i=1; i<=V; i++)
            dist[i] = INF;
        
        Start = Integer.parseInt(br.readLine());
        dist[Start] = 0;
        
        for(int e=0; e<E; e++) {
            st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());
            int v = Integer.parseInt(st.nextToken());
            int val = Integer.parseInt(st.nextToken());
            arrList[u].add(new Point(v, val));
        }
        solve();
        for(int i=1; i<=V; i++) {
            if(dist[i] == INF)
                System.out.println("INF");
            else
                System.out.println(dist[i]);
        }
    }
    
    public static void solve() {
        PriorityQueue<Point> pq = new PriorityQueue<>();
        
        // PriorityQueue = (Vertex, weight)
        pq.add(new Point(Start, 0));
        
        while(!pq.isEmpty()) {
            Point po = pq.poll();
            
            // 갱신하려고 하는 값이 PQ에서 poll한 노드의 값보다 작을 땐 갱신 X
            if(dist[po.vertex] < po.val)
                continue;
            
            // 현재 노드에 연결된 Vertex가 저장 된 ArrayList를 반복문을 통해 탐색하며 더 작은 값으로 갱신할 수 있다면 갱신하면서 PQ에 넣어준다.
            for(int i=0; i<arrList[po.vertex].size(); i++) {
                int tmpIndex = arrList[po.vertex].get(i).vertex;
                int tmpDist = po.val + arrList[po.vertex].get(i).val;
                
                if(dist[tmpIndex] > tmpDist) {
                    dist[tmpIndex] = tmpDist;
                    pq.add(new Point(tmpIndex, tmpDist));
                }
            }
        }
    }
    
    // 우선순위큐를 편하게 사용하기 위해 정렬기준 변경
    public static class Point implements Comparable<Point>{
        int vertex;
        int val;
        public Point(int v, int val) {
            this.vertex=v;
            this.val=val;
        }
        @Override
        public int compareTo(Point o) {
            if(this.val > o.val)
                return 1;
            // TODO Auto-generated method stub
            return 0;
        }
        
    }
}
 
cs

# 유형 : 재귀, DP

# 난이도 : 실버 1

# 1) 언제든지 왼쪽 카드를 버리거나 왼쪽,오른쪽 다 버리는 경우

   2) 왼쪽 값이 오른쪽 값보다 클 때 오른쪽 카드를 버리는 경우 로 나누어서 재귀함수로 구하면 된다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package bj;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class p10835 {
    static int N;
    static int A[],B[], dp[][];
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine());
        A = new int[N];
        B = new int[N];
        dp = new int[N][N];
        for(int i=0; i<N; i++) {
            for(int j=0; j<N; j++)
                dp[i][j] = -1;
        }
        StringTokenizer st = new StringTokenizer(br.readLine());
        for(int i=0; i<N; i++)
            A[i] = Integer.parseInt(st.nextToken());
        st = new StringTokenizer(br.readLine());
        for(int i=0; i<N; i++)
            B[i] = Integer.parseInt(st.nextToken());
        
        System.out.println(solve(0,0));
    }
    
//    언제든지 왼쪽 카드만 통에 버릴 수도 있고 왼쪽 카드와 오른쪽 카드를 둘 다 통에 버릴 수도 있다. 이때 얻는 점수는 없다.
//    오른쪽 카드에 적힌 수가 왼쪽 카드에 적힌 수보다 작은 경우에는 오른쪽 카드만 통에 버릴 수도 있다. 오른쪽 카드만 버리는 경우에는 오른쪽 카드에 적힌 수만큼 점수를 얻는다.
//    (1)과 (2)의 규칙에 따라 게임을 진행하다가 어느 쪽 더미든 남은 카드가 없다면 게임이 끝나며 그때까지 얻은 점수의 합이 최종 점수가 된다. 
    public static int solve(int left, int right) {
        if(left>=|| right>=N)
            return 0;
        
        if(dp[left][right] != -1)
            return dp[left][right];
        
        //언제든지 왼쪽 카드만 통에 버릴 수도 있고 왼쪽 카드와 오른쪽 카드를 둘 다 통에 버릴 수도 있다. 이때 얻는 점수는 없다.
        dp[left][right] = Math.max(solve(left+1, right), solve(left+1, right+1));
        
        //오른쪽 카드에 적힌 수가 왼쪽 카드에 적힌 수보다 작은 경우에는 오른쪽 카드만 통에 버릴 수도 있다. 오른쪽 카드만 버리는 경우에는 오른쪽 카드에 적힌 수만큼 점수를 얻는다.
        if(A[left] > B[right])
            dp[left][right] = Math.max(dp[left][right], B[right] + solve(left, right+1));
        
        return dp[left][right];
    }
}
 
 
cs

# 유형 : 탐색(BFS+DFS)

# 난이도 : 골드 4

# 주어진 바이러스 중 m개를 선택하는 것을 DFS 로, 선택한 M개의 바이러스를 퍼뜨리는 것을 BFS로 구현하면 된다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
package bj;
 
import java.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
 
public class p17142 {
    static int moveX[] = {0,1,0,-1};
    static int moveY[] = {-1,0,1,0};
    static int N,M,minValue = Integer.MAX_VALUE;
    static int arr[][];
    static ArrayList<Point> arrList = new ArrayList<>();
    static ArrayList<Integer> tmpList = new ArrayList<>();
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        
        arr = new int[N+1][N+1];
        for(int i=1; i<=N; i++) {
            st = new StringTokenizer(br.readLine());
            for(int j=1; j<=N; j++) {
                //0은 빈 칸, 1은 벽, 2는 바이러스의 위치이다.
                arr[i][j] = Integer.parseInt(st.nextToken());
                if(arr[i][j] == 2) {
                    arrList.add(new Point(j,i));
                }
            }
        }
        for(int i=0; i<arrList.size(); i++) {
            tmpList = new ArrayList<>();
            tmpList.add(i);
            comb(i);
        }
        
        if(minValue == Integer.MAX_VALUE)
            System.out.println(-1);
        else
            System.out.println(minValue);
        
    }
    private static void comb(int index) {
        if(tmpList.size() == M) {
            int result = bfs();
            if(result != -1 && minValue > result)
                minValue = result;
        }else {
            for(int v=index+1; v<arrList.size(); v++) {
                tmpList.add(v);
                comb(v);
                tmpList.remove(tmpList.size()-1);
            }
        }
    }
    public static boolean isPossible(int cp[][]) {
        for(int i=1; i<=N; i++) {
            for(int j=1; j<=N; j++) {
                if(cp[i][j] == 0)
                    return false;
            }
        }
        return true;
    }
    private static int bfs() {
        // TODO Auto-generated method stub
        Queue<Point> queue = new LinkedList<Point>();
        
        for(int i=0; i<M; i++) {
            int index = tmpList.get(i);
            queue.add(new Point(arrList.get(index).x , arrList.get(index).y));
        }
        int result=0;
        int temp=0;
        int cpArr[][] = new int[N+1][N+1];
        boolean visit[][] = new boolean[N+1][N+1];
        for(int i=1; i<=N; i++) {
            cpArr[i] = arr[i].clone();
        }
        
        while(!queue.isEmpty()) {
            int size = queue.size();
            boolean near = false;
            for(int i=0; i<size; i++) {
                Point po = queue.poll();
                int x = po.x;
                int y = po.y;
                
                visit[y][x] = true;
                
                for(int d=0; d<4; d++) {
                    int newX = x + moveX[d];
                    int newY = y + moveY[d];
                    
                    if(1<=newX && newX<=&& 1<=newY && newY<=N) {
                        if(!visit[newY][newX]) {
                            visit[newY][newX] = true;
                            if(arr[newY][newX] == 0) {
                                near = true;
                                cpArr[newY][newX] = 3;
                                queue.add(new Point(newX, newY));
                            }
                            if(arr[newY][newX] == 2) {
                                queue.add(new Point(newX, newY));
                            }
                        }
                    }
                }
            }
            
            if(!near) {
                temp++;
            }else {
                result += ++temp;
                temp = 0;
            }
        }
        
        if(!isPossible(cpArr))
            return -1;
        
        
        return result;
    }
}
 
cs

# 유형 : 시뮬레이션 + BFS

# 난이도 : 골드 V

# 코드 설명은 주석으로 써놨음. 캐릭터를 우선 9방향으로 이동가능한 곳으로 이동해준 다음 벽을 이동시켜주면 된다. 이 때 벽이 한개도 없다면 무조건 성공이다.

 

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
package bj;
 
import java.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
 
public class p16954 {
    static int moveX[] = {0,1,1,1,0,-1,-1,-1,0};
    static int moveY[] = {-1,-1,0,1,1,1,0,-1,0};
    static char arr[][];
    static Point start = new Point(1,8);
    static Queue<Point> Wall = new LinkedList<>();
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        arr = new char[9][9];
        for(int i=1; i<=8; i++) {
            String str = br.readLine();
            for(int j=1; j<=8; j++) {
                arr[i][j] = str.charAt(j-1);
                if(arr[i][j] == '#')
                    Wall.add(new Point(j,i));
            }
        }
        
        
        bfs();
    }
    
    private static void bfs() {
        // TODO Auto-generated method stub
        Queue<Point> queue = new LinkedList<Point>();
        queue.add(start);
        
        while(true) {
            // 욱제의 캐릭터를 갈 수 있는 곳 다 가주는 딘계
            while(!queue.isEmpty()) {
                Point po = queue.poll();
                if(po.x == 8 && po.y == 1) {
//                    System.out.println("here");
                    System.out.println("1");
                    return;
                }
                if(arr[po.y][po.x] == '#')
                    continue;
                
                // 상하좌우, 대각선, 제자리 
                for(int d=0; d<9; d++) {
                    int newY = po.y + moveY[d];
                    int newX = po.x + moveX[d];
                    
                    if(newY<1 || newY>8 || newX<1 || newX>8)
                        continue;
                    
                    //여기서 미리 queue에 넣어줘도 되긴 하는데 나중에 벽 움직이고 제거해줘야해서 뒤에서 하는 게 시간적으로 효율
                    if(arr[newY][newX] == '.')
                        arr[newY][newX] = '*';
                }
            }
            
            // 벽이 아예 없으면 무조건 도달할 수 있다.
            if(Wall.size() == 0){
//                System.out.println("another");
                System.out.println("1");
                return;
            }
            
            int len = Wall.size();
            for(int i=0; i<len; i++) {
                Point p = Wall.poll();
                if(p.y + 1 != 9) {
                    arr[p.y][p.x] = '.';
                    arr[p.y+1][p.x] = '#';
                    Wall.add(new Point(p.x, p.y+1));
                }
            }
            
            // 욱제의 캐릭터가 있는 위치를 큐에 넣는다
            for(int i=1; i<=8; i++) {
                for(int j=1; j<=8; j++) {
                    if(arr[i][j] == '*') {
                        queue.add(new Point(j,i));
                    }
                }
            }
            // 욱제 캐릭터가 없으면 불가능
            if(queue.size() == 0) {
                System.out.println(0);
                return;
            }
        }
    }
}
 
cs

# 유형 : 탐색 + 시뮬레이션

# 난이도 : 실버 4

# 브루트포스 문제였는데, 모든 배열의 값을 좌우, 상하로 바꾸면서 최댓값을 찾게 구현하면 된다. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
package bj;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class p3085 {
    static int N, result = Integer.MIN_VALUE;
    static char arr[][];
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine());
        arr = new char[N][N];
        for(int i=0; i<N; i++) {
            String str = br.readLine();
            for(int j=0; j<N; j++)
                arr[i][j] = str.charAt(j);
        }
        
        for(int i=0; i<N; i++) {
            for(int j=0; j<N-1; j++) {
                change(i,j,i,j+1);
                result = Math.max(result, solve());
                change(i,j,i,j+1);
            }
        }
        for(int j=0; j<N; j++) {
            for(int i=0; i<N-1; i++) {
                change(i,j,i+1,j);
                result = Math.max(result, solve());
                change(i,j,i+1,j);
            }
        }
        System.out.println(result);
    }
    private static int solve() {
        int rs = 1;
        // Compare Col value
        for(int i=0; i<N; i++) {
            int val = 1;
            for(int j=1; j<N; j++) {
                if(arr[i][j-1== arr[i][j]) {
                    val++;
                }else {
                    rs = Math.max(rs, val);
                    val = 1;
                }
            }
            rs = Math.max(rs, val);
        }
        for(int j=0; j<N; j++) {
            int val = 1;
            for(int i=1; i<N; i++) {
                if(arr[i-1][j] == arr[i][j]) {
                    val++;
                }else {
                    rs = Math.max(rs, val);
                    val = 1;
                }
            }
            rs = Math.max(rs, val);
        }
        return rs;
    }
    private static void change(int i, int j, int k, int l) {
        // TODO Auto-generated method stub
        char tmp = arr[i][j];
        arr[i][j] = arr[k][l];
        arr[k][l] = tmp;
    }
}
 
cs

# 유형 : 시뮬레이션

# 난이도 : 골드 3

# 다른 분들 코드 보니까 상어 클래스에 Comparable 구현해서 정렬도 하고 그러던데, 시뮬레이션은 각자 풀기 나름인듯 싶다. 시뮬레이션 풀 때마다 시간, 메모리 너무 과다하게 잡아먹어서 효율적으로 짜는 것도 연습해야겠다. 코드 설명은 주석을 달아 놓았음.

 

코드 순서

1. 낚시꾼을 오른쪽으로 한칸 이동(시작점은 0)

2. 이동한 지점을 기준으로 가장 가까운 상어를 찾는다. 

3. 상어를 큐에 넣고 조건에 맞게 이동시켜주고, 만약 상어가 이미 있다면 크기 비교 후 큰 상어만 남긴다.

> 2~3번 작업을 낚시꾼이 오른쪽 끝범위까지 갈때까지 반복한다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
package bj;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
 
public class p17143 {
    
    ///d가 1인 경우는 위, 2인 경우는 아래, 3인 경우는 오른쪽, 4인 경우는 왼쪽
    static int moveX[] = {0,0,0,1,-1};
    static int moveY[] = {0,-1,1,0,0};
    static int R ,C, M, result=0;
    static Shark[][] shark;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        R = Integer.parseInt(st.nextToken());
        C = Integer.parseInt(st.nextToken());
        M = Integer.parseInt(st.nextToken());
        shark = new Shark[R+1][C+1];
        for(int m=0; m<M; m++) {
            st = new StringTokenizer(br.readLine());
            int r = Integer.parseInt(st.nextToken());
            int c = Integer.parseInt(st.nextToken());
            int s = Integer.parseInt(st.nextToken());
            int d = Integer.parseInt(st.nextToken());
            int z = Integer.parseInt(st.nextToken());
            shark[r][c] = new Shark(s,d,z);
        }
        // 맨 왼쪽에서 시작
        int currentIndex = 0;
        for(int col=0; col<C; col++) {
            //시작하자마자 이동
            currentIndex++;
            for(int r=1; r<=R; r++) {
                // 현재 인덱스에서 가장 가까운 상어를 찾아서 result에 더한 후, break
                if(shark[r][currentIndex] != null) {
                    result += shark[r][currentIndex].z;
                    shark[r][currentIndex] = null;
                    break;
                }
            }
            // 상어를 큐에 넣고 이동을 위해 배열을 초기화시킨다.
            Queue<SharkMove> queue = new LinkedList<>();
            for(int i=1; i<=R; i++
                for(int j=1; j<=C; j++
                    if(shark[i][j] != null
                        queue.add(new SharkMove(i, j, shark[i][j].s, shark[i][j].d, shark[i][j].z));
                
            
            shark = new Shark[R+1][C+1];
            
            while(!queue.isEmpty()) {
                SharkMove sm = queue.poll();
                for(int s=0; s<sm.s; s++) {
                    /////d가 1인 경우는 위, 2인 경우는 아래, 3인 경우는 오른쪽, 4인 경우는 왼쪽
                    if(sm.d == 1 || sm.d == 2) {
                        int newY = sm.r + moveY[sm.d];
                        // 벽을 만나면 1은 2로 2는 1로 방향이 바뀐다. 이것을 처리해주기 위함 
                        if(!(1<=newY && newY<=R))
                            sm.d = 3 - sm.d;
                        sm.r += moveY[sm.d];
                    }else {
                        int newX = sm.c + moveX[sm.d];
                        // 벽을 만나면 3은 4로 4는 3로 방향이 바뀐다.
                        if(!(1<=newX && newX<=C))
                            sm.d = 7 - sm.d;
                        sm.c += moveX[sm.d];
                    }
                }
                // 만약 해당 위치에 이미 상어가 있다면 크기 비교후 큰 상어만 남긴다. 
                if(shark[sm.r][sm.c] != null) {
                    if(sm.z > shark[sm.r][sm.c].z) {
                        shark[sm.r][sm.c] = new Shark(sm.s, sm.d, sm.z);
                    }
                }else {
                    shark[sm.r][sm.c] = new Shark(sm.s, sm.d, sm.z);
                }
            }
        }
        System.out.println(result);
    }
    public static class SharkMove{
        int r;
        int c;
        int s;
        int d;
        int z;
        public SharkMove(int r,int c, int s, int d, int z) {
            this.r=r;
            this.c=c;
            this.s=s;
            this.d=d;
            this.z=z;
        }
    }
    public static class Shark{
        int s;
        int d;
        int z;
        public Shark(int s, int d, int z) {
            this.s=s;
            this.d=d;
            this.z=z;
        }
    }
}
 
cs

# 유형 : 시뮬레이션

# 난이도 : 골드 4

# 문제 이해하기가 제일 어려웠다.. 경사로 놓을 수 있는 조건과 그렇지 않은 조건만 잘 체크해준다면 어렵지 않게 풀 수 있다. 가로 세로 전부 다 구해줘야 하는 문제였다.

 

한 행 또는 한 열마다 구해주면 되는데, 배열을 두개 선언하여 편하게 사용하였다. 반복문을 통해 높이 차이가 1인 부분을 찾고 L만큼 가능한지를 체크하였다. 그리고 차이가 1인 경우와 -1인 경우로 나뉘는데 1인 경우는 왼쪽이 더 높은 경우(현재 인덱스부터 경사로 설치), -1 인 경우는 오른쪽이 더 높은 경우(다음 인덱스부터 경사로 설치)이다. L만큼 설치하면서, 이미 경사로가 설치되어있거나 높이 차이가 1 또는 -1 이 아니거나 범위를 벗어나면 해당 인덱스는 불가능 한 곳이다.

 

 

    <가능한 조건>

  • 경사로는 낮은 칸에 놓으며, L개의 연속된 칸에 경사로의 바닥이 모두 접해야 한다.
  • 낮은 칸과 높은 칸의 높이 차이는 1이어야 한다.
  • 경사로를 놓을 낮은 칸의 높이는 모두 같아야 하고, L개의 칸이 연속되어 있어야 한다.

  <불가능한 조건>

  • 경사로를 놓은 곳에 또 경사로를 놓는 경우
  • 낮은 칸과 높은 칸의 높이 차이가 1이 아닌 경우
  • 낮은 지점의 칸의 높이가 모두 같지 않거나, L개가 연속되지 않은 경우
  • 경사로를 놓다가 범위를 벗어나는 경우

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
package bj;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class p14890 {
    static int N,L,result = 0;
    static int arr[][],arr2[][];
    static boolean visit[];
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        L = Integer.parseInt(st.nextToken());
        
        arr = new int[N][N];
        arr2 = new int[N][N];
        
        for(int i=0; i<N; i++) {
            st = new StringTokenizer(br.readLine());
            for(int j=0; j<N; j++) {
                int val = Integer.parseInt(st.nextToken());
                arr[i][j] = val;
                arr2[j][i] = val;
            }
        }
        
        for(int i=0; i<N; i++) {
            solve(i, arr);
            solve(i, arr2);
        }
        System.out.println(result);
    }
    private static void solve(int index, int[][] array) {
        // TODO Auto-generated method stub
        visit = new boolean[N];
        
        for(int i=0; i<N-1; i++) {
            
            if(array[index][i] != array[index][i+1]) {
                int diff = array[index][i] - array[index][i+1];
                if(diff != -1 && diff != 1)
                    return;
                
                //왼쪽이 더 높은 경우 => 오른쪽으로 경사가 내려간다. L 만큼 경사로 설치, 현재 인덱스부터 설치
                if(diff == 1) {
                    for(int j=1; j<=L; j++) {
                        if(i+>= N || visit[i+j])
                            return;
                        
                        if(array[index][i] - 1 == array[index][i+j])
                            visit[i+j] = true;
                        else
                            return;
                    }
                }
                /// 오른쪽이 더 높은 경우 => 왼쪽으로 경사가 내려간다. L 만큼 경사로 설치, 다음 인덱스부터 설치
                else if(diff == -1) {
                    for(int j=0; j<L; j++) {
                        if(i<|| visit[i-j])
                            return;
                        
                        if(array[index][i] == array[index][i-j])
                            visit[i-j] = true;
                        else
                            return;
                    }
                }
            }
        }
        result++;
    }
}
 
cs

 

# 유형 : 시뮬레이션

# 난이도 : 브론즈 2

# 정답을 long 타입으로 하지 않으면 틀린다는 점만 생각하면 바로 풀 수 있던 문제

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package bj;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class p13458 {
    static int N,B,C;
    static int A[];
    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine());
        A = new int[N];
        StringTokenizer st = new StringTokenizer(br.readLine());
        for(int i=0; i<N; i++) {
            A[i] = Integer.parseInt(st.nextToken());
        }
        st = new StringTokenizer(br.readLine());
        B = Integer.parseInt(st.nextToken());
        C = Integer.parseInt(st.nextToken());
        
        long result = 0;
        
        for(int index=0; index < N; index++) {
            int num = A[index];
            
            if(num - B <= 0) {
                result++;
                continue;
            }else {
                num -= B;
                result++;
                
                if(num % C == 0)
                    result += num/C;
                else {
                    result += num/C;
                    result += 1;
                }
            }
//            System.out.println(result);
        }
        System.out.println(result);
    }
}
 
cs

+ Recent posts