Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
134 changes: 134 additions & 0 deletions problems/week09/Programmers_340210/DaewonKim/340210.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,134 @@
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>

using namespace std;

/*
1. 문자열 파싱

2. 수식 탐색. -> 2~9진법 까지 가능한 진법의 후보 추출
-> for base in 2~9까지
for e in expres
숫자를 모두 탐색
- if (현재 숫자가 base보다 크다면)
종료
- 모든 숫자가 base보다 작으므로,
- base 진법에 대한 수식을 실행.
- base 진법을 기반으로 stoi(숫자, nullptr, base)로 해서 10진법 변환
- 연산자 종료는 +, -만 있으므로 +면 그대로, 아니면 -실행.
- 결과 값과 수식 C의 값(10진법으로 변환한 후의 값)을 비교
- if( 값이 동일)
- 현재 진법은 가능하다는 뜻이므로, 진법 후보에 추가

3. X판별
- 가능한 진법이 1개라면 그 값을 X에 채움.
- 진법이 여러 개,
- 진법들에 대해서 result를 만듬.
- result가 같으면, 그 result를 반환
- 다르면, X를 그대로 설정.


*/

struct Expr {
string a, op, b, c; // A, 연산자(+/-), B, 결과 C ("X"일 수 있음)
};


/*
10진수 정수 n → base진법 문자열
stoi의 역방향은 표준 함수가 없으므로 직접 구현
예) toBase(6, 6) = "10", toBase(6, 7) = "6"
+
-> 표기를 특정 진법으로 해야하기 때문에.
*/
string toBase(int n, int base) {
if (n == 0) return "0";
string s;
while (n > 0) {
s += char('0' + n % base);
n /= base;
}
reverse(s.begin(), s.end());
return s;
}

/*

- stoi는 무효 숫자를 만나면 조용히 멈추므로 -> ex: (stoi("17", nullptr, 7) == 1)
- stoi함수를 사용하기 위해 아래 유효성을 만족하는지 체크하는 함수를 먼저 시행해야함.
- 현재 진법보다 숫자가 더 크다면, 그 진법으로 표현이 안되서
*/
bool validDigits(const string& s, int base) {
for (char ch : s) {
if (ch - '0' >= base) return false;
}
return true;
}

// A op B 를 base진법으로 계산해 10진수로 반환
int calc(const Expr& e, int base) {
int x = stoi(e.a, nullptr, base); // base진법 문자열 → 10진수
int y = stoi(e.b, nullptr, base);
return (e.op == "+") ? x + y : x - y;
}

vector<string> solution(vector<string> expressions) {
// 파싱
vector<Expr> exprs;
for (const string& line : expressions) {
stringstream ss(line);
Expr e;
string eq;
ss >> e.a >> e.op >> e.b >> eq >> e.c;
exprs.push_back(e);
}

// 가능한 진법 후보 찾기
vector<int> candidates;
for (int base = 2; base <= 9; ++base) {
bool ok = true;

// 현재 진법에 대해서 모든 수식을 순회하면서 비교.
for (const Expr& e : exprs) {
// base 진법의 숫자가 현재 수식의 숫자보다 더 작거나 같으면 불가.
// -> 6진법인데 숫자 7이 수식에 있다면, 불가능한 경우라고 판단.
if (!validDigits(e.a, base) || !validDigits(e.b, base)) { ok = false; break; }
if (e.c == "X") continue;
if (!validDigits(e.c, base)) { ok = false; break; }

// 위에서 유효성 검사를 통과했으므로 stoi가 안전하게 전체를 읽음
// base 진법으로 계산한 결과가 수식과 다르다면?
if (calc(e, base) != stoi(e.c, nullptr, base))
{
ok = false;
break;
}
}

// 모든 조건을 만족했으면 후보에 추가.
if (ok) candidates.push_back(base);
}

// X 채우기
vector<string> answer;
for (const Expr& e : exprs) {
// X인 것만 보기 위해 x가 아닌 건 건너뜀.
if (e.c != "X") continue;

// 결과를 각 진법의 "표기 문자열"로 비교
string result = "";
bool same = true;
for (int base : candidates) {
string r = toBase(calc(e, base), base);
if (result.empty()) result = r;
else if (result != r) { same = false; break; }
}

answer.push_back(e.a + " " + e.op + " " + e.b + " = " + (same ? result : "?"));
}

return answer;
}
99 changes: 99 additions & 0 deletions problems/week09/Programmers_340211/DaewonKim/340211.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,99 @@
#include <string>
#include <vector>
#include <algorithm>


using namespace std;

int solution(vector<vector<int>> points, vector<vector<int>> routes) {
int robotCount = (int)routes.size();

// robotPaths[robot][time] = time초에 robot이 있는 좌표 {row, col}
vector<vector<pair<int, int>>> robotPaths(robotCount);

for (int robot = 0; robot < robotCount; ++robot) {
// ---------- 출발 지점 ----------
int startPointId = routes[robot][0]; // 출발 지점 번호 (1부터 시작)
int startPointIndex = startPointId - 1; // points 벡터 인덱스 (0부터 시작)

// 시작 지점에 대한 좌표
int curRow = points[startPointIndex][0];
int curCol = points[startPointIndex][1];
robotPaths[robot].push_back({ curRow, curCol }); // time = 0

// ---------- 다음 목표 지점들을 차례로 이동 ----------
int routeLength = (int)routes[robot].size();
for (int routeOrder = 1; routeOrder < routeLength; ++routeOrder) {
int targetPointId = routes[robot][routeOrder];
int targetPointIndex = targetPointId - 1;

int targetRow = points[targetPointIndex][0];
int targetCol = points[targetPointIndex][1];

// row 이동을 먼저
while (curRow != targetRow) {
if (targetRow > curRow) {
curRow++;
}
else {
curRow--;
}
robotPaths[robot].push_back({ curRow, curCol });
}

// 그다음 col 이동
while (curCol != targetCol) {
if (targetCol > curCol) {
curCol++;
}
else {
curCol--;
}
robotPaths[robot].push_back({ curRow, curCol });
}
}
}


// 가장 긴 거리를 가진 로봇의 이동 시간 만큼 설정.
int maxTime = 0;
for (auto& path : robotPaths) {
maxTime = max(maxTime, (int)path.size());
}

// robotsAtCell[row][col] = 현재 시간에 (row, col)에 있는 로봇 수
vector<vector<int>> robotsAtCell(101, vector<int>(101, 0));
int dangerCount = 0;

for (int time = 0; time < maxTime; ++time) {
// 1) 현재 시간의 로봇 위치를 기록하고 위험 상황을 센다
for (int robot = 0; robot < robotCount; ++robot) {

// 이미 도착했다면
if (time >= robotPaths[robot].size())
continue;


int row = robotPaths[robot][time].first;
int col = robotPaths[robot][time].second;

robotsAtCell[row][col]++;
if (robotsAtCell[row][col] == 2) {
dangerCount++;
}
}

// 2) 기록한 칸만 0으로 되돌린다
for (int robot = 0; robot < robotCount; ++robot) {
// 이미 도착한 로봇은 제외
if (time >= (int)robotPaths[robot].size()) {
continue;
}
int row = robotPaths[robot][time].first;
int col = robotPaths[robot][time].second;
robotsAtCell[row][col] = 0;
}
}

return dangerCount;
}
83 changes: 83 additions & 0 deletions problems/week09/Programmers_340212/DaewonKim/340212.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,83 @@
#include <string>
#include <vector>
#include <algorithm>
#include <iostream>

using namespace std;

int n = 0;
long long maxLevel = 0;
long long minLevel = 0;

// 난이도, 소요 시간은 모두 양의 정수며, 숙련도도 양의 정수
// diff > level
// diff-level만큼 틀린다. + time_cur만큼의 시간을 사용한다.
// (diff-level) * (time_cur + time_prev) + time_cur

void binarySearch(int leftIdx, int rightIdx, vector<long long>& levels,
vector<int>& diffs, vector<int>& times, long long &limit)
{
if(leftIdx > rightIdx)
return;

long long midIdx = (leftIdx + rightIdx) /2;
long long curLevel = levels[midIdx];
long long totalTime =0;

for(int i=0; i<n; ++i)
{
long long prevTime = 0;
if(i > 0)
prevTime = times[i-1];
long long curDiff = diffs[i];
long long curTime = times[i];

if(curLevel >= curDiff)
totalTime += curTime;
else if (curLevel < curDiff)
{
// (diff-level) * (time_cur + time_prev) + time_cur
totalTime += (curTime + ((curTime+prevTime) * (curDiff-curLevel)) );
}

}
// 현재 수행한 레벨이 시간 내에 들어온다 -> 더 작은 레벨을 계산해본다.
if(totalTime <= limit)
{
// 시간 안에 들어왔는데 최소 레벨보다 현재 레벨이 더 작으면.
if(minLevel > curLevel)
{
minLevel = curLevel;
}
binarySearch(leftIdx, midIdx-1, levels, diffs, times, limit);

}
// totalTime > limit 시간 안에 수행 불가. -> 큰 레벨을 수행해본다
else
{
binarySearch(midIdx+1, rightIdx,levels, diffs, times, limit);
}

}

int solution(vector<int> diffs, vector<int> times, long long limit) {
int answer = 0;
n = (int)diffs.size(); // 퍼즐 n개
maxLevel = *max_element(diffs.begin(),diffs.end());
minLevel = maxLevel; // 초기 최소 숙련도는 최상으로 설정.

// 현재 가능한 maxLevel을 기준으로
// 이진 탐색으로 찾는다.
vector<long long> levels (maxLevel+1, 0);
for(int i=0; i<(int)levels.size(); ++i)
{
levels[i] = i;
}

long long leftIdx = 1;
long long rightIdx = (int)levels.size()-1;
binarySearch(leftIdx, rightIdx, levels, diffs, times, limit);
answer = minLevel;

return answer;
}
65 changes: 65 additions & 0 deletions problems/week09/Programmers_340213/DaewonKim/340213.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,65 @@
#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int toSec(string time)
{
int mm = stoi(time.substr(0, 2));
int ss = stoi(time.substr(3, 2));

return mm * 60 + ss;
}

string toTime(int time)
{
int mm = time / 60;
int ss = time % 60;

string result = "";

if(mm < 10) result += "0";
result += to_string(mm);

result += ":";

if(ss < 10) result += "0";
result += to_string(ss);

return result;
}

string solution(string video_len,string pos,string op_start,string op_end,vector<string> commands)
{
int videoLen = toSec(video_len);
int cur = toSec(pos);
int opStart = toSec(op_start);
int opEnd = toSec(op_end);

// 명령 실행 전에 현재 위치 검사
if(opStart <= cur && cur <= opEnd)
{
cur = opEnd;
}

for(string command : commands)
{
if(command == "prev")
{
cur = max(0, cur - 10);
}
else if(command == "next")
{
cur = min(videoLen, cur + 10);
}

// 명령 실행 후 오프닝 검사
if(opStart <= cur && cur <= opEnd)
{
cur = opEnd;
}
}

return toTime(cur);
}
Loading