[11월 12일] 투포인터

11_투포인터/도전/20437.cpp

@@ -0,0 +1,64 @@
+#include <iostream>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <climits>
+
+using namespace std;
+
+pair<int, int> findMinMaxLengths(const string& w, int k) {
+    int min_length = INT_MAX;
+    int max_length = -1;
+
+    // 각 문자의 위치를 저장
+    vector<vector<int>> char_positions(26);
+
+    // 각 문자의 위치를 char_positions에 저장
+    for (int i = 0; i < w.size(); i++) {
+        char_positions[w[i] - 'a'].push_back(i);
+    }
+
+    // 각 문자별 위치 리스트에서 K개씩 연속한 위치 간의 거리 계산
+    for (int i = 0; i < 26; i++) {
+        if (char_positions[i].size() < k) continue; // 해당 문자가 K번 미만 등장 시 건너뜀
+
+        // 해당 문자의 위치에서 K개 연속 부분 문자열의 길이 계산
+        for (int j = 0; j <= char_positions[i].size() - k; j++) {
+            int length = char_positions[i][j + k - 1] - char_positions[i][j] + 1;
+
+            min_length = min(min_length, length);
+            max_length = max(max_length, length);
+        }
+    }
+
+    // 가능한 문자열이 없을 경우 -1 반환
+    if (min_length == INT_MAX) min_length = -1;
+    if (max_length == -1) max_length = -1;
+
+    return {min_length, max_length};
+}
+
+int main() {
+    ios_base::sync_with_stdio(false); 
+    cin.tie(NULL);
+
+    int t;
+    cin >> t;
+
+    while (t--) {
+        string w;
+        int k;
+        cin >> w >> k;
+
+        pair<int, int> result = findMinMaxLengths(w, k);
+
+        // 둘 다 -1일 경우 단일 -1만 출력
+        if (result.first == -1 && result.second == -1) {
+            cout << -1 << '\n';
+        } else {
+            cout << result.first << " " << result.second << '\n';
+        }
+    }
+
+    return 0;
+}

11_투포인터/도전/2473.cpp

@@ -0,0 +1,62 @@
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <cmath> // math.h 대신 cmath 사용
+
+using namespace std;
+
+vector<long long> findClosestToZero(const vector<long long>& arr, int num) {
+    long long result = 3000000001; // 초기값 설정 (0에 가까운 값을 찾기 위해)
+    vector<long long> ans(3); // 결과를 저장할 벡터
+
+    // 배열을 오름차순으로 정렬
+    vector<long long> sorted_arr = arr;
+    sort(sorted_arr.begin(), sorted_arr.end());
+
+    // 첫 번째 포인터(k)를 고정하고, 두 번째 포인터(l)와 세 번째 포인터(r)를 사용해 탐색
+    for (int k = 0; k < num - 2; k++) {
+        int l = k + 1;
+        int r = num - 1;
+
+        while (l < r) {
+            long long val = sorted_arr[k] + sorted_arr[l] + sorted_arr[r];
+
+            // 절대값을 비교하여 0에 더 가까운 값을 찾으면 결과 갱신
+            if (abs(val) < result) {
+                result = abs(val);
+                ans[0] = sorted_arr[k];
+                ans[1] = sorted_arr[l];
+                ans[2] = sorted_arr[r];
+            }
+
+            // 합이 0 미만: 왼쪽 포인터 이동
+            if (val < 0) {
+                l++;
+            }
+            // 합이 0 이상: 오른쪽 포인터 이동
+            else {
+                r--;
+            }
+        }
+    }
+
+    return ans; // 최종 결과 반환
+}
+
+int main() {
+
+    int num;
+    cin >> num;
+
+    vector<long long> arr(num);
+    for (int i = 0; i < num; i++)
+        cin >> arr[i];
+
+    // findClosestToZero 함수를 호출
+    vector<long long> result = findClosestToZero(arr, num);
+
+    // 오름차순 정렬된 결과만 출력
+    cout << result[0] << " " << result[1] << " " << result[2] << '\n';
+
+    return 0;
+}

11_투포인터/필수/14503.cpp

@@ -0,0 +1,89 @@
+#include <iostream>
+#include <vector>
+
+using namespace std;
+
+int n, m; // 방의 크기 N x M
+int r, c, d;
+
+vector<vector<int>> room; // 방의 상태를 나타내는 2차원 벡터
+vector<vector<bool>> cleaned; // 청소 여부를 표시하는 2차원 벡터
+
+// 북, 동, 남, 서 방향에 대한 행/열 이동값 설정
+const int DR[4] = {-1, 0, 1, 0}; // 방향에 따른 행 이동
+const int DC[4] = {0, 1, 0, -1}; // 방향에 따른 열 이동
+
+// 방향을 반시계 방향으로 회전시키는 함수
+int rotateLeft(int direction) {
+    return (direction + 3) % 4; // 왼쪽으로 90도 회전
+}
+
+// 현재 방향에서 후진할 위치를 계산하는 함수
+pair<int, int> moveBackward(int row, int col, int direction) {
+    int back_dir = (direction + 2) % 4; // 현재 방향에서 뒤쪽 방향 계산
+    return {row + DR[back_dir], col + DC[back_dir]}; // 후진 위치 반환
+}
+
+// 방을 청소하고, 청소한 칸의 개수를 반환하는 함수
+int cleanRoom() {
+    int cleaned_count = 0; // 청소한 칸의 개수를 저장할 변수
+
+    while (true) {
+        // 1. 현재 위치를 청소
+        if (!cleaned[r][c]) { // 현재 칸이 청소되지 않았으면
+            cleaned[r][c] = true; // 청소 상태로 변경
+            cleaned_count++; // 청소한 칸 개수 증가
+        }
+
+        bool found_cleanable = false; // 청소 가능한 칸을 찾았는지 여부
+
+        // 2. 주변 4칸을 확인하며 청소할 칸을 탐색
+        for (int i = 0; i < 4; i++) {
+            d = rotateLeft(d);
+            int new_row = r + DR[d];
+            int new_col = c + DC[d];
+
+            // 청소되지 않은 빈 칸이 있는 경우 이동
+            if (new_row >= 0 && new_row < n && new_col >= 0 && new_col < m && !cleaned[new_row][new_col] && room[new_row][new_col] == 0) {
+                r = new_row; // 청소 가능한 위치로 이동
+                c = new_col;
+                found_cleanable = true;
+                break; // 청소 가능한 칸을 찾았으므로 4방향 탐색 종료
+            }
+        }
+
+        // 3. 주변에 청소할 빈 칸이 없는 경우
+        if (!found_cleanable) {
+            auto [back_row, back_col] = moveBackward(r, c, d);
+            if (room[back_row][back_col] == 1) { // 후진하려는 위치가 벽인 경우
+                break;
+            }
+            r = back_row; // 후진 가능하면 후진
+            c = back_col;
+        }
+    }
+    return cleaned_count; // 청소한 칸의 개수 반환
+}
+
+int main() {
+    ios::sync_with_stdio(false);
+    cin.tie(NULL);
+
+    // 방의 크기를 입력 받는다.
+    cin >> n >> m;
+    // 처음에 로봇 청소기가 있는 칸의 좌표 (r,c), 방향 d
+    cin >> r >> c >> d;
+
+    room.resize(n, vector<int>(m)); // 방 상태를 저장할 벡터 크기 설정
+    cleaned.resize(n, vector<bool>(m, false)); // 청소 여부를 저장할 벡터 설정
+
+    // 방의 상태 입력
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < m; j++) {
+            cin >> room[i][j];
+        }
+    }
+
+    cout << cleanRoom() << '\n'; // 청소한 칸의 개수 출력
+    return 0;
+}