개발자P의 코딩일기

앱스토어 개인정보처리방침 - Track Pod

개발자P — Sat, 17 May 2025 22:34:37 +0900

Privacy Policy

Last updated: May 17, 2025

This Privacy Policy describes Our policies and procedures on the collection, use and disclosure of Your information when You use the Service and tells You about Your privacy rights and how the law protects You.

We use Your Personal data to provide and improve the Service. By using the Service, You agree to the collection and use of information in accordance with this Privacy Policy. This Privacy Policy has been created with the help of the Free Privacy Policy Generator.

Interpretation and Definitions

Interpretation

The words of which the initial letter is capitalized have meanings defined under the following conditions. The following definitions shall have the same meaning regardless of whether they appear in singular or in plural.

Definitions

For the purposes of this Privacy Policy:

Account means a unique account created for You to access our Service or parts of our Service.
Affiliate means an entity that controls, is controlled by or is under common control with a party, where "control" means ownership of 50% or more of the shares, equity interest or other securities entitled to vote for election of directors or other managing authority.
Application refers to Track Pod, the software program provided by the Company.
Company (referred to as either "the Company", "We", "Us" or "Our" in this Agreement) refers to Track Pod.
Country refers to: South Korea
Device means any device that can access the Service such as a computer, a cellphone or a digital tablet.
Personal Data is any information that relates to an identified or identifiable individual.
Service refers to the Application.
Service Provider means any natural or legal person who processes the data on behalf of the Company. It refers to third-party companies or individuals employed by the Company to facilitate the Service, to provide the Service on behalf of the Company, to perform services related to the Service or to assist the Company in analyzing how the Service is used.
Usage Data refers to data collected automatically, either generated by the use of the Service or from the Service infrastructure itself (for example, the duration of a page visit).
You means the individual accessing or using the Service, or the company, or other legal entity on behalf of which such individual is accessing or using the Service, as applicable.

Collecting and Using Your Personal Data

Types of Data Collected

Personal Data

While using Our Service, We may ask You to provide Us with certain personally identifiable information that can be used to contact or identify You. Personally identifiable information may include, but is not limited to:

Usage Data

Usage Data

Usage Data is collected automatically when using the Service.

Usage Data may include information such as Your Device's Internet Protocol address (e.g. IP address), browser type, browser version, the pages of our Service that You visit, the time and date of Your visit, the time spent on those pages, unique device identifiers and other diagnostic data.

When You access the Service by or through a mobile device, We may collect certain information automatically, including, but not limited to, the type of mobile device You use, Your mobile device unique ID, the IP address of Your mobile device, Your mobile operating system, the type of mobile Internet browser You use, unique device identifiers and other diagnostic data.

We may also collect information that Your browser sends whenever You visit our Service or when You access the Service by or through a mobile device.

Information Collected while Using the Application

While using Our Application, in order to provide features of Our Application, We may collect, with Your prior permission:

Pictures and other information from your Device's camera and photo library

We use this information to provide features of Our Service, to improve and customize Our Service. The information may be uploaded to the Company's servers and/or a Service Provider's server or it may be simply stored on Your device.

You can enable or disable access to this information at any time, through Your Device settings.

Use of Your Personal Data

The Company may use Personal Data for the following purposes:

To provide and maintain our Service, including to monitor the usage of our Service.
To manage Your Account: to manage Your registration as a user of the Service. The Personal Data You provide can give You access to different functionalities of the Service that are available to You as a registered user.
For the performance of a contract: the development, compliance and undertaking of the purchase contract for the products, items or services You have purchased or of any other contract with Us through the Service.
To contact You: To contact You by email, telephone calls, SMS, or other equivalent forms of electronic communication, such as a mobile application's push notifications regarding updates or informative communications related to the functionalities, products or contracted services, including the security updates, when necessary or reasonable for their implementation.
To provide You with news, special offers and general information about other goods, services and events which we offer that are similar to those that you have already purchased or enquired about unless You have opted not to receive such information.
To manage Your requests: To attend and manage Your requests to Us.
For business transfers: We may use Your information to evaluate or conduct a merger, divestiture, restructuring, reorganization, dissolution, or other sale or transfer of some or all of Our assets, whether as a going concern or as part of bankruptcy, liquidation, or similar proceeding, in which Personal Data held by Us about our Service users is among the assets transferred.
For other purposes: We may use Your information for other purposes, such as data analysis, identifying usage trends, determining the effectiveness of our promotional campaigns and to evaluate and improve our Service, products, services, marketing and your experience.

We may share Your personal information in the following situations:

With Service Providers: We may share Your personal information with Service Providers to monitor and analyze the use of our Service, to contact You.
For business transfers: We may share or transfer Your personal information in connection with, or during negotiations of, any merger, sale of Company assets, financing, or acquisition of all or a portion of Our business to another company.
With Affiliates: We may share Your information with Our affiliates, in which case we will require those affiliates to honor this Privacy Policy. Affiliates include Our parent company and any other subsidiaries, joint venture partners or other companies that We control or that are under common control with Us.
With business partners: We may share Your information with Our business partners to offer You certain products, services or promotions.
With other users: when You share personal information or otherwise interact in the public areas with other users, such information may be viewed by all users and may be publicly distributed outside.
With Your consent: We may disclose Your personal information for any other purpose with Your consent.

Retention of Your Personal Data

The Company will retain Your Personal Data only for as long as is necessary for the purposes set out in this Privacy Policy. We will retain and use Your Personal Data to the extent necessary to comply with our legal obligations (for example, if we are required to retain your data to comply with applicable laws), resolve disputes, and enforce our legal agreements and policies.

The Company will also retain Usage Data for internal analysis purposes. Usage Data is generally retained for a shorter period of time, except when this data is used to strengthen the security or to improve the functionality of Our Service, or We are legally obligated to retain this data for longer time periods.

Transfer of Your Personal Data

Your information, including Personal Data, is processed at the Company's operating offices and in any other places where the parties involved in the processing are located. It means that this information may be transferred to — and maintained on — computers located outside of Your state, province, country or other governmental jurisdiction where the data protection laws may differ than those from Your jurisdiction.

Your consent to this Privacy Policy followed by Your submission of such information represents Your agreement to that transfer.

The Company will take all steps reasonably necessary to ensure that Your data is treated securely and in accordance with this Privacy Policy and no transfer of Your Personal Data will take place to an organization or a country unless there are adequate controls in place including the security of Your data and other personal information.

Delete Your Personal Data

You have the right to delete or request that We assist in deleting the Personal Data that We have collected about You.

Our Service may give You the ability to delete certain information about You from within the Service.

You may update, amend, or delete Your information at any time by signing in to Your Account, if you have one, and visiting the account settings section that allows you to manage Your personal information. You may also contact Us to request access to, correct, or delete any personal information that You have provided to Us.

Please note, however, that We may need to retain certain information when we have a legal obligation or lawful basis to do so.

Disclosure of Your Personal Data

Business Transactions

If the Company is involved in a merger, acquisition or asset sale, Your Personal Data may be transferred. We will provide notice before Your Personal Data is transferred and becomes subject to a different Privacy Policy.

Law enforcement

Under certain circumstances, the Company may be required to disclose Your Personal Data if required to do so by law or in response to valid requests by public authorities (e.g. a court or a government agency).

Other legal requirements

The Company may disclose Your Personal Data in the good faith belief that such action is necessary to:

Comply with a legal obligation
Protect and defend the rights or property of the Company
Prevent or investigate possible wrongdoing in connection with the Service
Protect the personal safety of Users of the Service or the public
Protect against legal liability

Security of Your Personal Data

The security of Your Personal Data is important to Us, but remember that no method of transmission over the Internet, or method of electronic storage is 100% secure. While We strive to use commercially acceptable means to protect Your Personal Data, We cannot guarantee its absolute security.

Children's Privacy

Our Service does not address anyone under the age of 13. We do not knowingly collect personally identifiable information from anyone under the age of 13. If You are a parent or guardian and You are aware that Your child has provided Us with Personal Data, please contact Us. If We become aware that We have collected Personal Data from anyone under the age of 13 without verification of parental consent, We take steps to remove that information from Our servers.

If We need to rely on consent as a legal basis for processing Your information and Your country requires consent from a parent, We may require Your parent's consent before We collect and use that information.

Links to Other Websites

Our Service may contain links to other websites that are not operated by Us. If You click on a third party link, You will be directed to that third party's site. We strongly advise You to review the Privacy Policy of every site You visit.

We have no control over and assume no responsibility for the content, privacy policies or practices of any third party sites or services.

Changes to this Privacy Policy

We may update Our Privacy Policy from time to time. We will notify You of any changes by posting the new Privacy Policy on this page.

We will let You know via email and/or a prominent notice on Our Service, prior to the change becoming effective and update the "Last updated" date at the top of this Privacy Policy.

You are advised to review this Privacy Policy periodically for any changes. Changes to this Privacy Policy are effective when they are posted on this page.

Contact Us

If you have any questions about this Privacy Policy, You can contact us:

By email: float@kakao.com

'그래프 탐색' 문제 풀이(DFS, BFS) | 백준 Swift 2606번, 1260번

개발자P — Wed, 12 Feb 2025 22:57:16 +0900

약간의 몸풀기 수학챕터를 어느정도 풀었고...

이제는 메인 문제 타입 중 하나인 DFS, BFS를 풀 차례다.

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

25.02.12 업데이트

25.02.16 업데이트

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

백준 Swift 2606번

문제 유형 : DFS

난이도 : 실버3

// MARK: - 2606번(DFS)
let M = Int(readLine()!)!
let N = Int(readLine()!)!

var board: [[Int]] = Array(repeating: Array(repeating: 0, count: M + 1), count: M + 1)
var visited = Array(repeating: false, count: M + 1)

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (y, x) = (input[0], input[1])
    
    board[y][x] = 1
    board[x][y] = 1
}

func dfs(_ index: Int) {
    
    for next in 1...M {
        if board[index][next] == 1 && visited[next] == false {
            visited[next] = true
            dfs(next)
        }
    }
}

dfs(1) // 1번컴퓨터 감염 시작
visited[1] = false // 1번컴퓨터는 제외
print(visited.filter{$0 == true}.count)

백준 Swift 1260번

문제 유형 : DFS, BFS

난이도 : 실버2

// MARK: - 1260번(DFS, BFS)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M, V) = (input[0], input[1], input[2])

var board: [[Int]] = Array(repeating: Array(repeating: 0, count: N + 1), count: N + 1)
var visited: [Bool] = Array(repeating: false, count: N + 1)
//var visited: [[Bool]] = Array(repeating: Array(repeating: false, count: N + 1), count: N + 1)

for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (y, x) = (input[0], input[1])
    board[y][x] = 1
    board[x][y] = 1
}

var answerDFS: [Int] = [V] // V는 무조건 첫방문

func dfs(_ index: Int) {
    visited[index] = true
    
    for next in 1...N {
        if board[index][next] == 1 && visited[next] == false { // 연결되어 있고, 미방문이면,
            visited[next] = true
            answerDFS.append(next)
            
            dfs(next)
        }
    }
}
dfs(V)

class Deque<T> {
    var enQue: [T]
    var deQue: [T] = []
    
    var count: Int {
        return enQue.count + deQue.count
    }
    
    var isEmpty: Bool {
        return enQue.isEmpty && deQue.isEmpty
    }
    
    init(_ que: [T]) {
        self.enQue = que
    }
    
    func pushFirst(_ element: T) {
        deQue.append(element)
    }
    
    func pushLast(_ element: T) {
        enQue.append(element)
    }
    
    func popFirst() -> T {
        if deQue.isEmpty {
            deQue = enQue.reversed()
            enQue.removeAll()
        }
        return deQue.popLast()!
    }
    
    func popLast() -> T {
        if enQue.isEmpty {
            enQue = deQue.reversed()
            deQue.removeAll()
        }
        return enQue.popLast()!
    }
}

visited = Array(repeating: false, count: N + 1)
var myDeque = Deque([V])
var answerBFS: [Int] = []

func BFS(_ index: Int) {
    visited[index] = true
    
    while !myDeque.isEmpty {
        let currentY = myDeque.popFirst()
        answerBFS.append(currentY)
        
        for next in 1...N {
            if board[currentY][next] == 1 && visited[next] == false {
                myDeque.pushLast(next)
                visited[next] = true
            }
        }
    }
}

BFS(V)
print(answerDFS.map{String($0)}.joined(separator: " "))
print(answerBFS.map{String($0)}.joined(separator: " "))

'수학' 문제 풀이 모음 | 백준 Swift 2581번, 22864번, 1978번, 2745번, 5618번, 1110번, 11653번, 1934번, 2609번, 5347번, 1747번

개발자P — Sat, 11 Jan 2025 22:02:48 +0900

PS 문제를 다시 시작한다. 한동안 안풀었더니 다 까먹었다.

매일매일 조금씩 실력을 갈고 닦아야 좋은 기회가 왔을 때 잡을 수 있으니...

블로그도 겸사겸사 다시 작성한다는 마음으로 시작하니까 부담은 적은 것 같다. 시작이 반이라는 말이 있으니깐.

우선은 오늘은 감을 익히기 위해 '수학' 파트를 풀려고 한다.

앞으로 매일매일은 아니더라도, 꾸준히 문제를 풀 예정이다. DP, DFS, BFS ... KMP 까지도 가야 한다.

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

25.01.11 업데이트

25.01.18 업데이트

25.02.09 업데이트

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

백준 Swift 2581번

문제 유형 : 수학

난이도 : 브론즈 2

'에라토스테네스의 체' 사용

단, 숫자가 커지면 메모리때문에 단일 숫자 소수 체크 사용하여야 함. (for i in 2..<Int(Sqrt(Double(n)) + 1)

// MARK: - 2581번
import Foundation

let M = Int(readLine()!)!
let N = Int(readLine()!)!

var isPrimary = [0] + Array(repeating: 0, count: N)

if N == 1 {
    print(-1)
    exit(0)
}

for i in 2...N {
    isPrimary[i] = i
}

for i in 2...N {
    if isPrimary[i] == 0 {
        continue
    }
    for j in stride(from: i*2, through: N, by: i) {
        isPrimary[j] = 0
    }
}

let sum = Array(isPrimary[M...N]).filter{$0 != 0}.reduce(0, +)
if sum == 0 {
    print(-1)
}
else {
    print(sum)
    let min = Array(isPrimary[M...N]).filter{$0 != 0}.first!
    print(min)
}

백준 Swift 22864번

문제 유형 : 수학

난이도 : 브론즈2

// MARK: - 22864번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (A, B, C, M) = (input[0], input[1], input[2], input[3])

var (tired, worked) = (0, 0)

for _ in 1...24 {
    if (tired + A) <= M { // 일 가능
        tired += A
        worked += B
    }
    else { // 일 불가능
        tired -= C
        if tired < 0 { tired = 0 } // 단, 피로도가 음수가 될 순 없음.
    }
}

print(worked)

백준 Swift 1978번

문제 유형 : 수학

난이도 : 브론즈2

// MARK: - 1978번
import Foundation
let N = Int(readLine()!)!
let input = readLine()!.split(separator: " ").map{Int(String($0))!}

func isPrimary(_ n: Int) -> Bool {
    if n < 2 {
        return false
    }
    for i in 2..<Int(sqrt(Double(n)) + 1) {
        if n % i == 0 {
            return false
        }
    }
    return true
}

//func isPrimary(_ num: Int) -> Bool {
//    if num < 4 {
//        return num == 1 ? false : true
//    }
//    for i in 2...Int(sqrt(Double(num))) {
//        if num % i == 0 {
//            return false
//        }
//    }
//    return true
//}

print(input.filter{isPrimary($0) == true}.count)

백준 Swift 2745번

문제 유형 : 수학

난이도 : 브론즈 2

// MARK: - 2745번
import Foundation
let input = readLine()!.split(separator: " ").map{String($0)}
let (N, B) = (input[0], input[1])

let result = Int(N, radix: Int(B)!)! // B진수 -> 10진수로 변환
print(result)

백준 Swift 5618번

문제 유형 : 수학

난이도 : 브론즈2

// MARK: - 5618번
let n = Int(readLine()!)!
let input = readLine()!.split(separator: " ").map{Int(String($0))!}.sorted(by: <)
let lastNum = input.first!

var answer: [Int] = []

for i in 1...lastNum {
    var isCd = true // 공약수 체크 플래그
    for num in input {
        if num % i != 0 {
            isCd = false
            break
        }
    }
    if isCd {
        answer.append(i)
    }
}

for ans in answer {
    print(ans)
}

백준 Swift 1110번

문제 유형 : 수학

난이도 : 브론즈1

// MARK: - 1110번
var N = Int(readLine()!)!
let originalN = N
var count: Int = 0

while true {
    if N < 10 { // 한자리 수
        N = N * 10 + N
    }
    else { // 두자리 수
        let (A, B) = (N / 10, N % 10)
        N = (B * 10) + ((A + B) % 10)
    }
    count += 1
    
    if N == originalN {
        print(count)
        break
    }
}

백준 Swift 11653번

문제 유형 : 수학

난이도 : 브론즈1

// MARK: - 11653번
var N = Int(readLine()!)!

for i in stride(from: 2, to: N, by: 1) {
    while N % i == 0 { // i로 계속 나눠줌.
        N = N / i
        print(i)
    }
}

if N != 1 { // 맨 마지막이 소수라면 출력해줘야 함. ex) 7
    print(N)
}

백준 Swift 1934번

문제 유형 : 수학

난이도 : 브론즈1

// MARK: - 1934번(최소공배수)
let T = Int(readLine()!)!
for _ in 0..<T {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}.sorted(by: >)
    let (A, B) = (input[0], input[1])
    
    print(lcm(A, B))
}


func gcd(_ a: Int, _ b: Int) -> Int { // 최대공약수
    return b == 0 ? a : gcd(b, a % b)
}

func lcm(_ a: Int, _ b: Int) -> Int { // 최소공배수
    return a * b / gcd(a, b)
}

백준 Swift 2609번

문제 유형 : 수학

난이도 : 브론즈1

// MARK: - 2609번(최대공약수, 최소공배수)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}.sorted(by: >)
let (A, B) = (input[0], input[1])

print(gcd(A, B))
print(lcm(A, B))

func gcd(_ a: Int, _ b: Int) -> Int {
    return b == 0 ? a : gcd(b, a % b)
}

func lcm(_ a: Int, _ b: Int) -> Int {
    return a * b / gcd(a, b)
}

백준 Swift 5347번

문제 유형 : LCM

난이도 : 실버5

// MARK: - 5347번(LCM)
let n = Int(readLine()!)!

for _ in 0..<n {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (a, b) = (input[0], input[1])
    
    let answer = LCM(a, b)
    print(answer)
}

func GCD(_ a: Int, _ b: Int) -> Int {
    return b == 0 ? a : GCD(b, a % b)
}

func LCM(_ a: Int, _ b: Int) -> Int {
    return a * b / GCD(a, b)
}

백준 Swift 1747번

문제 유형 : 소수 & 팰린드롬

난이도 : 실버1

// MARK: - 1747번(소수 & 팰린드롬)
import Foundation
var N = Int(readLine()!)!

while true {
    if isPrime(N) && isPalindrom(N) {
        print(N)
        break
    }
    N = N + 1
}

func isPrime(_ num: Int) -> Bool {
    if num < 4 {
        return num == 1 ? false : true
    }
    
    for i in 2...Int(sqrt(Double(num))) {
        if num % i == 0 {
            return false
        }
    }
    
    return true
}

func isPalindrom(_ num: Int) -> Bool {
//    let numArray = Array(String(num))
    let numArray = String(num).map{$0}
    let length: Int = numArray.count
    var flag: Bool = true
    
    for i in 0..<length/2 {
        if numArray[i] != numArray[length - i - 1] {
            flag = false
            break
        }
    }
    
    
    return flag
}

앱스토어 개인정보처리방침

개발자P — Mon, 9 Sep 2024 23:53:15 +0900

Privacy Policy

This privacy policy applies to the 쿠키타워 app (hereby referred to as "Application") for mobile devices that was created by Sumin Park (hereby referred to as "Service Provider") as a Free service. This service is intended for use "AS IS".

Information Collection and Use

The Application collects information when you download and use it. This information may include information such as

Your device's Internet Protocol address (e.g. IP address)
The pages of the Application that you visit, the time and date of your visit, the time spent on those pages
The time spent on the Application
The operating system you use on your mobile device

The Application does not gather precise information about the location of your mobile device.

The Service Provider may use the information you provided to contact you from time to time to provide you with important information, required notices and marketing promotions.

For a better experience, while using the Application, the Service Provider may require you to provide us with certain personally identifiable information. The information that the Service Provider request will be retained by them and used as described in this privacy policy.

Third Party Access

Only aggregated, anonymized data is periodically transmitted to external services to aid the Service Provider in improving the Application and their service. The Service Provider may share your information with third parties in the ways that are described in this privacy statement.

The Service Provider may disclose User Provided and Automatically Collected Information:

as required by law, such as to comply with a subpoena, or similar legal process;
when they believe in good faith that disclosure is necessary to protect their rights, protect your safety or the safety of others, investigate fraud, or respond to a government request;
with their trusted services providers who work on their behalf, do not have an independent use of the information we disclose to them, and have agreed to adhere to the rules set forth in this privacy statement.

Opt-Out Rights

You can stop all collection of information by the Application easily by uninstalling it. You may use the standard uninstall processes as may be available as part of your mobile device or via the mobile application marketplace or network.

Data Retention Policy

The Service Provider will retain User Provided data for as long as you use the Application and for a reasonable time thereafter. If you'd like them to delete User Provided Data that you have provided via the Application, please contact them at float@kakao.com and they will respond in a reasonable time.

Children

The Service Provider does not use the Application to knowingly solicit data from or market to children under the age of 13.

The Service Provider does not knowingly collect personally identifiable information from children. The Service Provider encourages all children to never submit any personally identifiable information through the Application and/or Services. The Service Provider encourage parents and legal guardians to monitor their children's Internet usage and to help enforce this Policy by instructing their children never to provide personally identifiable information through the Application and/or Services without their permission. If you have reason to believe that a child has provided personally identifiable information to the Service Provider through the Application and/or Services, please contact the Service Provider (float@kakao.com) so that they will be able to take the necessary actions. You must also be at least 16 years of age to consent to the processing of your personally identifiable information in your country (in some countries we may allow your parent or guardian to do so on your behalf).

Security

The Service Provider is concerned about safeguarding the confidentiality of your information. The Service Provider provides physical, electronic, and procedural safeguards to protect information the Service Provider processes and maintains.

Changes

This Privacy Policy may be updated from time to time for any reason. The Service Provider will notify you of any changes to the Privacy Policy by updating this page with the new Privacy Policy. You are advised to consult this Privacy Policy regularly for any changes, as continued use is deemed approval of all changes.

This privacy policy is effective as of 2024-09-09

Your Consent

By using the Application, you are consenting to the processing of your information as set forth in this Privacy Policy now and as amended by us.

Contact Us

If you have any questions regarding privacy while using the Application, or have questions about the practices, please contact the Service Provider via email at float@kakao.com.

This privacy policy page was generated by App Privacy Policy Generator

Xcode 14.3 ver | “ld: building for iOS Simulator, but linking in dylib built for iOS, file for architecture arm64” 오류

개발자P — Wed, 7 Aug 2024 23:00:30 +0900

정말 오랜만에 글 쓴다.

현생이 바쁘다는 핑계로, 막상 쓰면 좋아할 걸 알면서도 귀찮아서 쓰지 않았던 것 같다.

요즘은 미뤄왔던 SwiftUI를 해보고 있다. 좀 더 미리 했으면 좋았을텐데...

아무튼, 회사에서 간단한 앱을 새롭게 만들어야 해서, 겸사겸사 SwiftUI로 프로젝트를 만들었다.

호기롭게 Xcode 14.3으로 시작후, 빌드했더니 아래와 같은 오류 로그를 맞이했다.

“ld: building for iOS Simulator, but linking in dylib built for iOS, file for architecture arm64”

Xcode 14.3을 Rosetta로 돌리면 해결될 것 같았다.

기존 다른 구버전의 Xcode들처럼 Xcode 앱 정보 들어가서 'Rosetta를 켜려'했지만,

없어서 찾아보니 Xcode 14.3부턴 Rosetta로 실행하기 버튼이 사라졌다고 한다...

> 다른 해결방법을 찾아보자.

[해결법]

1. Excluded Architectures 를 arm64로 세팅

상세 방법
: 프로젝트 TARGET > Build Settings > Excluded Architectures
> Debug > Any iOS Simulator SDK를 arm64로 설정한다.

해결 단계 1

참고 자료: https://velog.io/@manpkh95/ld-building-for-iOS-Simulator-but-linking-in-dylib-built-for-iOS-file-for-architecture-arm64

2. Pod파일 수정

상세 방법
: 아래와 같이 pod 내용 추가 후 > pod install

post_install do |installer|
   installer.pods_project.targets.each do |target|
      target.build_configurations.each do |config|
         config.build_settings['EXCLUDED_ARCHS[sdk=iphonesimulator*]'] = 'arm64'
      end
   end
end

해결 단계 2

참고 자료: https://velog.io/@jee/Xcode-%EB%B9%8C%EB%93%9C%EC%97%90%EB%9F%AC-Architecture-arm64

보통 2번까지 하면 된다는 사람들이 있는데, 난 3번까지 해야만 오류가 해결됐다.

나처럼 안되는 사람들은 3번까지 진행해보면 될 것이다..!

3. 'Show Rosetta Destinations' 켜기

상세 방법
: Xcode14.3 상단 > Product > Destination > Destination Architectures > Show Rosetta Destinations 선택.

이렇게 설정하고 나면, 시뮬레이터 이름들이 (Rosetta) 가 붙으면서 정상적으로 빌드가 될 것이다. (아래 사진 참고)

해결 단계 3

참고 자료: https://sarunw.com/posts/open-using-rosetta-in-xcode-14-3/

이렇게 단계 1 ~ 단계 3까지 진행하고 난 뒤, 다시 빌드 해보면 정상적으로 될 거예요.

만약 다른 방법으로 해결된 분이 있다면 공유 부탁드립니다.

Proportional UIView | UIView를 StackView에서 원하는 비율로 배분하는 방법(StackView Trick, Fill Proportionally, To allocate UIViews to the desired proportions in StackView)

개발자P — Thu, 30 Mar 2023 01:11:15 +0900

프로젝트를 진행하면서,

서버에서 내려주는 데이터를 비율에 맞게

UIView를 StackView에서 동적으로 그려야 하는 상황이 있었고, 이를 정리하고자 한다.

StackView의 "Fill Proportionally" 를 활용한 게시글이 거의 없어서 도움이 되었으면 좋겠다.

최종 결과물 - Proportional UIView in StackView

1. 서버에서 내려오는 데이터를 통해 뷰의 비율을 계산하는 로직에 대해 설명하고,

2. 비율 커스텀 UIView(Proportional UIView)를 StackView에 그리는 방법에 대해 설명하겠다.

1번은 코딩테스트 문제같은 곳에서 볼 수 있을 것 같기도 하고, 나와 비슷한 상황의 사람에게 도움이 될 것 같아 겸사 겸사 정리한다.

(오직 Proportional UIView만 궁금하신 분은 글 중하단으로 내려가길 바란다.)

관련 샘플 소스 프로젝트는 글 최하단에서 다운 받을 수 있습니다.

0. 큰 틀

테이블뷰의 cell에 있는 StackView에,

흔히 생각하는 엑셀 표(UIView)를 비율에 맞게 동적으로 그린다고 생각하면 될 것 같다.

1. 서버에서 제공되는 데이터

1. 열의 개수(=column)를 줌.

2. 데이터를 열의 개수에 맞게 줌. (단, 병합되어야 하는 열이면 데이터를 "merge" 라고 준다.)

예를 들어, 아래처럼 서버에서 데이터가 내려온다고 가정하자.

column = 4
data: [String] = ["40", "merge", "37", "99"]

그렇다면 StackView의 UIView들은 아래의 그림처럼 그려져야 할 것이다.

예시 설명 (2 : 1 : 1)

2. 비율 계산 로직

어떻게 그려져야 할지는 알겠다.

그렇다면 몇대 몇대 몇인지는... 어떻게 구현해야 할까?

현 상황을 정리해보자면,

초기 열(=column)의 개수를 전달받고 있고,

"merge"를 만나면 앞의 인덱스와 합쳐져야 한다.

계산 로직

1. 각 열의 비율을 저장할 배열을 생성한다. → proportionalValues = [1.0, 1.0, 1.0, 1.0]

2. for문을 거꾸로 접근한다.

3. 만약 데이터가 "merge"라면, 앞의 인덱스에 본인의 비율값을 넘겨주고 본인은 0.0으로 만든다.

이해를 돕기 위해 인덱스 순서대로 적어보자면,

[1.0, 1.0, 1.0, 1.0] → [1.0, 1.0, 1.0, 1.0] → [2.0, 0.0, 1.0, 1.0] → [2.0, 0.0, 1.0, 1.0]

따라서, [2.0, 0.0, 1.0, 1.0]이 되는 것이다.

(0값은 필터를 걸어주면) 최종 비율 2 : 1 : 1 이라는 결과를 얻을 수 있다!

var proportionalValues: [Double] = Array(repeating: 1.0, count: column) // 비율값 저장 배열.

for i in stride(from: column - 1, through: 0, by: -1) { // merge를 위해 역순으로 참조.
    if data[i] == "merge" {
        proportionalValues[i - 1] += proportionalValues[i] // 이전 열에 비중 합침.
        proportionalValues[i] = 0.0
    }
}

위 로직을 사용하면, 이런 case가 아니더라도 1:3:2 등 모든 case에 적용이 된다.

이해를 돕기 위해 한번 더 설명하면,

만약 내려오는 data = ["a", "q", "merge", "merge", "YY", "merge"] 라면,

[1.0, 1.0, 1.0, 1.0, 2.0, 0.0] → [1.0, 1.0, 1.0, 1.0, 2.0, 0.0] → [1.0, 1.0, 2.0, 0.0, 2.0, 0.0] → [1.0, 3.0, 0.0, 0.0, 2.0, 0.0] → [1.0, 3.0, 0.0, 0.0, 2.0, 0.0] → [1.0, 3.0, 0.0, 0.0, 2.0, 0.0]

(0값은 필터를 걸어주면) 최종 비율 1 : 3 : 2 이라는 원하는 결과를 얻을 수 있다!

(더 좋은 방법이 있다면 댓글로 공유해주시면 감사하겠습니다.)

3. Proportional UIView를 StackView에 그리는 방법

ProportionalUIView를 만드는 법은 간단하다.

아래의 커스텀 UIView를 생성 및 상속받고, (ProportionalUIView)

아래의 함수들을 호출해서, ( calculateProportional(), drawProportionalView() )

StackView 안에 들어가는 subView의 비율들만 지정해서 넣어주면 된다.

커스텀 UIView 생성(ProportionalUIView)

import UIKit

class ProportionalUIView: UIView {

    var width = 1.0
    
    override var intrinsicContentSize: CGSize {
        return CGSize(width: width, height: 1.0)
    }

}

비율 계산 함수 호출(calculateProportional)

func calculateProportional(_ column: Int, _ data: [String]) -> [Double] { // 비율 계산 함수
    var proportionalValues: [Double] = Array(repeating: 1.0, count: data.count)

    for i in stride(from: column - 1, through: 0, by: -1) { // merge를 위해 역순으로 참조.
        if data[i] == "merge" {
            proportionalValues[i - 1] += proportionalValues[i] // 이전 열에 비중 합침.
            proportionalValues[i] = 0.0
        }
    }
    return proportionalValues
}

stackview에 uiview 그리는 함수 호출(drawProportionalView)

func drawProportionalView(_ column: Int, _ proportionalValues: [Double]) {
    var proportionalSubViews: [ProportionalUIView] = [] // 비율대로 생성할 subViews 저장 배열.

    for i in 0..<column {
        let tempView: ProportionalUIView = ProportionalUIView()
        tempView.width = proportionalValues[i] // 비율만큼 비중 세팅.

        tempView.backgroundColor = UIColor(red: CGFloat(drand48()), green: CGFloat(drand48()), blue: CGFloat(drand48()), alpha: 1.0) // view 구분을 위해, 랜덤배경색 추가.

        proportionalSubViews.append(tempView) // 비율에 맞게 세팅된 tempView들 우선 저장.
    }

    let _ = proportionalSubViews.map { // 스택뷰에 tempView추가.
        stackView.addArrangedSubview($0)
    }
}

주의!

StackView의 설정 > Distribution > Fill Proportionally로 설정해야 한다. (우측 상단)

StackView 설정 - Fill Equally 설정.

그렇지 않으면 아래의 사진처럼 다 깨진다!! (오른쪽에 아주 좁게 다른 영역이 보이는가?)

StackView 설정 - Fill 설정 시

Proportional View 최종 결과물

StackView에서, (1 : 3 : 1) 의 원하는 비율대로 잘 나오는걸 확인할 수 있다.

Proportional View in StackView 최종 결과물 / 1 : 3 : 1

설명 겸 정리를 위해 만든 샘플 프로젝트 소스도 함께 첨부하며, 이번 글을 마친다.

ProportionalUIVIewSampleProject.zip

0.07MB

참고 자료1: https://spin.atomicobject.com/2017/02/07/uistackviev-proportional-custom-uiviews/

참고 자료2: https://stackoverflow.com/questions/46253248/uistackview-proportional-layout-with-only-intrinsiccontentsize

구글포토 내보내기 날짜 안 뜰 때 | 구글포토 .json 메타데이터 연동하기(맥 ver.) | (Google Photo Takeout Metadata json)

개발자P — Sun, 29 Jan 2023 20:45:14 +0900

구글 Photo의 용량이 슬슬 차기도 하고, 클라우드를 옮겨보고자 "구글포토 내보내기"를 진행했다.

제일 큰 단위인 50기가로 내보내기를 걸어두고 며칠을 기다렸다. (약 4일정도 소요)

다운 받은 압축파일들을 풀어보곤 놀랐다...

이 글에 찾아왔다면 나와 같은 상황일 것이다.

모든 사진의 정보가 날라갔다!!

정확히는, 모든 사진 & 영상의 정보(메타데이터)가 추출일자(혹은 다운일자)로 되어 있을 것이다.

.json 파일과 함께...

많은 검색을 통해 방법을 찾게 되어 공유한다. ( 구글포토 다운로드 날짜 날라갔을 때, 구글포토 날짜데이터가 안 떠요 등..ㅠ)

지금부터 구글포토 사진의 .json파일을 이용해서 각 사진에 원본 데이터를 적용시키는 방법을 소개한다. (Mac 버전)

생각보다 자료가 많지 않았다. 최신자료가 없기도 했고, Step by Step 설명은 아니었어서 내가 사용한 방법을 정리하고자 글을 쓴다.

1. 구글포토에서 내보내기를 한다.

50기가로 내보내기를 한다. 구글포토 내보내기 하는 방법은 다른 글이 많으니 참고. ( https://takeout.google.com/ )

2. 깃허브에 들어가서 소스 파일을 다운받는다.

https://github.com/SuminPark-developer/google-metadata-matcher

GitHub - SuminPark-developer/google-metadata-matcher: Google Photos takeout metada merger

Google Photos takeout metada merger. Contribute to SuminPark-developer/google-metadata-matcher development by creating an account on GitHub.

github.com

깃허브 - 코드 다운로드

"깃허브 접속 - Code - Download ZIP 클릭" 하면 코드를 다운받을 수 있다.

참고 자료 : https://www.reddit.com/r/googlephotos/comments/svv751/download_google_photos_with_all_metadata_at_once/

윈도우 버전 : https://github.com/anderbggo/GooglePhotosMatcher

3. 분할된 압축파일들을 하나의 폴더에 옮긴다.

편의를 위해, 내가 생성한 폴더명 기준으로 설명하겠다.

3-1. 데스크탑에 googlePhotoResult 폴더와 googlePhotos 폴더를 생성한다.
(google-metadata-matcher-master는 설명2번을 제대로 진행했다면 생성되어 있을 것이다.)

3-2. 데스크탑 - googlePhotos 폴더에 아래 사진과 같이 압축파일들을 옮긴다.

단, 주의사항! 압축 해제를 위한 넉넉한 용량이 있어야 한다.

데스크탑 - googlePhotos 폴더 - 압축파일들 옮김.

4. Terminal 앱 실행 - googlePhotos 폴더로 이동 - ditto 명령어 입력

4-1. Terminal 앱을 실행한다.
Terminal 앱은 커맨드+스페이스 -> Terminal을 입력하면 실행시킬 수 있다.

4-2. Terminal 앱에서 googlePhotos 폴더로 이동한다.

cd [googlePhotos_폴더_디렉토리]
// 대괄호 []는 제외
// cd와 [디렉토리] 사이에 공백 있음.

cd + 스페이스 바 + Finder에서 googlePhotos폴더를 drag&drop 하면 바로 입력할 수 있다.

위 설명이 이해되지 않는다면, 커맨드 명령어에 대한 다른 글을 보고 오길 바란다.

4-3. 아래 ditto 명령어를 입력한다.

ditto -x -k *.zip ./takeout_photos

일정 시간이 지나면 아래 사진처럼 'Google 포토' 하나의 폴더에 압축이 해제되었을 것이다.

ditto 명령어 - 결과.

5. Terminal 앱 -> google-metadata-matcher-master 폴더로 이동한다.

5-1. 4-2와 같은 방법으로,

cd + 스페이스 바 + Finder에서 google-metadata-matcher-master 폴더를 drag&drop 하면 바로 입력할 수 있다.

cd [google-metadata-matcher-master_폴더_디렉토리]
// 대괄호 []는 제외
// cd와 [디렉토리] 사이에 공백 있음.

5-2. 아래 "requirements.txt" 설치 명령어를 입력한다.

pip3 install -r requirements.txt

"requirements.txt" 설치.

6. 파이썬 코드를 실행하는 명령어를 입력한다.

python3 src/merge_metadata.py [Google 포토_폴더_디렉토리] [googlePhotoResult_폴더_디렉토리]
// 대괄호 []는 제외
// 공백 넣어야 함.

앞서 설명했던 4-2와 같은 방법으로 디렉토리를 입력해주면 된다.

디렉토리와 디렉토리 사이에 공백을 넣어야 하는 것도 주의해야 함!

제대로 입력했다면 아래 이미지와 같이 진행될 것이다!!

파일 1개씩 진행되기 때문에, 오랜 시간이 걸리니 켜두고 다른 일을 하는 걸 추천한다.

파이썬 코드 - 진행중

7. 진행 완료!

Failed가 많아보이지만... 실제론 거의 모든 데이터를 복구했다!

파이썬 코드 - 진행 완료.

지금까지 구글 포토 내보내기 이미지들의 날짜 데이터들을 복구하는 방법에 대해서 알아봤다.

많은 사진 & 영상의 메타데이터를 복구할 수 있었고, 생각보다 더 오랜 시간이 걸리는 작업이었다.

이 글이 많은 사람들에게 도움되었으면 좋겠다.

python3 src/merge_metadata.py [Google 포토_폴더_디렉토리] [googlePhotoResult_폴더_디렉토리] // 대괄호 []는 제외 // 공백 넣어야 함.

python3 src/merge_metadata.py [Google 포토_폴더_디렉토리] [googlePhotoResult_폴더_디렉토리] // 대괄호 []는 제외 // 공백 넣어야 함.

DFS, BFS | Graph Traversal(그래프 탐색) 문제 풀이 모음 | 2606번, 11725번, 2178번, 2667번, 14940번, 7576번,

개발자P — Thu, 24 Nov 2022 22:08:15 +0900

DFS, BFS 문제부터 우선적으로 풀어야 될 것 같다.

출제 빈도가 높기 때문에 가장 먼저 감을 익혀야 하는 문제 유형 중 하나라고 생각하기 때문이다.

풀면서 틈틈이 구현(2) 문제도 풀 예정이다. 생각보다 짬이 안난다. 문제 하나 푸는데 시간이 꽤 오래 걸리기 때문이다....

차차 문제 푸는 속도가 빨라지지 않을까 싶다.

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

22.11.24 업데이트

22.11.26 업데이트

22.11.29 업데이트

22.11.30 업데이트

22.12.05 업데이트

아래 깃허브 주소에서 모든 백준 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

그래프 탐색 문제 리스트

https://github.com/tony9402/baekjoon/tree/main/graph_traversal

그래프 탐색 문제 리스트

백준 Swift 2606번

문제 유형 : 그래프 탐색(DFS)

난이도 : 실버3

// MARK: - 2606번
let N = Int(readLine()!)!
let M = Int(readLine()!)!

var board: [[Int]] = Array(repeating: Array(repeating: 0, count: N + 1), count: N + 1)
var visited: [Bool] = Array(repeating: false, count: N + 1)

for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (y, x) = (input[0], input[1])
    board[y][x] = 1
    board[x][y] = 1
}

var count: Int = 0

func dfs(_ index: Int) { // 재귀
    for next in 1...N {
//        if next != index && board[index][next] == 1 && visited[next] == false { // 자기 자신 X, 인접하고, 미방문 시
        if board[index][next] == 1 && visited[next] == false { // 인접하고, 미방문 시
            visited[next] = true
            count += 1
            dfs(next)
        }
    }
}

visited[1] = true
dfs(1)
print(count)

백준 Swift 11725번

문제 유형 : 트리, DFS

난이도 : 실버2

[큐 풀이]

// MARK: - 11725번(참고 : https://t.ly/T01a)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}


let N = Int(readLine()!)!
var adj: [[Int]] = Array(repeating: [], count: N + 1) // 인접리스트

for _ in 0..<N-1 {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (a, b) = (input[0], input[1])
    
    adj[a].append(b)
    adj[b].append(a)
}

var parents = Array(repeating: -1, count: N + 1) // -1이면 미방문.
var myDeq: Dequeue<Int> = Dequeue([1])


while !myDeq.isEmpty {
    let index = myDeq.popFirst()
    
    for next in adj[index] {
        if parents[next] == -1 {
            parents[next] = index
            myDeq.pushLast(next)
        }
    }
}

for parent in parents[2...] {
    print(parent)
}

[DFS 풀이]

// MARK: - 11725번(DFS) // 참고 : https://t.ly/fvs-T
let N = Int(readLine()!)!
var adj: [[Int]] = Array(repeating: [], count: N + 1) // 인접행렬

for _ in 0..<N-1 {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (a, b) = (input[0], input[1])
    
    adj[a].append(b)
    adj[b].append(a)
}

var parents: [Int] = Array(repeating: -1, count: N + 1) // -1은 미방문.

func dfs(_ index: Int, _ p: Int) {
    parents[index] = p
//    print(parents)
    
    for next in adj[index] {
        if parents[next] == -1 {
            dfs(next, index)
        }
    }
}

dfs(1, 0)

for parent in parents[2...] {
    print(parent)
}

백준 Swift 2178번

문제 유형 : 최단거리 길찾기(BFS)

난이도 : 실버1

// MARK: - 2178번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}

let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var board: [[Int]] = Array(repeating: [], count: N + 1)
var visited: [[Bool]] = Array(repeating: Array(repeating: false, count: M + 1), count: N + 1)

for i in 1...N {
    board[i] = [0] + readLine()!.map{Int(String($0))!}
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (1 <= y && y <= N) && (1 <= x && x <= M)
}

func bfs(_ startY: Int, _ startX: Int) -> Int {
    visited[startY][startX] = true // 시작점 방문
    let q = Dequeue([(startY, startX, 1)])
    
    while !q.isEmpty {
        let (y, x, d) = q.popFirst()
        
        if y == N && x == M { // 목적지에 도달 시,
            return d
        }
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            let nd = d + 1
            if isValidCoord(ny, nx) && !visited[ny][nx] && board[ny][nx] == 1 { // 유효 범위이고, 미방문이고, 길이면,
                visited[ny][nx] = true
                q.pushLast((ny, nx, nd))
            }
            
        }
    }
    return -1 // 여기 올 일은 없음.
}

let answer = bfs(1, 1)
print(answer)

백준 Swift 2667번

문제 유형 : DFS / BFS

난이도 : 실버1

BFS 풀이

// MARK: - 2667번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}
let N = Int(readLine()!)!
var visited: [[Bool]] = Array(repeating: Array(repeating: false, count: N), count: N)
var board: [[Int]] = []
for _ in 0..<N {
    let input = readLine()!.map{Int(String($0))!}
    board.append(input)
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < N)
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]

func bfs(_ startY: Int, _ startX: Int) -> Int {
    visited[startY][startX] = true
    let q = Dequeue([(startY, startX)])
    var count: Int = 1
    
    while !q.isEmpty {
        let (y, x) = q.popFirst()
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            
            if isValidCoord(ny, nx) && !visited[ny][nx] && board[ny][nx] == 1 { // 유효범위고, 미방문상태고, 주택이 있으면, (유효범위부터 체크해야 index 에러 안생김.)
                visited[ny][nx] = true
                count += 1
                q.pushLast((ny, nx))
            }
        }
    }
    return count
}


var answers: [Int] = []
for y in 0..<N {
    for x in 0..<N {
        if board[y][x] == 1 && !visited[y][x] { // 집이 있고, 미방문이면,
            let answer = bfs(y, x)
            answers.append(answer)
        }
    }
}

answers.sort(by: <)
print(answers.count)
print(answers.map{String($0)}.joined(separator: "\n"))

DFS 풀이

// MARK: - 2667번(DFS)
let N = Int(readLine()!)!
var board: [[Int]] = []
board.append(Array(repeating: 0, count: N + 1))
var visited: [[Bool]] = Array(repeating: Array(repeating: false, count: N + 1), count: N + 1)

for _ in 0..<N {
    let input = readLine()!.map{Int(String($0))!}
    board.append([0] + input)
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (1 <= y && y <= N) && (1 <= x && x <= N)
}

var count: Int = 0
let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]
func dfs(_ y: Int, _ x: Int) {
    visited[y][x] = true
    count += 1
    
    for k in 0..<4 {
        let ny = y + dy[k]
        let nx = x + dx[k]
        
        if isValidCoord(ny, nx) && board[ny][nx] == 1 && !visited[ny][nx] {
            dfs(ny, nx)
        }
        
    }
    
    
}


var answers: [Int] = []
for y in 1...N {
    for x in 1...N {
        if board[y][x] == 1 && !visited[y][x] {
            dfs(y, x)
            answers.append(count)
            count = 0
        }
    }
}

answers.sort(by: <)
print(answers.count)
for answer in answers {
    print(answer)
}

백준 Swift 12940번

문제 유형 : BFS

난이도 : 실버1

호기롭게 풀었는데 시간초과가 났다. 왜 그런지 고민해봐도 잘 모르겠어서 다른 풀이를 참고했다.

각 인덱스 -> 목표지점까지 BFS를 돌렸었는데, 그렇게 하면 시간초과가 난다.

반대로 목표지점 -> 각 인덱스로 BFS를 돌리면 된다!

// MARK: - 14940번(BFS / 참고 : https://www.acmicpc.net/source/49390198)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}

let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (n, m) = (input[0], input[1])

var board: [[Int]] = []
board.append(Array(repeating: 0, count: m + 1))

var goal: (y: Int, x: Int) = (0, 0)
for y in 1...n {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    board.append([0] + input)
    for (x, num) in input.enumerated() {
        if num == 2 {
            goal = (y, x + 1) // 목표위치 저장.
        }
    }
}

var visited: [[Bool]] = Array(repeating: Array(repeating: false, count: m + 1), count: n + 1)

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (1 <= y && y <= n) && (1 <= x && x <= m)
}

var answers: [[Int]] = Array(repeating: Array(repeating: 0, count: m), count: n)

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]
func bfs(_ startY: Int, _ startX: Int) {
    visited[startY][startX] = true
    let q = Dequeue([(startY, startX, 0)])
    
    while !q.isEmpty {
        let (y, x, count) = q.popFirst()
        answers[y-1][x-1] = count
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            if isValidCoord(ny, nx) && (board[ny][nx] == 1 || board[ny][nx] == 2) && !visited[ny][nx] { // 유효 범위고, 갈 수 있는 땅이고, 미방문이면,
                visited[ny][nx] = true
                q.pushLast((ny, nx, count + 1))
            }
        }
    }
}

bfs(goal.y, goal.x) // goal을 기준으로 bfs를 돌림.

for y in 1...n {
    for x in 1...m {
        if !visited[y][x] && board[y][x] == 1 { // 원래 갈 수 있는 땅인데 도달할 수 없는 위치면,
            answers[y-1][x-1] = -1
        }
    }
}

for answer in answers {
    let temp = answer.map{String($0)}.joined(separator: " ")
    print(temp)
}

BFS 초기 풀이(시간초과)

// MARK: - 14940번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}

let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (n, m) = (input[0], input[1])

var board: [[Int]] = []
board.append(Array(repeating: 0, count: m + 1))

for _ in 0..<n {
    board.append([0] + readLine()!.split(separator: " ").map{Int(String($0))!})
}

var visited: [[Bool]] = Array(repeating: Array(repeating: false, count: m + 1), count: n + 1)

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (1 <= y && y <= n) && (1 <= x && x <= m)
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]
func bfs(_ startY: Int, _ startX: Int) -> Int {
    visited[startY][startX] = true
    let q = Dequeue([(startY, startX, 0)])
    
    if board[startY][startX] == 0 { // 원래 갈 수 없는 땅인 위치면,
        return 0
    }
    
    while !q.isEmpty {
        let (y, x, count) = q.popFirst()
        
        if board[y][x] == 2 {
            return count
        }
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            if isValidCoord(ny, nx) && (board[ny][nx] == 1 || board[ny][nx] == 2) && !visited[ny][nx] { // 유효 범위고, 갈 수 있는 땅이고, 미방문이면,
                visited[ny][nx] = true
                q.pushLast((ny, nx, count + 1))
            }
        }
    }
    return -1 // 원래 갈 수 있는 땅인데 도달할 수 없으면 -1
}

var answers: [[Int]] = Array(repeating: Array(repeating: 0, count: m), count: n)
for y in 1...n {
    for x in 1...m {
        if board[y][x] == 2 || board[y][x] == 0 { // bfs돌 필요 없음.
            answers[y-1][x-1] = 0 // 결과값 저장.
        }
        else {
            answers[y-1][x-1] = bfs(y, x) // 결과값 저장.
            visited = Array(repeating: Array(repeating: false, count: m + 1), count: n + 1) // 방문기록 초기화.
        }
    }
}

for answer in answers {
    let temp = answer.map{String($0)}.joined(separator: " ")
    print(temp)
}

백준 Swift 7576번

문제 유형 : BFS

난이도 : 골드5

// MARK: - 7576번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}

let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (M, N) = (input[0], input[1])
var board: [[Int]] = []
var visited: [[Int]] = Array(repeating: Array(repeating: -1, count: M), count: N)

for _ in 1...N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    board.append(input)
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < M)
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]
let q: Dequeue<(Int, Int)> = Dequeue([])

func bfs() {
    
    while !q.isEmpty {
        let (y, x) = q.popFirst()
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            
            if isValidCoord(ny, nx) && board[ny][nx] == 0 && visited[ny][nx] == -1 { // 유효범위고, 토마토가 있고, 미방문상태면
                visited[ny][nx] = visited[y][x] + 1
                q.pushLast((ny, nx))
            }
        }
    }
}

for y in 0..<N {
    for x in 0..<M {
        if board[y][x] == 1 {
            visited[y][x] = 0
            q.pushLast((y, x))
        }
        else if board[y][x] == -1 { // 애초에 방문할 수 없는 곳이면,
            visited[y][x] = -2 // 미방문과 애초에 방문할 수 없는 곳 구분을 위해 -2로 저장. : 예제 input3.
        }
    }
}

bfs()

let visitedTemp = visited.flatMap{$0}
if visitedTemp.contains(-1) { // 미방문한 곳이 있다면,
    print(-1)
}
else { // 모두 방문했다면,
    print(visitedTemp.max()!) // 전부 익는데까지 걸리는 시간 = 최대값.
}

구현(2) 문제 풀이 모음 | 20546번, 2578번, 4396번, 1244번, 10994번, 20436번, 1913번, 12933번, 20291번, 17413번, 22858번, 17276번, 15787번, 2615번, 16926번, 20207번

개발자P — Tue, 15 Nov 2022 23:55:11 +0900

구현(1)에 이어서 구현(2)를 풀 생각이다. 감을 조금씩 찾는 것 같긴 한데, 아직 어색하긴 하다.

DP, BFS, DFS 등 한창 공부했다가 지금 거의 다 휘발된 것 같다. 얼른 구현유형으로 익숙해지고, 나머지 다른 유형들도 감 되찾아야겠다.

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

22.11.15 업데이트

22.11.23 업데이트

아래 깃허브 주소에서 모든 백준 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

문제 리스트

https://github.com/tony9402/baekjoon/tree/main/implementation

문제 리스트 - 구현(2) 파트(실버)

백준 Swift 20546번

문제 유형 : 구현

난이도 : 실버5

실버5인데 뭔가 잘 안풀렸다... 좀 더 잘 생각해보자.

인덱스가 벗어날 것 같으면, 미리 인덱스를 더 가서 for문을 돌리면 됨!!!

// MARK: - 20546번
let money = Int(readLine()!)!
let stocks: [Int] = readLine()!.split(separator: " ").map{Int(String($0))!}

var updown: [String] = ["="]
for i in 1..<stocks.count {
    if stocks[i] > stocks[i - 1] {
        updown.append("+")
    }
    else if stocks[i] < stocks[i - 1] {
        updown.append("-")
    }
    else {
        updown.append("=")
    }
}
//print(updown)

var (junMoney, seoungMoney) = (money, money)
var (junCount, seoungCount) = (0, 0)

for stock in stocks {
    junCount += junMoney / stock
    junMoney = junMoney % stock
}

for i in 2..<stocks.count {
//    if stocks[i] > seoungMoney { // 성민이 - 빚내서 주식하지 않음.
//        continue
//    }
    
    if updown[i] == "=" {
        continue
    }
    
    if updown[i] == "+" && updown[i - 1] == "+" && updown[i - 2] == "+" { // 전량매도
        seoungMoney += seoungCount * stocks[i]
        seoungCount = 0
    }
    else if updown[i] == "-" && updown[i - 1] == "-" && updown[i - 2] == "-" { // 전량매수
        seoungCount += seoungMoney / stocks[i]
        seoungMoney = seoungMoney % stocks[i]
    }
//    print(i, seoungMoney, seoungCount)
}

var (junSum, seoungSum) = (0, 0)
junSum = junMoney + junCount * stocks.last!
seoungSum = seoungMoney + seoungCount * stocks.last!

if junSum > seoungSum {
    print("BNP")
}
else if junSum < seoungSum {
    print("TIMING")
}
else {
    print("SAMESAME")
}

백준 Swift 2578번

문제 유형 : 구현

난이도 : 실버4

// MARK: - 2578번
var board: [[Int]] = []
var bingo: [[Bool]] = Array(repeating: Array(repeating: false, count: 5), count: 5)

for _ in 0..<5 {
    board.append(readLine()!.split(separator: " ").map{Int(String($0))!})
}

var calls: [Int] = []
for _ in 0..<5 {
    let temp: [Int] = readLine()!.split(separator: " ").map{Int(String($0))!}
    calls += temp
}

func findIndex(_ num: Int) -> (Int, Int) {
    for y in 0..<5 {
        for x in 0..<5 {
            if board[y][x] == num {
                return (y, x)
            }
        }
    }
    return (-1, -1) // 여기는 올 일 없음.
}

func bingoCount() -> Int {
    var lineCount: Int = 0
    
    for y in 0..<5 { // 가로줄 빙고 체크.
        var tempCount: Int = 0
        for x in 0..<5 {
            if bingo[y][x] == false {
                break
            }
            else {
                tempCount += 1
            }
            
            if tempCount == 5 { // 빙고면,
                lineCount += 1
            }
        }
    }
    
    for x in 0..<5 { // 세로줄 빙고 체크.
        var tempCount: Int = 0
        for y in 0..<5 {
            if bingo[y][x] == false {
                break
            }
            else {
                tempCount += 1
            }
            
            if tempCount == 5 { // 빙고면,
                lineCount += 1
            }
        }
    }
    
    if (bingo[0][0] == true) && (bingo[1][1] == true) && (bingo[2][2] == true) && (bingo[3][3] == true) && (bingo[4][4] == true) {
        lineCount += 1
    }
    
    if (bingo[0][4] == true) && (bingo[1][3] == true) && (bingo[2][2] == true) && (bingo[3][1] == true) && (bingo[4][0] == true) {
        lineCount += 1
    }
    
    return lineCount
}

var count: Int = 0
for call in calls {
    count += 1
    
    let (y, x) = findIndex(call)
    bingo[y][x] = true
    
    if bingoCount() >= 3 {
        print(count)
        break
    }
}

구현(1) 문제 풀이 모음 | 백준 Swift 2753번, 5597번, 20053번, 1212번, 21918번, 14467번

개발자P — Sat, 5 Nov 2022 23:58:18 +0900

정말 오랜만에 글을 쓰는 것 같다. PS공부를 꾸준히 하기로 해놓고선... 감을 다 잃었을까봐 두렵다. 빠르게 훑으면서, 실력을 다시 쌓아보자!

브론즈 문제는 오랜만에 풀 때 머리 활성화에 도움이 된다. 글을 오랜만에 쓰니까 기분도 좋고 더 쓰고 싶어서 손이 근질근질하다. 진작 쓸 걸 그랬다.

구현 파트를 풂으로써 감을 되찾아볼까 한다.

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

22.11.05 업데이트

22.11.09 업데이트

22.11.10 업데이트

아래 깃허브 주소에서 모든 백준 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

문제 리스트

https://github.com/tony9402/baekjoon/tree/main/implementation

문제 리스트 - 구현 파트(브론즈)

백준 Swift 2753번

문제 유형 : 구현

난이도 : 브론즈5

// MARK: - 2753번
let year = Int(readLine()!)!

if (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 {
    print("1")
}
else {
    print("0")
}

백준 Swift 5597번

문제 유형 : 구현

난이도 : 브론즈5

// MARK: - 5597번
var students: [Int] = [-1] + Array(repeating: 0, count: 30)

for _ in 0..<28 {
    let N = Int(readLine()!)!
    students[N] = 1
}

for (index, attendance) in students.enumerated() {
    if attendance == 0 {
        print(index)
    }
}

백준 Swift 20053번 - 시간초과

문제 유형 : 구현

난이도 : 브론즈3

// MARK: - 20053번(시간초과 - FileIO사용해야함)
let T = Int(readLine()!)!
for _ in 0..<T {
    let _ = Int(readLine()!)!
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    print(input.min()!, input.max()!)
}

백준 Swift 1212번

문제 유형 : 구현

난이도 : 브론즈2

참고 자료 : https://jeong9216.tistory.com/416

// MARK: - 1212번(참고 : https://jeong9216.tistory.com/416)
import Foundation
let NArray = readLine()!.map{String($0)}

var answer: String = String(Int(NArray.first!)!, radix: 2)

for ch in NArray[1...] {
    let binaryNum = String(Int(ch)!, radix: 2)
    let threeCh = String(format: "%03d", Int(binaryNum)!)
    answer += threeCh
}

print(answer)

런타임 오류 코드

// MARK: - 1212번(런타임오류)
let N: String = readLine()! // 8진수
let temp = Int(N, radix: 8)! // 8진수 -> 10진수
let answer = String(temp, radix: 2) // 10진수 -> 2진수
print(answer)

백준 Swift 21918번

문제 유형 : 구현

난이도 : 브론즈2

// MARK: - 21918번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var tempBulbs: [Int] = readLine()!.split(separator: " ").map{Int(String($0))!} // 전구상태 임시 저장.
var bulbs: [Bool] = [false] // 전구상태 저장.(인덱스 0은 채움.)
for bulb in tempBulbs {
    bulbs.append(bulb == 1 ? true : false)
}

func command(_ num: Int, _ b: Int, _ c: Int) -> Void { // 명령어 함수
    switch num {
    case 1: // 특정값으로 변경
        bulbs[b] = (c == 1 ? true : false)
    case 2: // 토글
        for index in b...c {
            bulbs[index].toggle()
        }
    case 3: // 끄기
        for index in b...c {
            bulbs[index] = false
        }
    case 4: // 켜기
        for index in b...c {
            bulbs[index] = true
        }
    default:
        print("default는 없음.")
    }
}

for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (a, b, c) = (input[0], input[1], input[2])
    command(a, b, c) // 명령어 호출
}

var answer: [String] = bulbs.map{$0 == true ? "1" : "0"}
print(answer[1...].joined(separator: " ")) // 0번째 인덱스는 제외.

백준 Swift 14467번

문제 유형 : 구현

난이도 : 브론즈1

// MARK: - 14467번
let N = Int(readLine()!)!
var answer: Int = 0
var cows: [Int] = [-2] + Array(repeating: -1, count: 10)

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (num, location) = (input[0], input[1])
    
//    if cows[num] == -1 { // 첫 등장이면,
//        cows[num] = location
//    }
//    else {
//        if cows[num] != location { // 위치가 달라졌다면,
//            answer += 1
//            cows[num] = location
//        }
//    }
    
    if cows[num] != -1 && cows[num] != location { // 첫 등장이 아니고 + 위치가 달라졌으면,
        answer += 1
    }
    cows[num] = location
    
}
print(answer)

백준 Swift 1018번, 2841번, 4796번, 15686번, 1389번, 1915번, 17136번,

개발자P — Fri, 15 Jul 2022 23:43:01 +0900

요 근래 일정이 많아지고 바빠졌다는 핑계(?)로 PS를 소홀히 했다. ~~근데 사실 핑계가 아니라 정말로 바쁘고 피곤했다.~~

고로, 문제를 꾸준히 풀기로 다짐했다.

사실 일주일에 5문제는 풀고 싶지만, 바빠서 현실적으로 1주당 3문제가 내가 지킬 수 있는 나와의 약속일 것 같다.

그럼 시작해보자.

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

22.07.15 업데이트

22.07.18 업데이트

22.07.20 업데이트

22.07.23 업데이트

22.07.24 업데이트

22.08.14 업데이트

22.08.15 업데이트

22.08.18 업데이트

아래 깃허브 주소에서 모든 백준 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

백준 Swift 1018번

문제 유형 : 완전탐색

난이도 : 실버4

처음 풀이(틀린 풀이)

시작점을 기준으로,

시작점부터 + 8 - 1까지 돌면서, 기준이 될 비교문자를 (B <-> W) 왔다리 갔다리 하면서, board[y][x]와 다르면 count를 증가시켜 answerArray에 저장 후 , 그 중 가장 작은 값을 출력하는 방법으로 풀었다.

TC 답이 안 나오길래 조금 더 고민해보니까, 이렇게 풀면 더 적게 칠할 수 있는 경우들을 놓치게 된다. 잘못하면 1개만 칠해도 되는걸 63개를 칠하게 될 수도 있는 풀이다. 이 방법은 패스! (BBWB... 일 때 사실 가장 처음에 있는 B만 바꾸면 되는데, 가장 처음 문자를 제외한 나머지 63개를 다 바꿔야 한다고 값이 나오게 된다.)

맞는 풀이

백준 Swift 1018번 고민.

방법 1.

1번과 2번의 배열을 만든다. 그 후 board[startY][startX]를 1번배열처럼 만들기 위한 값, 2번배열처럼 만들기 위한 값 중 작은 값을 answerArray에 넣는다. 그 후 answerArray.min()!을 출력하면 된다.

하지만 방법1은 만약 사이즈가 8*8이 아니라, 100*100이라면...? 이 풀이는 사실 매우 매우 확장성이 좋지 않다.

방법 2. (선택)

케이스를 두가지로 나눈 뒤, 두가지 케이스 중 작은 값을 answerArray에 넣고, 그 후 answerArray.min()!을 출력하면 된다.

Case 1. 시작점이 W로 시작

case 1-1. y홀, x홀 : "W"
case 1-2. y홀, x짝 : "B"
case 1-3. y 짝, x홀 : "B"
case 1-4. y 짝, x짝 : "W"

Case 2. 시작점이 B로 시작

case 2-1. y홀, x홀 : "B"
case 2-2. y홀, x짝 : "W"
case 2-3. y 짝, x홀 : "W"
case 2-4. y 짝, x짝 : "B"

// MARK: - 1018번(완전탐색)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])

var board: [[String]] = []
board.append(Array(repeating: ".", count: M + 1))
for _ in 0..<N {
    board.append(["."] + readLine()!.map{String($0)})
}

let (endY, endX) = ((N - 8) + 1, (M - 8) + 1)

var answerArray: [Int] = []
for startY in 1...endY {
    for startX in 1...endX {
        let answerTemp: Int = min(startW(startY, startX), startB(startY, startX)) // W 시작 Case, B 시작 Case 중 작은 값 저장.
        answerArray.append(answerTemp)
    }
}

print(answerArray.min()!) // 가장 최소값 출력.

func startW(_ startY: Int, _ startX: Int) -> Int { // W로 시작 Case.
    var count: Int = 0 // 변경 횟수 카운팅.
    
    for y in startY..<startY + 8 {
        for x in startX..<startX + 8 {
            if ((y % 2 == 1) && (x % 2 == 1)) || ((y % 2 == 0) && (x % 2 == 0)) { // W여야 함.
                if board[y][x] != "W" {
                    count += 1
                }
            }
            else if ((y % 2 == 1) && (x % 2 == 0)) || ((y % 2 == 0) && (x % 2 == 1)) { // B여야 함.
                if board[y][x] != "B" {
                    count += 1
                }
            }
        }
    }
    return count
}

func startB(_ startY: Int, _ startX: Int) -> Int { // B로 시작 Case.
    var count: Int = 0 // 변경 횟수 카운팅.
    
    for y in startY..<startY + 8 {
        for x in startX..<startX + 8 {
            if ((y % 2 == 1) && (x % 2 == 1)) || ((y % 2 == 0) && (x % 2 == 0)) { // B여야 함.
                if board[y][x] != "B" {
                    count += 1
                }
            }
            else if ((y % 2 == 1) && (x % 2 == 0)) || ((y % 2 == 0) && (x % 2 == 1)) { // W여야 함.
                if board[y][x] != "W" {
                    count += 1
                }
            }
        }
    }
    return count
}

백준 1018번 코드개선

// MARK: - 1018번(완전탐색 / 코드 개선)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])

var board: [[String]] = []
board.append(Array(repeating: ".", count: M + 1))
for _ in 0..<N {
    board.append(["."] + readLine()!.map{String($0)})
}

let (endY, endX) = ((N - 8) + 1, (M - 8) + 1)

var answer: Int = Int.max
for startY in 1...endY {
    for startX in 1...endX {
        let answerTemp: Int = min(fill(startY, startX, "W"), fill(startY, startX, "B")) // W 시작 Case, B 시작 Case 중 작은 값 저장.
        answer = min(answer, answerTemp)
    }
}

print(answer) // 가장 최소값 출력.

func fill(_ y: Int, _ x: Int, _ bw: String) -> Int {
    var count: Int = 0 // 변경 횟수 카운팅.
    
    for i in 0..<8 {
        for j in 0..<8 {
            if (i + j) % 2 == 0 { // (홀, 홀) || (짝, 짝) -> bw와 같아야 함.
                if board[y + i][x + j] != bw { // 같아야 하는데 다르면,
                    count += 1 // 변경.
                }
            }
            else { // (홀, 짝) || (짝, 홀) -> bw와 달라야 함.
                if board[y + i][x + j] == bw { // 달라야 하는데 같으면,
                    count += 1 // 변경.
                }
            }
        }
    }
    return count
}

백준 Swift 2841번

문제 유형 : 스택(Stack)

난이도 : 실버1

문제풀이방법을 생각하는 것 자체는 어렵지 않았다. 단지 원하는대로 구현이 안돼서 조금 당황하는 것 정도?다.

풀이 방법

0. 각 라인에 빈 stack(배열)을 생성한다.

1. 빈 스택이면 넣고 끝.

2-1. 새로 들어온 fret이 스택의 마지막 값보다 작으면, 스택의 마지막 값을 빼낸다. (스택의 마지막 값보다 작거나(2-3) 같아질 때(2-2)까지 반복하게 된다.)

2-2. 새로 들어온 fret이 스택의 마지막 값과 같으면 멈춘다.

2-3. 새로 들어온 fret이 스택의 마지막 값보다 크거나 or 커지게 되면, 이어 붙이고 멈춘다.

백준 Swift 2841번 고민.

// MARK: - 2841번(Stack)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, P) = (input[0], input[1])
var stacks: [[Int]] = Array(repeating: [], count: N + 1)
var count: Int = 0

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (line, fret) = (input[0], input[1])
    
    while true {
        if stacks[line].isEmpty { // 그 줄의 스택이 비었으면,
            stacks[line].append(fret) // 넣고 끝.
            count += 1
            break
        }
        
        if stacks[line].last! > fret { // 새로 들어온 프렛이 더 작으면, 그 줄의 스택에서 하나씩 빼냄.
            stacks[line].removeLast()
            count += 1
        }
        else if stacks[line].last! == fret { // 같으면, 멈춤.
            break
        }
        else { // 새로 들어온 프렛이 더 커지는 순간이 오면, 그 줄의 스택에 넣고 멈춤.
            stacks[line].append(fret)
            count += 1
            break
        }
    }
}
print(count)

백준 Swift 4796번

문제 유형 : 그리디

난이도 : 실버5

케이스를 2개로 나눠야 한다.

전체 V 중 P일을 최대한 사용하고, 남은 일수(= V % P)가 L일 이상인지 or 아닌지다.

Case 1. 남은 일수가 L일 이상인 경우의 TC는, (L = 1 / P = 3 / V = 17)

-> 우선 최대한 사용( = (V / P) * L)하고, L일을 사용하는데 문제가 없을만큼 남아 있기 때문에 그냥 L만큼 더해주면 된다.

Case 2. 남은 일수가 L일 미만인 경우의 TC는, (L = 8 / P = 9 / V = 24)

-> 우선 최대한 사용( = (V / P) * L)하고, L일을 사용하는데 문제가 있다. 그래서 남은 일수만큼(= V % P)만 더해줘야 한다.

백준 Swift 4796번 고민.

// MARK: - 4796번
var caseCount: Int = 0
while true {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (L, P, V) = (input[0], input[1], input[2])
    if L == 0 && P == 0 && V == 0 {
        break
    }
    
    caseCount += 1
    
    var answer: Int = -1
    if V % P >= L { // 나머지가 이용가능한 L일 이상일 땐, L일만큼만 더해주면 됨.
        answer = (V / P) * L + L
    }
    else { // 남은 나머지가 이용가능한 L일보다 적을 땐, 남은 나머지만큼 더해주면 됨.
        answer = (V / P) * L + (V % P)
    }
    
    print("Case \(caseCount): \(answer)")
}

22.07.23 업데이트 - 코드 개선

// MARK: - 4796번(그리디)
var caseCount: Int = 0
while true {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (L, P, V) = (input[0], input[1], input[2])
    
    if L == 0 {
        break
    }
    
    caseCount += 1

    let answer: Int = (V / P) * L + min(L, V % P)
    print("Case \(caseCount): \(answer)")
}

백준 Swift 15686번

문제 유형 : 조합, 완전탐색

난이도 : 골드5

골드5 문제지만 어렵지 않은 문제다.

[풀이 방법]

각 입력에 맞게 board 세팅한다. 인덱스 0일 때를 의미 없는 걸로 채워주면 편하다. (난 -1로 채웠다.)

치킨집(2)들을 배열에 저장하고, M개를 선택하는 경우를 조합으로 구한다.

전체 치킨조합(chickenCombi)을 돌면서, 집(1)일 때

그 치킨집(chickens)과 집(1) 사이의 chickenDistance를 구한다. 여러 chickenDistance가 나올텐데 그 중 min을 구한다.

마지막으로, 각 경우(chickens)의 치킨거리의 합(sum)을 저장하는 distances 중 최소값을 구해주면 된다.

// MARK: - 15686번(조합, 완전탐색)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var board: [[Int]] = Array(repeating: [], count: N + 1)

func combi(_ nums: [(Int, Int)], _ targetNum: Int) -> [[(y: Int, x: Int)]] {
    var result: [[(Int, Int)]] = []
    
    func combination(_ index: Int, _ nowCombi: [(Int, Int)]) {
        if nowCombi.count == targetNum {
            result.append(nowCombi)
            return
        }
        for i in index..<nums.count {
            combination(i + 1, nowCombi + [nums[i]])
        }
    }
    combination(0, [])
    
    return result
}

for i in 1...N {
    board[i] = [-1] + readLine()!.split(separator: " ").map{Int(String($0))!} // 0: 빈 칸, 1: 집, 2: 치킨집
}

var chickenCoords: [(Int, Int)] = [] // 치킨집들의 좌표 저장.
for y in 1...N {
    for x in 1...N {
        if board[y][x] == 2 { // 치킨집일 때,
            chickenCoords.append((y, x))
        }
    }
}
//print(chickenCoords)
let chickenCombi = combi(chickenCoords, M) // 치킨집들 중, M개를 선택하는 경우의 좌표 모음.
//print(chickenCombi)
var distances: [Int] = [] // 치킨거리 모음.

for chickens in chickenCombi {
    var sum: Int = 0
    
    for y in 1...N {
        for x in 1...N {
            if board[y][x] == 1 { // 집일 때,
                var chickenDistance: Int = Int.max
                for chicken in chickens {
                    let distanceY: Int = abs(y - chicken.y)
                    let distanceX: Int = abs(x - chicken.x)
                    chickenDistance = min(chickenDistance, distanceY + distanceX)
                }
                sum += chickenDistance
            }
        }
    }
    distances.append(sum)
}

print(distances.min()!)

백준 Swift 1389번

문제 유형 : BFS

난이도 : 실버1

일정이 바빠서 오랜만에 문제를 풀었는데, 못 풀겠었다. 3시간정도 고민해도 결국 못 풀었다가, 다음날(지금)에 다시 풀어서 해결했다.

기존의 풀던 감으로는 쉽게 풀었을 내용인데... 보자마자 어떤 문제인지도 파악 했는데... 풀이방법도 생각 되는데 구현이 잘 안됐다.

역시 꾸준함이 중요한 것 같다. 바쁜 시간이지만 짬을 더 내서라도 풀도록 노력해야겠다.

[풀이 방법]

1. 인접행렬을 구한다.

2. 1...N을 돌면서, y에서 (자기 자신을 제외한) destination에 도달하는 데 까지 걸리는 최단거리를 구하면 된다. 즉, BFS다.

2-1. y와 count를 큐에 저장한다.

2-2. 다음 지점(k)과 연결되어 있고, 미방문일 시 큐에 넣는다.

2-3. 만약 다음 지점(k)이 destination이면 return한다.

3. 각 인덱스들 중, 가장 작은 케빈 베이컨의 수의 인덱스 값을 구하면 된다.

백준 Swift 1389번 고민.

// MARK: - 1389번(BFS)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])

var board: [[Int]] = Array(repeating: Array(repeating: 0, count: N + 1), count: N + 1) // 0인덱스는 자리채우기 용.
var visited: [[Bool]] = Array(repeating: Array(repeating: false, count: N + 1), count: N + 1) // 0인덱스는 자리채우기 용.

for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (A, B) = (input[0], input[1])

    board[A][B] = 1
    board[B][A] = 1
}

func visitedArrayInit() { // 방문배열 초기화 필요.
    visited = Array(repeating: Array(repeating: false, count: N + 1), count: N + 1) // 0인덱스는 자리채우기 용.
    for i in 1...N {
        visited[i][i] = true
    }
}


func bfs(_ y: Int, _ destination: Int) -> Int {
    var q: [(Int, Int)] = [(y, 0)] // (y, count)

    while !q.isEmpty {
        let (y, count) = q.removeFirst()
        
        if y == destination { // 목적지 도착이면,
            return count
        }
        
        for k in 1...N {
            if board[y][k] == 1 && !visited[y][k] {
                visited[y][k] = true
//                if k == destination { // 목적지 도착이면,
//                    return count + 1
//                }
                q.append((k, count + 1))
            }
        }
    }
    return -1
}


var answerIndex: Int = 1
var minValue: Int = Int.max

for start in 1...N {
    var sum: Int = 0
    for destination in 1...N {
        if start != destination { // 자기자신은 제외.
            sum += bfs(start, destination)
            visitedArrayInit() // 방문배열 초기화.
        }
    }
    if sum < minValue { // 더 작은 케빈 베이컨의 수(sum)가 등장 시,
        minValue = sum
        answerIndex = start
    }
}
print(answerIndex)

백준 Swift 1915번

문제 유형 : DP

난이도 : 골드4

전에 풀어본 것 같은 기억은 나는데, 결국 못 풀었다. (https://developer-p.tistory.com/205)

다행인 건... 어떤 문제의 유형인지는 바로 알았다는 점?

[풀이 방법]

1. 0행과 0열을 우선 저장한다. dp의 점화식이 적용되지 않는 부분이기 때문이다.

2. dp = (y, x)칸을 우하단으로 하는 정사각형의 (최대) 한 변의 길이다.

2-1. 1...n행, 1...m열까지 돌면서, dp = min(↑, ←, ↖) + 1 을 구한다.

2-2. maxValue * maxValue를 구해주면 답이다. (이차원배열에서 flatMap을 쓰면 쉽게 일차원배열로 변경할 수 있다.)

백준 Swift 1915번 고민.

// MARK: - 1915번(DP)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (n, m) = (input[0], input[1])
var arr: [[Int]] = Array(repeating: [], count: n)
var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: m), count: n)

for y in 0..<n {
    let input = readLine()!.map{Int(String($0))!}
    arr[y] = input
}

for y in 0..<n {
    dp[y][0] = arr[y][0]
}

for x in 0..<m {
    dp[0][x] = arr[0][x]
}

for y in 1..<n {
    for x in 1..<m {
        if arr[y][x] == 0 { // 0일 땐, 사각형 X.
            dp[y][x] = 0
        }
        else { // 1일 때,
            dp[y][x] = min(dp[y - 1][x], dp[y][x - 1], dp[y - 1][x - 1]) + 1 //  min(↑, ←, ↖) + 1
        }
    }
}

let maxValue: Int = dp.flatMap{$0}.max()!
print(maxValue * maxValue)

백준 Swift 17136번

문제 유형 : 백트래킹

난이도 : 골드2

백준 1915번을 활용하면 될 것 같다고 생각하고 고민했는데, 사실 풀이방법과 전혀 상관 없었다...

백트래킹 문제는 처음 풀어본 것 같다. 쭉 풀던 DP문제를 마무리 하고 나선, 백트래킹 문제들을 풀어봐야겠다.

[풀이 방법]

0. board를 10*10칸으로 세팅하고, 각 종류별 사용 갯수를 저장할 paper배열을 선언한다.

1. backtracking(0, 0)을 시작으로,

1-1. 최종 목적지(y == 10)에 도달하면, min answer를 저장한다.

1-2. 열의 끝(x == 10)에 도달하면, 다음 행으로 이동한다. (backtracking(y + 1, 0))

1-3. board[y][x]가 0이라면, 다음 열로 이동한다. (backtracking(y, x + 1))

1-4. board[y][x]가 1이라면, 색종이 size를 1부터 5까지 돌면서,

2. 가능한 경우라면(isPossible) 색종이를 붙이고(mark() - board값을 0으로 저장) 다음 열로 이동한다. (backtracking(y, x + 1))

3. 또한, 안 돼서 돌아올 경우 색종이를 떼어주는(mark() - board값을 1로 되돌림) 원상복구를 해줘야 한다.

4-1. answer가 여전히 25라면 불가능한 경우이기 때문에 -1을 출력하고

4-2. 아니라면 answer를 출력하면 된다.

코드에 주석처리된 print문을 출력해본다면 이해가 좀 더 쉬울 것이다.

코드에 자세한 설명이 써 있고, 아래 이미지는 도움이 안된다.

백준 Swift 17136번 고민.

// MARK: - 17136번(백트래킹)
var board: [[Int]] = Array(repeating: [], count: 10)
for i in 0..<10 {
    board[i] = readLine()!.split(separator: " ").map{Int(String($0))!}
}
var paper: [Int] = Array(repeating: 0, count: 5 + 1) // 종류별 사용한 색종이의 수.
var answer: Int = 25 // 최대 : 5장 다 사용 * 5종류

func isPossible(_ coordY: Int, _ coordX: Int, _ paperSize: Int) -> Bool { // 좌측상단(y, x)의 색종이를 덮을 수 있는지.
    if paper[paperSize] == 5 { // 해당 종류의 색종이를 다 썼다면,
        return false
    }
    
    if (coordY + paperSize > 10) || (coordX + paperSize > 10) { // 좌표값 넘어가면,
        return false
    }
    
    for y in coordY..<coordY + paperSize {
        for x in coordX..<coordX + paperSize {
            if board[y][x] == 0 { // 0이 있어서 못 덮는 상황이라면,
                return false
            }
        }
    }
    return true // 여기까지 온 거라면, 덮을 수 있다는 뜻이기 때문에 true리턴.
}

func mark(_ coordY: Int, _ coordX: Int, _ paperSize: Int, _ value: Int) { // 색종이 덮는 함수. (혹은 떼어냄)
    for y in coordY..<coordY + paperSize {
        for x in coordX..<coordX + paperSize {
            board[y][x] = value
        }
    }
    
    if value == 0 { // 색종이를 덮음.
        paper[paperSize] += 1 // 색종이 사용 횟수 증가.
    }
    else if value == 1 { // 색종이를 떼어냄.
        paper[paperSize] -= 1 // 색종이 사용 횟수 감소.
    }
}

func backtracking(_ y: Int, _ x: Int) {
    if y == 10 { // 최종 도달.
        answer = min(answer, paper.reduce(0, +))
//        print(paper, answer)
        return
    }
    
    if x == 10 { // 열의 끝에 도달.
        backtracking(y + 1, 0) // 다음 행으로 넘어감.
        return
    }
    
    if board[y][x] == 0 { // 못 덮는 곳이면,
        backtracking(y, x + 1) // 다음 열로 넘어감.
        return
    }
    
    for size in 1...5 {
        if isPossible(y, x, size) { // (y, x)에 size의 색종이를 덮을 수 있다면,
            mark(y, x, size, 0) // (y, x)에 size의 색종이를 0으로 덮음.
//            print("before: \(y), \(x), \(size)")
            backtracking(y, x + 1) // 다음 열로 이동.
            mark(y, x, size, 1) // 원상복구. (y, x)에 다시 기존값으로 되돌려놓음.
//            print("after: \(y), \(x), \(size)")
        }
//        else {
//            print("불가능: \(y), \(x), \(size)")
//        }
    }
    
}

backtracking(0, 0)
print(answer == 25 ? -1 : answer)

팰린드롬 문제 풀이 모음 | 백준 Swift 10988번, 10174번, 4096번, 8892번, 8611번, 1254번, 1334번, 1747번, 10942번, 1990번, 5502번, 1053번

개발자P — Tue, 7 Jun 2022 22:55:37 +0900

DP공부를 위해 백준 1695번을 풀다가, 팰린드롬 관련된 문제를 한번정도 풀어보긴 했지만 기억도 안나고 아예 접근법이 달랐다.

그래서 이번 기회에 백준 팰린드롬 관련 문제모음 중,

실버와 골드 문제만이라도 우선 독파해놓으면 좋을 것 같아서 (DP를 공부하다가) 풀게 됐다.

https://www.acmicpc.net/workbook/view/1128

문제집: 팰린드롬 (cocomo1316)

www.acmicpc.net

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

22.06.07 업데이트

22.06.08 업데이트

22.06.09 업데이트

22.06.11 업데이트

22.06.12 업데이트

22.06.16 업데이트

22.06.20 업데이트

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

백준 Swift 10988번

문제 유형 : 팰린드롬(재귀, 반복문)

골드 문제 위주로 풀다가, 갑자기 브론즈 문제라서 뭔가 쉽다. ㅎㅎ

flag를 두고, 인덱스를 처음부터 ~ 길이의 절반까지만 돌면서 같은지 확인하면 된다.

난이도 : 브론즈1

풀이

// MARK: - 10988번
let arr = readLine()!.map{String($0)}
let length: Int = arr.count
var check: Bool = true

for i in 0..<length/2 { // 절반만 비교해도 됨.
    if arr[i] == arr[length - 1 - i] {
        continue
    }
    else {
        check = false
        break
    }
}

if check {
    print(1)
}
else {
    print(0)
}

백준 Swift 10174번

문제 유형 : 팰린드롬

풀이 자체는 10988번과 같다. .lowercased()정도 차이가 있다.

난이도 : 브론즈2

풀이

// MARK: - 10174번
let n = Int(readLine()!)!

for _ in 0..<n {
    let input = readLine()!.map{String($0).lowercased()}
    let length: Int = input.count
    var flag: Bool = true
    
    for i in 0..<length/2 {
        if input[i] == input[length - 1 - i] {
            continue
        }
        else {
            flag = false
            break
        }
    }
    
    if flag {
       print("Yes")
    }
    else {
        print("No")
    }
}

백준 Swift 4096번

문제 유형 : 팰린드롬

실버5인데 구현이 생각보다 어려웠다.

포인트 1. 무한 입력 받으면서 0일 때 종료.

포인트 2. 숫자 앞에 0을 붙여줘야 함. (String(format: "%0?d", ?)를 활용해서 해결)

풀이는 맞는데 시간초과가 난다...! Swift로 맞은 사람이 없는 걸 보니까

처리속도가 상대적으로 느린 Swift는 추가시간을 줘야만 통과할 수 있을 것 같다.

(만약 Swift로 이 문제를 통과하시는 분이 계신다면 댓글, 링크등으로 제게 꼭 좀 알려주세요! 배우고 싶습니다.)

난이도 : 실버5

참고 자료 : https://khu98.tistory.com/200

풀이 - 시간초과

// MARK: - 4096번(팰린드롬) - 50%에서 시간초과
import Foundation

while let temp = readLine() {
    if temp == "0" { // 0이면 종료.
        break
    }
    let input = temp.map{String($0)}
    
    if isPalindrome2(input) { // 처음부터 팰린드롬이면,
        print(0) // 바로 0 출력.
    }
    else { // 팰린드롬이 아니면,
        let num: Int = Int(input.joined(separator: ""))!
        let length: Int = input.count // 숫자의 개수
        
        var rangeEnd: String = "" // "9" * 길이 -> "999..."
        for _ in 0..<length {
            rangeEnd += "9"
        }
        let end: Int = Int(rangeEnd)!  // 끝 수 구해놓음.
        var count: Int = 0 // 주행 거리.
        
        for n in num+1...end { // 주어진숫자의 다음 수 ~ 끝까지 돌면서,
            count += 1 // 거리 1씩 추가.
            let strN = String(format: "%0\(length)d", n)
            let strNArray: [String] = strN.map{String($0)}.reversed()

            if isPalindrome2(strNArray) { // 팰린드롬이라면,
                print(count) // 최소 거리 출력.
                break
            }
        }
    }
}

//func isPalindrome(_ strArr: [String]) -> Bool {
//    return strArr == strArr.reversed()
//}

func isPalindrome2(_ strArr: [String]) -> Bool {
    let length: Int = strArr.count
    var flag: Bool = true // 팰린드롬 체크.
    
    for i in 0..<length/2 {
        if strArr[i] != strArr[length - 1 - i] {
            flag = false
            break
        }
    }
    
    return flag
}

풀이 개선 - 시간초과

// MARK: - 4096번(팰린드롬) - 개선 : 50% 시간초과
import Foundation

while let temp = readLine() {
    if temp == "0" { // 0이면 종료.
        break
    }
    let input = temp.map{String($0)}
    
    if isPalindrome2(input) { // 처음부터 팰린드롬이면,
        print(0) // 바로 0 출력.
    }
    else { // 팰린드롬이 아니면,
        let num: Int = Int(input.joined(separator: ""))!
        let length: Int = input.count // 숫자의 개수
        
//        var rangeEnd: String = "" // "9" * 길이 -> "999..."
//        for _ in 0..<length {
//            rangeEnd += "9"
//        }
//        let end: Int = Int(rangeEnd)!  // 끝 수 구해놓음.
        
        var count: Int = 0 // 주행 거리.
        var startNum: Int = num + 1
        while true {
            count += 1
            let strN: [String] = String(format: "%0\(length)d", startNum).map{String($0)}
            
            if isPalindrome2(strN) { // 팰린드롬이라면,
                print(count) // 최소 거리 출력.
                break
            }
            startNum += 1
        }
        
//        for n in num+1...end { // 주어진숫자의 다음 수 ~ 끝까지 돌면서,
//            count += 1 // 거리 1씩 추가.
//            let strN: [String] = String(format: "%0\(length)d", n).map{String($0)}
//
//            if isPalindrome2(strN) { // 팰린드롬이라면,
//                print(count) // 최소 거리 출력.
//                break
//            }
//        }
    }
}

//func isPalindrome(_ strArr: [String]) -> Bool {
//    return strArr == strArr.reversed()
//}

func isPalindrome2(_ strArr: [String]) -> Bool {
    let length: Int = strArr.count
    var flag: Bool = true // 팰린드롬 체크.
    
    for i in 0..<length/2 {
        if strArr[i] != strArr[length - 1 - i] {
            flag = false
            break
        }
    }
    
    return flag
}

백준 Swift 8892번

문제 유형 : 팰린드롬

팰린드롬인지 확인 후, 가능하다면 팰린드롬 문자열을 출력하면 되는 문제다.

팰린드롬인지 확인 유무 함수는 10174번 문제와 똑같이 구현했다. (10174번은 왜 안돼~~)

순열로 2개를 선택하는 것과 같다. 물론 미리 모든 순열을 다 구하고 비교하는 것이 아니라, (굳이 모든 경우를 미리 만들 필요가 없다.)

이중 for문을 통해, 하나의 tempArr를 만들고 팰린드롬인지 확인을 해가는 식으로 해야 그나마 시간을 단축시킬 수 있다.

백준 Swift 8892번 - 최초 풀이 등극.

난이도 : 실버5

풀이

// MARK: - 8892번(팰린드롬)
let T = Int(readLine()!)!

for _ in 0..<T {
    let k = Int(readLine()!)!
    var arr: [String] = []
    for _ in 0..<k {
        arr.append(readLine()!)
    }
    
    var hasPalindrome: Bool = false // 팰린드롬 존재 유무.
    outLoop: for i in 0..<k {
        for j in 0..<k {
            if i != j { // 인덱스가 다를 때에만,
                let temp: String = (arr[i] + arr[j])
                let tempArr: [String] = temp.map{String($0)}
                
                if isPalindrome(tempArr) {
                    hasPalindrome = true // 팰린드롬 존재.
                    print(temp)
                    break outLoop
                }
            }
        }
    }
    
    if !hasPalindrome { // 만들 수 없으면,
        print(0) // 0출력.
    }
    
}

func isPalindrome(_ strArr: [String]) -> Bool {
    let length: Int = strArr.count
    var flag: Bool = true // 팰린드롬 체크.

    for i in 0..<length/2 {
        if strArr[i] != strArr[length - 1 - i] {
            flag = false
            break
        }
    }

    return flag
}

백준 Swift 8611번

문제 유형 : 팰린드롬

구현 자체는 어렵지 않게 했다. 근데 런타임 오류가 뜬다.

고민해보니, n의 범위가 10^1000로 매우 크다. 그래서 런타임 오류가 뜨는 것 같다.... UInt64도 벗어나는 범위.. 해결 못했다.

난이도 : 실버5

풀이 - 런타임오류

// MARK: - 8611번(런타임오류 - n범위 초과)
let n: UInt64 = UInt64(readLine()!)!
// let n: Int = Int(readLine()!)!
var hasPalindrome: Bool = false

for i in 2...10 {
    let temp: String = String(n, radix: i)
    let tempArr: [String] = temp.map{String($0)}
    print(i, temp, tempArr)
    
    if isPalindrome(tempArr) {
        print(i, temp)
        hasPalindrome = true
    }
}

if !hasPalindrome { // 팰린드롬인게 없으면,
    print("NIE")
}

func isPalindrome(_ strArr: [String]) -> Bool {
    let length: Int = strArr.count
    var flag: Bool = true // 팰린드롬 체크.
    
    for i in 0..<length/2 {
        if strArr[i] != strArr[length - 1 - i] { // 앞부분과 뒷부분이 다르다면,
            flag = false
            break
        }
    }
    
    return flag
}

백준 Swift 1254번

문제 유형 : 팰린드롬

처음엔 어떻게 풀까 고민을 했는데, 지난번에 풀었던 백준 1695번과 같은 문제라고 생각했다. 아래 종이 풀이처럼 LCS를 활용하면 된다고 생각했다.(종이풀이 상단 회색박스)

주어진 TC도 다 맞고 해서, 호기롭게 풀어서 제출했는데 4%에서인가 틀렸다. 뭐지!!!!!! 고민을 많이 했다. (고민의 흔적은 종이풀이 최하단 빨간박스에 있다.)

백준 Swift 1254번 고민.

잘 생각해보니, LCS를 써서 나오는 결과가 더 짧은 팰린드롬이긴 하다.

근데 이 문제에서 그건 안된다. 왜냐???

1695번은 어디에든 삽입할 수 있었지만, 1254번은 주어진 문자열의 끝부분에만 이어 붙일 수 있기 때문이다.

해결방법

i가 0부터 length-1까지 돈다.

j가 i부터 length-1까지로 [String]을 만든 뒤, 팰린드롬인지 체크한다.

만약 팰린드롬이라면, 길이 length와 움직인 i만큼 더해준 게 답이다.

왜 이렇게 되는지 예시를 통해 알아보자. 주어진 S = "abaa"에서,

i가 0 : ["a", "b", "a", "a"] => abaa는 팰린드롬X

i가 1 : [_, "b", "a", "a"] => => baa는 팰린드롬X

i가 2 : [_, _, "a", "a"] => aa는 팰린드롬 O

그렇다면, 팰린드롬인 aa를 기준으로 앞2개는 뒤에 붙여지게 될 것이다. 즉, abaaba가 되고 기존길이(4) + 앞2개 = 6이 된다.

난이도 : 실버2

참고 자료 : https://ilmiodiario.tistory.com/145

풀이

// MARK: - 1524번(팰린드롬)
let S = readLine()!.map{String($0)}
let length: Int = S.count

for i in 0..<length { // 맨 앞부터 돌면서,
    var strArray: [String] = []
    for j in i...length-1 { // i번째부터 끝까지의 [String]을 만든 뒤,
        strArray.append(S[j])
    }
    
    if isPalindrome(strArray) { // 만약 팰린드롬이면, 기존의 길이(length) + 앞쪽에서 뒤로 이동한 만큼(인덱스 i)이 정답.
        print(length + i)
        break
    }
}

func isPalindrome(_ strArr: [String]) -> Bool {
    let length: Int = strArr.count
    var flag: Bool = true
    
    for i in 0..<length/2 {
        if strArr[i] != strArr[length - 1 - i] { // 앞부분과 뒷부분이 다르다면,
            flag = false
            break
        }
    }
    
    return flag
}

// MARK: - 1524번(LCS - 최장공통 부분 수열) - 틀림.
let S = readLine()!.map{String($0)}
let length: Int = S.count

var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: length + 1), count: length + 1)

for i in 1...length { // 뒤 부터 돈 것과,
    for j in 1...length { // 앞 부터 돌면서,
        if S[length - i] == S[j - 1] { // 같으면,
            dp[i][j] = dp[i - 1][j - 1] + 1
        }
        else { // 다르면,
            dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
        }
    }
}

let answer = 2 * length - dp[length][length]
print(answer)

백준 Swift 1334번

문제 유형 : 팰린드롬

정답률이 19%일 때부터 느낌이 쎄하긴 했다. 결국 시간초과의 늪에서 벗어나지 못했다... 왜 안돼~~

백준 Swift 1334번 - 시간초과.

입력 부분 : N이 최대 50자리이기 때문에, Int로는 못받고, array로 입력받아서 해결했다.

case 1 - ex) 9999 -> 10000

N의 index0자리에 [0]을 미리 붙여놔서, 09999 -> 10000이 될 때 문제 없도록 했다.

인덱스 0부터 중간까지 돌면서 팰린드롬인지 확인한다.

case 2 - ex) 1234 -> 1235

N의 0번째 자리는 쓰이지 않는다.

인덱스 1부터 중간까지 돌면서 팰린드롬인지 확인한다.

난이도 : 실버1

풀이

// MARK: - 1334번(팰린드롬) - 시간초과
var N: [Int] = [0] + readLine()!.map{Int(String($0))!}
//var newN: [Int] = N

while true {
    // newN값 1 증가.
    N[N.count-1] += 1 // 가장 끝부분 1증가.
    
    for i in stride(from: N.count-1, through: 1, by: -1) {
        if N[i] >= 10 {
            if i == 1 { // 가장 앞부분 자리수가 바껴야 한다면, ex) 09999 -> 10000
                N[i] = 0
                N[0] = 1
//                N.insert(1, at: 0)
//                    break // 있어도 되고, 없어도 됨. 어차피 for문의 가장 마지막이라.
            }
            else { // 그 외 자리수가 바뀐는 거라면,
                N[i] = 0
                N[i - 1] += 1
            }
        }
    }
    
    if N[0] == 1 { // ex) 09999 -> 10000
        if isPalindrome0(N) { // 팰린드롬이라면,
            print(N.map{String($0)}.joined(separator: "")) // joined로 정답 출력.
            break
        }
    }
    else { // ex) 01234 -> 01235
        if isPalindrome1(N) { // 팰린드롬이라면,
            print(N[1...N.count-1].map{String($0)}.joined(separator: "")) // joined로 정답 출력.
            break
        }
    }
}

func isPalindrome0(_ nArray: [Int]) -> Bool { // nArray의 맨 앞 자리가 유효할 때. ex) 09999 -> 10000
    let length: Int = nArray.count
    var flag: Bool = true
    
    for i in 0..<length/2 { // 처음(0)부터 중간까지 돎.
        if nArray[i] != nArray[length - 1 - i] {
            flag = false
            break
        }
    }
    return flag
}

func isPalindrome1(_ nArray: [Int]) -> Bool { // nArray의 맨 앞 자리가 유효하지 않을 때. ex) 01234 -> 01235
    let length: Int = nArray.count
    var flag: Bool = true
    
    for i in 1...length/2 { // 1부터 중간까지 돎.
        if nArray[i] != nArray[length - i] {
            flag = false
            break
        }
    }
    return flag
}

백준 Swift 1747번

문제 유형 : 소수(에라토스테네스의 체) + 팰린드롬

에라토스테네스의 체에 대해 몰랐다. "소수 판별 시 √n까지만 판별하면 소수인지 아닌지 알 수 있다는 사실"을 알았다.

에라토스테네스의 체와 팰린드롬을 체크하는 함수 두개를 합쳐서 풀면 된다.

난이도 : 실버1

풀이

// MARK: - 1747번(에라토스테네스의 체 + 팰린드롬)
import Foundation
var N = Int(readLine()!)!
while true {
    if isPrime(N) { // 소수인데,
        if isPalindrome(String(N).map{String($0)}) { // 팰린드롬이기까지 하면,
            print(N)
            break
        }
    }
    N += 1
}

func isPrime(_ num: Int) -> Bool { // 소수인지 확인하는 함수.
    if num < 4 {
        return num == 1 ? false : true // 1은 false, 2와 3은 true
    }
    let end: Int = Int(sqrt(Double(num))) // Int(√n)까지만.
    for i in 2...end {
        if num % i == 0 { // 약수가 있다면, 소수가 아님.
            return false
        }
    }
    return true
}

func isPalindrome(_ numArray: [String]) -> Bool { // 팰린드롬인지 확인하는 함수.
    let length: Int = numArray.count
    var flag: Bool = true

    for i in 0..<length/2 {
        if numArray[i] != numArray[length - 1 - i] {
            flag = false
            break
        }
    }
    return flag
}

에라토스테네스의 체

문제 유형 : 에라토스테네스의 체

소수 구하는 최적의 방식에 대해 공부했다. 임의의 수(n)의 약수는 대칭이라는 특징을 이용해, √n까지만 판별하면 소수인지 아닌지 알 수 있다.

참고 자료 : https://www.youtube.com/watch?v=5ypkoEgFdH8

소수 판별 - 임의의 수만 판별할 때

// MARK: - 소수 판별
import Foundation // sqrt를 위해.
func isPrime(_ num: Int) -> Bool {
    if num < 4 {
        return num == 1 ? false : true // 1은 false, 2와 3은 true
    }
    
    let end: Int = Int(sqrt(Double(num))) // Int(√n)까지만.
    for i in 2...end {
        if num % i == 0 { // 약수가 있다면, 소수가 아님.
            return false
        }
    }
    return true
}

//print(isPrime(1)) // false
//print(isPrime(2)) // true
//print(isPrime(3)) // true
//print(isPrime(4)) // false
//print(isPrime(5)) // true
//소수 관련 문제(백준 1978번) : https://www.acmicpc.net/problem/1978

에라토스테네스의 체 - 대량의 수를 한꺼번에 판별할 때

// MARK: - 에라토스테네스의 체
let N = Int(readLine()!)!
var arr: [Int] = [-1] + Array(repeating: -1, count: N)

if N >= 2 { // N == 1 방지
    for i in 2...N {
        arr[i] = i
    }
}

if N >= 2 { // N == 1 방지
    for i in 2...N {
        if arr[i] != -1 { // i위치의 값이 지워지지 않았다면,
            for j in stride(from: 2*i, through: N, by: i) { // i의 배수들은 모두 지워줌.
                arr[j] = -1
            }
        }
    }
}

print(arr.filter{$0 != -1}) // 지워지지 않고 남은 것들만 출력.

백준 Swift 10942번

문제 유형 : 팰린드롬

문제를 딱 보고 dp를 써야 될 거 같다고 생각이 들었다.

맨 처음엔 바텀업 방식이니까 밑에부터 올라가는 식으로 해야 된다고 생각해서 못풀다가, 힌트를 보고 풀었다.

힌트 : S...E가 팰린드롬이려면, S+1...E-1도 팰린드롬이어야 한다.

풀이 방법

dp배열을 만들고,

(1,1), (2,2), (3,3), ... (N,N)은 무조건 팰린드롬이다. 미리 세팅한다.

dp[S][E]를 알기 위해선, dp[S+1][E-1]을 이용하면 빠르게 알 수 있다. 근데 만약 (3,4)라면 공식을 이용시 (4,3)이라는 필요없는 부분을 검사하게 된다.

그래서 미리 (1,2), (2,3), (3,4), ... (N-1, N) 도 미리 세팅한다.

for i in 1...N {
    dp[i][i] = true // 1자리수는 무조건 팰린드롬.
}

for i in 1..<N {
    if arr[i] == arr[i + 1] { // dp공식을 위해 미리 체크해놓음.
        dp[i][i + 1] = true
    }
}

하단 종이 풀이에서, 빨간 동그라미부터 낮은 방향으로 가면 된다. 1행은 체크표시하지 않았다. (그냥)

즉, N-2행부터 1행까지, i+2열부터 N까지 확인하면 된다.

추가적으로, arr[S]와 arr[E]도 확인해야 진짜 팰린드롬인지 알 수 있다.

(dp[S+1][E-1] == true) && (arr[S] == arr[E]) 를 모두 만족하면 팰린드롬이다.

for i in stride(from: N-2, through: 1, by: -1) {
    for j in i+2...N { // i와 i+1은 미리 세팅됨.
        if (dp[i + 1][j - 1]) && (arr[i] == arr[j]) {
            dp[i][j] = true
        }
    }
}

백준 Swift 10942번 고민.

추가적으로, 풀이 자체는 맞는데, Swift에 할당된 시간이 부족해서 시간초과가 난다.

FileIO를 써서 해결하면 된다.

틀렸습니다가 뜬 이유는..... 가장 마지막 부분에 print(answer)를 안해줘서..... 이런 실수는 Naver~~가자!

백준 Swift 10942번 해결.

난이도 : 골드4

참고 자료 : https://4z7l.github.io/2021/04/07/algorithms-boj-10942.html

풀이 - FileIO 사용

// MARK: - 10942번(dp + 팰린드롬)
import Foundation
// 라이노님의 FileIO
final class FileIO {
    private var buffer:[UInt8]
    private var index: Int
    
    init(fileHandle: FileHandle = FileHandle.standardInput) {
        buffer = Array(fileHandle.readDataToEndOfFile())+[UInt8(0)] // 인덱스 범위 넘어가는 것 방지
        index = 0
    }
    
    @inline(__always) private func read() -> UInt8 {
        defer { index += 1 }
        
        return buffer.withUnsafeBufferPointer { $0[index] }
    }
    
    @inline(__always) func readInt() -> Int {
        var sum = 0
        var now = read()
        var isPositive = true
        
        while now == 10
                || now == 32 { now = read() } // 공백과 줄바꿈 무시
        if now == 45{ isPositive.toggle(); now = read() } // 음수 처리
        while now >= 48, now <= 57 {
            sum = sum * 10 + Int(now-48)
            now = read()
        }
        
        return sum * (isPositive ? 1:-1)
    }
    
    @inline(__always) func readString() -> String {
        var str = ""
        var now = read()
        
        while now == 10
                || now == 32 { now = read() } // 공백과 줄바꿈 무시
        
        while now != 10
                && now != 32 && now != 0 {
            str += String(bytes: [now], encoding: .ascii)!
            now = read()
        }
        
        return str
    }
}

// 풀이
let file = FileIO()
//let N = Int(readLine()!)!
let N = file.readInt()
//var arr: [Int] = [-1] + readLine()!.split(separator: " ").map{Int(String($0))!}
var arr: [Int] = [-1]
for _ in 0..<N {
    arr.append(file.readInt())
}
//let M = Int(readLine()!)!
let M = file.readInt()
//var question: [(start: Int, end: Int)] = []
//for _ in 0..<M {
//    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
//    question.append((input[0], input[1]))
//}
var dp: [[Bool]] = Array(repeating: Array(repeating: false, count: N + 1), count: N + 1)

for i in 1...N {
    dp[i][i] = true // 1자리수는 무조건 팰린드롬.
}

for i in 1..<N {
    if arr[i] == arr[i + 1] { // dp공식을 위해 미리 체크해놓음.
        dp[i][i + 1] = true
    }
}

for i in stride(from: N-2, through: 1, by: -1) {
    for j in i+2...N { // i와 i+1은 미리 세팅됨.
        if (dp[i + 1][j - 1]) && (arr[i] == arr[j]) {
            dp[i][j] = true
        }
    }
}

//for q in question {
//    if dp[q.start][q.end] { // 팰린드롬인 경우,
//        print(1)
//    }
//    else { // 팰린드롬이 아닐 경우,
//        print(0)
//    }
//}

var answer = ""
for _ in 0..<M {
    let (S, E) = (file.readInt(), file.readInt())
    answer += (dp[S][E] == true ? "1\n" : "0\n")
}
print(answer)

풀이 : 시간초과(FileIO 미사용)

// MARK: - 10942번(dp + 팰린드롬) : 시간초과
let N = Int(readLine()!)!
var arr: [Int] = [-1] + readLine()!.split(separator: " ").map{Int(String($0))!}
let M = Int(readLine()!)!
var question: [(start: Int, end: Int)] = []
for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    question.append((input[0], input[1]))
}
var dp: [[Bool]] = Array(repeating: Array(repeating: false, count: N + 1), count: N + 1)

for i in 1...N {
    dp[i][i] = true // 1자리수는 무조건 팰린드롬.
}

for i in 1..<N {
    if arr[i] == arr[i + 1] { // dp공식을 위해 미리 체크해놓음.
        dp[i][i + 1] = true
    }
}

for i in stride(from: N-2, through: 1, by: -1) {
    for j in i+2...N { // i와 i+1은 미리 세팅됨.
        if (dp[i + 1][j - 1]) && (arr[i] == arr[j]) {
            dp[i][j] = true
        }
    }
}

for q in question {
    if dp[q.start][q.end] { // 팰린드롬인 경우,
        print(1)
    }
    else { // 팰린드롬이 아닐 경우,
        print(0)
    }
}

백준 Swift 1990번

문제 유형 : 팰린드롬

논리적으론 맞게 풀었는데, 시간 초과가 난다... 후..

Manacher 알고리즘을 적용하면 통과할 수 있을 것 같은데, 공부 후에 통과 코드를 올리도록 하겠다.

난이도 : 골드5

풀이 - 시간초과

// MARK: - 1990번(소수 + 팰린드롬) - 시간초과
import Foundation
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (a, b) = (input[0], input[1])

func isPrime(_ num: Int) -> Bool {
    if num < 4 {
        return num == 1 ? false : true // 2와 3은 소수.
    }
    
    let end: Int = Int(sqrt(Double(num)))
    
    for i in 2...end {
        if num % i == 0 { // 나뉜다면, 소수가 아님.
            return false
        }
    }
    return true
}

func isPalindrome(_ num: [String]) -> Bool {
    let length: Int = num.count
    var flag: Bool = true
    
    for i in 0..<length/2 {
        if num[i] != num[length - 1 - i] {
            flag = false
            break
        }
    }
    return flag
}

var answer: String = ""
for n in a...b {
    if isPrime(n) { // 소수인데,
        let temp = String(n).map{String($0)} // ex) 181 -> "181" -> ["1", "8", "1"]
        if isPalindrome(temp) {
            answer += "\(n)\n"
        }
    }
}
answer += "-1"
print(answer)

백준 Swift 5502번

문제 유형 : 팰린드롬 / DP / LCS

비슷한 문제(백준 1695번)를 풀었어서, 쉽게 풀 수 있었다.

arr과 뒤집은 rArr의 LCS(최장 공통 부분수열)로 풀면 된다.

단, LCS(최장 공통 문자열)는 안된다.

처음엔 문제 없다고 생각했는데, 최장 공통 문자열로 했을 땐 틀려서 고민해보니, 반례가 있다.

반례 : "abca"

"abca" 일 때 최장 공통 부분수열은 3이다. => 답 : 4 - 3 = 1

"abca" 일 때 최장 공통 문자열은 1이다. => 답 : 4 - 1 = 3

answer = N - LCS

백준 Swift 5502번 고민.

난이도 : 골드3

백준 Swift 5502번 - 시간 차이.

풀이1

// MARK: - 5502번(dp - LCS)
let N = Int(readLine()!)!
let arr: [String] = ["@"] + readLine()!.map{String($0)} // @는 인덱스 채우기용.
var dp = Array(repeating: Array(repeating: 0, count: N + 1), count: N + 1)

// LCS(최장 공통 부분수열)
for i in 1...N { // 뒤 부터 돌면서,
    for j in 1...N { // 앞 부터 돌면서,
        if arr[N + 1 - i] == arr[j] {
            dp[i][j] = dp[i - 1][j - 1] + 1 // (이전 행, 이전열의 값) + 1
        }
        else {
            dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) // max(이전 행의 같은 열, 같은 행의 이전 열)
        }
    }
}

// LCS(최장 공통 문자열) - 잘못됨. 반례 : "abca"
//for i in 1...N { // 뒤 부터 돌면서,
//    for j in 1...N { // 앞 부터 돌면서,
//        if arr[N + 1 - i] == arr[j] {
//            dp[i][j] = dp[i - 1][j - 1] + 1
//        }
//    }
//}

print(N - dp[N][N]) // N - LCS값이 정답.

풀이2 - .reversed() 사용 이유 = O(1)이라, 유의미한 시간 단축이 될 것이라 생각.

// MARK: - 5502번(dp - LCS) / .reversed()사용 : 눈에 띄는 시간 단축은 없네...
let N = Int(readLine()!)!
let arr: [String] = ["@"] + readLine()!.map{String($0)} // @는 인덱스 채우기용.
let rArr: [String] = arr.reversed()
var dp = Array(repeating: Array(repeating: 0, count: N + 1), count: N + 1)

// LCS(최장 공통 부분수열)
for i in 0..<N { // 뒤 부터 돌면서,
    for j in 1...N { // 앞 부터 돌면서,
        if rArr[i] == arr[j] {
            dp[i + 1][j] = dp[i][j - 1] + 1 // (이전 행, 이전열의 값) + 1
        }
        else {
            dp[i + 1][j] = max(dp[i][j], dp[i + 1][j - 1]) // max(이전 행의 같은 열, 같은 행의 이전 열)
        }
    }
}

print(N - dp[N][N]) // N - LCS값이 정답.

백준 Swift 1053번

문제 유형 : DP, 팰린드롬

팰린드롬 문제들 중에 Swift로 한번도 풀리지 않은 문제들이 종종 있다.

공부하면서 Swift 기준 최초 풀이에 등극할 때 마다 기분이 참 좋다. ㅎㅎ

백준 1053번 - Swift 최초 풀이 등극.

문제를 보고 사실 어떻게 풀어야 할지 모르겠어서 다른 블로그를 참고했다.

[풀이]

4개의 방법들 중, 방법4는 한번만 사용할 수 있다.

방법1,2,3은 팰린드롬을 만드는 데 이득이 되는 방향이다. 방법 1,2,3을 하고 난 뒤에 방법4를 확인하는건 이득이 없다.

최소의 횟수로 팰린드롬을 만들어야 하는 상황에서,

비유하자면 방법 1,2,3을 통해 올바르게 가고 있었는데, 방법4를 써서 후진하게 되는 것과 같다.

따라서, 방법4를 먼저 사용하고, 나머지 방법들을 통해 횟수를 기록한다.

하단 종이 풀이를 함께 참고하자.

dp[i][j] = arr[i] ~ arr[j] 까지의 문자열을 팰린드롬으로 만드는데 필요한 횟수다.

[dp배열 초기 세팅]

i부터 i까지는 이미 팰린드롬이니까 당연히 0이다.

초록 동그라미 부분도 미리 세팅한다. 값은 1 또는 0이다.

1. 방법 1이 더 필요한 경우

i부터 j-1까진 이미 팰린드롬이고, i부터 j까지 팰린드롬을 만들고 싶은 경우다. 방법1을 써서 맨 앞에 붙이면 될 것이다.

dp[i][j] = dp[i][j-1] + 1 (= 연산 횟수 1 증가)

2. 방법 2가 더 필요한 경우

i+1부터 j까진 이미 팰린드롬이고, i부터 j까지 팰린드롬을 만들고 싶은 경우다. 방법2을 써서 맨 앞(i)을 삭제하면 될 것이다.

dp[i][j] = dp[i+1][j] + 1 (= 연산 횟수 1 증가)

3. 방법 3가 더 필요한 경우

i+1부터 j-1까진 이미 팰린드롬이고, i부터 j까지 팰린드롬을 만들고 싶은 경우다.

3-1. arr[i]와 arr[j]가 같은 경우

i부터 j까지도 팰린드롬이다. 연산 횟수가 증가할 필요가 없다.(=연산할 필요가 없다.)

dp[i][j] = dp[i+1][j-1] (= 연산 횟수 증가X)

3-2. arr[i]와 arr[j]가 다른 경우

방법3을 써서 arr[i]를 arr[j]로 교체하면 될 것이다. (혹은 arr[j]를 arr[i]로.)

dp[i][j] = dp[i+1][j-1] + 1 (= 연산 횟수 1 증가)

백준 Swift 1053번 풀이.

마지막으로, 인덱스를 돌면서 최소값 of 최소값을 찾아 출력하면 된다.

var answer: Int = findMin(0, 0) // 방법4를 사용하지 않고, 방법1,2,3만을 이용해서 팰린드롬을 만드는데 필요한 횟수.

for i in 0..<N {
    for j in i+1..<N {
        let temp = findMin(i, j) + 1 // +1인 이유는, 방법4를 쓴 횟수 더해줌.
        answer = min(answer, temp)
        arr.swapAt(i, j)
    }
}
print(answer)

난이도 : 골드2

참고 자료 : https://t.ly/fCF8 | https://for-development.tistory.com/96

풀이

// MARK: - 1053번(DP, 팰린드롬)
var arr: [String] = readLine()!.map{String($0)}
let N: Int = arr.count

func findMin(_ start: Int, _ end: Int) -> Int {
    var dp = Array(repeating: Array(repeating: -1, count: N), count: N)
    arr.swapAt(start, end) // 방법4 사용.
    
    // 기본 세팅1.
    for i in 0..<N {
        dp[i][i] = 0
    }
    // 기본 세팅2.
    for i in 0..<N-1 {
        if arr[i] == arr[i + 1] { // 같으면,
            dp[i][i + 1] = 0 // 방법 사용할 필요 없으니 0.
        }
        else { // 다르면,
            dp[i][i + 1] = 1 // 방법1 사용.
        }
    }
    
    for i in stride(from: N - 2, through: 0, by: -1) {
        for j in i+2..<N {
            if arr[i] == arr[j] { // 방법3 사용.
                dp[i][j] = dp[i + 1][j - 1]
            }
            else { // 방법3 사용.
                dp[i][j] = dp[i + 1][j - 1] + 1
            }
            dp[i][j] = min(dp[i][j], dp[i][j - 1] + 1, dp[i + 1][j] + 1) // 방법3, 방법1, 방법2 중 가장 작은 값 저장.
        }
    }
    
    return dp[0][N - 1]
}

var answer: Int = findMin(0, 0) // 방법4를 사용하지 않고, 방법1,2,3만을 이용해서 팰린드롬을 만드는데 필요한 횟수.

for i in 0..<N {
    for j in i+1..<N {
        let temp = findMin(i, j) + 1 // +1인 이유는, 방법4를 쓴 횟수 더해줌.
        answer = min(answer, temp)
        arr.swapAt(i, j)
    }
}
print(answer)

DP(2-2) 문제 풀이 모음 | 백준 Swift 1520번, 2056번, 1695번, 21923번,

개발자P — Fri, 3 Jun 2022 22:14:34 +0900

{"mean":["<dicwordclass style=\"user-select: text;\">mark 미국식[mɑːrk] 영국식[mɑːk] (표기호 등으로) 표시하다 (외관을 망치는) 흔적[자국]을[이] 내다[나다] (외관을 망치는) 자국[흔적] (피부의) 점[반점] (→birthmark, marking) </dicwordclass>","<dicwordclass style=\"user-select: text;\">let 미국∙영국[let] (…하게) 놓아두다 (…을 하도록) 허락하다 레트(테니스에서 제대로 들어오기는 했으나 네트에 닿았다가 들어온 서브) 英 임대 </dicwordclass>","<dicwordclass style=\"user-select: text;\">번 (횟수, 차례, 경우) time, occasion; (시도) try (번호) number ((abb.)No.) </dicwordclass>","<dicwordclass style=\"user-select: text;\">input 미국∙영국[ˈɪnpʊt] (일사업 등을 성공시키기 위한) 조언[시간/지식 등](의 제공), 투입 컴퓨터 입력 입력하다 (→output) </dicwordclass>","<dicwordclass style=\"user-select: text;\">-let <‘작은 것’, ‘별로 중요하지 않은 것’을 나타냄> </dicwordclass>","<dicbridgeLine>","오픈","<dicwordclass style=\"user-select: text;\">mark 정정 </dicwordclass>","<dicwordclass style=\"user-select: text;\">input [명사] 전문적 지식(( 주로 복수형 inputs )) </dicwordclass>","<dicwordclass style=\"user-select: text;\">input 전문적 지식(( 주로 복수형 inputs )) </dicwordclass>","<dicwordclass style=\"user-select: text;\">VAR 부가가치 판매업자 </dicwordclass>","<dicbridgeLine>","예제","<dicbridgeLine>","VLIVE 자막"],"word":"MARK 번DFS\nlet input readLinesplitseparator mapIntString\nlet M N input input\n\nvar arr Int Arrayrepeating","basicWord":"MARK 번DFS\nlet input readLinesplitseparator mapIntString\nlet M N input input\n\nvar arr Int Arrayrepeating","soundWord":"MARK 번DFS\nlet input readLinesplitseparator mapIntString\nlet M N input input\n\nvar arr Int Arrayrepeating","phoneticSymbol":""}

문제 유형 중, DP의 추천문제들을 풀고 있습니다.

DP2의 문제양이 많아, DP2-1과 DP2-2로 나눕니다. (DP2-1은 여기서 확인할 수 있습니다.)

추천문제 번호 모음은 여기서 확인할 수 있습니다. 골드 문제입니다.

DP2-2 추천문제 번호 모음.

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

22.06.03 업데이트

22.06.06 업데이트

22.06.07 업데이트

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

https://developer-p.tistory.com/201

DP(1-1) 문제 풀이 모음 | 백준 Swift 2748번, 11051번, 2839번, 1010번, 9655번, 17626번, 1463번, 9095번, 15988번,

문제 유형 중, DP의 추천문제들을 풀어보려고 합니다. (Dynamic Programming 1) DP1과 DP2 중 DP1부터 풀어나가겠습니다. (DP1의 문제양이 많아, DP1-1과 DP1-2로 나눕니다.) 추천문제 번호 모음은 여기서 확인

developer-p.tistory.com

https://developer-p.tistory.com/203

DP(1-2) 문제 풀이 모음 | 백준 Swift 2294번, 11660번, 21317번, 22869번, 1106번, 2293번

developer Eng developer 미국∙영국[dɪˈveləpə(r)] (부동산) 개발업자[개발 회사] (신상품) 개발자[개발 회사] (사진) 현상액 a property developer 부동산 개발 업자[회사] late developer 발육[발달, 성장]..

developer-p.tistory.com

백준 Swift 1520번

문제 유형 : DFS + DP

처음에 DFS만으로 푸는 건 풀었다. 혹시나 했지만 역시나 20~30%즈음에서 시간초과...

못풀겠어서 다른 블로그를 찾아보니, DFS와 DP를 합쳐서 푸는 문제였다.

보통 DFS를 풀 땐 방문체크를 한다. DP에서 방문체크를 하기 위해선 어떻게 해야 할까?

dp를 -1로 초기화 한 뒤, -1값이라는건 첫방문이라는 뜻이다.

첫방문일 시, dp값을 0으로 바꿔주고, dfs를 다시 시작한다.

첫방문이 아닐 시, 저장된 값을 바로 return해준다. 저장된 값은 몇개의 길이 있는지에 대한 정보를 담고 있다.

목적지에 도달했을 때 1값을 return해준다.

하단 그림을 참고하자.

목적지에 도달할 때 1을 리턴해줘서, 탐색하는건 (그림기준) 위에서부터인데, 저장되는건 밑에서부터이다.

출처 - https://wootool.tistory.com/83

난이도 : 골드4

참고 자료 : https://sihyungyou.github.io/baekjoon-1520/ | https://wootool.tistory.com/83

DFS + DP

// MARK: - 1520번(DFS + DP)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (M, N) = (input[0], input[1])

var arr: [[Int]] = Array(repeating: [], count: M + 1)
arr[0] = Array(repeating: 0, count: N + 1)
for i in 1...M {
    arr[i] = [0] + readLine()!.split(separator: " ").map{Int(String($0))!}
}

var dp: [[Int]] = Array(repeating: Array(repeating: -1, count: N + 1), count: M + 1)

func isValidCoord(_ y: Int, _ x: Int) -> Bool { // 유효범위 체크.
    return (1 <= y && y <= M) && (1 <= x && x <= N)
}

func isEscape(_ y: Int, _ x: Int) -> Bool { // 도착완료 체크.
    return y == M && x == N
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]

func dfs(_ y: Int, _ x: Int) -> Int {
//    print(y, x, dp)
    if isEscape(y, x) { // 도착 시,
        return 1
    }
    
//    if dp[y][x] != -1 { // 방문 좌표일 시,
//        return dp[y][x]
//    }
    
    if dp[y][x] == -1 { // 미방문 좌표일 시,
        dp[y][x] = 0 // 우선 값 0으로 초기화.
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            
            if isValidCoord(ny, nx) && arr[y][x] > arr[ny][nx] { // 유효범위이고, 높이가 낮으면,
                dp[y][x] += dfs(ny, nx)
            }
        }
    }
    
    return dp[y][x] // 방문 좌표일 시,
}

let answer = dfs(1, 1)
print(answer)

Only DFS - 시간초과

// MARK: - 1520번(DFS)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (M, N) = (input[0], input[1])

var arr: [[Int]] = Array(repeating: [], count: M + 1)
arr[0] = Array(repeating: 0, count: N + 1)
for i in 1...M {
    arr[i] = [0] + readLine()!.split(separator: " ").map{Int(String($0))!}
}

//var dp: [[Int]] = Array(repeating: Array(repeating: -1, count: N + 1), count: M + 1)

func isValidCoord(_ y: Int, _ x: Int) -> Bool { // 유효범위 체크.
    return (1 <= y && y <= M) && (1 <= x && x <= N)
}

func isEscape(_ y: Int, _ x: Int) -> Bool { // 도착완료 체크.
    return y == M && x == N
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]

var answer: Int = 0
func dfs(_ y: Int, _ x: Int) {
    if isEscape(y, x) {
        answer += 1
        return
    }
    
    for k in 0..<4 {
        let ny = y + dy[k]
        let nx = x + dx[k]
        
        if isValidCoord(ny, nx) && arr[y][x] > arr[ny][nx] {
            dfs(ny, nx)
        }
    }
}

dfs(1, 1)
print(answer)

백준 Swift 2056번

문제 유형 : DP(반복문) / 위상 정렬(Topology Sort)

전에 위상정렬 관련 문제를 풀었었다. 근데 풀이 방법을 잊고 있었다. 위상정렬을 기억하고 있었다면, 이 문제를 보고 바로 알아챌 수 있었을 것 같은데 아쉽다. 결국 다른 블로그를 참고했다.

이 문제는 DP만으로 풀 수 있었고, 위상 정렬을 이용해서도 풀 수 있었다.

DP 풀이

미리 받아놓고 나중에 for문을 돌리는 식이 아니다.

1. i번부터 N번까지의 작업을 돌면서,

2. j를 count 개수만큼 선행 관계를 돌면서,

let beforeWorkNum = input[2 + j] // 선행 관계 작업 번호
//  dp[i] = max(dp[i], dp[beforeWorkNum] + time) (ver.1)
dp[i] = max(dp[i], dp[beforeWorkNum]) // (ver.2)

3. 구한 dp값에, i번 작업에 걸리는 시간을 더해주면 된다.

dp[i] += time // i번 작업에 걸리는 시간을 추후에 저장. (ver.2)

4. dp배열의 최대값이 정답이 된다.

위상정렬 풀이

1. 연결된 그래프를 저장한다. 각 작업의 진입차수도 저장한다.

2. 진입차수가 0인 것만 큐에 넣는다.

3. 큐가 empty가 될 때까지 돌면서,

3-1. q.popFirst()를 한다. 우선, 해당 작업(node)에 걸리는 시간을 저장한다.

let node = q.popFirst()
completeTimeArray[node] += times[node] // 우선, 해당 작업(현재꺼)에 걸리는 시간 저장.

3-2. 현재 노드(node)와 연결된 노드(nextNode)들을 돌면서,

연결된 노드(nextNode)의 진입차수를 1 감소 시키고,

연결된 노드와 현재 노드 의 값중 최대값을 저장한다.

연결된 노드의 진입 차수가 0이라면 큐에 집어 넣는다.

for nextNode in graph[node] { // 현재 노드와 연결된 노드들을 돌면서,
    indegree[nextNode] -= 1 // 연결된 노드의 진입 차수를 -1씩 감소.
    completeTimeArray[nextNode] = max(completeTimeArray[nextNode], completeTimeArray[node]) // 다음꺼 걸리는 시간, 현재꺼 걸리는 시간

    if indegree[nextNode] == 0 { // 진입 차수가 0이라면,
        q.pushLast(nextNode) // 큐에 저장.
    }
}

난이도 : 골드5

참고 자료 : https://m.blog.naver.com/ndb796/221236874984 | https://steady-coding.tistory.com/182

큐 - 위상정렬

// MARK: - 2056번(큐 - 위상정렬)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}

let N = Int(readLine()!)!
var graph: [[Int]] = Array(repeating: [], count: N + 1)
var times: [Int] = [-1] + Array(repeating: 0, count: N) // 해당 작업에 걸리는 시간들 저장.
var indegree: [Int] = [-1] + Array(repeating: 0, count: N) // 각 작업들의 진입 차수 저장.

for i in 1...N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    times[i] = input[0]
    let count: Int = input[1]
    indegree[i] = count // 진입 차수 저장.
    
    for j in 0..<count {
        let beforeWorkNum = input[2 + j] // 선행 관계 작업 번호
        graph[beforeWorkNum].append(i)
    }
}

let q: Dequeue<Int> = Dequeue([])
for i in 1...N {
    if indegree[i] == 0 {
        q.pushLast(i)
    }
}

var completeTimeArray: [Int] = [-1] + Array(repeating: 0, count: N) // 각 작업을 완료하는데 걸리는 시간.
while !q.isEmpty {
    let node = q.popFirst()
    completeTimeArray[node] += times[node] // 우선, 해당 작업(현재꺼)에 걸리는 시간 저장.
    
    for nextNode in graph[node] { // 현재 노드와 연결된 노드들을 돌면서,
        indegree[nextNode] -= 1 // 연결된 노드의 진입 차수를 -1씩 감소.
        completeTimeArray[nextNode] = max(completeTimeArray[nextNode], completeTimeArray[node]) // 다음꺼 걸리는 시간, 현재꺼 걸리는 시간
        
        if indegree[nextNode] == 0 { // 진입 차수가 0이라면,
            q.pushLast(nextNode) // 큐에 저장.
        }
    }
}

print(completeTimeArray.max()!)

반복문 - DP

// MARK: - 2056번(DP - 반복문)
let N = Int(readLine()!)!
var dp: [Int] = [-1] + Array(repeating: 0, count: N)

for i in 1...N { // 작업을 돌면서,
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let time = input[0] // i번 작업에 걸리는 시간.
    let count: Int = input[1] // 선행 관계에 있는 작업 개수
    
//    dp[i] = time // i번 작업에 걸리는 시간을 우선 저장. (ver.1)
    
    for j in 0..<count { // 선행 관계를 돌면서,
        let beforeWorkNum = input[2 + j] // 선행 관계 작업 번호
//        dp[i] = max(dp[i], dp[beforeWorkNum] + time) (ver.1)
        dp[i] = max(dp[i], dp[beforeWorkNum]) // (ver.2)
    }
    dp[i] += time // i번 작업에 걸리는 시간을 추후에 저장. (ver.2)
}

print(dp.max()!)

백준 Swift 1695번

문제 유형 : DP(재귀, 반복문) / LCS(최장 공통 부분 수열)

고민하다보니 LIS가 생각났다. 근데 다시 생각해보니 increase는 전혀 상관이 없었다. 그러다 결국 찾지 못하고 다른 블로그를 참고했다.

풀이

arr과 reverseArr의 LCS를 구하면 된다.

숫자가 같다면, dp[i][j] = dp[i - 1][j - 1] + 1

숫자가 다르다면, dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) // 이전 행의 같은 열, 같은 행의 이전 열 중 큰 값을 저장.

그 다음, 총 길이 N에서 LCS값인 dp[N][N]을 빼면 된다.

백준 Swift 1695번 고민.

난이도 : 골드4

참고 자료 : https://ddiyeon.tistory.com/67 | https://t.ly/iQq7 | https://mapocodingpark.blogspot.com/2020/07/1695.html

재귀

// MARK: - 1695번(DP - 재귀함수)
let N = Int(readLine()!)!
var arr: [Int] = [-1] + readLine()!.split(separator: " ").map{Int(String($0))!}
var dp: [[Int]] = Array(repeating: Array(repeating: -1, count: N + 1), count: N + 1)

func topDown(_ start: Int, _ end: Int) -> Int {
    if start >= end {
        return 0
    }
    
    if dp[start][end] != -1 {
        return dp[start][end]
    }
    
    if arr[start] == arr[end] { // 시작과 끝 값이 같을 때,
        dp[start][end] = topDown(start + 1, end - 1)
    }
    else { // 다를다면,
        dp[start][end] = min(topDown(start + 1, end), topDown(start, end - 1)) + 1 // min(우측에 좌측값을 넣을 때, 좌측에 우측값을 넣을 때) + 1
    }
    
    
    return dp[start][end]
}

let answer = topDown(1, N)
print(answer)

반복문

// MARK: - 1695번(DP - 반복문)
let N = Int(readLine()!)!
var arr: [Int] = [-1] + readLine()!.split(separator: " ").map{Int(String($0))!}
//var rArr = arr.reversed() // arr을 뒤집음.

var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: N + 1), count: N + 1)

for i in 1...N { // 뒤부터 돈 것(rArr)과,
    for j in 1...N { // 앞부터 돈 것(arr)에서,
        if arr[N + 1 - i] == arr[j] { // 숫자가 같다면,
            dp[i][j] = dp[i - 1][j - 1] + 1
        }
        else { // 숫자가 다르다면,
            dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) // 이전 행의 같은 열, 같은 행의 이전 열 중 큰 값을 저장.
        }
    }
}

print(N - dp[N][N])

백준 Swift 21923번

문제 유형 : DP(재귀, 반복문)

- 느낀점, 설명설명~~~

난이도 : 골드4

반복문

import Foundation

DP(2-1) 문제 풀이 모음 | 백준 Swift 15724번, 9084번, 12865번, 9251번, 2225번, 5557번, 1965번, 12015번, 12738번, 14002번, 14003번, 2631번, 2565번, 2624번, 14567번, 17485번, 21941번, 18427번, 1915번, 2228번, 2758번, 2073번

개발자P — Fri, 6 May 2022 13:36:15 +0900

문제 유형 중, DP의 추천문제들을 풀어보려고 합니다. (Dynamic Programming 2)

DP1과 DP2 중 DP2-1부분 입니다. (DP2-2은 여기서 확인할 수 있습니다.)

추천문제 번호 모음은 여기서 확인할 수 있습니다.

DP2 추천문제 번호 모음

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

22.05.06업데이트

22.05.12 업데이트

22.05.13 업데이트

22.05.16 업데이트

22.05.21 업데이트

22.05.23 업데이트

22.05.25 업데이트

22.05.26 업데이트

22.05.29 업데이트

22.05.31 업데이트

22.06.01 업데이트

22.06.02 업데이트

22.06.03 업데이트

아래 깃허브 주소에서 모든 백준 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

https://developer-p.tistory.com/201

DP(1-1) 문제 풀이 모음 | 백준 Swift 2748번, 11051번, 2839번, 1010번, 9655번, 17626번, 1463번, 9095번, 15988번,

developer-p.tistory.com

https://developer-p.tistory.com/203

DP(1-2) 문제 풀이 모음 | 백준 Swift 2294번, 11660번, 21317번, 22869번, 1106번, 2293번

백준 Swift 2293번 Eng 백준 Swift 2293번 {"mean":[" swift 미국∙영국[swɪft] (일진행 등이) 신속한[재빠른] (움직임이) 빠른[날랜] 칼새 "," 번 (횟수, 차례, 경우) time, occasion; (시도) try (번호) number..

developer-p.tistory.com

백준 Swift 15724번

문제 유형 : DP(재귀, 반복문)

- 비슷한 문제를 풀었어서 어렵지 않았다. 백준 11660번을 먼저 풀고 오면 쉽다. (풀이도 거의 같다.)

순서 1. 2차원배열의 누적합을 구해 dp배열에 넣는다.

순서 2. 그다음 원하는 직사각형의 범위에 해당하는 값을 구하면 된다.

백준 Swift 15724번 고민.

순서2가 이해가 안된다면 아래 그림을 봐보자.

예를 들어 (2,2) ~ (3,4)를 구해야 한다. 누적합dp배열을 이용해 어떻게 식을 짜면 될까?

D - A - B + C일 것이다.

즉, 전체 D에서 A와 B를 빼주고, 중복으로 뺀 C를 더해주면 흰색부분(구간합)을 구할 수 있다.

이를 식으로 쓰면 dp[3][4] - dp[3][1] - dp[1][4] + dp[1][1]이다.

dp배열 누적합 - (2, 2) ~ (3, 4)

백준 Swift 15724번 시간.

난이도 : 실버1

반복문(시간 개선 - 2차원 배열 누적합)

// MARK: - 15724번(DP - 반복문 : 시간 개선(2차원배열 누적합))
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var arr: [[Int]] = Array(repeating: [], count: N + 1)

for i in 1...N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    arr[i] = [0] + input
}
arr[0] = Array(repeating: 0, count: M + 1)

var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: M + 1), count: N + 1)
for i in 1...N {
    for j in 1...M {
        dp[i][j] = dp[i][j - 1] + dp[i - 1][j] - dp[i - 1][j - 1] + arr[i][j]
    }
}

let K = Int(readLine()!)!
for _ in 0..<K {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (x1, y1, x2, y2) = (input[0], input[1], input[2], input[3])

    let sum: Int = dp[x2][y2] - dp[x2][y1 - 1] - dp[x1 - 1][y2] + dp[x1 - 1][y1 - 1]
    print(sum)
}

반복문(맞긴 맞으나 오래걸리는 코드 - 1차원배열의 누적합을 누적해서 더함.)

처음 고민.

맞긴 맞았지만 이렇게 풀면 시간이 오래걸린다.

백준 Swift 15724번 처음 고민.

// MARK: - 15724번(DP - 반복문)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var arr: [[Int]] = Array(repeating: [], count: N + 1)

for i in 1...N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    arr[i] = [0] + input
}
arr[0] = Array(repeating: 0, count: M + 1)

var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: M + 1), count: N + 1)
for i in 1...N {
    for j in 1...M {
        dp[i][j] = dp[i][j - 1] + arr[i][j]
    }
}

let K = Int(readLine()!)!
for _ in 0..<K {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (x1, y1, x2, y2) = (input[0], input[1], input[2], input[3])
    
    var sum: Int = 0
    for x in x1...x2 {
        sum += dp[x][y2] - dp[x][y1 - 1]
    }
    print(sum)
}

백준 Swift 9084번

문제 유형 : DP(재귀, 반복문)

백준 2293번 문제와 거의 유사하다. (백준 2293번 Swift 풀이 : https://developer-p.tistory.com/203)

처음엔 2차원 배열로 풀고 싶어서 그렇게 작성했는데 50%에서 계속 안됐다.

백준 Swift 9084번 2차원 배열 풀이 도전.

질문도 남겨놨는데, 추후에 답변이 달린다면 다시 시도해봐야겠다.(https://www.acmicpc.net/board/view/89943)

백준 Swift 9084번 고민.

dp[0] 값을 1로 선언해주는게 핵심이다.

그 다음 안쪽 for문을 돌릴 때 coin...M이 아니라 굳이 stride(from: coin, through: M, by: 1)로 한 게 눈에 띌 것이다.

swift에서 for문을 돌릴 때 lowerBound가 upperBound보다 크게 되면 에러가 발생한다. 아래 이미지 처럼 말이다.

for i in 8...2 {
    print(i)
}

for문 range 에러.

하지만 stride를 쓰면 Range 에러 나는 걸 방지할 수 있다. 범위가 안맞게 되면 에러가 발생하는게 아니라 패스하게 된다.

문제에서 주어지는 coin이, 만들어야 하는 금액M보다 큰 경우를 방지하기 위해 이렇게 작성했다.

stride를 안쓰고 작성하면 런타임 에러가 발생한다.

백준 Swift 9084번 Range 에러.

난이도 : 골드5

반례

10000

9999

반복문

// MARK: - 9084번(DP - 반복문)
let T = Int(readLine()!)!

for _ in 0..<T {
    let _ = Int(readLine()!)! // N
    let coins: [Int] = readLine()!.split(separator: " ").map{Int(String($0))!}
    let M = Int(readLine()!)!
    var dp: [Int] = [1] + Array(repeating: 0, count: M)

    for coin in coins {
        for i in stride(from: coin, through: M, by: 1) {
            dp[i] = dp[i] + dp[i - coin]
        }
//        for i in coin...M {
//            dp[i] = dp[i] + dp[i - coin]
//        }
    }

    print(dp[M])
}

백준 Swift 12865번

문제 유형 : DP(재귀, 반복문)

처음에 풀었을 때, 위에서 푼 9084번 문제와 풀이가 같다고 생각했다. 주어진 TC도 통과했다. 그래서 맞는줄 알았다. 근데 틀렸다.

왜 틀렸는지 모르겠어서 고민했는데, 반례를 보고 내가 짠 코드가 왜 틀렸는지 깨달았다.

물건이 1개씩만 있다는 사실이다. (9084번 문제는 코인이 무제한이였다.)

방금 문장이 굉장히 중요한 힌트다. 이전의 값이 필요하고, 그럼 자연스레 dp배열이 2차원이어야 한다.

백준 Swift 12865번 고민 1.

그 다음, 반복문에서 bags[i].weight...K만큼은 점화식을 적용해야 하고, 그 외 부분은 dp[i][j] = dp[i - 1][j]로 신경써줘야 한다.

아래 종이에는 적혀 있지 않고, 코드를 보면 알 수 있다.

백준 Swift 12865번 고민 2.

난이도 : 골드5

반례

3 5

4 2

3 4

1 5

ans => 9가 나와야 함.

참고 자료 : https://cocoon1787.tistory.com/206

반복문

// MARK: - 12865번(DP - 반복문)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, K) = (input[0], input[1])
var bags: [(weight: Int, value: Int)] = [(0, 0)] // 인덱스0의 값은 0으로 공간메꾸기.
for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (W, V) = (input[0], input[1])
    bags.append((W, V))
}

var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: K + 1), count: N + 1)

for i in 1...N {
//    for j in stride(from: bags[i].weight, through: K, by: 1) { // 이렇게만 하면, 다음 행의 나머지 부분들의 값이 계속 유지되는게 아니라 0이 됨.
//        dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - bags[i].weight] + bags[i].value)
//    }
    for j in 1...K { // 1부터 K까지 돌면서,
        if j >= bags[i].weight { // j - bags[i].weight가 인덱스의 범위를 벗어나지 않으면,
            dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - bags[i].weight] + bags[i].value)
        }
        else { // j - bags[i].weight가 인덱스의 범위를 벗어나면,
            dp[i][j] = dp[i - 1][j]
        }
    }
}
print(dp[N][K])

백준 Swift 9251번

문제 유형 : DP(재귀, 반복문)

LCS문제를 이전에 풀어보긴 했었는데, 그 때 LCS 유형을 다시 풀어본다 했는데 역시나 어렵다.

아예 모르겠어서 다른 블로그를 참고했다.

각 문자열로 이루어진 행렬을 만들고,

문자가 같을 땐 좌상측값 + 1

문자가 다를 땐 max(좌측값, 우측값)

점화식은 아래 사진에서 확인할 수 있다.

백준 Swift 9251번 고민.

난이도 : 골드5

참고 자료 : https://st-lab.tistory.com/139

반복문

// MARK: - 9251번(DP - 반복문)
let str1: [String] = [""] + readLine()!.map{String($0)} // 하단 반복문에서 인덱스 맞추기 위해, 미리 맨 앞에 "" 붙임.
let str2: [String] = [""] + readLine()!.map{String($0)}
let (len1, len2) = (str1.count - 1, str2.count - 1)
var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: len2 + 1), count: len1 + 1)

for i in 1...len1 {
    for j in 1...len2 {
        if str1[i] == str2[j] { // 문자가 같을 땐,
            dp[i][j] = dp[i - 1][j - 1] + 1
        }
        else { // 문자가 다를 땐,
            dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
        }
    }
}
print(dp[len1][len2])

백준 Swift 2225번

문제 유형 : DP(재귀, 반복문)

처음에 보고 중복조합을 사용하려 했다. 근데 factorial이 숫자가 커지면서 불가능했다.

결국 다른 블로그를 참고했다.

사진 속 좌측 하단의 1번을 보자. (참고 자료 : https://mygumi.tistory.com/135)

dp[K]N]의 뜻은 무엇인가? -> (0~N의 숫자)K개를 더한 합이 N이 되는 경우의 수다.

dp[K][N]

K개의 숫자들 중 가장 마지막의 수를 L이라고 한다면,

K - 1개의 숫자들의 합은 N - L이 된다. => dp[K - 1][N - L]

dp[K - 1][N - L]

K-1개의 숫자들 중 가장 마지막의 수를 L'이라고 한다면,

K-2개의 숫자들의 합은 N - L - L'이 된다. => dp[K - 2][N- L - L']

이런 식으로, dp[K][N]은 Σdp[K-1][N-L] (0 <= L <= N) 이 된다.

백준 Swift 2225번 고민.

사진 속 우측 상단의 2번을 보면, (참고 자료 : https://haesoo9410.tistory.com/249)

낮은 숫자부터 나열하다보면 규칙을 찾을 수 있다.

=> dp[i][j] = dp[i - 1][j] + dp[i][j - 1]

난이도 : 골드5

반복문(1번)

// MARK: - 2225번(DP - 반복문(1))
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, K) = (input[0], input[1])

var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: N + 1), count: K + 1)

for i in 0...N {
    dp[1][i] = 1
}

for i in 1...K {
    for j in 0...N {
        for l in 0...j {
            dp[i][j] += dp[i - 1][j - l]
            dp[i][j] %= 1000000000
        }
    }
}

print(dp[K][N])

반복문(2번) - 시간 단축

// MARK: - 2225번(DP - 반복문(2) : 시간 개선)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, K) = (input[0], input[1])

var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: N + 1), count: K + 1)

for i in 1...K {
    dp[i][0] = 1
}

for i in 1...K {
    for j in 1...N {
        dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
        dp[i][j] %= 1000000000
    }
}

print(dp[K][N])

백준 Swift 5557번

문제 유형 : DP(재귀, 반복문)

dp문제일 거라고 생각하고 표를 그리고 규칙을 찾으려고 했는데 모르겠어서 결국 다른 블로그를 참고했다.

dp[i][j]의 의미는,

arr의 i번째 인덱스까지에서, j라는 결과값을 갖는 경우의 수를 의미한다.

따라서 dp의 i는 0부터 N - 1까지 있으면 된다. (중요하진 않아서 난 그냥 N으로 했다.)

따라서 dp의 j는 0 <= j <= 20이 된다.

초기값

dp[0]의 arr[0]은 반드시 식에 포함된다.

즉, dp[0][arr[0]] = 1이다.

이전 인덱스(i - 1)의 값이 j에서 존재한다면 -> j라는 값을 만들 수 있다는 뜻이다.

이전 인덱스(i - 1)의 값이 j에서 존재할 때,

더할 때(+)

j라는 값에서, 이번 인덱스(i)의 값을 더해도 20이 넘지 않는 경우에만 경우의 수를 더해줄 수 있을 것이다.

뺄 때(-)

j라는 값에서, 이번 인덱스(i)의 값을 빼도 음수가 되지 않는 경우에만 경우의 수를 더해줄 수 있을 것이다.

난이도 : 골드5

참고 자료 : https://baby-ohgu.tistory.com/23

반복문

// MARK: - 5557번(DP - 반복문)
let N = Int(readLine()!)!
var arr = readLine()!.split(separator: " ").map{Int(String($0))!}
var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: 21), count: N)

dp[0][arr[0]] = 1 // 가장 첫번째 숫자는 무조건 0~20에 포함됨.

for i in 1...N-2 {
    for j in 0...20 {
        if dp[i - 1][j] >= 1 {
            if j + arr[i] <= 20 { // 더했을 때, 20이하여야 가능.
                dp[i][j + arr[i]] += dp[i - 1][j]
            }
            
            if j - arr[i] >= 0 { // 뺐을 때, 0이상이어야 가능.
                dp[i][j - arr[i]] += dp[i - 1][j]
            }
        }
    }
}

print(dp[N - 2][arr[N - 1]])

백준 Swift 1965번

문제 유형 : DP(재귀, 반복문)

LIS관련 문제다. LIS관련된 문제를 최대한 많이 풀어보면서 공부했다. 누가 이런식으로 LIS활용 문제 번호 모음집이 있으면 좋을 것 같다.

이 문제는 LIS에 대한 언급이 없지만, 결론적으로 백준 11053번 문제와 같다.

LIS를 2중반복문으로 풀면 되는 간단한 문제다.

난이도 : 실버2

반복문

// MARK: - 1965번(DP - 반복문 / LIS - 이중반복문)
let n = Int(readLine()!)!
var arr: [Int] = readLine()!.split(separator: " ").map{Int(String($0))!}
var dp = Array(repeating: 1, count: n)

for i in 1..<n {
    for j in 0..<i {
        if arr[j] < arr[i] {
            dp[i] = max(dp[i], dp[j] + 1)
        }
    }
}

print(dp.max()!)

백준 Swift 12015번, 12738번

문제 유형 : DP(재귀, 반복문)

백준 2631번을 풀다가, LIS에 대해 모른다는 걸 느껴서 LIS를 공부하고 풀었다.

LIS를 dp로 푸는 방법은 2가지가 있다.

방법 1 : 이중 for문 - O(N^2) / 관련 문제 : https://www.acmicpc.net/problem/11053

방법 2 : 이분탐색 활용 - O(NlogN) / 관련 문제 : https://www.acmicpc.net/problem/12015

12015번은 시간초과가 나서 방법 1로는 못푼다.

LIS를 풀 때 방법2의 존재에 대해서 알고는 있었다. 미루다 오늘에서야 공부했다..ㅋㅋ

[풀이 방법]

1. dp배열을 선언한다.

단, dp배열은 부분 수열의 길이를 저장하는 게 아니라, dp배열 자체가 가장 긴 증가하는 부분 수열이 된다.

여기서 주의할 점은, dp배열이 진짜 가장 긴 증가하는 부분 수열은 아니라는 점이다. 길이만 같다.

아래 사진을 보면 이해가 쉽다. [5, 6, 7, 1]의 LIS는 [5, 6, 7]일 것이다.

하지만 이분탐색을 통해 풀면 나오는 값은 [1, 6, 7]이다.

나도 이렇게 풀면, 진짜 LIS는 아닌 거 같은데? 라는 생각으로 고민하다가 알게 됐다.

이와 관련해선 추후에 백준 14002번, 14003번 문제를 풀면 알 수 있을 것이다. (https://yabmoons.tistory.com/561)

dp 배열 설명 - 진짜 LIS는 아니다?!

2. arr을 돌면서, dp의 가장 마지막 배열과 비교한다.

2-1. 더 큰 수가 들어 온다면, (arr[i] > dp.last!)

-> dp의 끝부분에 이어 붙인다. (dp.append(arr[i]))

2-2. 작거나 같은 수가 들어온다면, (else)

-> 이분탐색을 통해 arr[i]가 들어가야 하는 위치에 대해 찾아낸 뒤, 기존의 값과 교체한다.

더 긴 수열을 만드는 데 있어서, 최대한 작은 수로 교체하는 게 이득이다.

예를 들어, dp 배열이 [3, 7, 12]와 [3, 7, 8]이라고 가정하자.

근데 뒤에 올 숫자가 만약 10이라면, 후자만 더 긴 LIS를 만들 수 있게 된다.

3. dp의 길이를 출력하면 끝이다. (dp.count)

난이도 : 골드2

참고 자료 : https://ttl-blog.tistory.com/486

반복문 - 12015번

// MARK: - 12015번(DP - 반복문) / LIS(이분탐색)
let N = Int(readLine()!)!
var arr: [Int] = readLine()!.split(separator: " ").map{Int(String($0))!}
var dp: [Int] = [arr[0]] // 이번 dp배열에선 길이를 저장하는 게 아니라, dp 전체가 가장 긴 증가하는 부분수열이 된다.(길이는 맞지만, 실제의 LIS와는 다르다.)

for i in 1..<N {
    if arr[i] > dp.last! { // dp배열의 가장 마지막에 있는 수보다 더 큰 수가 들어온다면,
        dp.append(arr[i]) // 그냥 맨 뒤에 이어 붙이면 됨.
    }
    else { // 하지만 그렇지 않다면, 이분탐색을 통해서 위치를 찾아서 넣어야 함.
        let index = binarySearch(arr[i])
        dp[index] = arr[i]
    }
}
print(dp.count)

func binarySearch(_ target: Int) -> Int { // 이분탐색
    var (low, high) = (0, dp.count - 1)
    
    while low <= high {
        let middle = (low + high) / 2
        
        if dp[middle] >= target {
            high = middle - 1
        }
        else {
            low = middle + 1
        }
    }
    
    return low
}

반복문 - 12738번

// MARK: - 12738번(DP - 반복문 / LIS - 이분탐색)
let N = Int(readLine()!)!
let arr: [Int] = readLine()!.split(separator: " ").map{Int(String($0))!}
var dp: [Int] = [arr[0]]

for i in 1..<N {
    if arr[i] > dp.last! { // 더 크면 그냥 뒤에 이어 붙이면 됨.
        dp.append(arr[i])
    }
    else {
        let index = binarySearch(arr[i])
        dp[index] = arr[i]
    }
}
print(dp.count)

func binarySearch(_ target: Int) -> Int {
    var (low, high) = (0, dp.count - 1)
    
    while low <= high {
        let middle = (low + high) / 2
        
        if dp[middle] >= target {
            high = middle - 1
        }
        else {
            low = middle + 1
        }
    }
    return low
}

백준 Swift 14002번, 14003번

문제 유형 : DP(재귀, 반복문)

[백준 14002번 풀이]

14002번은 반복문을 사용했다. 길이를 구하는 풀이는 11053번 풀이와 같다.

그 다음 각각의 인덱스에서 나올 수 있는 LIS의 길이를 담고 있는 dp배열을 보고, 어떻게 LIS배열을 구해야 할지 생각해야 된다.

이 아이디어를, 전에 이분탐색풀이(12015번)할 때 LIS배열이 이상하게 나와서, 내 생각(이상하게 나오는)이 맞는지 찾아보다가 스포? 당했다.

핵심 : dp배열의 뒤에서부터 반복문을 돌린다.

dp배열의 뒤에서부터 돌면서, dp 중 가장 큰 수를 기준으로 잡고, 기준값을 1씩 줄이면서 같은 값이 나올 때 answer 배열에 넣으면 된다.

끝까지 다 돌았다면, answer배열을 뒤집어서 출력하면 정답이다.

[백준 14003번 풀이]

LIS 문제를 풀면서, 관련 문제를 끝까지 푸는 게 좋을 거 같았다. 플래티넘 문제는 처음 풀어봤다. ~~(무섭ㅋㅋ)~~

14002번(아이디어)과 12015번(이분탐색)을 활용 +α 해서 풀면 된다.

N의 범위가 매우 크기 때문에 이분탐색을 활용한다.

핵심 : arr의 값이 dp배열에 들어갈 때, 어디에 들어가는지 위치를 저장하는 indexArray를 선언한다.

var indexArray: [Int] = [0] // dp배열에서 arr의 각 값이 몇번째 인덱스에 위치하는지 저장하는 배열.

indexArray배열의 뒤에서부터 돌면서, dp.count - 1를 기준으로 잡고, (인덱스이기 때문에 dp의 전체 갯수 - 1을 해야 끝부터 확인할 수 있다.)

기준값을 1씩 줄이면서 같은 값이 나올 때 answer 배열에 넣으면 된다.

끝까지 다 돌았다면, answer배열을 뒤집어서 출력하면 정답이다.

난이도 : 골드4 / 플래티넘 5

14003번 참고 링크 : https://yabmoons.tistory.com/561

반복문 - 14002번

// MARK: - 14002번(DP - 반복문 / LIS - 이중반복문)
let N = Int(readLine()!)!
var arr: [Int] = readLine()!.split(separator: " ").map{Int(String($0))!}
var dp: [Int] = Array(repeating: 1, count: N)

for i in 1..<N {
    for j in 0..<i {
        if arr[j] < arr[i] {
            dp[i] = max(dp[i], dp[j] + 1)
        }
    }
}

var standard: Int = dp.max()!
print(standard) // LIS의 길이 출력.
var answer: [Int] = []

for i in stride(from: N - 1, through: 0, by: -1) { // dp를 뒤에서부터 돌면서,
    if dp[i] == standard { // 기준 : 최대값부터 1까지
        answer.append(arr[i])
        standard -= 1
    }
}

answer.reverse()
print(answer.map{String($0)}.joined(separator: " "))

반복문 - 14003번

// MARK: - 14003번(DP - 반복문 / LIS - 이분탐색)
let N = Int(readLine()!)!
var arr: [Int] = readLine()!.split(separator: " ").map{Int(String($0))!}
var dp: [Int] = [arr[0]]
var indexArray: [Int] = [0] // dp배열에서 arr의 각 값이 몇번째 인덱스에 위치하는지 저장하는 배열.

for i in 1..<N {
    if arr[i] > dp.last! { // dp의 마지막 값보다 크면, 확인할 필요 없이 이어 붙이면 됨.
        dp.append(arr[i])
        indexArray.append(dp.count - 1) // dp배열에서의 위치(인덱스) 저장.
    }
    else { // dp의 마지막 값보다 크지 않다면, 이분탐색.
        let index = binarySearch(arr[i])
        dp[index] = arr[i] // 값 교체.
        indexArray.append(index) // dp배열에서의 위치(인덱스) 저장.
    }
}

print(dp.count) // LIS의 길이 출력.

var standard: Int = dp.count - 1 // 기준.
var answer: [Int] = []

for i in stride(from: N - 1, through: 0, by: -1) { // indexArray를 뒤에서부터 돌면서,
    if indexArray[i] == standard { // 기준값과 같다면,
        answer.append(arr[i])
        standard -= 1 // 기준값 -1씩.
    }
}

answer.reverse()
print(answer.map{String($0)}.joined(separator: " "))


func binarySearch(_ targetNum: Int) -> Int { // 이분탐색
    var (low, high) = (0, dp.count - 1)
    
    while low <= high {
        let middle = (low + high) / 2
        
        if dp[middle] >= targetNum {
            high = middle - 1
        }
        else {
            low = middle + 1
        }
    }
    return low
}

백준 Swift 2631번

문제 유형 : DP(재귀, 반복문)

이 문제가 LIS를 전부 공부하게 만든 이유다.

(LIS에 대해선 잘 모르고) LCS만 알고 이 문제를 접근 했을 때, LCS로 풀긴 풀었다. 아래 더보기를 누르면 더 자세한 스토리를 알 수 있다.

백준 Swift 2631번 - LCS 질문 / 스토리

백준 Swift 2631번 - LCS 질문

LIS 풀이

1. LIS의 길이를 구한다.

1-1. LIS의 길이를 구할 때 이중반복문(O(N^2)) or 이분탐색(O(NlogN))을 쓸 수 있다.

이 문제에선 N의 범위가 작기 때문에, 간단하게 이중반복문으로 구현하면 된다. (하단 코드에 두 버전 모두 올렸습니다.)

2. answer = N - LIS

우린 최종적으로 증가하는 순서대로 아이들을 배치해야 한다. 테스트케이스를 보면 알 수 있듯이, 기존에 주어지는 순서에서 이미 오름차순인 아이들의 상대위치는 변하지 않는다. (주어진 TC에서 3, 5, 6의 상대적인 순서는 그대로다. 사이에 어떤 수가 끼긴 해도, 3이 제일 앞이고, 5가 중간이고, 6이 마지막이라는 뜻이다.)

LIS는 증가하는 부분 수열이다.

이미 올바르게 서 있는 아이들의 수를 최대(= LIS)로 해야 움직이는 수가 최소가 된다. => 즉, N - LIS

난이도 : 골드5

참고 링크 : https://www.acmicpc.net/board/view/4872

반복문 - 이중반복문

// MARK: - 2631번(DP - 반복문 / LIS - 이중반복문)
let N = Int(readLine()!)!
var arr: [Int] = []
for _ in 0..<N {
    arr.append(Int(readLine()!)!)
}

var dp = Array(repeating: 1, count: N) // LIS를 저장하는 dp배열.

for i in 1..<N {
    for j in 0..<i {
        if arr[j] < arr[i] { // 증가하는 배열일 때,
            dp[i] = max(dp[i], dp[j] + 1)
        }
    }
}

let answer: Int = N - dp.max()! // N - LIS
print(answer)

반복문 - 이분탐색

// MARK: - 2631번(DP - 반복문 / LIS - 이분탐색)
let N = Int(readLine()!)!
var arr: [Int] = []
for _ in 0..<N {
    arr.append(Int(readLine()!)!)
}

var dp: [Int] = [arr[0]]

for i in 1..<N {
    if arr[i] > dp.last! { // dp의 가장 마지막에 있는 값보다 클 땐,
        dp.append(arr[i]) // dp 뒤에 이어붙이면 됨.
    }
    else { // 그렇지 않다면,
        let index = binarySearch(arr[i]) // arr[i]가 들어갈 위치를 찾고,
        dp[index] = arr[i] // 기존의 값을 변경.
    }
}

let answer: Int = N - dp.count // N - LIS
print(answer)



func binarySearch(_ targetNum: Int) -> Int { // 이분탐색
    var (low, high) = (0, dp.count - 1)
    
    while low <= high {
        let middle = (low + high) / 2
        
        if dp[middle] >= targetNum {
            high = middle - 1
        }
        else {
            low = middle + 1
        }
    }
    return low
}

LCS 관련 풀이

LCS 풀이

백준 2631번 - LCS 풀이

// MARK: - 2631번(DP - 반복문)
let N = Int(readLine()!)!
var ans = Array(0...N) // https://stackoverflow.com/questions/34571043/how-to-create-an-array-with-incremented-values-in-swift
var arr: [Int] = [0]
for _ in 0..<N {
    arr.append(Int(readLine()!)!)
}

var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: N + 1), count: N + 1)

for i in 1...N {
    for j in 1...N {
        if ans[i] == arr[j] { // 숫자가 같으면,
            dp[i][j] = dp[i - 1][j - 1] + 1
        }
        else { // 숫자가 다르면,
            dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]) // 왼쪽과 위쪽 중 큰 값.
        }
    }
}

let answer: Int = N - dp[N][N] // N - LCS
print(answer)

백준 Swift 2565번

문제 유형 : DP(재귀, 반복문)

뭔가 풀릴 것 같은데 안풀려서 고민했다.

LIS를 활용하면 될 것 같다고 생각했다. 처음엔 각각의 LIS를 구해서 N - 최댓값을 하면 될 것 같았는데 반례가 바로 나왔다.

튜플로 묶은 arr배열을 A기준 오름차순 정렬한다.

그 다음 B를 기준으로 LIS를 구한 뒤, N - LIS를 하면 된다.

백준 Swift 2565번 고민.

난이도 : 골드5

반복문

// MARK: - 2565번(DP - 반복문 / LIS - 이중반복문)
let N = Int(readLine()!)!
var arr: [(A: Int, B: Int)] = []
for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    arr.append((input[0], input[1]))
}

arr.sort(by: <) // A기준으로, 오름차순 정렬.

var dp: [Int] = Array(repeating: 1, count: N)

for i in 1..<N {
    for j in 0..<i {
        if arr[j].B < arr[i].B {
            dp[i] = max(dp[i], dp[j] + 1)
        }
    }
}

let answer: Int = N - dp.max()!
print(answer)

백준 Swift 2624번

문제 유형 : DP(재귀, 반복문)

비슷한 문제를 풀었어서 쉽게 풀 수 있을 거라고 생각했다. 계속 될 거 같은데 안풀렸다. 약 3시간을 고민했는데 결국 모르겠어서 다른 블로그를 참고했다.

근데 머리를 이미 다 썼는지... 모든 글을 찾아봐도 설명이 다 이해가 안됐다. (이 문제에 대해 설명이 있는 글이 별로 없는 것도 한 몫한 것 같다.)

풀이

1. 코인배열을 오름차순으로 정렬한다. (하지 않아도 된다.)

2. 코인(i)을 순차적으로 돌면서,

2-1. 1부터 T까지 도는 j가 currCoin보다 작을 땐 기존의 값(dp[i-1][j])을 그대로 저장한다.

2-2. 2-1에 해당하지 않는다면,

3. 사용가능한 코인 개수(currCnt)를 0개부터 currCnt를 사용한다.

3-1. 코인을 k개(0개, 1개, 2개, ... currCnt개) 썼을 때 인덱스를 벗어나지 않는 경우에만,

이전 코인(i - 1)의 현재코인을 k개 썼을 때의 값을 더한다. ( dp[i][j] += dp[i - 1][j - k * currCoin] )

백준 Swift 2624번 고민.

난이도 : 골드5

참고 자료 : https://ioqoo.tistory.com/16

반복문

// MARK: - 2624번(DP - 반복문)
let T = Int(readLine()!)!
let K = Int(readLine()!)!
var coins: [[Int]] = [[0, 0]] // [0, 0]은 인덱스 채우기용.
for _ in 0..<K {
    coins.append(readLine()!.split(separator: " ").map{Int(String($0))!})
}
coins.sort{$0[0] < $1[0]} // 동전금액기준 오름차순 정렬. (2차원배열 sort - https://stackoverflow.com/questions/31088974/use-sort-for-multidimensional-array-array-in-array-in-swift)

var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: T + 1), count: K + 1)

for i in 0...K { // 초기값 세팅.
    dp[i][0] = 1 // 0원 만드는 경우는 1가지.
}

for i in 1...K {
    let (currCoin, currCnt) = (coins[i][0], coins[i][1]) // (현재 코인, 현재 코인의 사용 가능한 개수)
    for j in 1...T {
        if j < currCoin { // 현재 비교할 코인보다 작은 인덱스일 땐,
            dp[i][j] = dp[i - 1][j] // 지난번 값 그대로 저장.
            continue
        }
        for k in 0...currCnt { // 현재 코인의 사용가능한 개수까지 사용하면서, (현재 코인 | 0개 사용일 때, 1개 사용일 때, ... currCnt개 사용일 때)
            if j - k * currCoin >= 0 { // 인덱스를 벗어나지 않는 경우에만,
                dp[i][j] += dp[i - 1][j - k * currCoin]
            }
        }
    }
}

print(dp[K][T])

백준 Swift 14567번

문제 유형 : DP(재귀, 반복문) / 위상 정렬(Topology Sort)

DP풀이를 먼저 보고, 위상 정렬풀이를 보면 쉬울 것이다.

DP 풀이

맨 처음엔 그래프문제인 거 같았지 DP문제 같아 보이진 않았다. 근데 종이에 적어보니 느낌이 바로 왔다.

이전과목의 이수학기가 다음과목의 이수학기에 영향을 끼치기 때문이다!

arr에 입력받고, from기준으로 오름차순으로 정렬한다. (선수 과목이 낮은 순서대로 정렬(A과목 기준으로)을 해야 올바르게 모든 과목을 들을 수 있을 것이다!)

arr을 돌면서 max(다음과목의 기존 값, 이전과목의 값 + 1) 중 큰 값을 다음과목의 값에 넣으면 된다.

즉, dp[line.to] = max(dp[line.to], dp[line.from] + 1) 이다.

백준 Swift 14567번 고민.

위상정렬 풀이

우선 DP로 풀고 제출해서 맞았다. 다른 사람들의 풀이가 궁금해서 보니까 큐로 풀었더라..? dp문제인데 왜 큐가 나오지 싶었다.

찾아보니까 백준 14567번 문제가 DP도 가능하고 위상정렬도 가능하다고 한다. 난 사실 위상정렬을 처음 들어봤다.

우선 진입차수(indegree)를 기록한다.

진입차수가 0인 노드들만 큐에 넣는다.

q.popFirst()를 해서 나온 노드(node)와 연결된 노드(nextNode)를 확인 후 answer값을 증가시킨다. (= 현재노드의 다음학기에 수강.)

q.popFirst()를 해서 나온 노드(node)와 연결된 노드(nextNode)의 진입차수를 낮추고, 만약 0이라면 큐에 넣는다.

반복하고 answer를 출력하면 된다.

위상정렬과 관련해서 아래 참고 자료를 확인하길 추천한다.

난이도 : 골드5

참고 자료 : https://m.blog.naver.com/ndb796/221236874984

DP - 반복문

// MARK: - 14567번(DP - 반복문)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var arr: [(from: Int, to: Int)] = []
for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    arr.append((input[0], input[1]))
}
arr.sort(by: <) // from기준 오름차순 정렬

var dp: [Int] = Array(repeating: 1, count: N + 1)
dp[0] = 0
for line in arr {
    dp[line.to] = max(dp[line.to], dp[line.from] + 1)
}

print(dp[1...N].map{String($0)}.joined(separator: " "))

위상정렬 - 큐

// MARK: - 14567번(위상정렬 - 큐)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []

    var count: Int {
        return enQueue.count + deQueue.count
    }

    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }

    init(_ queue: [T]) {
        enQueue = queue
    }

    func pushLast(_ element: T) {
        enQueue.append(element)
    }

    func pushFirst(_ element: T) {
        deQueue.append(element)
    }

    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }

    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}

let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var indegree =  Array(repeating: 0, count: N + 1) // 진입차수
var graph: [[Int]] = Array(repeating: [], count: N + 1) // 노드i에서 이동가능한 노드들 모음.
var answerArray: [Int] = Array(repeating: 1, count: N + 1) // 학기 저장 배열.

for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (from, to) = (input[0], input[1])
    graph[from].append(to)
    indegree[to] += 1 // 진입차수 저장.
}

let q: Dequeue<Int> = Dequeue([])
for i in 1...N {
    if indegree[i] == 0 { // 진입차수가 0인 것들만 큐에 넣음.
        q.pushLast(i)
    }
}

while !q.isEmpty { // 큐가 빌 때까지,
    let node: Int = q.popFirst()

    for nextNode in graph[node] {
        answerArray[nextNode] = answerArray[node] + 1 // 현재노드의 다음학기 수강.
        indegree[nextNode] -= 1 // 진입차수 감소.

        if indegree[nextNode] == 0 { // 만약 진입차수가 0이면, 큐에 넣음.
            q.pushLast(nextNode)
        }
    }
}

print(answerArray[1...N].map{String($0)}.joined(separator: " "))

백준 Swift 17485번

문제 유형 : DP(재귀, 반복문)

이 문제를 봤을 때 DP를 이용해야겠다는 느낌은 들었다.

고민을 하다가 모르겠어서 다른 블로그를 참고했다.

풀이 방법

0) 움직일 수 있는 방향을 0(↙), 1(↓), 2(↘)로 정의한다.

dp를 [y][x]와 [0 or 1 or 2]를 써서 방향을 나타낼 수 있게 3차원배열로 정의한다.

인덱스가 헷갈리지 않게 하기 위해, y와 x가 0일 때는 (최소값을 구할 거기 때문에) Int.max값으로 채워 놓는다. (1...N 과 1...M만 신경쓸 예정.)

1) y를 1...N까지 돌면서, y가 1일 땐(인덱스 0일 땐 메워둠.)

dp[1][x][0], dp[1][x][1], dp[1][x][2]에 각각의 board값을 넣는다.

전제조건 : 같은 방향 2번은 불가능하다.

2) x가 가장 좌측일 땐, 방향0과 방향1만 가능하다. 가장 좌측으로 오기 위해 방향2는 불가능하다.

2-1) 방향0일 때: 전제조건에 의해, (y - 1)행의 (x + 1)열의 방향1와 방향2 중 최소값 + board[y][x] = dp[y][x][0]값이 된다.

2-2) 방향1일 때: 전제조건에 의해, (y - 1)행의 (x)열의 방향0 값 + board[y][x] = dp[y][x][1]값이 된다.

3) x가 가장 우측일 땐, 방향 1과 방향2만 가능하다. 가장 우측으로 오기 위해 방향1은 불가능하다.

3-1) 방향2일 때: 전제조건에 의해, (y - 1)행의 (x - 1)열의 방향0 과 방향1 중 최소값 + board[y][x] = dp[y][x][2]값이 된다.

3-2) 방향1일 때: 전제조건에 의해, (y - 1)행의 (x)열의 방향2 값 + board[y][x] = dp[y][x][2]값이 된다.

4) x가 그 외일 땐, 모든 방향이 가능하다.

4-1) 방향0일 때: 전제조건에 의해, (y - 1)행의 (x + 1)열의 방향1 과 방향2 중 최소값 + board[y][x] = dp[y][x][0]값이 된다.

4-2) 방향1일 때: 전제조건에 의해, (y - 1)행의 (x)열의 방향0 과 방향2 중 최소값 + board[y][x] = dp[y][x][1]값이 된다.

4-3) 방향2일 때: 전제조건에 의해, (y - 1)행의 (x - 1)열의 방향0 과 방향1 중 최소값 + board[y][x] = dp[y][x][2]값이 된다.

5) y가 N일 때, (가장 끝에 왔을 때)

x를 1부터 M까지 돌리면서, 가장 작은 min값을 찾으면 정답이다.

백준 Swift 17485번

난이도 : 골드5

참고 자료 : https://maeng2world.tistory.com/470

반복문

// MARK: - 17485번(DP - 반복문)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])

var board: [[Int]] = Array(repeating: [], count: N + 1)
board[0] = Array(repeating: 0, count: M + 1)
for i in 1...N {
    board[i] = [0] + readLine()!.split(separator: " ").map{Int(String($0))!} // [0]은 인덱스 맞추기 위해.
}

var dp: [[[Int]]] = Array(repeating: Array(repeating: Array(repeating: Int.max, count: 3), count: M + 1), count: N + 1) // 0(↙), 1(↓), 2(↘)

for y in 1...N {
    if y == 1 { // 가장 첫 스타트일 땐 board값 dp에 저장.
        for x in 1...M {
            for d in 0..<3 {
                dp[y][x][d] = board[y][x]
            }
        }
    }
    else { // 2...N
        for x in 1...M {
            if x == 1 { // 가장 좌측일 때, 방향 0과 1은 가능. 2로 오는건 불가능.
                dp[y][x][0] = min(dp[y - 1][x + 1][1], dp[y - 1][x + 1][2]) + board[y][x] // 지난 행, 다음 열의 min(방향1, 방향2)값 + 현재값
                dp[y][x][1] = dp[y - 1][x][0] + board[y][x] // 지난 행, 같은 열의 값(방향0) + 현재값
            }
            else if x == M { // 가장 우측일 때, 방향 1과 2는 가능. 0으로 오는건 불가능.
                dp[y][x][2] = min(dp[y - 1][x - 1][0], dp[y - 1][x - 1][1]) + board[y][x] // 지난 행, 지난 열의 min(방향0, 방향1)값 + 현재값
                dp[y][x][1] = dp[y - 1][x][2] + board[y][x] // 지난 행, 같은 열의 값(방향2) + 현재값
            }
            else { // 그 외,
                dp[y][x][0] = min(dp[y - 1][x + 1][1], dp[y - 1][x + 1][2]) + board[y][x] // 지난 행, 다음 열의 min(방향1, 방향2)값 + 현재값
                dp[y][x][1] = min(dp[y - 1][x][0], dp[y - 1][x][2]) + board[y][x] // 지난 행, 같은 열의 min(방향0, 방향2)값 + 현재값
                dp[y][x][2] = min(dp[y - 1][x - 1][0], dp[y - 1][x - 1][1]) + board[y][x] // 지난 행, 지난 열의 min(방향0, 방향1)값 + 현재값
            }
        }
    }
}

var answer: Int = Int.max
for x in 1...M {
    answer = min(answer, dp[N][x].min()!)
}
print(answer)

백준 Swift 21941번

문제 유형 : DP(재귀, 반복문) / 그리디(X)

어떻게 풀어야할지 고민해봤지만 잘 모르겠었다. 처음엔 DP가 아닌 그리디 풀이법을 생각했다. 그러다 결국 다른 블로그를 참고했다.

문제 푸는 로직은 이해됐는데, 이를 Swift로 구현하려고 하니까 힘들었다...(하단 3-2부분)

그래도 해결했으니 잘 설명해보겠다!

백준 Swift 21941번 - Swift기준 최초의 풀이 등극!

백준 21941번 DP풀이

1. S배열에 [String]으로 저장한다. ["0"]을 맨 앞에 붙여서, 인덱스를 맞춰준다.

2. dp배열을 0부터 S.count만큼 만들고, 1씩 증가하게 값을 저장한다. (사실 그냥 값을 0으로 초기화해도 상관없다.)

1씩 증가하게 저장한 이유는 문자열조건(A)에 해당하는 게 없으면 점수가 1씩 증가하기 때문이다.

3. i를 1부터 sLength만큼 돌면서,

3-1. 우선 기존의 값(dp[i])과 dp[i -1] + 1 중 큰 값을 저장한다. (+1은 문자열조건(A)에 해당하는 게 없으면 1을 더해주는 것이다.)

dp[i] = max(dp[i], dp[i - 1] + 1) // 문자열조건에 해당되는 게 없을 땐 1점만.

3-2. [String]의 일부로 String을 만들고, 만든 String이 임의의 String으로 시작하는지 체크하는 게 필요했는데, 여기가 Swift로 구현이 힘들었다.

배열 S 인덱스의 i부터 끝까지로 String을 만든다. = testS

testS를 만든 이유는, condition.str이 문자열조건(A)으로 시작하는지 체크하기 위함이다.

let testS: String = S[i...sLength].joined(separator: "") // S의 i부터 끝까지를 String으로 만든 다음, 그 String이 문자열조건(A)로 시작하는지 체크.

4. 조건들(문자열조건(A), 점수)을 돌면서,

4-1. 만약 testS가 문자열조건(A)으로 시작한다면, (hasPrefix관련 : https://stackoverflow.com/questions/32664543/swift-startswith-method)

4-2. 문자열조건(A)의 길이만큼 인덱스를 옮긴 곳에, max(기존 값, (i - 1)의 dp값 + 조건 점수) 큰 값을 저장한다.

인덱스가 i가 아닌, (i - 1)이어야 str의 길이를 더했을 때 dp의 알맞은 인덱스에 위치하게 된다. 종이 풀이의 좌측 하단 dp표를 참고하면 이해가 쉽다.

for condition in arr { // 조건들(문자열조건(A), 점수)을 돌면서,
        if testS.hasPrefix(condition.str) { // testS가 문자열조건(A)으로 시작한다면,
            dp[(i - 1) + condition.str.count] = max(dp[(i - 1) + condition.str.count], dp[i - 1] + condition.score) // 문자열조건(A)의 길이만큼 인덱스를 옮겨서, max(기존 값, (i - 1)의 dp값 + 조건 점수) 큰 값을 저장한다.
        }
    }

5. DP의 가장 끝 값을 출력하면 끝!

백준 Swift 21941번 고민.

백준 Swift 21941번 - DP값 출력 결과.

백준 21941번 그리디 풀이 - 97%에서 틀림.

풀이 1. 조건들 중, str의길이가 점수(X)보다 작으면 교체하는 게 손해다. 그런 조건은 arr에 넣지 않는다.

풀이 2. arr을 교체효율이 좋은 순으로 정렬한다. str의 길이는 짧을 수록, 점수는 클 수록 이득이다.

arr 정렬 기준 : score / length

풀이 3. 문자열S에 condition.str이 존재한다면,

풀이 3-1. .replacingOccurrences를 통해 "_"로 교체한다. 단점은 몇개가 교체됐는지 한 번에 알 수 없다는 것이다.

풀이 3-2. 단점을 해결하기 위해, countArray를 둬 각 조건에 의해 변경된 개수를 저장한 걸 이용해 nowCount를 구한다.

풀이 4. "_"로 교체되지 않은 나머지(remain)의 개수만큼 더해주면 끝!

풀이가 틀린 게 없는 것 같은데.... 왜 97%에서 틀리는지 모르겠다... 어디가 틀렸는지 아시겠는 분은 꼭 좀 댓글이나 백준답변으로 달아주시면 감사하겠습니다. (백준 질문 글 - https://www.acmicpc.net/board/view/91564 / 백준 반례 글 - https://www.acmicpc.net/board/view/89027)

22.05.31 추가 내용 : 반례 글을 보니까, 제 생각에 이 문제는 그리디로는 불가능 한 것 같습니다..!

난이도 : 골드5

참고 자료 : https://t.ly/DZ29w | https://stackoverflow.com/questions/25827033/how-do-i-convert-a-swift-array-to-a-string | https://t.ly/Yewx

(여기선 결국 필요 없었지만 유용한) 참고 자료 : https://stackoverflow.com/questions/56175794/check-if-a-string-is-substring-of-another-string-using-swift-5

DP - 반복문

// MARK: - 21941번(DP - 반복문)
import Foundation
let S: [String] = ["0"] + readLine()!.map{String($0)} // 0은 인덱스 채우기 용.
let M = Int(readLine()!)!
var arr: [(str: String, score: Int)] = []

for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{String($0)}
    let (A, X): (String, Int) = (input[0], Int(input[1])!) // 문자열조건, 점수
    arr.append((A, X))
}

var dp: [Int] = Array(repeating: 0, count: S.count)
for i in 0..<dp.count {
    dp[i] = i
}

let sLength: Int = S.count - 1 // 입력받은 S의 진짜 길이.
for i in 1...sLength {
    dp[i] = max(dp[i], dp[i - 1] + 1) // 문자열조건에 해당되는 게 없을 땐 1점만.
    
    let testS: String = S[i...sLength].joined(separator: "") // S의 i부터 끝까지를 String으로 만든 다음, 그 String이 문자열조건(A)로 시작하는지 체크.
    
    for condition in arr { // 조건들(문자열조건(A), 점수)을 돌면서,
        if testS.hasPrefix(condition.str) { // testS가 문자열조건(A)으로 시작한다면,
            dp[(i - 1) + condition.str.count] = max(dp[(i - 1) + condition.str.count], dp[i - 1] + condition.score) // 문자열조건(A)의 길이만큼 인덱스를 옮겨서, max(기존 값, (i - 1)의 dp값 + 조건 점수) 큰 값을 저장한다.
        }
    }
//    print(dp)
}
print(dp.last!)

그리디 - 97%에서 틀림.

// MARK: - 21941번(그리디 - 97%에서 틀림.)
import Foundation
//let S: [String] = readLine()!.map{String($0)}
var S: String = readLine()!
let M = Int(readLine()!)!
var arr: [(str: String, length: Double, score: Double)] = []

for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{String($0)}
    let (A, X): (String, Double) = (input[0], Double(input[1])!) // 문자열조건, 점수
    
    if X / Double(A.count) > 1 { // 효율이 1이하면 문자열교체하는게 손해임. (교체안하고 그냥 1점씩 받는 게 더 이득.)
        arr.append((A, Double(A.count), X))
    }
//    if A.count < Int(X) { // 위 if문과 같은 의미.
//        arr.append((A, Double(A.count), X))
//    }
}

arr.sort(by: {($0.score / $0.length) > ($1.score / $1.length)}) // 내림차순 정렬.(효율적인 것부터 앞으로)

var sum: Int = 0
var countArray: [Int] = [0] // 문자열조건에 의해 바뀐 개수 저장하는 배열.
for condition in arr { // 조건을 돌면서,
    if S.contains(condition.str) { // S에 문자열조건이 있다면, (check String contain String - https://stackoverflow.com/questions/56175794/check-if-a-string-is-substring-of-another-string-using-swift-5)
        S = S.replacingOccurrences(of: condition.str, with: "_") // 문자열을 "_"로 대체.
        
        let totalCount = S.filter{$0 == "_"}.count // 지금까지 문자열조건에 의해 바뀐 총개수 카운트.
        let nowCount = totalCount - countArray.reduce(0, +) // 현재 문자열조건에 의해 바뀐 개수.
        countArray.append(nowCount)
        
        sum += Int(condition.score) * nowCount
    }
}

let remain: Int = S.filter{$0 != "_"}.count // 문자열조건들에 바뀌지 않은, 나머지들.
sum += remain // 나머지들 개수만큼 +1.
print(sum)

백준 Swift 18427번

문제 유형 : DP(재귀, 반복문)

온전히 나의 힘으로 풀었다!! 백준 2624번 문제와 매우 유사하다.

21941번 이후 또다시 Swift기준 최초 풀이 등극했다! 후훗 뭔가 뿌듯하다.

백준 Swift 18427번 - Swift기준 최초의 풀이 등극!

백준 18427번 풀이

풀이 1. 학생들의 블록을 저장한다. [0]은 인덱스 채우기 용.

var studentBlocks: [[Int]] = [[0]] // 학생들 블록 저장하는 배열.

풀이 2. dp를 (N + 1) * (H + 1) 사이즈의 2차원배열을 선언한다.

풀이 2-1. 각 행의 0번째열의 값을 1로 채운다.

풀이 2-2. 1번 학생(1번행)의 블록값(num)과 같은 열의 값을 1로 채운다.

var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: H + 1), count: N + 1)
for i in 1...N { // 초기 세팅.
    dp[i][0] = 1 // 인덱스 0번째는 1로 채워놓는다.
}

for num in studentBlocks[1] { // 초기 세팅.
    dp[1][num] = 1 // 1번학생이 갖고 있는 블록들과 같은 인덱스들의 값을 1로 채워놓는다.
}

풀이 3. 2번째 학생부터 N번째 학생까지 돌면서, (= i를 2...N까지 돌면서,)

풀이 3-1. 1번열부터 H열까지 돌면서,

풀이 3-2. 우선 이전 행의 dp값을 저장한다. dp[i][j] = dp[i-1][j]

풀이 3-3. i번째 학생이 갖고 있는 블록들을 돌면서,

j - num이 인덱스를 벗어나지 않을 때에만 이전 행의 (j-num)열 값들을 더한다.

풀이 4. dp[N][H] % 10007를 출력하면 끝!

백준 Swift 18427번 고민.

Swift 주의사항

계속 100%에서 런타임에러가 떠서 당혹스러웠다.

찾아보니 100%에서 에러가 뜨는거면, 최소값에서 에러가 생기는 확률이 크다고 했다.

아래 반례에서 실제로 에러가 나왔다.

이유는 for문을 2...N으로 돌렸는데, N이 1일 때 문제가 생기는 것이었다.

stride로 for문 돌게 변경해주고 정답!

반례
1 1 1
1

=> 1이 나와야 함.

난이도 : 골드4

참고 자료 : https://www.acmicpc.net/board/view/44660

반복문

// MARK: - 18427번(DP - 반복문)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M, H) = (input[0], input[1], input[2])
var studentBlocks: [[Int]] = [[0]] // 학생들 블록 저장하는 배열.
for _ in 0..<N {
    studentBlocks.append(readLine()!.split(separator: " ").map{Int(String($0))!}.sorted(by: <)) // 오름차순으로 정렬해서 넣어놓음.
}

var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: H + 1), count: N + 1)
for i in 1...N { // 초기 세팅.
    dp[i][0] = 1 // 인덱스 0번째는 1로 채워놓는다.
}

for num in studentBlocks[1] { // 초기 세팅.
    dp[1][num] = 1 // 1번학생이 갖고 있는 블록들과 같은 인덱스들의 값을 1로 채워놓는다.
}

for i in stride(from: 2, through: N, by: 1) { // 2...N으로 하면 1에서 에러남. (그래서 stride로 함.)
    for j in 1...H { // 1번째 열부터 H열까지 돌면서,
        dp[i][j] = dp[i - 1][j] % 10007 // 우선 이전 행 dp값 저장.
        
        for num in studentBlocks[i] { // i번째 학생이 갖고 있는 블록들 중,
            if j - num >= 0 { // 인덱스를 벗어나지 않을 때에만,
                dp[i][j] += (dp[i - 1][j - num]) % 10007 // 이전 행의 (j-num)열 값들을 더함.
            }
        }
    }
}
print(dp[N][H] % 10007)

백준 Swift 1915번

문제 유형 : DP(재귀, 반복문)

조금 더 고민했으면 혼자 힘으로 풀 수 있었을 것 같은데 뭔가 아쉽다. 모르겠어서 다른 블로그를 참고했다.

사각형의 우측 하단을 기준으로 dp를 저장해가면 된다.

dp[i][j]는 i행j열 기준으로, 만들 수 있는 최대 정사각형의 한변의 길이다.

풀이 1. 0행이거나 0열이면 dp값은 arr[i][j]의 값이다.

풀이 2. 그 외에서,

풀이 2-1. arr[i][j]값이 0이면 -> dp값은 0이다.

풀이 2-2. arr[i][j]값이 1이면 -> dp값은 ↖, ↑, ← 중 최소값 + 1이다.

풀이 3. dp배열 중 최대값 * 최대값이 정답.

백준 Swift 1915번 고민.

난이도 : 골드4

참고 자료 : https://kyun2da.github.io/2021/04/09/biggestSquare/ | https://t.ly/y8dE

반복문

// MARK: - 1915번(DP - 반복문)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (n, m) = (input[0], input[1])
var arr: [[Int]] = []
for _ in 0..<n {
    arr.append(readLine()!.map{Int(String($0))!})
}

var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: m), count: n)

for i in 0..<n { // 초기세팅 - 0열
    dp[i][0] = arr[i][0]
}

for j in 0..<m { // 초기세팅 - 0행
    dp[0][j] = arr[0][j]
}


for i in 1..<n {
    for j in 1..<m {
        if arr[i][j] == 0 { // 값이 0이면,
            dp[i][j] = 0 // 사각형이 애초에 불가능.
        }
        else { // 값이 1이면,
            dp[i][j] = min(dp[i - 1][j - 1], dp[i - 1][j], dp[i][j - 1]) + 1 // ↖, ↑, ← 중 최소값 + 1
        }
    }
}

var maxValue: Int = -1
for i in 0..<n { // 각 행을 돌면서,
    maxValue = max(maxValue, dp[i].max()!) // 최대값 비교.
}
print(maxValue * maxValue)

백준 Swift 2228번

문제 유형 : DP(재귀, 반복문)

딱 보고 여러가지 테스트케이스를 만들어서 시도해봤으나 규칙이나 감이 전혀 안왔다... 결국 다른 블로그를 참고했는데, 봐도 처음엔 이해가 안됐다.

바텀업 방식으로 보통 DP문제를 풀어 왔는데, 이 문제는 바텀업방식이 되려 복잡하고 이해가 잘 안됐다.

탑다운 방식(재귀)으로 설명을 하겠다.

풀이

풀이 1. (1...N까지의) 각각의 누적합(cumSum)을 구한다. 0번째는 인덱스 채우기 용.

풀이 2. dp는 (N+1)*(M+1)의 사이즈로 구성한다. 각행과 각열의 0번째는 인덱스 채우기 용.

arr의 최대 개수는 100개(N이 최대 100)이고, 수의 최소값은 -32768이다.

따라서, 누적합의 가능한 최소값은 -32768 * 100개일 것이다. dp에 초기값으로 불가능한 값을 넣어놔야 하기 때문에 아래처럼 세팅했다.

let initValue: Int = (-32768 * 100) - 1 // 최소값 -32768 * 최대 100개 -> 가능한 최소 누적합, 거기에 -1을 해야 불가능한 값이 됨.

풀이 3. arr 관련된 그림 - 아래 종이풀이를 확인하자. 경우가 2가지로 나뉜다.

풀이 3-1. (우리에게 필요한) index번째 수가, 구간 section에 속하지 않을 때(X)

: index - 1번째 수의 값과 같을 것이다.

즉, dp[index][section] = solve(index - 1, section)이다.

풀이 3-2. index번째 수가, 구간 section에 속할 때(O)

: 하단 그림을 참고해서 보자.

임의의 수 k부터 n(=index)까지 -> 구간 section에 속한다는 뜻이다.

우리는 가장 끝에 있는 n(=index번째) 수가, 어디부터 시작된 게(=k, k-1, k-2, ...) 구간 section의 최대값인지 알지 못한다.

즉, 구간 section의 최대값을 알기 위해선 다음과 같다.

-> (k - 2번째 수, 구간 section - 1)의 값 + Σarr[k...n] 이다.

Σarr[k...n] = cumSum[n] - cumSum[k-1] 이다.

다시 써보자면,

dp[index][section] = solve(k - 2, section - 1) + (cumSum[n] - cumSum[k-1]) 가 된다.

우린 최대값을 구하는 거니까, 기존의 dp값과 비교를 해주는 부분도 추가되어야 한다.

for k in stride(from: index, through: 1, by: -1) {
	dp[index][section] = max(dp[index][section], solve(k - 2, section - 1) + (cumSum[index] - cumSum[k - 1]))
}

재귀함수에서,

범위를 벗어나거나 방문한 적이 있다면 return을 해줘서 빠르게 벗어날 수 있게 한다.

if section == 0 {
        return 0
}
if index <= 0 { // index를 벗어날 땐,
    return initValue
}

if visited[index][section] { // 방문한 적이 있다면,
    return dp[index][section]
}

visited[index][section] = true // 방문 기록.

백준 Swift 2228번 고민.

난이도 : 골드4

재귀 참고자료 : https://loosie.tistory.com/260

반복문 참고자료: https://lotuslee.tistory.com/116 | https://ddiyeon.tistory.com/62

재귀

// MARK: - 2228번(DP - TopDown)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var arr: [Int] = [-32769]
for _ in 0..<N {
    arr.append(Int(readLine()!)!)
}
let initValue: Int = (-32768 * 100) - 1 // 최소값 -32768 * 최대 100개 -> 가능한 최소 누적합, 거기에 -1을 해야 불가능한 값이 됨.
var dp: [[Int]] = Array(repeating: Array(repeating: initValue, count: M + 1), count: N + 1)
var cumSum: [Int] = Array(repeating: 0, count: N + 1) // 누적합

for i in 1...N { // 누적합 저장.
    cumSum[i] = cumSum[i - 1] + arr[i]
}
//print(cumSum)
var visited: [[Bool]] = Array(repeating: Array(repeating: false, count: M + 1), count: N + 1) // 방문체크.

func solve(_ index: Int, _ section: Int) -> Int { // 재귀함수
    if section == 0 {
        return 0
    }
    if index <= 0 { // index를 벗어날 땐,
        return initValue
    }
    
    if visited[index][section] { // 방문한 적이 있다면,
        return dp[index][section]
    }
    
    visited[index][section] = true // 방문 기록.
    dp[index][section] = solve(index - 1, section) // index번째수가 구간section에 속하지 않는 경우.
    
    for k in stride(from: index, through: 1, by: -1) {
        dp[index][section] = max(dp[index][section], solve(k - 2, section - 1) + (cumSum[index] - cumSum[k - 1]))
    }
        
    return dp[index][section]
}

let answer = solve(N, M)
print(answer)

백준 Swift 2758번

문제 유형 : DP(재귀, 반복문)

dp접근은 맞았다. 지금 다시 생각해보면, 규칙도 거의 찾았는데 끝까지 고민해보지 않은 것 같다. 뭔가 아쉽다. 다른 블로그를 참고했다.

이 문제도 Swift로는 최초 풀이다!

백준 Swift 2758번 - Swift 최초 풀이 등극!

주어진 TC를 아래 종이풀이처럼 써보면 규칙이 보일 것이다.

풀이

풀이 1. i가 1일 땐, 가능한 경우의 수를 미리 저장한다.

풀이 2. i가 2이상일 때,

dp = (같은 행의) 이전 열 값 + (이전 행의) 열/2 값 이다.

즉, 점화식은 다음과 같다.

dp[i][j] = dp[i][j - 1] + dp[i - 1][j / 2] // 이전열 값 + 이전행, 열/2 값

백준 Swift 2758번 고민.

개선 가능성

지금은 새로운 테스트케이스를 돌 때마다 dp를 새로 계산하고 있다.

속도를 더 개선하려면, 미리 n과 m의 최대범위까지 계산 해서 dp배열에 넣고, 각 TC에 맞는 배열값만 출력하게 하면 속도 개선이 될 것이다.

난이도 : 골드4

참고 자료 : https://ddiyeon.tistory.com/65

반복문

// MARK: - 2758번(DP - 반복문)
let T = Int(readLine()!)!

for _ in 0..<T {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (n, m) = (input[0], input[1])
    
    var dp: [[Int]] = Array(repeating: Array(repeating: 0, count: m + 1), count: n + 1)
    
    for j in 1...m { // 초기세팅 - 1개 고를 때
        dp[1][j] = j
    }
    
    for i in stride(from: 2, through: n, by: 1) { // n이 1일 때 error를 방지하기 위해.
        for j in 1...m {
            dp[i][j] = dp[i][j - 1] + dp[i - 1][j / 2] // 이전열 값 + 이전행, 열/2 값
        }
    }
    
    print(dp[n][m])
}

백준 Swift 2073번

문제 유형 : DP(재귀, 반복문)

백준 Swift 2073번 - Swift 최초 풀이 등극!

dp의 인덱스를 0...D까지 하면 된다는 것까진 고민 했지만, 그 후에 어떻게 풀면 좋을지 모르겠었다. 결국 다른 블로그를 참고했다.

풀이

이 문제엔 2가지 핵심이 있다.

핵심 1. dp[0]에 0이 아닌 매우 큰 값을 넣어놔야 한다는 것.

핵심 2. dp의 인덱스를 뒤에서부터 돌려야 한다는 것. - 이걸 이해하는 데 애를 먹었다. ~~아직도 정확히 이해한 거 같지 않다.~~

수도관의 용량은 각 파이프.capacity들 중 최소값이다.

[for문 안에서 전제조건 : 현재 파이프를 반드시 설치는 한다.]

인덱스를 D에서부터 1까지 거꾸로 돌면서,

1. 현재 파이프의 용량이 더 작은지 VS 2. (현재 파이프) 이전까지의 용량이 더 작은지를 비교한다.

min(pipe.capacity, dp[i - pipe.length])

Case1. 2 < 1 : 현재 파이프가 용량이 더 크다는 뜻이다. -> 값은 결국 지금까지의 값(=2)으로 결정된다.

Case2. 1 < 2 : 현재 파이프가 용량이 더 작다는 뜻이다. -> 값이 현재 파이프의 용량 값(=1)으로 결정된다.

위의 순서대로 비교를 할 때, i가 0일 때 dp[0]값이 더 작은 수라면 원하는 결과가 안 나올 것이다.

이를 방지하기 위해 dp[0]에 미리 Int.max를 저장해놓는다.

"우리가 구해야 하는 최종 결론"

해당 i에서의 값(=dp[i])은 최대가 돼야 하기 때문에, max를 써서 매번 더 큰 값을 저장한다.

dp[i] = max(dp[i], min(pipe.capacity, dp[i - pipe.length]))

백준 Swift 2073번 고민.

백준 Swift 2073번 - dp표

난이도 : 골드4

참고 자료 : https://kwoncorin.tistory.com/83

반복문

// MARK: - 2073번(DP - 반복문)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (D, P) = (input[0], input[1])
var pipes: [(length: Int, capacity: Int)] = []
for _ in 0..<P {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    pipes.append((input[0], input[1])) // L, C 저장.
}
pipes.sort(by: <) // 오름차순 정렬 - 할 필요는 없음. dp값 확인 용이하게 하려고 정렬.

var dp: [Int] = [Int.max] + Array(repeating: 0, count: D) // dp[0]에 매우 큰 값을 넣어놔야, min비교할 때 정상적으로 작동함. 0이나 음수, 다른 값을 넣으면 꼬임.

for pipe in pipes {
    
    for i in stride(from: D, through: 1, by: -1) {
        if i - pipe.length >= 0 {
            dp[i] = max(dp[i], min(pipe.capacity, dp[i - pipe.length]))
        }
    }
//    print(dp)
}

print(dp[D])

깃허브 2022 졸업 등록 및 참여하는 방법(GitHub Graduation 2022)

개발자P — Tue, 3 May 2022 17:53:24 +0900

깃허브에서 메일로 연락이 하나 왔다.

깃허브에서 온 메일. 이하 생략.

단순히 광고인줄 알고 넘어가려 했는데, 깃허브 2022 졸업식(GitHub Graduation 2022)에 초대됐다.

{"mean":["<dicwordclass style=\"user-select: text;\">forever 미국∙영국[fərˈevə(r)] 영원히 비격식 아주 오랜 시간 비격식 (동사의 진행형과 함께 쓰여) 쉴 새 없이 </dicwordclass>","<dicwordclass style=\"user-select: text;\">for ever 영국 영원히, 영구히 </dicwordclass>","<dicwordclass style=\"user-select: text;\">For(n)ever An awesome album by the alternative rock band Hoobastank that comes out on the 27th of January 2009. </dicwordclass>","<dicwordclass style=\"user-select: text;\">I'll love you forever! 난 영원히 당신을 사랑할 거야! </dicwordclass>","<dicwordclass style=\"user-select: text;\">keep in mind forever 만세불망하다 </dicwordclass>","<dicbridgeLine>","오픈","<dicwordclass style=\"user-select: text;\">take forever 직역하면 ‘영원한 시간이 걸린다’는 뜻으로, 시간이 오래 걸린다는 뜻이다. </dicwordclass>","<dicwordclass style=\"user-select: text;\">since forever 늘 그래오다. </dicwordclass>","<dicwordclass style=\"user-select: text;\">forever free [두운] 영원히 자유로운, 영원히 자유로이 </dicwordclass>","<dicwordclass style=\"user-select: text;\">friends forever [두운] 영원한 친구 </dicwordclass>","<dicwordclass style=\"user-select: text;\">스탠드업 코미디: I intend to live forever. So far, so good. 난 영원히 살 작정이야. 아직까진 잘 되고 있지. </dicwordclass>","<dicbridgeLine>","예제","<dicwordclass style=\"user-select: text;\">for ever 영원히.</dicwordclass>","<dicwordclass style=\"user-select: text;\">I’ll love you forever! 난 영원히 당신을 사랑할 거야!</dicwordclass>","<dicwordclass style=\"user-select: text;\">It takes her forever to get dressed. 그녀가 옷을 입는 데는 시간이 아주 오래 걸린다.</dicwordclass>","<dicwordclass style=\"user-select: text;\">After her death, their lives changed forever. 그녀가 죽은 후 그들의 삶은 영원히 달라졌다.</dicwordclass>","<dicwordclass style=\"user-select: text;\">You can’t shield her from the truth forever. 그녀로 하여금 그 진실을 영원히 모르게 할 수는 없어요.</dicwordclass>","<dicbridgeLine>","VLIVE 자막","<dicwordclass style=\"user-select: text;\">Forever? - Forever? - Forever? 평생? - 평생? - 평생?</dicwordclass>","<dicwordclass style=\"user-select: text;\">Forever! - Forever! 포에버! - 영원하자!</dicwordclass>","<dicwordclass style=\"user-select: text;\">Forever. - Forever? 계속 해야 돼요 - 계속 해줘야 돼요?</dicwordclass>","<dicwordclass style=\"user-select: text;\">[012 = forever] - Forever. - Forever! [012=영원히?] - 영원히! - 영원히!</dicwordclass>","<dicwordclass style=\"user-select: text;\">"DIA forever!". - Forever. '다이아 평생 가자'고. - 평생 가야죠.</dicwordclass>"],"word":"forever","basicWord":"forever","soundWord":"forever","phoneticSymbol":""}

참여하면 깃허브의 2022 year-book에 등재될 수 있다고 한다!

(2021 year-book은 여기서 확인할 수 있다.)

GitHub Graduation 2022

좀 더 자세한 내용은 하단 깃허브 공지를 함께 확인하길 바란다.

https://github.com/education/GitHubGraduation-2022

GitHub - education/GitHubGraduation-2022: Join the GitHub Graduation Yearbook and "walk the stage" on June 11.

Join the GitHub Graduation Yearbook and "walk the stage" on June 11. - GitHub - education/GitHubGraduation-2022: Join the GitHub Graduation Yearbook and "walk the stage" on June...

github.com

GitHub Graduation 2022에 참여하는 방법

1. 배송 Form을 제출한다. 링크에 접속해서 주소, 이름, 개인정보등을 입력하면 된다.

https://airtable.com/shrVMo8ItH4wjsO9f

Airtable | Everyone's app platform

Airtable is a low-code platform for building collaborative apps. Customize your workflow, collaborate, and achieve ambitious outcomes. Get started for free.

www.airtable.com

2. GithubGraduation-2022를 Fork한다.

GithubGraduation-2022를 Fork하기.

우측상단에 Fork를 누르면 내 저장소로 포크된다.

잘 모르는 사람들은 링크를 참고하자. (https://blog.naver.com/jooeun0502/221932959912)

3. 내 저장소에 포크가 잘 됐다면, 내 로컬에 clone을 한다.

내 로컬에 clone.

Terminal을 열고, 하단 이미지의 1번처럼 진행한다. (2번, 3번은 나중에)

번거로우니 Terminal을 닫지 말자.

그럼 클론이 잘 됐을 것이다.

로컬에 clone 완료.

4. 위 이미지처럼, 내 깃허브 userName과 동일한 폴더를 생성한다.

주의! 반드시 _data폴더 안에 [userName폴더]를 생성해야 한다. (위 이미지처럼 만들면 된다.)

5. userName.md 파일을 생성한다.

---
name: Sumin Park
institution: Sejong University  
quote: Live as if you were to die tomorrow. Learn as if you were to live forever.
github_user: SuminPark-developer
---

잘 모르겠다면,

기존에 있는 yomaokobiah의 .md파일을 복사하거나, 위 코드를 복사해서 생성하고 자신의 정보에 맞게 수정하면 된다.

userName.md 파일 생성.

userName.md 파일 생성 결과.

6. Terminal에서, 2번과 3번을 입력하면 된다.

2번에서 자신의 루트에 맞게 수정해주는 센스!

3번에서, git push origin master가 아니라 main이다!

Terminal 입력.

7. Pull Request를 한다.

Contribute를 누르고, Pull Request를 누르면 된다.

Pull Request 하기.

8. 체크리스트를 체크한다.

체크리스트 체크 중.

체크리스트 체크 완료.

9. Mac에서 작업했는데, 맥의 .DS_Store파일이 같이 푸쉬돼서 발생한 에러다.

Pull Request 에러 발생.

9-1. 내 레포지토리에 들어가서 .DS_Store파일을 삭제한다.

하단 이미지처럼 쉽게 지울 수 있다.

내 레포지토리 - 에러 파일 삭제.

9-2. Re-request를 한다.

쓰리닷을 누르고, Re-request review를 요청하면 된다!

어렵다면 하단 링크에 있는 영상을 따라하면 쉽다.

Re-request 하는 방법.

https://egghead.io/lessons/github-re-request-a-pr-review-on-github

Re-Request a PR Review on GitHub

Learn how to re-request a PR review. At the bottom, above the Merge button, there should be a change requested header if someone has requested a change. Click the down arrow then the three buttons and you can request another review. If the reviewer request

egghead.io

GitHub Graduation 2022 참여 완료!

문제없이 참여 됐다면, 하단 이미지와 같은 메일이 날라온다.

찾아보니 자료가 없어, 직접 참여하면서 글을 정리해봤다. 다음 참여자들에게 도움이 됐길 바라면서.

GitHub Graduation 2022 참여 제출 완료.

GitHub Graduation 2022 PR 성공.

Fork 리스트에서도 이름을 확인할 수 있다.

https://github.com/education/GitHubGraduation-2022/network/members

GitHub - education/GitHubGraduation-2022: Join the GitHub Graduation Yearbook and "walk the stage" on June 11.

Join the GitHub Graduation Yearbook and "walk the stage" on June 11. - GitHub - education/GitHubGraduation-2022: Join the GitHub Graduation Yearbook and "walk the stage" on June...

github.com

GitHub Graduation 2022 Fork 리스트 일부.

Live as if you were to die tomorrow. Learn as if you were to live forever.

늘 발전하기 위해 노력하는 개발자. 늘 열심히 하자.

22.05.04 - 등록 완료 메일.

DP(1-2) 문제 풀이 모음 | 백준 Swift 2294번, 11660번, 21317번, 22869번, 1106번, 2293번

개발자P — Sun, 1 May 2022 15:49:54 +0900

문제 유형 중, DP의 추천문제들을 풀고 있습니다.

DP1의 문제양이 많아, DP1-1과 DP1-2로 나눕니다. (DP1-1은 여기서 확인할 수 있습니다.)

추천문제 번호 모음은 하단 링크에서 확인할 수 있습니다. 실버, 골드가 섞여있습니다.

DP1-2 문제 번호 모음.

https://github.com/tony9402/baekjoon/tree/main/dynamic_programming_1

GitHub - tony9402/baekjoon: 코딩테스트 대비 문제집(Baekjoon Online Judge)

코딩테스트 대비 문제집(Baekjoon Online Judge). Contribute to tony9402/baekjoon development by creating an account on GitHub.

github.com

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

22.05.01 업데이트

22.05.02 업데이트

22.05.03 업데이트

22.05.04 업데이트

아래 깃허브 주소에서 모든 백준 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

https://developer-p.tistory.com/201

DP(1-1) 문제 풀이 모음 | 백준 Swift 2748번, 11051번, 2839번, 1010번, 9655번, 17626번, 1463번, 9095번, 15988번,

developer-p.tistory.com

백준 Swift 2294번

문제 유형 : DP(재귀, 반복문)

- 고민해서 풀었지만 틀렸다. 하단의 반례에서 바로 막혔다. 큰 coin부터 돌면서 target을 나눠주고 나뉠때의 count를 배열에 저장하고, 그 중 가장 작은 값을 출력하면 될 거라고 생각했기 때문이다. 최하단의 틀린코드에서 볼 수 있다.

다른 블로그를 참고해서 해결했다.

만약 막혀서 글을 찾아오게 된 거라면, dp배열을 0부터 ~ k까지 만들고, dp[0] = 0, 나머지 인덱스엔 10001을 넣고 다시 시도해보길 추천한다.

(왜 10001인가? 가능한 합인 k가 최대 10000이니까, 개수를 최대한으로 늘리고 싶으면 1원짜리로 만개를 만들면 된다. 즉, 문제풀이는 동전갯수를 최소한으로 하기 싶기 때문에 dp값의 최대를 100001으로 준다.)

TC 1번에서,

0원을 만들 땐 코인이 0개 필요하다. -> dp[0] = 0

"Coin이 1원"일 때

1원을 만들 땐 코인이 1개 필요하다. -> dp[1] = 1

2원을 만들 땐 코인이 2개 필요하다. -> dp[2] = dp[1] + 1

... dp[15] = dp[14] + 1 = 15가 될 것이다.

"Coin이 5원"일 때

5원을 만들 땐 코인이 1개 필요하다. 근데 이미 dp[5]에 5가 저장되어 있다. -> dp[5] = min(dp[5], dp[5 - coin] + 1) = 1

10원을 만들 땐 코인이 2개 필요하다. 근데 이미 dp[5]에 10이 저장되어 있다. -> dp[10] = min(dp[10], dp[10 - coin] + 1) = 2

... dp[15] = min(dp[15], dp[15 - coin] + 1) = min(15, dp[10] + 1) = min(15, 3) = 3

이런식으로 업데이트가 될 것이다.

점화식
dp[i] = min(dp[i], dp[i - coin] + 1)

주의해야 할 것은 i - coin이 범위를 벗어나면 error가 난다. 이는 따로 처리를 해줘야겠지?

난이도 : 실버1

반례

대표 반례

2 10

=> 5가 아니라 4가 나와야 함.

참고 링크 : https://sihyungyou.github.io/baekjoon-2294/ | https://t.ly/RriS

반복문

// MARK: - 2294번(DP - 반복문)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (n, k) = (input[0], input[1])
var coins: [Int] = []
for _ in 0..<n {
    coins.append(Int(readLine()!)!)
}
coins.sort(by: <)

var dp: [Int] = [0] + Array(repeating: 10001, count: k) // k의 최대값이 10000이기 때문에. (최대한 개수가 많게 1원짜리로해도 dp값의 최대는 10000이기 때문에.)

for coin in coins {
    for j in 1...k {
        if j - coin < 0 { // dp의 인덱스를 벗어나면 패스.
            continue
        }
        dp[j] = min(dp[j], dp[j - coin] + 1)
    }
}

if dp[k] == 10001 {
    print(-1)
}
else {
    print(dp[k])
}

틀린 코드

틀린 코드

// MARK: - 2294번(틀린 코드)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (n, k) = (input[0], input[1])
var coins: [Int] = []
for _ in 0..<n {
    coins.append(Int(readLine()!)!)
}
coins.sort(by: >)

var possibleCase: [Int] = []
for i in 0..<n {
    var target = k
    var count: Int = 0
    var isDivided: Bool = false // 나눠지는 case인지 구분.
    
    for j in i..<n {
        count += target / coins[j]
        target = target % coins[j]
        if target == 0 { // 이미 k가 됐으면 더 이상 돌아볼 필요 없음.
            isDivided = true
            break
        }
    }
    
    if isDivided {
        possibleCase.append(count)
    }

}

var answer: Int? = possibleCase.min()
if answer == nil { // 만약 가능한 case가 없으면, -1을 출력.
    print("-1")
}
else {
    print(answer!)
}

백준 Swift 11660번

문제 유형 : DP(재귀, 반복문)

- 백준 11659번을 먼저 풀기를 추천한다. (https://www.acmicpc.net/problem/11659 | https://www.acmicpc.net/board/view/17136)

11659번을 풀고 생각한다면, 하나의 행에서 (a ~ b)의 부분합은 S(b) - S(a-1)일 것이다.

하지만 이번엔 하나의 행이 아니다. 두가지의 단계를 거치면 된다.

(1,1) ~ (i, j)까지의 합을 구하는 dp배열을 우선 구한다.

0	0	0
0	1	3
0	3	?

위는 dp배열의 일부이다. 예를 들어 (1,1) ~ (2,2)의 합은 무엇일까? 즉, dp[2][2]는 무엇인가?

빨간색과 파란색을 섞으면 보라색이 된다. 보라색은 중복되는 부분이란 소리다.

-> dp[2][2] = dp[2][1] + dp[1][2] - dp[1][1] + arr[2][2]이다.

dp배열의 점화식은 위와 같다.

dp배열을 구했으니, 이젠 답을 구해야 한다.

예를들어 (2, 2) ~ (3, 4)를 구해보자. 아래는 dp배열의 일부이다.

dp배열 - (2, 2) ~ (3, 4)

(2, 2) ~ (3, 4)의 구간합(흰색부분)을 구하기 위해선 어떻게 해야 할까? 위 그림을 참고하면 이해가 쉽다.

전체 D에서 A와 B를 빼주고, 중복으로 뺀 C를 더해주면 흰색부분(구간합)을 구할 수 있다.

즉, answer = dp[3][4] - dp[3][1] - dp[1][4] + dp[1][1] 이다.

이런식으로 점화식을 짜면 된다.

점화식
answer = dp[x2][y2] - dp[x2][y1 - 1] - dp[x1 - 1][y2] + dp[x1 - 1][y1 - 1]

난이도 : 실버1

참고 자료 : https://chanhuiseok.github.io/posts/baek-19/

반복문

// MARK: - 11660번(DP - 반복문)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var arr: [[Int]] = Array(repeating: [], count: N + 1)
var dp = Array(repeating: Array(repeating: 0, count: N + 1), count: N + 1)

for _ in 0...N {
    arr[0].append(0)
}

for i in 1...N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    arr[i] = [0] + input
}

for i in 1...N {
    for j in 1...N {
        dp[i][j] = dp[i][j - 1] + dp[i - 1][j] - dp[i - 1][j - 1] + arr[i][j]
    }
}
//print(dp)

for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (x1, y1, x2, y2) = (input[0], input[1], input[2], input[3])
    
    let answer = dp[x2][y2] - dp[x2][y1 - 1] - dp[x1 - 1][y2] + dp[x1 - 1][y1 - 1]
    print(answer)
}

백준 Swift 21317번

문제 유형 : DP(재귀, 반복문)

- 처음엔 푼게 맞은줄 알았다. 근데 아래에 반례를 넣어보니까 안됐다. 처음에 생각했던건 k를 한번만 쓰는거니까 check Bool을 두고, 경우를 나눠줬다.

왜 틀렸는지에 대해서 생각을 많이 했다. 생각해보니 TC1은 잘 되긴 하지만, N이 짧아서 가능했다. 즉, N이 길어질수록 k가 쓰였을 때의 최소가 되는 값을 알 수 없게 되게 짜서 틀렸다.

dp[i][j]에서,

j == 0 : k를 사용하지 않은 경우.

j == 1 : k를 사용한 경우.

최소값을 구해야 하는 문제고, 에너지의 최대가 5000이기 때문에 5001을 기본적으로 저장한다. (지금 작성하면서 생각해보니 5001이 아니라, Int의 최대값과 인접한 값을 넣는게 맞는 것 같다. 잘못하면 dp[4][1]의 값에서 문제가 생기는 케이스가 발생할 수 있는 거 같다.)

1번 돌은 시작점이기 때문에 dp값이 0이다.

[0]에 대해 생각해보자. (k를 쓰지 않을 때)

2번 돌은 1번돌에서 smallJ일 때만 가능하기 때문에, dp[2][0] = smallJ[1]이다.

3번 돌은 1번돌에서 bigJ 혹은 2번돌에서 smallJ가 가능하기 때문에, dp[3][0] = min(dp[1][0] + bigJ[1], dp[2][0] + smallJ[2])이다.

즉, [0]의 점화식은 dp[i][0] = min(dp[i - 1][0] + smallJ[i - 1], dp[i - 2][0] + bigJ[i - 2]) 다.

4번 돌부터 매우 큰 점프 k를 쓸 수 있다. [0]은 계속 위와 같은 방식이고, [1]에 대해 생각해보자. (k를 쓸 때)

1번째 돌에서 k를 써서 오는 경우 or 2번째 돌에서 bigJ를 써서 오는 경우 or 3번째 돌에서 smallJ를 써서 오는 경우가 있을 것이다.

즉, [1]의 점화식은 dp[i][1] = min(dp[i - 3][0] + k, dp[i - 2][1] + bigJ[i - 2], dp[i - 1][1] + smallJ[i - 1]) 다.

백준 Swift 21317번 고민.

난이도 : 실버1

참고 자료 : https://blog.naver.com/PostView.nhn?blogId=gustn3964&logNo=222303877311

반례

반복문

// MARK: - 21317번(DP - 반복문)
let N = Int(readLine()!)!
var smallJ: [Int] = [0] + Array(repeating: 0, count: N - 1)
var bigJ: [Int] = [0] + Array(repeating: 0, count: N - 1)
var dp: [[Int]] = Array(repeating: Array(repeating: 5001, count: 2), count: N + 1)
dp[0][0] = 0
dp[0][1] = 0
dp[1][0] = 0
dp[1][1] = 0

for i in 1..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (smallEnergy, bigEnergy) = (input[0], input[1])
    smallJ[i] = smallEnergy
    bigJ[i] = bigEnergy
}

let k: Int = Int(readLine()!)!

if N == 2 {
    dp[2][0] = smallJ[1]
}
else if N == 3 {
    dp[2][0] = smallJ[1]
    dp[3][0] = min(dp[2][0] + smallJ[2], bigJ[1])
}
else if N >= 4 {
    dp[2][0] = smallJ[1]
    dp[3][0] = min(dp[2][0] + smallJ[2], bigJ[1])
    
    for i in 4...N {
        dp[i][0] = min(dp[i - 1][0] + smallJ[i - 1], dp[i - 2][0] + bigJ[i - 2]) // k를 사용하지 않을 때.
        dp[i][1] = min((dp[i - 3][0] + k), (dp[i - 1][1] + smallJ[i - 1]), (dp[i - 2][1] + bigJ[i - 2])) // k를 사용할 때.
    }
}

//print(dp)
print(dp[N].min()!)

틀린코드

// MARK: - 21317번(DP - 반복문: 틀린코드)
let N = Int(readLine()!)!
var smallJ: [Int] = [0] + Array(repeating: 0, count: N - 1)
var bigJ: [Int] = [0] + Array(repeating: 0, count: N - 1)
var dp: [Int] = [0] + Array(repeating: 0, count: N)

for i in 1..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (smallEnergy, bigEnergy) = (input[0], input[1])
    smallJ[i] = smallEnergy
    bigJ[i] = bigEnergy
}

let k: Int = Int(readLine()!)!

if N == 2 {
    dp[2] = smallJ[1]
}
else if N == 3 {
    dp[2] = smallJ[1]
    dp[3] = min(dp[2] + smallJ[2], bigJ[1])
}
else if N >= 4 {
    dp[2] = smallJ[1]
    dp[3] = min(dp[2] + smallJ[2], bigJ[1])
    
    var useK: Bool = false // k를 썼는지 체크.
    for i in 4...N {
        if !useK { // k를 아직 쓰지 않았을 때,
            var minTemp = min((dp[i - 1] + smallJ[i - 1]), (dp[i - 2] + bigJ[i - 2])) // 잠시 저장.(k를 쓸 때가 가장 작은지 확인하기 위해.)
            
            if dp[i - 3] + k < minTemp { // k를 쓴게 더 작으면,
                minTemp = dp[i - 3] + k
                useK = true // k 사용.
            }
            dp[i] = minTemp
        }
        else { // k를 이미 사용한 상태라면,
            dp[i] = min((dp[i - 1] + smallJ[i - 1]), (dp[i - 2] + bigJ[i - 2]))
        }
    }
}

//print(dp)
print(dp[N])

백준 Swift 22869번

문제 유형 : DP(재귀, 반복문)

- 풀이를 알고 보면 매우 간단하다. 대부분의 문제가 그렇긴 하겠지만...

최단경로가 아니라, 갈 수 있는지 없는지만 알면 된다. dp배열을 (boolean)배열로 놓고, true일 때만 확인해주면 된다. (난 true/false = 1/0로 했다.)

그리고 매 반복문마다 dp[N] == 1인지 체크해서, 1이라면 더 알아볼 필요도 없이 YES하고 break를 하면 시간을 조금 더 단축시킬 수 있다.

백준 Swift 22869번 고민.

난이도 : 실버1

반복문

// MARK: - 22869번(DP - 반복문)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, K) = (input[0], input[1])
var arr: [Int] = [0] + readLine()!.split(separator: " ").map{Int(String($0))!}

var dp: [Int] = [0] + Array(repeating: 0, count: N)
dp[1] = 1 // 첫번째 돌은 이동가능이라 1로 표시.

var answer: String = "NO"
for i in 1..<N { // 첫번째 돌부터,
    if dp[i] == 1 { // 이동 가능한 곳만 체크.
        for j in i+1...N {
            let power = (j - i) * (1 + abs(arr[i] - arr[j]))
            if power <= K { // 이동가능하다면,
                dp[j] = 1 // 이동가능한곳 1로 표시.
            }
        }
        
        if dp[N] == 1 {
            answer = "YES"
            break
        }
    }
}
print(answer)

틀린 고민

백준 Swift 22869번 틀린 고민.

백준 Swift 1106번

문제 유형 : DP(재귀, 반복문)

- 처음에 얼추 비슷하게 접근은 했는데 구현을 잘 못했다.

dp배열은 i명까지 만드는데 드는 비용을 저장한다. 근데 문제에서 물어보는게 적어도 C명일 때의 최소비용이기 때문에, dp[C]가 아니다!

적어도 C명이라는건 C명 이상이란 뜻이기도 하고, C를 넘기면서 최소인 상황이 존재하기 때문이다.

이해가 되는가? 따라서 dp[C] ~ dp[C+100] 중에서 최소값이다.

비용과 고객 수는 최대 100이다. 값은 Int.max - 100을 해줘야 계산이 error가 안나고, 길이는 C + 100을 해줘야 한다.

좀 더 자세한 내용은 아래 풀이에서 확인할 수 있다.

var dp: [Int] = [0] + Array(repeating: Int.max - 100, count: C + 100) // 비용이 최대 100이기 때문에, 최대값 - 100을 해줘야 계산이 가능해진다.

백준 Swift 1106번 고민.

난이도 : 골드5

참고 자료 : https://dirmathfl.tistory.com/379

반복문

// MARK: - 1106번(DP - 반복문)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (C, N) = (input[0], input[1])
var ad: [(cost: Int, customer: Int)] = [(0, 0)]

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    ad.append((input[0], input[1]))
}

var dp: [Int] = [0] + Array(repeating: Int.max - 100, count: C + 100) // 비용이 최대 100이기 때문에, 최대값 - 100을 해줘야 계산이 가능해진다.
//var dp: [Int] = [0] + Array(repeating: 10000, count: C + 100)

for (cost, customer) in ad {
    for i in customer...(C+100) {
        dp[i] = min(dp[i], dp[i - customer] + cost)
    }
}

let answer = dp[C...C+100].min()! // C ~ C+100명 늘이는 것 중 돈의 최소값.
print(answer)

백준 Swift 2293번

문제 유형 : DP(재귀, 반복문)

- 쭉 나열해봤는데 모르겠었다.

핵심은 새로운 coin이 나타나면서 생길 수 있는 경우의 수를 기존의 dp값에 더해주는 게 핵심이다.

~~내 힘으로 푼 게 아니라서 다음에 다시 풀어봐야겠다.~~

(매우 유사한) 백준 9084번을 다시 풀었다. (풀이 : https://developer-p.tistory.com/205) - 22.05.12 업데이트

백준 Swift 2293번 고민.

백준 2293번 컴파일 에러나는 이유 2가지

1. 동전의 가치(coin)이 가치들의 합(k)보다 큰 케이스가 있으니, 예외처리를 해줘야 한다.

2. 경우의 수가 2^31을 벗어나는 케이스가 있으니, 예외처리를 해줘야 한다.

3. (Swift만 해당) - 나처럼 바보같이 import Foundation을 빼먹고 작성하면...안된다!

pow를 썼는데 어떻게 에러가 뜬 걸 모를 수 있지? 라고 의문이 들 수 있다.

작성하던 코드 위쪽에 import Darwin이 있어서 에러가 안나서 몰랐다. (https://stackoverflow.com/questions/24012511/mathematical-functions-in-swift)

난이도 : 골드5

백준 Swift 2293번 - 컴파일 에러 지옥.

반례

반례
1 10000
100000

참고 자료 : https://seongonion.tistory.com/108 | https://www.acmicpc.net/board/view/27103

반복문

// MARK: - 2293번(DP - 반복문)
import Foundation // pow에 쓰임.
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (n, k) = (input[0], input[1])
var coins: [Int] = []

for _ in 0..<n {
    coins.append(Int(readLine()!)!)
}
var dp: [Int] = [1] + Array(repeating: 0, count: k) // dp[0] = 1

for coin in coins {
    if coin > k { // 동전의 가치가 합k보다 클 때, 에러를 방지하기 위해.
        continue
    }
    
    for i in coin...k {
        if dp[i] + dp[i - coin] > Int(pow(2.0, 31.0)) { // 경우의 수가 2^31을 벗어나는 경우, 에러를 방지하기 위해.
            dp[i] = 0
        }
        else {
            dp[i] = dp[i] + dp[i - coin]
        }
    }
}

print(dp[k])

DP(1-1) 문제 풀이 모음 | 백준 Swift 2748번, 11051번, 2839번, 1010번, 9655번, 17626번, 1463번, 9095번, 15988번, 11726번, 2579번, 11727번, 2407번, 11053번, 1912번, 11055번, 1890번, 9465번, 15486번, 2156번, 10844번

개발자P — Fri, 15 Apr 2022 14:15:27 +0900

문제 유형 중, DP의 추천문제들을 풀어보려고 합니다. (Dynamic Programming 1)

DP1과 DP2 중 DP1부터 풀어나가겠습니다. (DP1의 문제양이 많아, DP1-1과 DP1-2로 나눕니다.)

추천문제 번호 모음은 여기서 확인할 수 있습니다. 브론즈, 실버, 골드가 섞여있습니다.

GitHub - tony9402/baekjoon: 코딩테스트 대비 문제집(Baekjoon Online Judge)

코딩테스트 대비 문제집(Baekjoon Online Judge). Contribute to tony9402/baekjoon development by creating an account on GitHub.

github.com

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

22.04.15업데이트

22.04.16 업데이트

22.04.17 업데이트

22.04.18 업데이트

22.04.19 업데이트

22.04.22 업데이트

22.04.23 업데이트

22.04.25 업데이트

22.04.26 업데이트

22.04.28 업데이트

22.04.29 업데이트

22.04.30 업데이트

아래 깃허브 주소에서 모든 백준 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

https://developer-p.tistory.com/203

DP(1-2) 문제 풀이 모음 | 백준 Swift 2294번, 11660번, 21317번, 22869번, 1106번, 2293번

developer-p.tistory.com

백준 Swift 2748번

문제 유형 : DP(재귀, 반복문)

난이도 : 브론즈1

DP - 재귀

// MARK: - 2748번(DP - 탑다운)
let n = Int(readLine()!)!
var cache = Array(repeating: -1, count: 91)
cache[0] = 0
cache[1] = 1

func fibo(_ num: Int) -> Int {
    if cache[num] == -1 {
        cache[num] = fibo(num - 1) + fibo(num - 2)
    }
    return cache[num]
}

let answer = fibo(n)
print(answer)

DP - 반복문

// MARK: - 2748번(DP - 바텀업)
let n = Int(readLine()!)!
var cache = Array(repeating: -1, count: n + 1)
cache[0] = 0
cache[1] = 1

if n >= 2 {
    for i in 2...n {
        cache[i] = cache[i - 1] + cache[i - 2]
    }
}
print(cache[n])

//var numArray = [0, 1]
//
//func fibo(_ num: Int) -> Int {
//    if num >= 2 {
//        for i in 2...n {
//            numArray.append(numArray[i-1] + numArray[i-2])
//        }
//    }
//    return numArray[num]
//}
//print(fibo(n))

백준 Swift 11051번

문제 유형 : DP(재귀, 반복문)

- DP문제들을 처음 접해보는데, 점화식을 알아내서 세우는 게 어려운 것 같다.

난이도 : 실버1

재귀

// MARK: - 11051번(DP - 재귀함수)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, K) = (input[0], input[1])
var cache = Array(repeating: Array(repeating: -1, count: K + 1), count: N + 1)

func bino(_ n: Int, _ k: Int) -> Int {
    if cache[n][k] != -1 {
        return cache[n][k]
    }
    
    if k == 0 || k == n {
        cache[n][k] = 1
    }
    else {
        cache[n][k] = (bino(n - 1, k - 1) + bino(n - 1, k)) % 10007 // 나중에 answer에서 mod를 해주면 안됨.(그러면 Int범위 초과)
    }
    
    return cache[n][k]
}

let answer = bino(N, K)
print(answer)

반복문

// MARK: - 11051번(DP - 반복문)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, K) = (input[0], input[1])
var cache = Array(repeating: Array(repeating: -1, count: K + 1), count: N + 1)

for j in 1...N {
    for i in 0...K {
        if i == 0 || i == j {
            cache[j][i] = 1
        }
        else {
            cache[j][i] = (cache[j - 1][i - 1] + cache[j - 1][i]) % 10007 // 나중에 mod해주면 Int범위 초과.
        }
    }
}
print(cache[N][K])

백준 Swift 2839번

문제 유형 : DP(재귀, 반복문)

재귀 - 생각 못했다. 그리디로 풀면 풀 수 있을 거 같은데, 재귀로 풀려니까 어려웠다. 분기 조건을 눈치채야 하는데... 쭉 써 봤는데 그래도 알아내는 게 어려운 것 같다.

반복문 - 재귀로 풀고 나서 해서 그런지, 쉽게 풀었다. 재귀함수 다루는 걸 어려워 하는 것도 한 몫 하는 것 같다. 얼른 익숙해지도록 노력해야겠다.

swift는 for문을 돌릴 때, for문의 범위를 벗어나는 N이 들어오면 Error가 뜬다. 그래서 for문 밖에 if문을 넣어서 해결하면 된다. (파이썬은 에러없이 알아서 패스해주던데...)

난이도 : 골드5

참고 링크 : https://velog.io/@hye0n/BOJPython-2839.%EC%84%A4%ED%83%95-%EB%B0%B0%EB%8B%AC

재귀

// MARK: - 2839번(DP - 재귀함수)
let N = Int(readLine()!)!
var cache = Array(repeating: -1, count: 5001)
(cache[3], cache[5]) = (1, 1)

func topDown(_ num: Int) -> Int {
    if num <= 0 { // topDown(num-5) 때문에 인덱스를 벗어나게 되면 -1을 리턴.
        return -1
    }

    if cache[num] != -1 { // 결과값이 있다면, 더 돌아볼 필요 없이 결과값 리턴.
        return cache[num]
    }
    
    if num % 5 == 0 { // 5의 배수일 때,
        cache[num] = topDown(num - 5) + 1 // 현재num의 결과값 = 이전 5의배수의 결과값 + 1
    }
    else if num % 3 == 0 { // 3의 배수일 때,
        cache[num] = topDown(num - 3) + 1 // 현재num의 결과값 = 이전 3의배수의 결과값 + 1
    }
    else if topDown(num - 5) != -1 { // 이전(num-5)가 값이 있다면,
        cache[num] = topDown(num - 5) + 1 // 현재num의 결과값 = 이전 결과값 + 1
    }
    else if topDown(num - 3) != -1 { // 이전(num-3)가 값이 있다면,
        cache[num] = topDown(num - 3) + 1 // 현재num의 결과값 = 이전 결과값 + 1
    }
//    else {
//        cache[num] = -1
//    }
    
    return cache[num]
}

print(topDown(N))

반복문

// MARK: - 2839번(DP - 반복문)
let N = Int(readLine()!)!
var cache = Array(repeating: -1, count: 5001)
cache[3] = 1

if N >= 5 { // i - 5를 체크할 때 인덱스를 벗어나는걸 방지하기 위해, N >= 5 부터 for문 시작.
    for i in 5...N {
        if i % 5 == 0 { // 5로 나뉘면,
            cache[i] = i / 5
        }
        else if i % 3 == 0 { // 3으로 나뉘면,
            cache[i] = cache[i - 3] + 1 // 이전 결과값 + 1
        }
        else if (cache[i - 5] != -1) { // 이전(i-5)이 값이 있다면,
            cache[i] = cache[i - 5] + 1 // 현재 결과값 = 이전 결과값 + 1
        }
        else if (cache[i - 3] != -1) { // 이전(i-3)이 값이 있다면,
            cache[i] = cache[i - 3] + 1 // 현재 결과값 = 이전 결과값 + 1
        }
    }
}
print(cache[N])

백준 Swift 1010번

문제 유형 : DP(재귀, 반복문)

백준 Swift 1010번 고민.

재귀 - 오로지 내 힘으로 풀었다! 아까 이항 계수(파스칼의 삼각형) 공식을 배워놔서, 풀 수 있었다. (백준 11051번)

DP문제를 풀 때 자주 나온다고 하니 잊지 않도록 해야겠다.

반복문 - 역시 재귀와 마찬가지로, 이항계수 점화식을 활용해 풀 수 있었다.

이항계수 조건 및 점화식
bino(n, 0) = 1
bino(n, n) = 1
bino(n, r) = bino(n-1, r-1) + bino(n-1, r)

난이도 : 실버5

재귀

// MARK: - 1010번(DP - topDown)
let T = Int(readLine()!)!

for _ in 0..<T {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (N, M) = (input[0], input[1])
    
    var cache = Array(repeating: Array(repeating: -1, count: 30), count: 30)
    func bino(_ m: Int, _ n: Int) -> Int { // 이항계수
        if cache[m][n] != -1 {
            return cache[m][n]
        }
        
        if n == 0 || n == m { // mC0 이나 mCm일 때,
            cache[m][n] = 1
        }
        else { // n이 1 ~ m-1일 땐,
            cache[m][n] = bino(m - 1, n - 1) + bino(m - 1, n)
        }
        
        return cache[m][n]
    }
    let answer = bino(M, N)
    print(answer)
}

반복문

// MARK: - 1010번(DP - bottomUp)
let T = Int(readLine()!)!

for _ in 0..<T {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (N, M) = (input[0], input[1])
//
//    var cache = Array(repeating: Array(repeating: -1, count: N + 1), count: M + 1)
//
//    for i in 1...M {
//        for j in 0...N {
//            if j == 0 || j == i {
//                cache[i][j] = 1
//            }
//            else {
//                cache[i][j] = cache[i - 1][j - 1] + cache[i - 1][j]
//            }
//        }
//    }
    var cache = Array(repeating: Array(repeating: -1, count: 30), count: 30)
    for i in 1..<30 {
        cache[i][i] = 1
        cache[i][0] = 1
        for j in 1..<i {
            cache[i][j] = cache[i - 1][j - 1] + cache[i - 1][j]
        }
    }
    print(cache[M][N])
}

백준 Swift 9655번

문제 유형 : DP(재귀, 반복문)

- 이 문제는 DP가 아니라, 그냥 쭉 써보고 홀수&짝수로 나누면 풀리는 문제였다.(3번째 코드)

하지만 DP로 분류가 되어 있으니까 DP로도 풀어보려 했는데, 잘 안됐다.

고민하다가 다른 블로그들을 참고했다.

백준 Swift 9655번 고민.

재귀가 익숙치 않아서 그런지, 문제를 풀 때 반복문이 더 쉬운 것 같다.

앞으론 DP문제를 접근할 때 반복문으로 먼저 접근을 하고, 재귀로 재접근을 하는 식으로 푸는 게 나을 것 같다.

(알고리즘 코테 강의에선 재귀가 더 쉽다고 했는데... 난이도 느끼는건 사람마다 다른 거니깐...)

BottomUp(반복문)은 n-3과 n-1의 결과값을 계속 끌고 올라가면 된다.

주의해야 할 건, n-3이 있기 때문에, cache에 인덱스1, 2, 3의 값은 저장해놓고, n을 4부터 반복문을 돌린다.

TopDown(재귀)은 주어진 n값에서, n-3과 n-1의 값을 반복해서 호출하면 된다.

반복문과 마찬가지로, 인덱스 1, 2, 3의 값은 예외처리 해주고,

추가적으로 cache[n] 값이 -1이 아닐 땐 방문한 적이 있다(=값이 저장되어 있다.)는 뜻이므로, 바로 값을 리턴해준다.

난이도 : 실버5

참고 링크 : https://beginnerdeveloper-lit.tistory.com/83 | https://propercoding.tistory.com/21

재귀

// MARK: - 9655번(DP - 재귀함수)
let N = Int(readLine()!)!
var cache = Array(repeating: -1, count: 1001)

func topDown(_ n: Int) -> Int {
    if cache[n] != -1 { // 기록된 적 있으면, 더 확인할 필요 없이 저장된 값을 리턴.
        return cache[n]
    }
    
    if n == 3 || n == 1 { // n이 1이나 3일 땐, 게임횟수 1.
        cache[n] = 1
    }
    else if n == 2 { // n이 2일 땐, 게임횟수 2.
        cache[n] = 2
    }
    else { // n이 4이상일 땐, 이전 기록(n-3, n-1) 중 작은것 + 1
        cache[n] = min(topDown(n - 3), topDown(n - 1)) + 1
    }
    
    return cache[n]
}

if topDown(N) % 2 == 1 { // 게임횟수가 홀수면,
    print("SK")
}
else { // 게임횟수가 짝수면,
    print("CY")
}

반복문

// MARK: - 9655번(DP - 반복문)
let N = Int(readLine()!)!
var cache = Array(repeating: -1, count: 1001) // 게임 과정 기록.
cache[2] = 2
cache[3] = 1

if N >= 4 {
    for i in 4...N {
        cache[i] = min(cache[i - 3], cache[i - 1]) + 1
    }
}

if cache[N] % 2 == 1 { // 게임한 횟수가 홀수면,
    print("SK")
}
else { // 게임한 횟수가 짝수면,
    print("CY")
}

그냥 풀이

// MARK: - 9655번(그냥 풀이)
let N = Int(readLine()!)!
if N % 2 == 1 {
    print("SK")
}
else {
    print("CY")
}

백준 Swift 17626번

문제 유형 : DP(재귀, 반복문)

쭉 써봐도 규칙을 못찾겠었다. 결국엔 다른 블로그를 참고해서 이해했다. 점화식을 구하는 게 핵심인데, 아직 어려운 것 같다.

백준 Swift 17626번 고민.

주의사항은, i보다 이전 숫자 중, 가장 큰 제곱수의 결과값 + 1이 답이 아니다.

반례 : 12일 때 dp[3^2] + 1을 하면 4인데, 실제론 2^2 + 2^2 + 2^2 해서 3이 나와야 한다.

재귀함수로 푼 코드는 없는 거 같아서, 시도해봤는데 Xcode에서 시간초과가 난다.

혹시나 몰라서 백준에 제출해보니 백준에선 통과가 됐다. 아마 depth가 깊어지면서 xcode에선 막는 것 같다.

어떻게 수정해야 하는진 모르겠는데, 아시는 분은 댓글로 꼭 알려주세요! (https://www.acmicpc.net/board/view/88588)

백준 Swift 17626번 - 재귀함수 문제 발생.

난이도 : 실버4

참고 링크 : https://loosie.tistory.com/229

재귀

// MARK: - 17626번(DP - 재귀함수) - 시간초과
let n = Int(readLine()!)!
var cache = Array(repeating: -1, count: n + 1)
//cache[0] = 0
//cache[1] = 1

func topDown(_ num: Int) -> Int {
    if cache[num] != -1 {
        return cache[num]
    }
    
    if num == 0 || num == 1 {
        cache[num] = num
    }
    else {
        var minValue = 50001
        var i = 1
        while i * i <= num {
            minValue = min(minValue, topDown(num - i * i))
            i += 1
        }
        cache[num] = minValue + 1
    }
    return cache[num]
}

print(topDown(n))

반복문

// MARK: - 17626번(DP - 반복문)
let n = Int(readLine()!)!
var cache = Array(repeating: -1, count: n + 1)
cache[0] = 0
cache[1] = 1

if n >= 2 {
    for i in 2...n {
        var minValue = 50001
        var j = 1
        while j * j <= i { // 제곱했을 때 i의 범위를 벗어나지 않을 때,
            minValue = min(minValue, cache[i - j * j]) // i보다 작은, 가능한 제곱수들 중 가장 작은 값으로. 가능한 최소여야 하기 때문.
            j += 1
        }
        cache[i] = minValue + 1 // 값 + 1을 해줘야 해당 결과값이 나옴.
//        print(cache)
    }
}
print(cache[n])

백준 Swift 1463번

문제 유형 : DP(재귀, 반복문)

쭉 작성하다 보니까 규칙이 보였다. 처음엔 3이나 2로 나뉘면, 그 값 + 1이 결과값이라고 생각했다. 아니다!

하단 이미지의 dp[10]을 보면 알겠지만, 10에서 -1연산을 하고, 3으로 나눠주는 연산을 하는게 최소다.

즉, 3으로 나뉠 때, min(dp [i / 3], dp[i - 1]) + 1이다.

2로 나뉠때도 마찬가지로, min(dp [i / 2], dp[i - 1]) + 1이다.

이렇게 코드를 짜고 틀렸다. 왜 틀렸을까?

주의해야 할 것은, 3과 2가 동시에 나뉘는 6의 배수일 때다.

3과 2로 나뉘는 수일 땐, dp[i/3] 값과 dp[i/2]값 중 작은 값으로 계산을 해줘야 한다. +1은 당연히 해줘야 하고.

반례는 642다. (정답: 10, 오답: 11) 6의 배수를 고려하지 않았던 첫 코드는 오답이 나온다. (대표 반례 : https://www.acmicpc.net/board/view/49959)

백준 Swift 1463번 고민.

재귀함수 코드보다, 반복문 코드를 먼저 보고 이해하기를 추천한다. (개인적으론 그게 더 쉽다..)

난이도 : 골드5

재귀

// MARK: - 1463번(DP - 재귀함수)
let N = Int(readLine()!)!
var cache = Array(repeating: -1, count: 1000001)

func topDown(_ n: Int) -> Int {
    if cache[n] != -1 {
        return cache[n]
    }
    if n <= 0 {
        return -1
    }
    
    if n <= 3 { // 3이하일 땐, 기본값 세팅.
        cache[1] = 0
        cache[2] = 1
        cache[3] = 1
    }
    else { // 4이상일 땐,
        if n % 6 == 0 {
            cache[n] = min(topDown(n / 3), topDown(n / 2), topDown(n - 1)) + 1
        }
        else if n % 3 == 0 {
            cache[n] = min(topDown(n / 3), topDown(n - 1)) + 1
        }
        else if n % 2 == 0 {
            cache[n] = min(topDown(n / 2), topDown(n - 1)) + 1
        }
        else {
            cache[n] = topDown(n - 1) + 1
        }
    }
    
    return cache[n]
}

let answer = topDown(N)
print(answer)

반복문

// MARK: - 1463번(DP - 반복문)
let N = Int(readLine()!)!
var cache = Array(repeating: -1, count: 1000001)
cache[1] = 0
cache[2] = 1
cache[3] = 1

if N >= 4 {
    for i in 4...N {
        if i % 3 == 0 && i % 2 == 0 { // 6의 배수일 때 -> (/3 연산, /2 연산, -1연산) 중 작은 값 + 1
            cache[i] = min(cache[i / 3], cache[i / 2], cache[i - 1]) + 1
        }
        else if i % 3 == 0 { // 3의 배수일 때 -> (/3 연산, -1연산) 중 작은 값 + 1
            cache[i] = min(cache[i / 3], cache[i - 1]) + 1
        }
        else if i % 2 == 0 { // 2의 배수일 때 -> (/2 연산, -1연산) 중 작은 값 + 1
            cache[i] = min(cache[i / 2], cache[i - 1]) + 1
        }
        else { // 다 해당되지 않으면, -1연산 값 + 1
            cache[i] = cache[i - 1] + 1
        }
    }
}
print(cache[N])

백준 Swift 9095번, 15988번

문제 유형 : DP(재귀, 반복문)

9095번을 먼저 푸는 걸 추천한다.

탑다운dp보다 바텀업dp를 권장한다고 한다. (참고 : https://www.acmicpc.net/board/view/70869)

쭉 적어봤을 때 규칙을 찾으려 했는데 못 찾았다. 고민하다 결국 다른 블로그를 참고했다.

백준 Swift 9095번, 15988번 고민.

그렇게 나온 점화식은 dp[n] = dp[n-1] + dp[n-2] + dp[n-3]이다.

15988번을 기존에 썼던 코드를 확인 안하고 그대로 넣었더니 틀렸다. 매우 당황스러웠는데, 그 이유는 3가지였다. 틀린 이유 3이 제일 중요하다.

틀린 이유 1. cache범위를 늘리지 않았다.

틀린 이유 2. 문제에 주어진 수(1000000009)로 나누지 않았다.

틀린 이유 3. 시간초과가 나서 생각해보니, 9095번처럼 코드를 짜면 안됐다. 그렇게 하면 매 n마다, cache값을 다시 구하기 때문이다. (이미 값을 구한 적이 있음에도 불구하고.)

그래서 모든 값을 먼저 구해서 저장해놓고, 그 다음 결과값만 호출하는 식으로 수정해서 해결했다.

난이도 : 실버3, 실버2

참고 링크 : https://blog.naver.com/PostView.nhn?blogId=vjhh0712v&logNo=221470862600

9095번

재귀

// MARK: - 9095번(DP - 재귀함수)
let T = Int(readLine()!)!
var cache = Array(repeating: -1, count: 11)

for _ in 0..<T {
    let n = Int(readLine()!)!
    
    let answer = topDown(n)
    print(answer)
}

func topDown(_ N: Int) -> Int {
    if cache[N] != -1 {
        return cache[N]
    }
    
    if N <= 3 {
        cache[1] = 1
        cache[2] = 2
        cache[3] = 4
    }
    else {
        cache[N] = topDown(N - 1) + topDown(N - 2) + topDown(N - 3)
    }
    
    return cache[N]
}

반복문

// MARK: - 9095번(DP - 반복문)
let T = Int(readLine()!)!
var cache = Array(repeating: -1, count: 11)
cache[1] = 1
cache[2] = 2
cache[3] = 4

for _ in 0..<T {
    let n = Int(readLine()!)!
    
    if n >= 4 { // 4부터 점화식 성립.
        for i in 4...n {
            cache[i] = cache[i - 1] + cache[i - 2] + cache[i - 3]
        }
    }
    
    print(cache[n])
}

15988번

재귀

// MARK: - 15988번(DP - 재귀함수) : Xcode에선 에러
let T = Int(readLine()!)!
var cache = Array(repeating: -1, count: 1000001)

func topDown(_ N: Int) -> Int {
    if cache[N] != -1 {
        return cache[N]
    }
    
    if N <= 3 {
        cache[1] = 1
        cache[2] = 2
        cache[3] = 4
    }
    else {
        cache[N] = (topDown(N - 1) + topDown(N - 2) + topDown(N - 3)) % 1000000009
    }
    
    return cache[N]
}

for _ in 0..<T {
    let n = Int(readLine()!)!
    let answer = topDown(n)
    print(answer)
}

반복문

// MARK: - 15988번(DP - 반복문)
let T = Int(readLine()!)!
var cache = Array(repeating: -1, count: 1000001)
cache[1] = 1
cache[2] = 2
cache[3] = 4

for i in 4...1000000 { // 4부터 점화식 성립.
    cache[i] = (cache[i - 1] + cache[i - 2] + cache[i - 3]) % 1000000009
}

for _ in 0..<T {
    let n = Int(readLine()!)!
    print(cache[n])
}

백준 Swift 11726번

문제 유형 : DP(재귀, 반복문)

어렵지 않게 풀 수 있었다. DP문제는 쭉 나열하면서 표를 그린 뒤, 점화식을 구하는 게 핵심인 것 같다. 점화식을 구하는 게 어려워서 그렇지...

아래 그림을 보면, 직사각형이 어떻게 채워지고 갯수는 몇 개가 나오는지 알 수 있다.

백준 Swift 11726번 고민.

난이도 : 실버3

재귀

// MARK: - 11726번(DP - 재귀함수)
let n = Int(readLine()!)!
var cache = Array(repeating: -1, count: 1001)

func topDown(_ N: Int) -> Int {
    if cache[N] != -1 {
        return cache[N]
    }
    
    if N <= 2 {
        cache[N] = N
    }
    else {
        cache[N] = (topDown(N - 1) + topDown(N - 2)) % 10007
    }
    return cache[N]
}

print(topDown(n))

반복문

// MARK: - 11726번(DP - 반복문)
let n = Int(readLine()!)!
var cache = Array(repeating: -1, count: 1001)
cache[1] = 1
cache[2] = 2

if n >= 3 {
    for i in 3...n {
        cache[i] = (cache[i - 1] + cache[i - 2]) % 10007
    }
}
print(cache[n])

DP Eng

DP
data processing, degree of polymerization [화학] 중합도(重合度), [야구] designated player, dew point, displaced person, doctor of pharmacy, double play

dp
data processing, [야구] double play

D/P
상업 documents against payment.

D.P.
의학 적당(適當)한 지시(指示)대로, L. directione propria의 약자.
의학 약학박사(藥學博士) Doctor of Pharmacy의 약자.
의학 수족치료의사(手足治療醫師). Doctor of Podiatry의 약자.

drop point
군사 투하지점

오픈

예제

The DP has been aggressively promoting its campaign.
민주당은 이 무상급식 캠페인을 강력하게 추진해왔다.

We think some events should be held in North Korea,' said Sohn Kak-kyu, chairman of the DP.'
일부 경기는 북한에서 개최되어야 한다고 생각한다.'

DP lawmakers then used a sledgehammer and crowbars to break down the door to the meeting room.
그러자 민주당 국회의원들은 쇠망치와 쇠지레를 사용해 회의실 문을 부수었다.

They hoped to keep DP lawmakers from participating in the process.
이들은 민주당 의원들이 이 절차에 참여하는 것을 막기를 원했다.

The DP criticized him more specifically for behavior they call unethical.
민주당은 비윤리적인 행동에 대해 명확히 비판하였다.

VLIVE 자막

What is "DP"? "DP"?
플꾸가 뭐야? 폴꾸?

What is "DP"?
폴꾸가 뭐예요?

"DP"? - What does that mean?
폴꾸? - 무슨 소리지?

What is that? - Don't you know DP?
그게 뭐예요? - 폴꾸, 그것도 몰라요?

What are you doing? - Do you know DP?
뭐 하는 거예요? - 폴꾸라고 아세요?

백준 Swift 2579번

문제 유형 : DP(재귀, 반복문)

생각 못했다. 다른 블로그를 참고해서 풀었다. 1일때부터 어떤 규칙인걸까 생각했는데, n을 기준으로 생각하니까 바로 나오더라.

case가 2가지로 나뉜다.

제일 마지막칸인 n을 기준으로,

case1. 직전칸 O : dp[n] = dp[n-3] + arr[n-1] + arr[n]

가장 마지막칸(n)은 반드시 방문해야 하고, 그 직전칸(n-1)에 방문한다면, n-2칸은 방문하지 못한다. (문제 조건 2에 의해)

그럼 n-3칸은 반드시 방문해야 하기 때문에, dp[n-3]값에 직전칸값(arr[n-1])과 마지막칸값(arr[n])을 더해주면 점화식이 나온다.

case2. 직전칸 X : dp[n] = dp[n-2] + arr[n]

직전칸(n-1)은 방문하지 않으므로, n-2칸은 반드시 방문해야 한다. 따라서 dp[n-2]값과 마지막칸값(arr[n])을 더해주면 점화식이 나온다.

case1과 case2 결과값 중 최대값을 dp[n]에 넣어주면 된다.

=> max((dp[n] = dp[n-3] + arr[n-1] + arr[n]), (dp[n] = dp[n-2] + arr[n]))

백준 Swift 2579번 고민.

난이도 : 실버3

재귀

// MARK: - 2579번(DP - 재귀문)
let T = Int(readLine()!)!
var stairs = Array(repeating: 0, count: 301)

for i in 1...T {
    let input = Int(readLine()!)!
    stairs[i] = input
}

var cache = Array(repeating: -1, count: 301)

func topDown(_ N: Int) -> Int {
    if cache[N] != -1 {
        return cache[N]
    }
    
    if N <= 3 {
        cache[1] = stairs[1]
        cache[2] = stairs[1] + stairs[2]
        cache[3] = max(stairs[1] + stairs[3], stairs[2] + stairs[3])
    }
    else {
        cache[N] = max(topDown(N - 3) + stairs[N - 1] + stairs[N], topDown(N - 2) + stairs[N])
    }
    
    return cache[N]
}

let answer = topDown(T)
print(answer)

반복문

// MARK: - 2579번(DP - 반복문)
let T = Int(readLine()!)!
var stairs = Array(repeating: 0, count: 301)

for i in 1...T {
    let input = Int(readLine()!)!
    stairs[i] = input
}

var cache = Array(repeating: -1, count: 301)
cache[1] = stairs[1]
cache[2] = stairs[1] + stairs[2]
cache[3] = max(stairs[1] + stairs[3], stairs[2] + stairs[3])

if T >= 4 {
    for i in 4...T {
        cache[i] = max((cache[i - 3] + stairs[i - 1] + stairs[i]), (cache[i - 2] + stairs[i]))
    }

}
print(cache[T])

백준 Swift 11727번

문제 유형 : DP(재귀, 반복문)

쭉 나열해보면 규칙이 금방 보이는 문제다. n이 4일때까지 쭉 나열한다면 대부분 점화식을 구할 수 있을 것이다.

=> dp[n] = (2 * dp[n-2]) + dp[n-1]

백준 Swift 11727번 고민.

난이도 : 실버3

재귀

// MARK: - 11727번(DP - 재귀)
let n = Int(readLine()!)!
var cache = Array(repeating: -1, count: 1001)

func topDown(_ N: Int) -> Int {
    if cache[N] != -1 {
        return cache[N]
    }
    
    if N <= 2 {
        cache[1] = 1
        cache[2] = 3
    }
    else {
        cache[N] = (2 * topDown(N - 2) + topDown(N - 1)) % 10007
    }
    
    return cache[N]
}

let answer = topDown(n)
print(answer)

반복문

// MARK: - 11727번(DP - 반복문)
let n = Int(readLine()!)!
var cache = Array(repeating: -1, count: 1001)
cache[1] = 1
cache[2] = 3

if n >= 3 {
    for i in 3...n {
        cache[i] = (2 * cache[i - 2] + cache[i - 1]) % 10007
    }
}

print(cache[n])

백준 Swift 2407번

문제 유형 : DP(재귀, 반복문)

문제 자체는 사실 이항계수를 알고 있다면 풀 수 있을 것이다. 하지만 이 문제는 그것만으론 풀리지 않는다. (백준 1010번을 먼저 풀고 오는걸 추천한다.)

분명히 1010번과 동일하게 코드를 짰는데도 불구하고 틀렸다고 나온다.

처음엔 '로직 자체가 틀렸었는데, 1010번이 우연히 맞았던걸까?' 라는 생각에 다시 고민을 해봤다. 하지만 틀린 게 없었다.

질문검색을 참고하니, n과 m값이 커지면서 Int의 범위를 벗어나게 되면서 생기는 런타임오류였다.

(100 50을 입력했을 때 100891344545564193334812497256가 잘 나오는지 확인해봐라.)

(X) 생각한 방법1. Double형으로 바꾸고, 마지막에 출력 시 String(format: "%0.f", cache[n][m])을 하면 될 거라고 생각했다. 실제로 100C50이 작동해서 맞는줄 알았는데, 작동만 하는 거였지 값이 틀리게 나왔다. 숫자가 커지면서 계산에 문제가 생기는 듯 하다.

아래 더보기를 누르면 틀렸던 코드를 확인할 수 있다.

Double을 썼던, 틀린 코드.

// MARK: - 2407번(DP - 반복문)
import Foundation
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (n, m) = (input[0], input[1])
var cache: [[Double]] = Array(repeating: Array(repeating: -1, count: m + 1), count: n + 1)

for i in 1...n {
    for j in 0...m {
        if j == 0 || j == i {
            cache[i][j] = 1
        }
        else {
            cache[i][j] = cache[i - 1][j - 1] + cache[i - 1][j]
        }
    }
}

//print(cache[n][m])
print(String(format: "%.0f", cache[n][m]))

(O) 생각한 방법2. String으로 숫자를 계산하기로 했다. 설명을 편하게 하기 위해 문자열 a와 b로 두겠다. (a = cache[i-1][j-1], b = cache[i-1][j])

크게 4가지로 나누어 stringAdd메소드에 대해 설명하겠다.

ex) (a = "123", b = "99")

- 초기 셋팅

1. 계산을 편리하게 하기 위해, a와 b중 긴 문자열을 b로 둔다. 만약 a가 더 길다면 swap한다.

(Swift에선 String을 다루는 것보다, [String]을 다루는 게 쉽기 때문에 .map을 써서 바꾼다.)

- 첫번째 for문 흐름

2-1. 우선 a의 문자열의 길이만큼 뒤에서 for문을 돌면서 숫자(문자열)를 더한다. = sum

2-2. 예시에선 sum이 9 + 3 = 12가 되고, sum % 10 = 2를 answerString에 이어 붙인다. - answerString = "2"

2-3. carry(올려질 숫자)는 sum / 10 = 1이 되고, 다음 sum에 함께 더해진다. - answerString = "2"

2-4. sum은 9 + 2 + 1(carry) = 12이 되고, 2-2처럼 한다. - answerString = "22"

2-5. carry(올려질 숫자)는 sum / 10 = 1이 되고, 다음 sum에 함께 더해진다. - answerString = "22"

2-6. carry는 1을 갖고 두번째 for문으로 간다.

- 두번째 for문 흐름

3-1. a의 길이만큼은 이미 다 돌았으니까, b의 나머지 길이만큼만 거꾸로 더 이어 붙여주면 된다. 즉, index : len2 - len1 - 1부터 0까지다.

3-2. sum이 1 + 1(carry) = 2가 되고, sum % 10 = 2를 answerString에 이어 붙인다. - answerString = "222"

3-3. carry는 0이 된다.

- 세번째 if문

4. 이 예시에선 if문은 들어오지 않는다. 하지만 길이가 같은 a와 b였다면 이 조건문에 들어오게 된다.

예를들어 a = "9974", b = "9999" 에선 두번째 for문엔 들어가지 않고, carry는 첫번째 for문에서 1의 값을 갖고 조건문에 들어온다. (carry는 19 / 10 = 1이다.)

answerString에 carry값을 문자로 바꿔서 이어붙여주면 된다.

- 마지막 return

answerString을 뒤집어주면 두 숫자 문자열을 더할 수 있다.

이렇게 stringAdd를 만들어서 cache[i][j] = cache[i-1][j-1] + cache[i-1][j]에 적용하면 된다!

난이도 : 실버3

재귀

// MARK: - 2407번(DP - 재귀)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (n, m) = (input[0], input[1])
var cache: [[String]] = Array(repeating: Array(repeating: "0", count: m + 1), count: n + 1)

func stringAdd(_ a: String, _ b: String) -> String { // 큰 숫자 더하기.
    var aArray = a.map{String($0)}
    var bArray = b.map{String($0)}
    
    if aArray.count > bArray.count { // b가 무조건 길게.
        swap(&aArray, &bArray)
    }
    
    let len1 = aArray.count
    let len2 = bArray.count
    var answerString: String = ""
    
    var carry: Int = 0 // 올림되는 숫자값
    let diff = len2 - len1
    
    for i in stride(from: len1-1, through: 0, by: -1) {
        let sum: Int = Int(aArray[i])! + Int(bArray[diff + i])! + carry
        answerString += String(UnicodeScalar(sum % 10 + 48)!) // 48이 "0"의 유니코드값.
        carry = sum / 10
    }
    
    for i in stride(from: len2-len1-1, through: 0, by: -1) {
        let sum: Int = Int(bArray[i])! + carry
        answerString += String(UnicodeScalar(sum % 10 + 48)!)
        carry = sum / 10
    }
    
    if carry > 0 {
        answerString += String(UnicodeScalar(carry + 48)!)
    }
    
//    answerString = answerString.reversed().map{String($0)}.joined(separator: "")
    answerString = String(answerString.reversed())
    return answerString
}


for i in 1...n {
    for j in 0...m {
        if j == 0 || j == i {
            cache[i][j] = "1"
        }
        else {
//            cache[i][j] = cache[i - 1][j - 1] + cache[i - 1][j]
            cache[i][j] = stringAdd(cache[i - 1][j - 1], cache[i - 1][j])
        }
    }
}

func topDown(_ N: Int, _ M: Int) -> String {
    if cache[N][M] != "0" {
        return cache[N][M]
    }
    
    if M == 0 || M == N {
        cache[N][M] = "1"
    }
    else {
        cache[N][M] = stringAdd(topDown(N - 1, M - 1), topDown(N - 1, M))
    }
    
    return cache[N][M]
}

let answer = topDown(n, m)
print(answer)

반복문

// MARK: - 2407번(DP - 반복문)
import Foundation
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (n, m) = (input[0], input[1])
var cache: [[String]] = Array(repeating: Array(repeating: "0", count: m + 1), count: n + 1)

func stringAdd(_ a: String, _ b: String) -> String { // 큰 숫자 더하기.
    var aArray = a.map{String($0)}
    var bArray = b.map{String($0)}
    
    if aArray.count > bArray.count { // b가 무조건 길게.
        swap(&aArray, &bArray)
    }
    
    let len1 = aArray.count
    let len2 = bArray.count
    var answerString: String = ""
    
    var carry: Int = 0 // 올림되는 숫자값
    let diff = len2 - len1
    
    for i in stride(from: len1-1, through: 0, by: -1) {
        let sum: Int = Int(aArray[i])! + Int(bArray[diff + i])! + carry
        answerString += String(UnicodeScalar(sum % 10 + 48)!) // 48이 "0"의 유니코드값.
        carry = sum / 10
    }
    
    for i in stride(from: len2-len1-1, through: 0, by: -1) {
        let sum: Int = Int(bArray[i])! + carry
        answerString += String(UnicodeScalar(sum % 10 + 48)!)
        carry = sum / 10
    }
    
    if carry > 0 {
        answerString += String(UnicodeScalar(carry + 48)!)
    }
    
//    answerString = answerString.reversed().map{String($0)}.joined(separator: "")
    answerString = String(answerString.reversed())
    return answerString
}


for i in 1...n {
    for j in 0...m {
        if j == 0 || j == i {
            cache[i][j] = "1"
        }
        else {
//            cache[i][j] = cache[i - 1][j - 1] + cache[i - 1][j]
            cache[i][j] = stringAdd(cache[i - 1][j - 1], cache[i - 1][j])
        }
    }
}


print(cache[n][m])

백준 Swift 11053번

문제 유형 : DP(재귀, 반복문)

- 어려웠다. 이해가 안됐다. 규칙을 찾지 못했다... 결국 다른 블로그를 참고해서 풀었다.

가장 긴 증가하는 부분 수열을 LIS(Longest Increasing Subsequence)라고 한다.

O(N^2)와 O(NlogN)으로 풀어낼 수 있다고 하는데, 우선 O(N^2)인 이중반복문으로 풀었다. 이 유형이 익숙해지면 이분탐색으로 O(NlogN)으로도 풀어볼 예정이다.

1. 모든 dp 값을 우선 1로 초기화한다.

2. 기준이 되는 aArray[i]가 aArray[j]보다 큰지 비교한다.

3. 크다면, 현재 위치(i)보다 이전 숫자들 중, dp의 최댓값 + 1이 dp[i]값이 된다.

하단 참고 링크에 있는 나무위키 글을 한번 읽어보면 이해가 빠를 것이다.

난이도 : 실버3

참고 링크 : https://namu.wiki/w/%EC%B5%9C%EC%9E%A5%20%EC%A6%9D%EA%B0%80%20%EB%B6%80%EB%B6%84%20%EC%88%98%EC%97%B4#rfn-1 | https://t.ly/sqXnQ

재귀 - 틀림

// MARK: - 11053번(DP - 재귀함수) : 틀림
let N = Int(readLine()!)!
let aArray = readLine()!.split(separator: " ").map{Int(String($0))!}
var dp = Array(repeating: 1, count: N)

func topDown(_ index: Int) -> Int {
    if dp[index] != 1 {
        return dp[index]
    }
    
    for j in 0..<index {
        if aArray[index] > aArray[j] {
            dp[index] = max(dp[index], topDown(j) + 1)
        }
    }
    
    return dp[index]
}

var maxAnswer: Int = 0
for i in 1..<N {
    maxAnswer = max(maxAnswer, topDown(i))
}

print(maxAnswer)

반복문(1) - 참고 코드

// MARK: - 11053번(DP - 반복문)
let N = Int(readLine()!)!
let aArray = readLine()!.split(separator: " ").map{Int(String($0))!}
var dp = Array(repeating: 1, count: N)

for i in 1..<N {
    
    for j in 0..<i {
        if aArray[i] > aArray[j] {
            dp[i] = max(dp[i], dp[j] + 1)
        }
    }
}

print(dp.max()!)

반복문(2) - 11055번 풀고 다시 시도한 혼자 힘으로 작성한 코드. (22.04.25)

// MARK: - 11053번 다시
let N = Int(readLine()!)!
let arr = readLine()!.split(separator: " ").map{Int(String($0))!}
var dp = Array(repeating: 0, count: N)
dp[0] = 1

for i in 1..<N {
    let standard = arr[i]
    var maxValue = 0
    for j in 0..<i {
        if arr[j] < standard { // 기준보다 작지만,
            maxValue = max(maxValue, dp[j]) // 그 중 제일 큰 dp값에
        }
    }
    dp[i] = maxValue + 1 // 1을 더한게 dp[n]값.
}

print(dp.max()!)

백준 Swift 1912번

문제 유형 : DP(재귀, 반복문)

- 문제를 보고 바로 떠오르진 않았다. 풀이방법을 매우 보고 싶었지만... 고민하고, 값을 쭉 쓰다보니 규칙이 보였다!!!

아래 사진들이 이해가 안된다면, 밑에 설명을 읽고 다시 돌아와서 보면 이해가 될 것이다.

백준 Swift 1912번 고민 1.

백준 Swift 1912번 고민2.

우선 첫번째 인덱스의 값은 그 자체가 최대 합이기 때문에, cache[0] = arr[0]으로 넣는다.

cache는 그 자리에서 나올 수 있는 최대 합을 저장하는 배열이다. 그 인덱스에 있는 숫자(=arr[i])는 반드시 포함되어야 한다는 뜻이기도 하다.

그럼 생각해보자. 이해를 돕기 위해 케이스를 나눠보겠다.

case1. 지금 인덱스 전까지의 합(= cache[i-1])이 음수였는데, 지금 인덱스에 있는 값(= arr[i])이 1000으로 엄청 크다면(양수라면)?

-> 최대합 cache[i]는 arr[i]일 것이다. 음수합에 양수를 더하는 것보다 본인(arr[i])만 포함시키는게 최대 합에 가까워지지 않겠는가. 그럼 cache[i]는 (cache[i-1] + arr[i]보단) arr[i]값을 넣어야 최대 합일 것이다.

case2. 지금 인덱스 전까지의 합(= cache[i-1])이 음수였는데, 지금 인덱스에 있는 값(= arr[i])이 음수라면?

-> 최대합 cache[i]는 arr[i]일 것이다. 최대 합을 구해야 하는데, 음수를 추가로 더한다면... 더 음수가 되지 않겠는가. 그럼 그나마 이번 값(arr[i])만 넣는게 최대합에 더 가까울 것이다.

case3. 지금 인덱스 전까지의 합(= cache[i-1])이 양수였는데, 지금 인덱스에 있는 값(= arr[i])이 음수라면?

-> 최대합 cache[i]는 cache[i-1] + arr[i]일 것이다. 본인(arr[i])만 포함되거나 or 이전 양수합(cache[i-1])에 본인 음수(arr[i])을 추가한 것 중 큰 건 후자일 것이다.

case4. 지금 인덱스 전까지의 합(= cache[i-1])이 양수였는데, 지금 인덱스에 있는 값(= arr[i])이 양수라면?

-> 최대합 cache[i]는 cache[i-1] + arr[i]일 것이다. 이유는 case3과 같다. 본인(arr[i])만 포함되거나 or 이전 양수합(cache[i-1])에 본인 양수(arr[i])을 추가한 것 중 큰 건 후자일 것이다.

위의 케이스를 하나의 점화식으로 나타낼 수 있다.

=> cache[i] = max(arr[i], cache[i-1] + arr[i])

그 다음 cache값의 max를 출력해주거나, 아래 코드처럼 매번 maxValue보다 큰지 비교한뒤 maxValue값을 출력해주면 된다!

난이도 : 실버2

재귀

// MARK: - 1912번(DP - 재귀함수)
let n = Int(readLine()!)!
let arr = readLine()!.split(separator: " ").map{Int(String($0))!}
var cache = Array(repeating: 0, count: n)

func topDown(_ N: Int) -> Int {
    if cache[N] != 0 {
        return cache[N]
    }
    if N == 0 {
        cache[N] = arr[0]
    }
    else {
        cache[N] = max(arr[N], topDown(N-1) + arr[N])
    }
    
    return cache[N]
}

let _ = topDown(n-1)
print(cache.max()!)

반복문

// MARK: - 1912번(DP - 반복문)
let n = Int(readLine()!)!
let arr = readLine()!.split(separator: " ").map{Int(String($0))!}
var cache = Array(repeating: 0, count: n)
cache[0] = arr[0]
var maxValue = cache[0] // cache에 있는 값 중, 최대값(최종 정답)

for i in 1..<n {
    cache[i] = max(arr[i], cache[i-1] + arr[i])
    
    if cache[i] > maxValue {
        maxValue = cache[i]
    }
}

print(maxValue)

백준 Swift 11055번

문제 유형 : DP(재귀, 반복문)

- 비슷한 문제인 11053번문제는 못풀었었는데, 이번 문제는 도움 하나도 없이 풀었다!

지난번 11053번을 풀면서 참고했던 풀이보다, 이번에 풀면서 작성하게 된 코드가 내겐 더 이해가 쉬운 것 같다.

쭉 적으면서 생각해보니 규칙이 보였다.

=> 자신(arr[n])보단 작고, 그 중 제일 큰 dp값에 본인값(arr[n])을 더한게 dp[n]이다.

하단에 코드&주석을 보고 다시 이 문장을 보면 이해가 될 것이다.

난이도 : 실버2

백준 Swift 11055번 고민.

반복문

// MARK: - 11055번(DP - 바텀업)
let N = Int(readLine()!)!
let arr = readLine()!.split(separator: " ").map{Int(String($0))!}
var dp = Array(repeating: 0, count: N)
dp[0] = arr[0]


for i in 1..<N {
    let standard = arr[i] // 기준(자신)
    var maxValue = 0
    for j in 0..<i {
        if arr[j] < standard { // 기준보단 작지만,
            maxValue = max(maxValue, dp[j]) // 그 중 제일 큰 dp값에
        }
    }
    dp[i] = maxValue + standard // 자기자신을 더한게 dp[n]값.
}

print(dp.max()!)

백준 Swift 1890번

문제 유형 : DP(재귀, 반복문), DFS

- 문제를 보자마자 DFS나 BFS가 떠올랐다. 방문체크도 필요 없어보였다. 그렇게 DFS와 BFS로 풀어봤다. 결과는 둘 다 시간초과다. 관련 코드는 아래에 더보기를 누르면 확인할 수 있다.

사람들이 많이 푼 bottomUp(dp테이블) 방법이 제일 무난하고 쉬운 것 같다.

dfs와 dp를 합쳐서 푼 topDown방식은, 고려해야 할 게 있어서 bottomUp방식보다 더 어려운 것 같다.

난이도 : 실버2

dp없이 DFS or BFS로만 풀면 테스트케이스는 나오지만, 시간초과가 난다.

백준 Swift 1890번 - 시간초과

BFS - 시간초과

// MARK: - 1890번(BFS - 시간초과)
let N = Int(readLine()!)!
var map: [[Int]] = Array(repeating: [], count: N)

for i in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    map[i] = input
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < N)
}

var answerCount: Int = 0
func bfs(_ startY: Int, _ startX: Int) {
    var q: [(Int, Int)] = [(startY, startX)]

    while !q.isEmpty {
        let (y, x) = q.removeFirst()
        
        if (y == N - 1) && (x == N - 1) { // 목적지에 도달하면,
            answerCount += 1 // 경로 개수 1 증가.
            continue
        }
        
        // if map[y][x] == 0 {
        //     continue
        // }

        let ny = y + map[y][x] // 밑으로 가게 될 때의 다음 y좌표.
        let nx = x + map[y][x] // 우측으로 가게 될 때의 다음 x좌표.
        
        if isValidCoord(ny, x) { // 1. 밑으로 갈 때,
            q.append((ny, x))
        }
        if isValidCoord(y, nx) { // 2. 우측으로 갈 때,
            q.append((y, nx))
        }
    }

}

bfs(0, 0)
print(answerCount)

DFS - 시간초과

// MARK: - 1890번(DFS - 시간초과)
let N = Int(readLine()!)!
var map: [[Int]] = Array(repeating: [], count: N)

for i in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    map[i] = input
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < N)
}

var answerCount: Int = 0

func dfs(_ y: Int, _ x: Int) {

    if y == N - 1 && x == N - 1 {
        answerCount += 1
    }
    else {
        let ny = y + map[y][x]
        let nx = x + map[y][x]
        
        if isValidCoord(ny, x) { // 1. 밑으로 갈 때,
            dfs(ny, x)
        }
        if isValidCoord(y, nx) { // 2. 우측으로 갈 때,
            dfs(y, nx)
        }
    }

}

dfs(0, 0)
print(answerCount)

재귀

map[y][x]값이 0일때 맴돌게 되기 때문에, 맴도는걸 방지하기 위해 처음에 cache를 -1로 초기화 후 방문 시 0으로 초기화해준다.

참고 링크 : https://sihyungyou.github.io/baekjoon-1890/

// MARK: - 1890번(DFS, DP - topDown)
let N = Int(readLine()!)!
var map: [[Int]] = Array(repeating: [], count: N)
var cache = Array(repeating: Array(repeating: -1, count: N), count: N)

for i in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    map[i] = input
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < N)
}


func dfs(_ y: Int, _ x: Int) -> Int { // topDown
    
    if y == N - 1 && x == N - 1 {
        return 1
    }
    else if cache[y][x] == -1 {
        cache[y][x] = 0
        
        let ny = y + map[y][x]
        let nx = x + map[y][x]
        
        if isValidCoord(ny, x) { // 1. 밑으로 갈 때,
            cache[y][x] += dfs(ny, x)
        }
        if isValidCoord(y, nx) { // 2. 우측으로 갈 때,
            cache[y][x] += dfs(y, nx)
        }
    }
    
    return cache[y][x]
}

let answer = dfs(0, 0)
//print(cache)
print(answer)

반복문

참고 링크 : https://dailymapins.tistory.com/m/91

// MARK: - 1890번(DP - 반복문)
let N = Int(readLine()!)!
var map: [[Int]] = Array(repeating: [], count: N)
var cache = Array(repeating: Array(repeating: 0, count: N), count: N)

for i in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    map[i] = input
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < N)
}

cache[0][0] = 1

for y in 0..<N {
    for x in 0..<N {
        if cache[y][x] != 0 && map[y][x] != 0 {
            let ny = y + map[y][x]
            let nx = x + map[y][x]
            
            if isValidCoord(ny, x) { // 1. 밑으로 갈 때,
                cache[ny][x] += cache[y][x]
            }
            
            if isValidCoord(y, nx) { // 2. 우측으로 갈 때,
                cache[y][nx] += cache[y][x]
            }
        }
    }
}
print(cache[N-1][N-1])

백준 Swift 9465번

문제 유형 : DP(재귀, 반복문)

- 총 3번의 시도끝에 풀었다. 결국 다른 블로그를 참고했다.

첫번째 시도

: 처음엔 dp배열을 1차원배열로 하면 된다고 생각했다. 이유는 아래 사진처럼 나열해봤을 때, 규칙을 발견한 거 같았기 때문이다. 근데 dp[4]에서 안되는 거 보고 틀린걸 깨달았다.

백준 Swift 9465번 - 1차시도(틀림)

두번째, 세번째 시도

: 블로그를 참고해서 dp를 2차원배열로 선언하면 된다는걸 깨달았다. dp를 2차원배열로 하고,

바로 대각선(0행 기준 dp[1][i-1]) or 한칸 간 뒤 대각선(0행 기준 dp[1][i-2]) 중에 큰 걸 선택하면 된다. + arr[0][i]

똑같은 로직인데도 불구하고 두번째 시도는 왜 틀렸냐면, 0열과 1열일 때 arr의 값을 넣은게 아니라 그 행에서 나올 수 있는 최댓값으로 넣었더니 틀렸다. 잘 생각해보면, 이렇게 하면 예시 testcase는 맞는데 아래 반례는 틀린다.

처음엔 틀려서 당황했는데, 아래 반례를 보고 생각해보니 2행에서부터 문제가 생긴다.

점화식

0행 : dp[0][i] = max(dp[1][i-1], dp[1][i-2]) + arr[0][i]

1행 : dp[1][i] = max(dp[0][i-1], dp[0][i-2]) + arr[1][i]

백준 Swift 9465번 - 2차시도(틀림)

난이도 : 실버1

아래 더보기 - 반례

반례

100 1 1 100

1 1 100 1

반복문

// MARK: - 9465번(DP - 반복문)
let T = Int(readLine()!)!

for _ in 0..<T {
    let n = Int(readLine()!)!
    var arr: [[Int]] = Array(repeating: [], count: 2)
    
    arr[0] = readLine()!.split(separator: " ").map{Int(String($0))!}
    arr[1] = readLine()!.split(separator: " ").map{Int(String($0))!}
    
    var dp = Array(repeating: Array(repeating: -1, count: n), count: 2)
    dp[0][0] = arr[0][0] // a
    dp[1][0] = arr[1][0] // b
    
    if n >= 2 {
        dp[0][1] = arr[1][0] + arr[0][1] // (b+c)
        dp[1][1] = arr[0][0] + arr[1][1] // (a+d)
        
        for i in 2..<n {
            dp[0][i] = max(dp[1][i-1], dp[1][i-2]) + arr[0][i] // 위쪽
            dp[1][i] = max(dp[0][i-1], dp[0][i-2]) + arr[1][i] // 아래쪽
        }
    }
    
    let answer = max(dp[0][n-1], dp[1][n-1])
    print(answer)
}

처음짠 잘못된 코드

// MARK: - 9465번(DP - 처음짠 잘못된 코드)
let T = Int(readLine()!)!

for _ in 0..<T {
    let n = Int(readLine()!)!
    var arr: [[Int]] = Array(repeating: [], count: 2)
    
    arr[0] = readLine()!.split(separator: " ").map{Int(String($0))!}
    arr[1] = readLine()!.split(separator: " ").map{Int(String($0))!}
    
    var dp = Array(repeating: -1, count: n + 1)
    dp[1] = max(arr[0][0], arr[1][0]) // max(a, b)
    dp[2] = max(arr[0][0] + arr[1][1], arr[1][0] + arr[0][1]) // max(a+d, b+c)
    
    for i in 3...n {
        dp[i] = max(dp[i-1], dp[i-2]) + max(arr[0][i-1], arr[1][i-1])
    }
    print(dp)
}

백준 Swift 15486번

문제 유형 : DP(재귀, 반복문)

- 고민해봤는데 모르겠어서 다른 블로그를 참고했다.

dp배열의 값들은 그 날에 받을 수 있는 최대금액을 의미한다.

각 @일에서 next를 생각해야 하는게 핵심인 것 같다.

점화식에서 dp[next]를 할 때 자기자신(dp[next])과 비교하는 이유는, 이미 이전 @일차에서 next일차에 접근했을 때의 값이 더 클 수가 있기 때문이다.

주의사항 2가지

1. 점화식에서, dp[i]값이 아니라 maxValue값으로 해야 한다. 그렇지 않으면 지금까지 쌓인 금액을 제대로 끌고 올라갈 수 없다.(바텀업이니까.. 이해가 되려나?)

테스트케이스1~3에선 최소 한번씩은 접근을 했기 때문에 dp[i]로 해도 문제가 안생겼는데, 테스트케이스4의 8일차에서는 이미 많이 진행됐음에도 불구하고 첫접근이여서 문제가 생기는 것이었다.

테스트케이스4에서, 8일차일 때 dp[next]값은 90이 돼야 하는데, dp[i]로 하게 되면 30이 된다. (=8일차 전까지 이미 쌓인 (최대)금액 50 + 10이 계산이 안된다는 뜻이다.)

이해가 안된다면 테스트케이스4를 함께 돌리면서 글을 다시 읽어봐라. 빠르게 이해 될 것이다.

2. 마지막 날에 Tn이 1이라면 근무가 가능하다. 이게 무슨 뜻일까? 힌트는 dp배열의 길이와 관련이 있다.

=> 즉, N일차때의 계산을 위해 dp배열을 1칸 더 늘려줘야 한다는 뜻이다.(드래그를 하면 볼 수 있다.)

백준 Swift 15486번 고민.

점화식

i일차 일 때,

next = i + Ti
dp[next] = max(dp[next], ~~dp[i]~~ + Pi) -> dp[next] = max(dp[next], maxValue + Pi)

난이도 : 실버1

참고 링크 : https://loosie.tistory.com/219

반복문

// MARK: - 15486번(DP - 반복문)
let N = Int(readLine()!)!
var T: [Int] = [0] + Array(repeating: 0, count: N) // 0일 제외
var P: [Int] = [0] + Array(repeating: 0, count: N) // 0일 제외

for i in 1...N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (time, pay) = (input[0], input[1])
    T[i] = time
    P[i] = pay
}

var dp: [Int] = [0] + Array(repeating: 0, count: N) + [0] // 0일 제외, N개 + 1개(마지막날의 T값이 1일 땐 근무 가능. -> 그 값을 저장하기 위해 배열 1 증가시킴.)
var maxValue: Int = -1

for i in 1...N {
    let next = i + T[i]
    maxValue = max(maxValue, dp[i]) // 이전까지의 최대값을 계속 갖고 있어야 함.
    
    if next <= N + 1 {
//        dp[next] = max(dp[next], dp[i] + P[i])
        dp[next] = max(dp[next], maxValue + P[i]) // dp[i]가 아니라 maxValue여야 됨. 예제4에서 틀려서 확인.
    }
}

print(dp.max()!)

백준 Swift 2156번

문제 유형 : DP(재귀, 반복문)

- 예제 TC는 맞아서 처음엔 맞게 푼 것 같았다. 사실 문제를 보고 어떤 규칙이 없을까 라고 생각하고 무작정 돌입해서 푼 것 같다. min을 생각하고 있었으니...

결국 틀렸고 다른 블로그를 참고했다.

현재 잔을 기준으로, 총 3가지의 case로 나뉜다.

case1 : 현재 잔(인덱스 i) + 직전 잔 + (3잔연속은 불가능하기 때문에) i-3위치의 최대값

case2 : 현재 잔(인덱스 i) + (직전 잔은 패스) + i-2위치의 최대값

case3 : (현재 잔 패스) + i-1위치의 최대값

백준 Swift 2156번 고민.

따라서 점화식은 다음과 같다.

(i >= 4)
case1 : arr[i] + arr[i-1] + dp[i-3]
case2 : arr[i] + dp[i-2]
case3 : dp[i-1]

-> dp[i] = max(case1, case2, case3)

난이도 : 실버1

참고 링크 : https://myjamong.tistory.com/313

재귀

// MARK: - 2156번(DP - 재귀함수)
let n = Int(readLine()!)!
var arr = [0] + Array(repeating: 0, count: 10000) // 0번째는 무시.
var dp = [-1] + Array(repeating: -1, count: 10000) // 0번째는 무시.

for i in 1...n {
    arr[i] = Int(readLine()!)!
}

func topDown(_ N: Int) -> Int {
    if dp[N] != -1 {
        return dp[N]
    }
    if N <= 3 {
        dp[1] = arr[1]
        dp[2] = arr[1] + arr[2]
        dp[3] = max(arr[1] + arr[2], arr[1] + arr[3], arr[2] + arr[3]) // 인덱스 1 + 2, 1 + 3, 2 + 3
    }
    else {
        let case1 = arr[N] + arr[N - 1] + topDown(N - 3) // 현재잔 + 직전잔 + N-3위치의 최대값
        let case2 = arr[N] + topDown(N - 2) // 현재잔 + N-2위치의 최대값
        let case3 = topDown(N - 1) // 현재잔X -> N-1위치의 최대값
        dp[N] = max(case1, case2, case3)
    }
    return dp[N]
}

print(topDown(n))

반복문

// MARK: - 2156번(DP - 반복문)
let n = Int(readLine()!)!
var arr = [0] + Array(repeating: 0, count: 10000) // 0번째는 무시.
var dp = [0] + Array(repeating: 0, count: 10000) // 0번째는 무시.

for i in 1...n {
    arr[i] = Int(readLine()!)!
}

dp[1] = arr[1]
dp[2] = arr[1] + arr[2]
dp[3] = max(arr[1] + arr[2], arr[1] + arr[3], arr[2] + arr[3]) // 인덱스 1 + 2, 1 + 3, 2 + 3

if n >= 4 {
    for i in 4...n {
        let case1 = arr[i] + arr[i - 1] + dp[i - 3] // 현재잔 + 직전잔 + i-3위치의 최대값
        let case2 = arr[i] + dp[i - 2] // 현재잔 + i-2위치의 최대값
        let case3 = dp[i - 1] // 현재잔X -> i-1위치의 최대값
        dp[i] = max(case1, case2, case3)
    }
}
print(dp.max()!)

틀린 코드

// MARK: - 2156번(DP - 반복문 : 틀린코드)
let n = Int(readLine()!)!
var arr = [0] + Array(repeating: 0, count: n) // 0번째는 무시.
var dp = [0] + Array(repeating: 0, count: n) // 0번째는 무시.

for i in 1...n {
    arr[i] = Int(readLine()!)!
}

dp[1] = arr[1]
var minValue: Int = arr[1]
dp[2] = max(minValue + arr[2], arr[2]) // 무조건 arr[1] + arr[2]가 클 수 밖에 없긴 함.
minValue = min(minValue + arr[2], arr[2]) // 무조건 arr[2]가 작을 수 밖에 없긴 함.

if n >= 3 {
    for i in 3...n {
        dp[i] = max(minValue + arr[i], dp[i-2] + arr[i])
        minValue = min(minValue + arr[i], dp[i-2] + arr[i])
    }
}
print(dp)
print(dp.max()!)

백준 Swift 10844번

문제 유형 : DP(재귀, 반복문)

- 처음 고민한 방식은 틀렸다. 모르겠어서 다른 블로그를 참고했다.

dp를 2차원 배열로 생각하니까 접근이 가능했다.

이전 길이(N-1)의 수에서, 끝자리(일의 자리)가 0이라면 -> 이번 길이(N)의 끝자리는 1.

이전 길이(N-1)의 수에서, 끝자리(일의 자리)가 9라면 -> 이번 길이(N)의 끝자리는 8.

이전 길이(N-1)의 수에서, 끝자리(일의 자리)가 1~8이라면 -> 이번 길이(N)의 끝자리는 +-1.

방금 위 3줄을 다시 생각해보면,

이번 길이(N)의 끝자리가 0일때의 값 dp[N][0]은, dp[N-1][1]일 것이다.

이번 길이(N)의 끝자리가 9일때의 값 dp[N][9]은, dp[N-1][8]일 것이다.

이번 길이(N)의 끝자리가 1~8일때의 값 dp[N][1] ~ dp[N][8]은, dp[N-1][+-1]일 것이다.

점화식은 아래의 이미지를 보면 이해가 쉬울 것이다.

주의! mod를 answer 출력할 때도 빼트리면 안된다! (https://www.acmicpc.net/board/view/7755)

백준 Swift 10844번 고민.

난이도 : 실버1

참고 링크 : https://t.ly/VYMC | https://st-lab.tistory.com/134 | https://www.acmicpc.net/board/view/7755

재귀

// MARK: - 10844번(DP - 재귀함수)
let N = Int(readLine()!)!
var dp = Array(repeating: Array(repeating: 0, count: 10), count: N + 1)

let mod = 1000000000 // mod로 나눈 나머지.
var sum: Int = 0
for j in 0...9 {
    sum += topDown(N, j) % mod
}
print(sum % mod) // mod 빼먹으면 안됨.

func topDown(_ n: Int, _ lastNum: Int) -> Int {
    if dp[n][lastNum] != 0 {
        return dp[n][lastNum]
    }
    
    if n == 1 { // 1일땐 미리 세팅.
        dp[n][lastNum] = 1
        dp[n][0] = 0
    }
    else { // n >= 2일 때,
        if lastNum == 0 {
            dp[n][lastNum] = topDown(n - 1, 1)
        }
        else if lastNum >= 1 && lastNum <= 8 {
            dp[n][lastNum] = (topDown(n - 1, lastNum - 1) + topDown(n - 1, lastNum + 1))
        }
        else if lastNum == 9 {
            dp[n][lastNum] = topDown(n - 1, 8)
        }
    }
    
    return dp[n][lastNum] % mod
}

반복문

// MARK: - 10844번(DP - 반복문)
let N = Int(readLine()!)!
var dp = Array(repeating: Array(repeating: 0, count: 10), count: N + 1)

for j in 1...9 { // N은 1이고, 1부터 9일 때
    dp[1][j] = 1
}

let mod = 1000000000 // mod로 나눈 나머지.
if N >= 2 {
    for i in 2...N {
        for j in 0...9 {
            if j == 0 {
                dp[i][j] = (dp[i - 1][1]) % mod // = dp[i-1][j+1] % mod
            }
            else if j >= 1 && j <= 8 {
                dp[i][j] = (dp[i - 1][j - 1] + dp[i - 1][j + 1]) % mod
            }
            else if j == 9 {
                dp[i][j] = (dp[i - 1][8]) % mod // = dp[i-1][j-1] % mod
            }
        }
    }
}

let sum = dp[N].reduce(0, +) % mod // 길이가 N인 계단 수의 개수.
print(sum)

틀린 코드

백준 Swift 10844번 - 틀린 고민.

// MARK: - 10844번(DP - 반복문: 틀림)
let N = Int(readLine()!)!
var dp: [Int] = [0] + Array(repeating: 0, count: N)
dp[1] = 9

if N >= 2 {
    for i in 2...N {
        dp[i] = (2 * dp[i - 1] - 1) % 1000000000
    }
}
print(dp[N])

이분탐색 문제 풀이 모음 | 백준 Swift 1789번, 2417번, 10815번, 2805번, 1654번, 2512번, 19637번, 11663번, 2110번, 3079번, 2470번, 20444번, 1477번, 1939번, 2473번, 13397번, 1300번,

개발자P — Tue, 5 Apr 2022 22:17:48 +0900

문제 유형 중, Binary Search의 추천문제들을 풀어보려고 합니다.(Paremetric Search)

추천문제 번호 모음은 여기서 확인할 수 있습니다. 실버와 골드가 섞여있습니다.

https://github.com/tony9402/baekjoon/tree/main/binary_search

GitHub - tony9402/baekjoon: 코딩테스트 대비 문제집(Baekjoon Online Judge)

코딩테스트 대비 문제집(Baekjoon Online Judge). Contribute to tony9402/baekjoon development by creating an account on GitHub.

github.com

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

22.04.05 업데이트

22.04.06업데이트

22.04.07 업데이트

22.04.08 업데이트

22.04.10 업데이트

22.04.11 업데이트

22.04.13업데이트

아래 깃허브 주소에서 모든 백준 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

백준 Swift 1789번

문제 유형 : 이분탐색 기본

난이도 : 실버5

// MARK: - 1789번(이분탐색)
let S = Int(readLine()!)!

var low = 1
var high = S
var answer: Int = 0

while low <= high {
    
    let middle = (low + high) / 2
    let sum = (middle) * (middle + 1) / 2 // 합 공식: n*(n+1)/2
    
    if sum <= S {
        low = middle + 1
        answer = middle
    }
    else {
        high = middle - 1
    }
}

print(answer)

백준 Swift 2417번

문제 유형 : 이분탐색 기본

- Int형의 범위를 초과하는 숫자여서 애를 먹었다. Double로 변경해서 풀어서 해결함.

난이도 : 실버4

// MARK: - 2417번(이분탐색)
let n = Double(readLine()!)! // Int로 하면 middle제곱부분에서 범위 초과.
//var low = 0
//var high = n
//var answer: Int = 0
//
//while low <= high {
//    let middle = (low + high) / 2
//
//    if middle * middle >= Int(n) {
//        high = middle - 1
//        answer = middle
//    }
//    else {
//        low = middle + 1
//    }
//}

var low = 0.0, high = n, answer = 0.0 // Double로 하면 이분탐색 가능.

while low <= high {
    let middle = Double(Int((low + high) / 2)) // 중간에 Int로 바꾸는 이유는, /2를 했을 때 소수점을 없애기 위해서.
    
    if middle * middle >= n {
        high = middle - 1
        answer = middle
    }
    else {
        low = middle + 1
    }
    
}

print(Int(answer))

백준 Swift 10815번

문제 유형 : 이분탐색 기본

난이도 : 실버4

// MARK: - 10815번(이분탐색)
let N = Int(readLine()!)!
let sanggeunCards = readLine()!.split(separator: " ").map{Int(String($0))!}.sorted(by: <)
let M = Int(readLine()!)!
let checkCards = readLine()!.split(separator: " ").map{Int(String($0))!}
var answerArray: [String] = Array(repeating: "0", count: M)

for (index, card) in checkCards.enumerated() {
    var lowIndex: Int = 0
    var highIndex: Int = N - 1
    
    while lowIndex <= highIndex {
        let middleIndex = (lowIndex + highIndex) / 2
        
        if sanggeunCards[middleIndex] == card {
            answerArray[index] = "1"
        }
        
        if sanggeunCards[middleIndex] < card {
            lowIndex = middleIndex + 1
        }
        else {
            highIndex = middleIndex - 1
        }
    }
}

print(answerArray.joined(separator: " "))

백준 Swift 2805번

문제 유형 : 이분탐색 기본 - 단순 합이 아니라, 한번 더 조건을 생각해야 하는 문제였다.

난이도 : 실버3

// MARK: - 2805번(이분탐색)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
let trees = readLine()!.split(separator: " ").map{Int(String($0))!}

var lowHeight: Int = 0
var highHeight: Int = trees.max()!
var answer: Int = 0 // 절단기 높이

while lowHeight <= highHeight {
    let middleHeight = (lowHeight + highHeight) / 2
    
//    let sum = trees.map{$0 - middleHeight}.reduce(0, +) // 이렇게 하면, 절단기 높이(middleHeight)가 더 높을 때 음수가 같이 더해짐.
    var sum: Int = 0
    for tree in trees {
        sum += tree - middleHeight > 0 ? tree - middleHeight : 0 // (나무 - 중간값) 들의 합 : 만약 음수면 안더함.
    }
    
    if sum >= M {
        lowHeight = middleHeight + 1
        answer = middleHeight
    }
    else {
        highHeight = middleHeight - 1
    }
}

print(answer)

백준 Swift 1654번

문제 유형 : 이분탐색 기본

난이도 : 실버3

// MARK: - 1654번(이분탐색)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (K, N) = (input[0], input[1])
var lan: [Int] = [] // 랜선들 모음.
for _ in 0..<K {
    lan.append(Int(readLine()!)!)
}

var low = 1 // 0으로 하면 런타임 에러(자연수라고 했기 때문에)
var high = lan.max()!
var answer: Int = 0

while low <= high {
    let middle = (low + high) / 2
    var countSum: Int = 0 // 생성되는 랜선개수 합
//    for l in lan {
//        countSum += (l / middle)
//    }
    countSum = lan.map{$0 / middle}.reduce(0, +) // for문 축약.
    
    if countSum >= N { // 필요한 랜선이 충분하면, 랜선 길이를 더 늘려본다.(최대 길이를 구해야 하기 때문에)
        low = middle + 1
        answer = middle
    }
    else { // 필요한 랜선이 안나오면, 랜선 길이를 줄여본다.
        high = middle - 1
    }
}

print(answer)

백준 Swift 2512번

문제 유형 : 이분탐색 기본

난이도 : 실버3

// MARK: - 2512번(이분탐색)
let N = Int(readLine()!)!
let moneys = readLine()!.split(separator: " ").map{Int(String($0))!}
let M = Int(readLine()!)!

var low = 1
var high = moneys.max()!
var answer: Int = 0

while low <= high {
    let middle = (low + high) / 2
    var sum: Int = 0
    
    for money in moneys {
        sum += money > middle ? middle : money
    }
    
    if sum <= M {
        low = middle + 1
        answer = middle
    }
    else {
        high = middle - 1
    }
}

print(answer)

백준 Swift 19637번

문제 유형 : 이분 탐색 기본 활용 - 처음에 약간 고민을 했다. power가 기준값(values[middleIndex])보다 낮을 때 highIndex를 -1해주는게 중요했다. (lowIndex를 +1해주면 안된다. 더 높은 기준에서 되는지 체크할 게 아니라, 더 낮은 기준에서 되는지 체크해야 되기 때문이다.)

그리고 입력받을 때, 중복되는 값을 제외하려고 하지 않아도 됐다. 처음엔 해야만 문제가 안생긴다고 생각했는데,

시간초과가 나서 다시 고민해보니 어차피 입력이 오름차순으로 들어오고,

예시2처럼 만약 입력이 같더라도 highIndex가 -1이 되면서, 더 최근꺼로 넘어가게 되기 때문에 할 필요가 없었다.

난이도 : 실버3

// MARK: - 19637번(이분탐색)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var titles: [String] = []
var values: [Int] = []
for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{String($0)}
//    if !values.contains(Int(input[1])!) { // (예제2처럼) 중복되는 값은 제외. - 이 부분 필요 없었음. 이유 : 어차피 오름차순으로 들어오고, 같더라도 highIndex가 -1이 되면서 더 최근꺼로 출력하게 되기 때문.
    titles.append(input[0])
    values.append(Int(input[1])!)
//    }
}

for _ in 0..<M {
    let power = Int(readLine()!)!
    var lowIndex: Int = 0
    var highIndex: Int = values.count - 1
    var answerIndex: Int = 0
    
    while lowIndex <= highIndex {
        let middleIndex = (lowIndex + highIndex) / 2
//        print(lowIndex, highIndex, middleIndex)
        
        if power <= values[middleIndex] { // 기준이 더 낮을 때도 포함되는지 확인하기 위해,
            highIndex = middleIndex - 1 // 높은 인덱스를 -1.
            answerIndex = middleIndex
        }
        else { // 기준이 더 높을 때는 포함되는지 확인하기 위해,
            lowIndex = middleIndex + 1 // 낮은 인덱스를 +1.
        }
    }
    print(titles[answerIndex])
}

백준 Swift 11663번

문제 유형 : 이분탐색 활용 - 어려웠다. 하루동안 고민한 거 같다. 뭔가 값은 비슷하게 나오는데, 모든 case에 맞는 답이 계속 안나오더라.

백준 Swift 11663번 풀이 고민 - 참고용

다시 종이에 풀면서 고민을 했다.

계속 고민 하다보니, 한번에 모든 case에 맞는 답이 나오는 게 아니라, case를 나눠서 답을 출력해주면 되겠다 싶었다.

풀이종이를 함께 보면,

case 1 : 인덱스 값끼리 빼준다. ( highIndex - lowIndex)

case 2 : 인덱스 값끼리 빼주고, 1을 더한다. (highIndex - lowIndex + 1)

케이스가 이렇게 두가지로 나뉜다는 걸 알았다.

그 다음,

선분의 작은 값(lowCoord)보다 coords[lowIndexAnswer]가 더 작을 때, 혹은 선분의 큰 값(highCoord)보다 coords[highIndexAnswer]가 더 클 때, 가 case1에 해당하는걸 찾아냈다.

coords가 [4, 7, 11, 19]일 때,

case1의 예시는 선분이 (5~12), (20~30) 등은 왼쪽조건에 해당하고, 선분이 (1~3)은 오른쪽조건에 해당한다. - 하단 코드 참고

규칙성을 찾았으니, 케이스가 나뉘는 부분을 코드로 구현해서 해결했다!

아 그리고 케이스 나눠줬으니까 맞게 푼 거 같았는데 또 틀리더라. 절망했지만... 다시 처음부터 확인하면서 고민해보니, coords의 오름차순정렬을 빠트렸었다. (이런 -_-)

이분정렬을 할 때는 정렬을 절대 빠트리지 말자!

뭔가 힘들었다... 그래도 해결해서 기분은 좋다. 나중에 시간이 지나 잊었을 때 다시 풀어봐야겠다.

난이도 : 실버3

// MARK: - 11663번(이분탐색)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
let coords = readLine()!.split(separator: " ").map{Int(String($0))!}.sorted(by: <)

func findHigh(_ coord: Int) -> Int {
    var lowIndex: Int = 0
    var highIndex: Int = N - 1
    var answerIndex: Int = 0
    
    while lowIndex <= highIndex {
        let middleIndex = (lowIndex + highIndex) / 2
        if coords[middleIndex] <= coord {
            lowIndex = middleIndex + 1
            answerIndex = middleIndex
        }
        else {
            highIndex = middleIndex - 1
        }
    }
    return answerIndex
}

func findLow(_ coord: Int) -> Int {
    var lowIndex: Int = 0
    var highIndex: Int = N - 1
    var answerIndex: Int = 0
    
    while lowIndex <= highIndex {
        let middleIndex = (lowIndex + highIndex) / 2
        if coords[middleIndex] <= coord {
            lowIndex = middleIndex + 1
            answerIndex = middleIndex
        }
        else {
            highIndex = middleIndex - 1
        }
    }
    return answerIndex
}

for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (lowCoord, highCoord) = (input[0], input[1])
    
    let highIndexAnswer = findHigh(highCoord)
    let lowIndexAnswer = findLow(lowCoord)
//    print(lowIndexAnswer, highIndexAnswer)
    
    var count: Int = 0
    if coords[lowIndexAnswer] < lowCoord || coords[highIndexAnswer] > highCoord { // ex) coords가 [4, 7, 11, 19]일 때, 선분이 (5~12), (20~30) 등은 왼쪽조건에 해당. 선분이 (1~3)은 오른쪽조건에 해당.
        count = highIndexAnswer - lowIndexAnswer
    }
    else {
        count = highIndexAnswer - lowIndexAnswer + 1
    }
    print(count)
}

백준 Swift 2110번

문제 유형 : Parametric Search, 이분탐색 활용 - 이 문제를 보고 이분탐색인지 알아내는게 어려웠다.

다른 풀이들을 보고,

가능한 거리들을 1부터 최대로 둔 다음, 각각의 거리일 때 공유기의 개수를 확인하는 식으로 코드를 짜면 된다는 걸 알게 됐다.

많이 풀다 보면 이 문제가 어떤 유형인지 알 수 있는 날이 오겠...지... ㅠㅠ

난이도 : 골드5

참고 링크 : https://assaeunji.github.io/python/2020-05-07-bj2110/

// MARK: - 2110번(이분탐색)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, C) = (input[0], input[1])
var houses: [Int] = []
for _ in 0..<N {
    houses.append(Int(readLine()!)!)
}
houses.sort(by: <)

var lowDistance = 1 // 가능한 거리 중, 최소 거리
var highDistance = houses[N - 1] - houses[0] // 가능한 거리 중, 최대 거리
var answer = 0

while lowDistance <= highDistance {
    let middleDstance = (lowDistance + highDistance) / 2 // gap
    
    var count: Int = 1 // 맨 처음에 공유기 설치.
    var base = houses[0]
    for i in 1..<N { // 둘째집부터 돌면서 체크.
        if (base + middleDstance) <= houses[i] { // 다음 집이 (base+설정한gap)에 포함될 때, 공유기 설치.
            count += 1
            base = houses[i]
        }
    }
    
    if count >= C { // 설치된 공유기가 C개 이상이면, gap을 늘려서 더 큰 거리일 때 되는지 체크가 필요. -> gap 늘림.
        lowDistance = middleDstance + 1
        answer = middleDstance
    }
    else { // 설치된 공유기가 C개보다 적다는 건, 더 설치 필요. -> gap 축소.
        highDistance = middleDstance - 1
    }
}

print(answer)

백준 Swift 3079번

문제 유형 : 이분탐색 활용 - 계속 내 힘으로 푸는 게 아니라 참고해서 푼다...

풀다 보니 느낀건 어떤걸 탐색돌려야 하는지와, 탐색의 첫 low와 high를 생각 못해서 못 푸는 것 같다.

문제를 마주했을 때 생각흐름도를 정형화해야겠다.

순서 1. 이분탐색 문제인지 확인한다.
순서 2. 이분탐색 문제라면, 어떤걸 탐색돌려야 하는지 고민한다. (중요!)
순서 3. 어떤걸 탐색돌려야 하는지 찾았다면, 탐색의 범위(low, high)를 찾는다.

이 문제에선 (정답이 되는) 결과 시간을 탐색돌려야 했다.

결과 시간이 x초(middle)일때, 몇 명이 pass했는지 체크하면 되는 문제였다.

각 심사대에서 몇 명이 패스했는지 아는 방법은 (x초 / 심사하는데 걸리는 시간)을 하면 몇 명인지 구할 수 있다.

난이도 : 골드5

// MARK: - 3079번(이분탐색)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var times: [Int] = []

for _ in 0..<N {
    times.append(Int(readLine()!)!)
}
times.sort(by: <)

var lowTime = 1 // 최소 결과 시간
var highTime = times[N - 1] * M // 최대 결과 시간
var answerTime: Int = 0

while lowTime <= highTime {
    let middleTime = (lowTime + highTime) / 2
    
    var sum: Int = 0
    for time in times {
        sum += middleTime / time // x초(middleTime)까지의 시간이 지났을 때, 각 심사대에서 pass한 인원의 합.
    }
    
    if sum >= M { // M명이상이 이미 통과했으면, 더 적은 시간일 때 어떨지 체크를 위해 high를 감소.
        highTime = middleTime - 1
        answerTime = middleTime
    }
    else { // M명이 아직 통과도 못했으면, 더 긴 시간일 때 어떨지 체크를 위해 low를 증가.
        lowTime = middleTime + 1
    }
    
}
print(answerTime)

백준 Swift 2470번

문제 유형 : 이분탐색 활용 - 어떤걸 탐색돌려야 하는지 고민했을 때 조합을 쓰고, 그 조합결과에서 나온 값들을 탐색돌려야 한다고 생각해서 틀렸었다.

조합을 쓰면 한단계를 더 거쳐가는 것이기 때문에 불필요하다.

이 문제엔 두가지 핵심이 있었다.

첫번째, 용액 자체들을 바로 탐색을 돌리면 되고, middleIndex가 필요 없다.

두번째, 두 용액이 같을 수는 없기 때문에, while문에서 < 로 해야 하는걸 생각해야 했다.

while (lowIndex <= highIndex) 로 하면 안되는 반례

6
-4 -3 -1 0 2 5 => (0 0)이 나온다. (틀림)

위 반례에서 if문 abs의 < 나 <= 에 따라서, (-4 5) 혹은 (-1 0)이 나와야 한다.

난이도 : 골드5

참고 링크 : https://data-bank.tistory.com/29

// MARK: - 2470번(이분탐색)
let N = Int(readLine()!)!
let liquids = readLine()!.split(separator: " ").map{Int(String($0))!}.sorted(by: <)
var lowIndex: Int = 0
var highIndex: Int = N - 1

var distance: Int = 2000000000 // 0과의 거리. - 최대 1000000000라서 2배.
var answerLowIndex: Int = 0
var answerHighIndex: Int = N - 1

while lowIndex < highIndex {
    let temp = liquids[lowIndex] + liquids[highIndex]
    if abs(temp) < distance { // 새로운조합이 기존보다 0과의 거리가 더 작으면, (등호가 들어가도 되고 안 들어가도 됨. 등호가 들어가게 되면, 거리가 같은게 있을 때 점점 가운데쪽 인덱스로 가까워짐. 등호가 없으면, 거리가 같은게 있어도 바깥쪽 인덱스에서 가운데쪽으로 가까워지지 않음.)
        distance = abs(temp)
        answerLowIndex = lowIndex
        answerHighIndex = highIndex
        if temp == 0 { // 만약 0이면, 더 이상 확인할 필요 없이 바로 stop.
            break
        }
    }
    
    if temp < 0 { // 음(-)이 더 강하면, 양(+)쪽으로.
        lowIndex += 1
    }
    else { // 양(+)이 더 강하면, 음(-)쪽으로.
        highIndex -= 1
    }
}

print(liquids[answerLowIndex], liquids[answerHighIndex])

처음 짠 코드 - 메모리 초과

// MARK: - 2470번(조합, 이분탐색) - 메모리초과
func combi(_ nums: [Int], _ targetNum: Int) -> [[Int]] {
    var results: [[Int]] = []
    
    func combination(_ index: Int, _ nowCombi: [Int]) {
        if nowCombi.count == targetNum {
            results.append(nowCombi)
            return
        }
        for i in index..<nums.count {
            combination(i + 1, nowCombi + [nums[i]])
        }
    }
    combination(0, [])
    return results
}

let N = Int(readLine()!)!
let liquids = readLine()!.split(separator: " ").map{Int(String($0))!}.sorted(by: <)

let liquidsTwo = combi(liquids, 2)
//print(liquidsTwo)
var sumDict: [Int : Int] = [:]
for (index, nums) in liquidsTwo.enumerated() {
    sumDict[index] = nums.reduce(0, +)
//    sumArray.append(nums.reduce(0, +))
}
//print(sumDict)

let sumArray: [Int] = sumDict.values.sorted(by: <)
//print(sumArray)
var lowIndex: Int = 0
var highIndex: Int = sumArray.count - 1
var minD = 2000000000 // 0과의 거리
var answerIndex: Int = 0

while lowIndex <= highIndex {
    let middleIndex = (lowIndex + highIndex) / 2

    if abs(sumArray[middleIndex]) <= minD { // minD보다 더 작은 거리가 있는지 체크하기 위해, highIndex를 줄임.
        minD = abs(sumArray[middleIndex])
        highIndex = middleIndex - 1
        answerIndex = middleIndex
    }
    else { // minD보다 크면, low를 높여야함.(low보다 index가 더 작은 곳엔, 거리(값)가 더 큰 애들밖에 없음.)
        lowIndex = middleIndex + 1
    }
}

for data in sumDict {
    if data.value == sumArray[answerIndex] {
        print(liquidsTwo[data.key][0], liquidsTwo[data.key][1])
        break
    }
}

백준 Swift 20444번

문제 유형 : 이분탐색 활용 - 처음의 생각대로 풀었을 땐, 메모리초과가 났다. 배열에 담았다가 값들을 다시 꺼내오는 식으로 구조를 짜서 문제가 됐다.

값들을 바로 탐색 돌리는 식으로 코드를 수정하니 해결 성공!

하얀 박스 부분 참고

(가로방향 + 1) * (세로방향 + 1)이 색종이의 총 개수다.

세로방향은 (n - 가로방향)이므로, let count = (middle + 1) * ((n - middle) + 1) 가 된다. 위 사진 참고!

백준 Swift 20444번

난이도 : 골드5

// MARK: - 20444번(이분탐색)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (n, k) = (input[0], input[1])

var low: Int = 0
var high: Int = n/2 // 전체 n번 중, n/2까지만 확인하면 됨.
var answer: String = "NO"

while low <= high {
    let middle = (low + high) / 2
    let count = (middle + 1) * ((n - middle) + 1) // 종이의 개수 = (가로방향 + 1) * (세로방향 + 1)
    
    if count == k { // 정답일 땐 더 이상 돌아볼 필요 X.
        answer = "YES"
        break
    }
    
    if count > k {
        high = middle - 1
    }
    else {
        low = middle + 1
    }
}

print(answer)

처음 짠 코드 - 메모리 초과 코드

// MARK: - 20444번(이분탐색)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (n, k) = (input[0], input[1])

//var numArray: [(horizontal: Int, vertical: Int)] = [] // (가로방향으로 자르는 횟수, 세로방향으로 자르는 횟수)
//for i in 0...n/2 {
//    numArray.append((i, n - i))
//}

var countArray: [Int] = []
//for nums in numArray {
//    countArray.append((nums.horizontal + 1) * (nums.vertical + 1))
//}

for i in 0...n/2 {
    countArray.append((i + 1) * ((n - i) + 1))
}

//countArray.sort(by: <)

var lowIndex: Int = 0
var highIndex: Int = countArray.count - 1
var answer: String = "NO"

while lowIndex <= highIndex {
    let middleIndex = (lowIndex + highIndex) / 2
    
    if countArray[middleIndex] == k {
        answer = "YES"
        break
    }
    
    if countArray[middleIndex] > k {
        highIndex = middleIndex - 1
    }
    else {
        lowIndex = middleIndex + 1
    }
}

print(answer)

백준 Swift 1477번

문제 유형 : Parametric Search, 이분탐색 활용

처음 문제를 봤을 때 이분탐색일 거라고 생각이 안 들었다.

첫 풀이는 각각의 거리들을 구해 distance배열에 넣고, M번까지 for문을 돌리면서 distance.max() 값의 /2 를 다시 넣어주고, 그 distance배열의 max값을 출력해주면 된다고 생각했다.

하지만 이 풀이방법은 각각의 거리에, 1개씩만 휴게소가 들어간다는 조건일 때에만 가능한 것인거다. 잘못 됐다.

고민 끝에 다른 게시물을 참고해서 풀었다.

주의사항 1. low를 0으로 해서 런타임 에러가 계속 났었다. low와 high값을 잘 확인하자.

주의사항 2. distance가 기준값(middle)에 정확히 나눠떨어질 때 마지막 설치에서 겹치기 때문에, count에 -1을 해줘야 한다.

주의사항 3. 설치 개수가 M보다 적으면, 간격을 더 줄일 때 - M개를 설치했을 때 구간들의 최댓값을 최소로 하려는 거기 때문에, 여기에 등호가 들어간다.

백준 Swift 1477번

난이도 : 골드4

참고 링크 : https://paris-in-the-rain.tistory.com/44

// MARK: - 1477번(이분탐색)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M, L) = (input[0], input[1], input[2])
let storeCoord: [Int] = [0] + readLine()!.split(separator: " ").map{Int(String($0))!}.sorted(by: <) + [L] // 휴게소들 좌표 저장. (시작 0, 끝 L)

var low: Int = 1 // 설치 가능한 최저
var high: Int = L - 1 // 설치 가능한 최대
var answerDistance: Int = 0 // 정답

while low <= high {
    let middle = (low + high) / 2 // 기준 거리

    var newStoreCount: Int = 0
    
    for i in 1..<storeCoord.count {
        let distance = storeCoord[i] - storeCoord[i - 1] // 각각의 거리.
        
        newStoreCount += distance / middle // 각각의 거리에서 나올 수 있는 휴게소의 개수.
        
        if distance % middle == 0 { // 만약 나눠떨어지면, 끝부분에 중복설치가 됨.
            newStoreCount -= 1 // 그래서 count값에 -1해줌.
        }
    }

    if newStoreCount <= M { // 개수가 M보다 적으면, 간격을 더 줄여야 함. - M개를 설치했을 때 구간들의 최댓값을 최소로 하려는 거기 때문에, 여기에 등호가 들어감.
        high = middle - 1 // (그래야 개수가 늘어나니깐)
        answerDistance = middle
    }
    else { // 개수가 M보다 많으면, 간격을 더 늘려야 함.
        low = middle + 1 // (그래야 개수가 줄어드니깐)
    }
}
print(answerDistance)

백준 Swift 1939번

문제 유형 : 이분탐색 + DFS/BFS

- 문제를 처음 봤을 때, 어디에서 이분탐색을 돌려야 하는지 알지 못했다. 인접행렬을 만든 뒤, 목표지점까지 도달할 수 있는 여러 길들 중, 각각의 길의 결과weight(최소)를 배열에 넣고, 배열에서 최댓값을 출력하면 된다고 생각했다.

우선 기본 인접행렬을 하면 두 섬 사이에 다리가 여러 개일 때 문제가 생겼다. 또한, 인접행렬을 해결했다고 하더라도, 방문처리를 하는 과정에서 지나간 길은 다시 못지나가는 문제가 생겼다.

백준 Swift 1939번 - 초기 생각한 DFS 코드.

결국 초기의 풀이는 틀린 것으로 판단하고, 다른 블로그들에서 풀이를 보고 해결했다.

low와 high를 통해 정해진 mid(기준)중량이 목표지점까지 갈 수 있는지 없는지 체크하는 식으로 해결하면 되는 거였다.

실제 코테에서 이분탐색만 있는 문제는 거의 안 나오고, 이분탐색과 다른 유형이 합쳐진 문제가 주로 출제된다고 하니깐... 더 열심히 해야겠다.

난이도 : 골드4

예시

백준 Swift 1939번 고민.

5 6

1 2 5

5 4 1

4 1 6

5 1 3

4 3 4

3 4 2

2 3

=> 나올 답은 4

참고 링크 : https://woongsios.tistory.com/234 | https://velog.io/@ckstn0778/%EB%B0%B1%EC%A4%80-1939%EB%B2%88-%EC%A4%91%EB%9F%89%EC%A0%9C%ED%95%9C-1-Python

이분탐색 + BFS

// MARK: - 1939번(BFS + 이분체크)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var graph: [[(Int, Int)]] = Array(repeating: [], count: N + 1)
var visited = Array(repeating: false, count: N + 1)

for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (A, B, C) = (input[0], input[1], input[2])
    graph[A].append((B, C))
    graph[B].append((A, C))
}
let fromTo = readLine()!.split(separator: " ").map{Int(String($0))!}
let (startX, endX) = (fromTo[0], fromTo[1])

func isEscape(_ island: Int) -> Bool { // 섬번호가 목표지점에 도달하면 탈출.
    return island == endX
}

func bfs(_ startIsland: Int, _ standardWeight: Int) -> Bool {
    var q: [Int] = [startIsland]
    visited[startIsland] = true
    
    while !q.isEmpty {
        let islandNumber = q.removeFirst()
        
        if isEscape(islandNumber) { // 탈출 성공 시,
            return true // middle(기준)중량으로 운송 가능.
        }
        
        for (nextIsland, limitWeight) in graph[islandNumber] {
            if limitWeight >= standardWeight && !visited[nextIsland] { // 다음섬과 연결된 다리의 중량제한이 middle(기준)중량 이상일 때에만 다음 섬으로 이동 가능. + 미방문시,
                visited[nextIsland] = true
                q.append(nextIsland)
            }
        }
        
        
    }
    return false
}



var low: Int = 1
var high: Int = 1000000001
var answer: Int = 0
while low <= high {
    visited = Array(repeating: false, count: N + 1) // 매 middle(기준)중량일 때, 방문배열 초기화해줘야 함.
    let middle = (low + high) / 2
    
    if bfs(startX, middle) { // 지금 middle(기준) 중량이 운송 가능하다면, 더 높은 중량에서 가능한지 체크하기 위해 low를 높여본다.
        low = middle + 1
        answer = middle
    }
    else { // middle(기준) 중량으로 운송 불가능하다면, 낮춰야 함.
        high = middle - 1
    }
}

print(answer)

이분탐색 + DFS

참고 링크 : https://loosie.tistory.com/313

// MARK: - 1939번(DFS + 이분체크)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var graph: [[(Int, Int)]] = Array(repeating: [], count: N + 1)
var visited = Array(repeating: false, count: N + 1)

for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (A, B, C) = (input[0], input[1], input[2])
    graph[A].append((B, C))
    graph[B].append((A, C))
}
let fromTo = readLine()!.split(separator: " ").map{Int(String($0))!}
let (startX, endX) = (fromTo[0], fromTo[1])

func isEscape(_ island: Int) -> Bool { // 섬번호가 목표지점에 도달하면 탈출.
    return island == endX
}

//func bfs(_ startIsland: Int, _ standardWeight: Int) -> Bool {
//    var q: [Int] = [startIsland]
//    visited[startIsland] = true
//
//    while !q.isEmpty {
//        let islandNumber = q.removeFirst()
//
//        if isEscape(islandNumber) { // 탈출 성공 시,
//            return true // middle(기준)중량으로 운송 가능.
//        }
//
//        for (nextIsland, limitWeight) in graph[islandNumber] {
//            if limitWeight >= standardWeight && !visited[nextIsland] { // 다음섬과 연결된 다리의 중량제한이 middle(기준)중량 이상일 때에만 다음 섬으로 이동 가능. + 미방문시,
//                visited[nextIsland] = true
//                q.append(nextIsland)
//            }
//        }
//    }
//    return false
//}

func dfs(_ island: Int, _ standardWeight: Int) {
    if isEscape(island) {
        canTransit = standardWeight // standardWeight = middle 같음.
        return
    }
    for (nextIsland, limitWeight) in graph[island] {
        if limitWeight >= standardWeight && !visited[nextIsland] { // 다음섬과 연결된 다리의 중량제한이 middle(기준)중량 이상일 때에만 다음 섬으로 이동 가능. + 미방문시,
            visited[nextIsland] = true
            dfs(nextIsland, standardWeight)
        }
    }
}


var low: Int = 1
var high: Int = 1000000001
var canTransit: Int = -1 // // middle(기준)중량으로 운송 가능한지 체크를 위한 변수.
var answer: Int = 0
while low <= high {
    visited = Array(repeating: false, count: N + 1) // 매 middle(기준)중량일 때, 방문배열 초기화해줘야 함.
    let middle = (low + high) / 2

    canTransit = -1 // middle(기준)중량으로 운송 가능한지 여부.
    visited[startX] = true
    dfs(startX, middle) // canTransit값이 바뀌어 있다면, middle(기준)중량으로 운송 가능.
    
    if canTransit != -1 { // 지금 middle(기준) 중량이 운송 가능하다면, 더 높은 중량에서 가능한지 체크하기 위해 low를 높여본다.
        low = middle + 1
        answer = middle
    }
    else { // middle(기준) 중량으로 운송 불가능하다면, 낮춰야 함.
        high = middle - 1
    }
}

print(answer)

백준 Swift 2473번

문제 유형 : 이분탐색 활용 - 2470번 문제를 풀고, 조금만 더 생각해보면 쉽게 풀 수 있는 문제였다. 2개의 용액이 아닌, 3개의 용액을 선택해야 하기 때문에,

index 0..<N-2까지 돌면서 첫번째 용액을 선택 시, 나머지 2개의 용액 선택범위를 low와 high로 선정 후 이분탐색을 돌리면 해결 된다.

난이도 : 골드4

// MARK: - 2473번(이분탐색)
let N = Int(readLine()!)!
let liquids = readLine()!.split(separator: " ").map{Int(String($0))!}.sorted(by: <)

var liquidSumDistance: Int = 3000000001 // 세 용액의 합.
var answerIndex1: Int = 0
var answerIndex2: Int = 0
var answerIndex3: Int = 0
outLoop: for i in 0..<N-2 {
    let liq1 = liquids[i] // 첫번째 용액 선택.
    var lowIndex: Int = i + 1
    var highIndex: Int = N - 1

    while lowIndex < highIndex {
        let liq2 = liquids[lowIndex]
        let liq3 = liquids[highIndex]
        
        let sum = liq1 + liq2 + liq3
        if abs(sum) < liquidSumDistance { // 용액의 합(sum)이 0과 더 가깝다면,
            liquidSumDistance = abs(sum) // 더 가까운 합으로 0과의 거리 업데이트.
            (answerIndex1, answerIndex2, answerIndex3) = (i, lowIndex, highIndex)
        }
        
        if sum == 0 { // 더 이상 돌 필요 없이 끝.
            break outLoop
        }
        else if sum > 0 { // 양의 기운이 강한 상태라면, 음쪽으로 가야 함.
            highIndex -= 1
        }
        else { // 음의 기운이 강한 상태라면, 양쪽으로 가야 함.
            lowIndex += 1
        }
    }
}
print(liquids[answerIndex1], liquids[answerIndex2], liquids[answerIndex3])

백준 Swift 13397번

문제 유형 : Parametric Search, 이분탐색

- 어려웠다. 솔직히 감을 못잡았다. 풀이 안 봤으면 계속 못 풀었을 것 같다... 언제쯤 이런 문제도 쉽게 풀 수 있을까..

핵심 1

구간점수들 중 기준이 될 최댓값(middle)을 잡고, numsArray배열을 돌면서 구간점수(max-min)가 middle보다 클 시, 구간이 바뀌는 곳이다.

-> (이해가 처음에 안됐는데, 계속 생각하다 보니 알겠더라.) 기준이 되는 middle보다 구간점수가 커진다는 건, 이미 middle이 나올 수 있는 최댓값이라는 걸 isAble에 들어갈 때부터 정하고 while문을 도는 것이기 때문에 사실 불가능한 상황인 거다. => 그 뜻은, middle보다 구간점수가 커지는 index가 새로운 구간의 시작점이 되는 것이다.

핵심 2

구간이 바뀌는 상황일 때 index를 -1 해줘야 한다.

-> 그렇지 않으면, 구간에 하나의 숫자만 있는 상황이 고려 되지 않는다.

이 테스트케이스들에선 문제되는 케이스가 없어서 다른 글에 있는 코드들이 pass가 된건지 or 논리적으로 고려하지 않아도 돼서 안한건지는 모르겠다.

그래도 나는 위 케이스를 판단해주는 게 맞다고 생각해서 while문으로 작성후 index를 빼줬다. (for문으로 하고 싶었지만, swift에서는 for문 다시 index 되돌아가는 게 없어서...)

참고한 대부분의 블로그에선 하나의 숫자만 있는 상황이 고려되진 않은 것 같다. 참고한 글들 중 유일하게 위 케이스가 고려된 글 - https://loosie.tistory.com/638

핵심 3

count가 0이 아니라 1로 시작해야 한다.

-> 가장 마지막 구간은 카운팅이 안되기 때문이다.

=> count가 만약 0으로 시작.

(쉽게 생각하기 위해) 만약 if문에 해당되는 게 없다면(= 구간이 바뀌는 곳이 없다면) count가 0이 나온다.

배열의 모든 숫자가 하나의 구간인 상황이니까 1이 답인데 말이다!

난이도 : 골드4

참고한 글 : https://loosie.tistory.com/638 | https://kyu9341.github.io/algorithm/2020/03/10/algorithm13397/

// MARK: - 13397번(Parametric Search, 이분탐색)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
let numsArray = readLine()!.split(separator: " ").map{Int(String($0))!}

func isAble(_ standardScore: Int) -> Bool {
    var index: Int = 0
    var count: Int = 1 // 가장 마지막 구간은 카운팅이 안됨. 그래서 1로 시작.
    var temp: [Int] = []
    
    while index < N { // index가 0..<N까지. 그 구간에 1개만 있는 상황 체크를 위해, index를 빼줘야 해서 for문이 아닌 while문으로.
        temp.append(numsArray[index])
        let (max, min) = (temp.max()!, temp.min()!)
        if max - min > standardScore { // 기준값보다 클 때 구간이 바뀜.
            temp.removeAll()
            count += 1
//            temp.append(numsArray[index]) // 구간이 바뀌게 된 숫자부터 다시 시작. - 이 코드는 필요 없음. 이유 : 인덱스를 빼주면, 어차피 (코드상)5줄 위에서 다시 그 구간에 1개만 있는 상황으로 됨.
            index -= 1 // 인덱스를 다시 하나 빼줘야, 구간에 1개만 있는 상황이 체크됨.
        }
        index += 1
    }
    
    return count <= M // middle(standardScore)로 M개 이하의 구간을 만들었는가.
}

var low = 0
var high = numsArray.max()!
var answer: Int = 0
while low <= high {
    let middle = (low + high) / 2

    if isAble(middle) { // 구간점수들 중 최댓값(middle)으로 가능하다면, 더 작은 수로는 가능한지 체크하기 위해.
        high = middle - 1
        answer = middle
    }
    else { // 최솟값(middle)로 불가능하면, 더 큰 수로는 가능한지 체크하기 위해.
        low = middle + 1
    }
}

print(answer)

백준 Swift 1300번

문제 유형 : 이분탐색 활용

- 처음엔 실제로 2차원 배열을 생성한 뒤 flatMap을 써서 제출했다. 당연하게.. 메모리 초과. 문제는 짧은데, 생각하기가 어렵다.

이 문제가 이분탐색 문제라는건 알고 있어서 어떻게 접근하면 좋을까 고민을 하다가 모르겠어서 다른 글들을 참고했다.

문제에서 B[k]를 찾는다는 건, k이하의 숫자가 적어도 k개 있다는 뜻이 된다. (=> 즉, 이분탐색의 high는 k가 된다.)

배열을 쓰지 않고(N이 매우 커서 메모리초과가 남) 몇개가 있는지 알아야 k번째 숫자(= 정답)를 구할 수 있을 것이다.

1. low와 high를 통해 middle(기준값)을 정하고, 기준값을 통해 기준값보다 작거나 같은 숫자 개수를 구한다.

1-1. 기준값을 각 행으로 나눠주면, 그 행에서 나올 수 있는 (기준값보다 작은) 숫자의 개수가 나온다.

ex) 구구단의 8단에서, 8의 배수들 중 54보다 작은 숫자의 개수를 구하라고 한다면 어떻게 구할 것인가? 54 / 8 = 6개 일 것이다. 예시와 1-1은 같은 내용이다.

1-2. 각 행에서 나올 수 있는 숫자의 개수는 N개일 것이다. NxN행렬이니깐. 하지만, (middle(기준값) / i(행렬)) 로만 계산한다면 N개보다 큰 값이 나오게 될 수 있다. 따라서, (middle(기준값) / i(행렬)) 과 N 중 작은 숫자를 더해줘야 한다. => count += min(middle/i, N)

ex) N은 3이고 middle은 4일 때, 1행에서 그냥 (middle(기준값) / i(행렬))로만 계산하면 4가 나오게 된다. 3이 나와야 하는데!

기준값이 K보다 크거나 같을 때는, 더 작은 기준값일 때도 K개에 해당하는지 찾기 위해 낮춰보면 된다.

난이도 : 골드2

참고한 글 : https://st-lab.tistory.com/281 | https://woongsios.tistory.com/216

// MARK: - 1300번(이분탐색)
let N = Int(readLine()!)!
let k = Int(readLine()!)!
//var A = Array(repeating: Array(repeating: 0, count: N + 1), count: N + 1)
//
//for j in 1..<N+1 {
//    for i in 1..<N+1 {
//        A[j][i] = j * i
//    }
//}
//
//let B = A.flatMap{$0.filter{$0 > 0}}.sorted(by: <)
//print(B[k])

var low: Int = 1
var high: Int = k
var answer: Int = -1
while low <= high {
    let middle = (low + high) / 2
    
    var count: Int = 0
    for i in 1...N {
        count += min(middle / i, N) // (middle/i)와 N 중, 작은 걸 더해야 한다. 예를 들어, 1행(i=1)에서 나올 수 있는 갯수는 최대 N개인데, 더 큰 값이 나올 수도 있기 때문.
    }
    
    if count >= k { // 개수가 K개 이상이면, 더 작은 수일 때도 K개에 해당하는지 찾기 위해 낮춰본다.
        high = middle - 1
        answer = middle
    }
    else { // 개수가 K개보다 아직 적다면, 더 큰 수로 만든다.
        low = middle + 1
    }
}
print(answer)

백준 Swift 1743번, 2667번, 2583번, 2468번, 7562번, 1697번, 1182번, 2512번, 10815번,

개발자P — Thu, 24 Mar 2022 18:47:02 +0900

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

22.03.24 업데이트

22.03.27 업데이트

22.03.29 업데이트

22.03.30 업데이트

22.04.04 업데이트

22.04.05 업데이트

아래 깃허브 주소에서 모든 백준 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

백준 Swift 1743번(DFS)

// MARK: - 1743번(DFS)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M, K) = (input[0], input[1], input[2])
var board = Array(repeating: Array(repeating: ".", count: M + 1), count: N + 1)
var visited = Array(repeating: Array(repeating: false, count: M + 1), count: N + 1)

for _ in 0..<K {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (r, c) = (input[0], input[1])
    
    board[r][c] = "#" // 음식물 표시.
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]

func isValidCoord(_ y: Int, _ x: Int) -> Bool { // board 밖으로 안나가야됨.
    return (1 <= y && y <= N) && (1 <= x && x <= M)
}

var count: Int = 0
var temp: [Int] = []

func dfs(_ y: Int, _ x: Int) {
    for k in 0..<4 {
        let ny = y + dy[k]
        let nx = x + dx[k]
        
        if isValidCoord(ny, nx) && !visited[ny][nx] && board[ny][nx] == "#" {
            visited[ny][nx] = true
            count += 1
            dfs(ny, nx)
        }
    }
}

for y in 1...N {
    for x in 1...M {
        if !visited[y][x] && board[y][x] == "#" {
            visited[y][x] = true
            count = 1 // 방문한거로 되면서, 음식물 크기 1부터 시작.
            dfs(y, x)
            
            temp.append(count)
        }
    }
}

print(temp.max()!)

백준 Swift 1743번(BFS)

// MARK: - 1743번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}

let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M, K) = (input[0], input[1], input[2])
var board = Array(repeating: Array(repeating: ".", count: M + 1), count: N + 1)
var visited = Array(repeating: Array(repeating: false, count: M + 1), count: N + 1)

for _ in 0..<K {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (r, c) = (input[0], input[1])
    
    board[r][c] = "#"
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (1 <= y && y <= N) && (1 <= x && x <= M)
}


func bfs(_ startY: Int, _ startX: Int) -> Int {
    visited[startY][startX] = true
    var count: Int = 1
    let q = Dequeue([(startY, startX)])
    
    while !q.isEmpty {
        let (y, x) = q.popFirst()
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            
            if isValidCoord(ny, nx) && !visited[ny][nx] && board[ny][nx] == "#" {
                visited[ny][nx] = true
                count += 1
                q.pushLast((ny, nx))
            }
        }
    }
    return count
}

var temp: [Int] = []

for y in 1...N {
    for x in 1...M {
        if !visited[y][x] && board[y][x] == "#" {
            visited[y][x] = true
            let count = bfs(y, x)
            temp.append(count)
        }
        
    }
    
}

print(temp.max()!)

백준 Swift 2667번(DFS)

// MARK: - 2667번(DFS)
let N = Int(readLine()!)!
var board: [[Int]] = []
var visited = Array(repeating: Array(repeating: false, count: N), count: N)
for _ in 0..<N {
    let input = readLine()!.map{Int(String($0))!}
    board.append(input)
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < N)
}

var count: Int = 0

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]

func dfs(_ y: Int, _ x: Int) {
    for k in 0..<4 {
        let ny = y + dy[k]
        let nx = x + dx[k]
        if isValidCoord(ny, nx) && !visited[ny][nx] && board[ny][nx] == 1 {
            visited[ny][nx] = true
            count += 1
            dfs(ny, nx)
        }
    }
}


var temp: [Int] = []
for y in 0..<N {
    for x in 0..<N {
        if !visited[y][x] && board[y][x] == 1 {
            count = 1
            visited[y][x] = true
            dfs(y, x)
            temp.append(count)
        }
    }
    
}

temp.sort(by: <)

print(temp.count)

for num in temp {
    print(num)
}

백준 Swift 2667번(BFS)

// MARK: - 2667번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}
let N = Int(readLine()!)!
var board: [[Int]] = []
var visited = Array(repeating: Array(repeating: false, count: N), count: N)
for _ in 0..<N {
    let input = readLine()!.map{Int(String($0))!}
    board.append(input)
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < N)
}

var count: Int = 0

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]

func bfs(_ startY: Int, _ startX: Int) -> Int {
    visited[startY][startX] = true
    let q = Dequeue([(startY, startX)])
    count = 1
    
    while !q.isEmpty {
        let (y, x) = q.popFirst()
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            
            if isValidCoord(ny, nx) && !visited[ny][nx] && board[ny][nx] == 1 {
                visited[ny][nx] = true
                count += 1
                q.pushLast((ny, nx))
            }
        }
    }
    return count
}

var temp: [Int] = []

for y in 0..<N {
    for x in 0..<N {
        if !visited[y][x] && board[y][x] == 1 {
            visited[y][x] = true
            let count = bfs(y, x)
            temp.append(count)
        }
        
    }
}

temp.sort(by: <)

print(temp.count)

for num in temp {
    print(num)
}

백준 Swift 2583번(DFS)

// MARK: - 2583번(DFS)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (M, N, K) = (input[0], input[1], input[2])
var board = Array(repeating: Array(repeating: 0, count: N), count: M)
var visited = Array(repeating: Array(repeating: false, count: N), count: M)

for _ in 0..<K {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (x1, y1, x2, y2) = (input[0], input[1], input[2], input[3])
    
    for y in y1..<y2 { // 직사각형에 속하는 부분을 다 1처리.
        for x in x1..<x2 {
            board[y][x] = 1
        }
    }
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < M) && (0 <= x && x < N)
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]
var count: Int = 0

func dfs(_ y: Int, _ x: Int) {
    for k in 0..<4 {
        let ny = y + dy[k]
        let nx = x + dx[k]
        
        if isValidCoord(ny, nx) && !visited[ny][nx] && board[ny][nx] == 0 {
            visited[ny][nx] = true
            count += 1
            dfs(ny, nx)
        }
    }
}

var temp: [Int] = []
for y in 0..<M {
    for x in 0..<N {
        if !visited[y][x] && board[y][x] == 0 {
            visited[y][x] = true
            count = 1
            dfs(y, x)
            temp.append(count)
        }
    }
    
}

temp.sort(by: <)
print(temp.count)
print(temp.map{String($0)}.joined(separator: " "))

백준 Swift 2583번(BFS)

// MARK: - 2583번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
    
}
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (M, N, K) = (input[0], input[1], input[2])
var board = Array(repeating: Array(repeating: 0, count: N), count: M)
var visited = Array(repeating: Array(repeating: false, count: N), count: M)
for _ in 0..<K {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (x1, y1, x2, y2) = (input[0], input[1], input[2], input[3])
    
    for y in y1..<y2 {
        for x in x1..<x2 {
            board[y][x] = 1
        }
    }
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < M) && (0 <= x && x < N)
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]
var count: Int = 0

func bfs(_ startY: Int, _ startX: Int) -> Int {
    visited[startY][startX] = true
    count = 1
    let q = Dequeue([(startY, startX)])
    
    while !q.isEmpty {
        let (y, x) = q.popFirst()
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            
            if isValidCoord(ny, nx) && !visited[ny][nx] && board[ny][nx] == 0 {
                visited[ny][nx] = true
                count += 1
                q.pushLast((ny, nx))
            }
        }
    }
    return count
}


var temp: [Int] = []
for y in 0..<M {
    for x in 0..<N {
        if !visited[y][x] && board[y][x] == 0 {
            visited[y][x] = true
            let area = bfs(y, x)
            temp.append(area)
        }
        
    }
}

temp.sort(by: <)
print(temp.count)
print(temp.map{String($0)}.joined(separator: " "))

백준 Swift 2468번(DFS)

// MARK: - 2468번(DFS)
let N = Int(readLine()!)!
var board: [[Int]] = []
var visited = Array(repeating: Array(repeating: false, count: N), count: N)

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    board.append(input)
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < N)
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]


func dfs(_ y: Int, _ x: Int, _ standardHeight: Int) {
    for k in 0..<4 {
        let ny = y + dy[k]
        let nx = x + dx[k]
        
        if isValidCoord(ny, nx) && !visited[ny][nx] && (board[ny][nx] > standardHeight) {
            visited[ny][nx] = true
            dfs(ny, nx, standardHeight)
        }
    }
    
}



var area: [Int] = []
let maxHeight = board.flatMap{$0}.max()! // 기준점 - 제일 높은곳까지

for height in 0...maxHeight { // 비가 안 올 때부터 ~ 비가 최대로 올 때까지.
    visited = Array(repeating: Array(repeating: false, count: N), count: N) // 매 기준점마다, 방문기록 초기화.
    var count: Int = 0 // 영역 카운팅
    
    for y in 0..<N {
        for x in 0..<N {
            if !visited[y][x] && board[y][x] > height {
                visited[y][x] = true
                count += 1
                dfs(y, x, height)
            }
        }
    }
    area.append(count)
}

print(area.max()!)

백준 Swift 2468번(BFS)

// MARK: - 2468번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}

let N = Int(readLine()!)!
var board: [[Int]] = []
var visited = Array(repeating: Array(repeating: false, count: N), count: N)

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    board.append(input)
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < N)
}

func bfs(_ startY: Int, _ startX: Int, _ standardHeight: Int) {
    visited[startY][startX] = true
    let q = Dequeue([(startY, startX)])
    
    while !q.isEmpty {
        let (y, x) = q.popFirst()
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            if isValidCoord(ny, nx) && !visited[ny][nx] && board[ny][nx] > standardHeight {
                visited[ny][nx] = true
                q.pushLast((ny, nx))
            }
        }
    }
    
}

var area: [Int] = []
let maxHeight: Int = board.flatMap{$0}.max()!

for height in 0...maxHeight { // 비가 0부터, 최대높이까지 올 때.
    visited = Array(repeating: Array(repeating: false, count: N), count: N) // 방문기록 초기화.
    var count: Int = 0
    
    for y in 0..<N {
        for x in 0..<N {
            if !visited[y][x] && board[y][x] > height { // 방문기록 없고, 안전할 시
                visited[y][x] = true
                count += 1
                bfs(y, x, height)
            }
            
        }
        
    }
    area.append(count)
}

print(area.max()!)

백준 Swift 7562번

문제 유형 : BFS

난이도 : 실버1

// MARK: - 7562번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}

let T = Int(readLine()!)!

let dx = [1, 2, 2, 1, -1, -2, -2, -1]
let dy = [2, 1, -1, -2, -2, -1, 1, 2]


for _ in 0..<T {
    let l = Int(readLine()!)!
    var board = Array(repeating: Array(repeating: 0, count: l), count: l)
    var visited = Array(repeating: Array(repeating: -1, count: l), count: l)
    
    var input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (stX, stY) = (input[0], input[1])
    input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (endX, endY) = (input[0], input[1])
    
    board[stY][stX] = 1
    board[endY][endX] = 2 // 임의로 2로 정함.
    
    
    func isValidCoord(_ y: Int, _ x: Int) -> Bool {
        return (0 <= y && y < l) && (0 <= x && x < l)
    }
    
    func isEscape(_ y: Int, _ x: Int) -> Bool {
        return board[y][x] == 2 // board값이 (임의로 정한) 2일 때 탈출.
    }
    
    func bfs(_ startY: Int, _ startX: Int) -> Int {
        let q = Dequeue([(startY, startX)])
        visited[startY][startX] = 0
        
        while !q.isEmpty {
            let (y, x) = q.popFirst()
            
            if isEscape(y, x) { // 목표에 도달하면,
                return visited[y][x]
            }
            
            for k in 0..<8 {
                let ny = y + dy[k]
                let nx = x + dx[k]
                
                if isValidCoord(ny, nx) && visited[ny][nx] == -1 && board[ny][nx] != 1 { // 유효 범위고, 방문한적이 없고, 시작지점이 아니면,
                    visited[ny][nx] = visited[y][x] + 1
                    q.pushLast((ny, nx))
                }
            }
            
        }
        return -1 // 불가능 시 -1 return.
    }
    
    let answer = bfs(stY, stX)
    print(answer)
}

백준 Swift 1697번

문제 유형 : BFS 최단거리 - +1, -1은 상관 없는데 2배조건 때문에 dx를 쓰지 못하고, 각각을 if조건 처리해줌.

(+1,-1,*2 각각의 케이스를 모두 체크해야 하는 거기 때문에 else if로 하면 안됨!)

난이도 : 실버1

// MARK: - 1697번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, K) = (input[0], input[1])
var board = Array(repeating: 0, count: 100001) // 0부터 100000까지.
var visited = Array(repeating: -1, count: 100001) // 0부터 100000까지.

func isValidCoord(_ x: Int) -> Bool {
    return (0 <= x && x <= 100000)
}

func isEscape(_ x: Int) -> Bool { // 수빈이를 만나면 탈출.
    return (x == K)
}

func bfs(_ startX: Int) -> Int {
    let q = Dequeue([startX])
    visited[startX] = 0 // 첫 위치 0으로 초기화.
    
    while !q.isEmpty {
        let x = q.popFirst()
        
        if isEscape(x) { // 탈출 성공 시,
            return visited[x]
        }
        
        if isValidCoord(x + 1) && board[x + 1] == 0 && visited[x + 1] == -1 { // x+1한게 유효한 범위고, x+1이 갈 수 있는 곳이고, 미방문한 곳이면,
            visited[x+1] = visited[x] + 1
            q.pushLast(x+1)
        }
        if isValidCoord(x - 1) && board[x - 1] == 0 && visited[x - 1] == -1 { // x-1한게 유효한 범위고, x-1이 갈 수 있는 곳이고, 미방문한 곳이면,
            visited[x-1] = visited[x] + 1
            q.pushLast(x-1)
        }
        if isValidCoord(2 * x) && board[2 * x] == 0 && visited[2 * x] == -1 { // 2*x한게 유효한 범위고, 2*x이 갈 수 있는 곳이고, 미방문한 곳이면,
            visited[2*x] = visited[x] + 1
            q.pushLast(2*x)
        }
    }
    return -1
}

let answer = bfs(N)
print(answer)

백준 Swift 1182번

문제 유형 : 조합 or DFS

난이도 : 실버2

// MARK: - 1182번(DFS)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, S) = (input[0], input[1])
let numArray = readLine()!.split(separator: " ").map{Int(String($0))!}
var visited = Array(repeating: false, count: N)
//var sum: Int = 0
var count: Int = 0

//func dfs(_ startIndex: Int, _ depth: Int) { // ver1
//
//    if sum == S && depth > 0 { // 부분수열의 합이 S일 때,
//        count += 1
//    }
//
//    for k in startIndex..<N {
//        if !visited[k] {
//            visited[k] = true
//            sum += numArray[k]
//
//            dfs(k, depth + 1)
//
//            sum -= numArray[k]
//            visited[k] = false
//        }
//    }
//
//}

func dfs(_ startIndex: Int, _ depth: Int, _ sum: Int) { // ver2(개선)
    if sum == S && depth > 0 { // 부분수열의 합이 S일 때,
        count += 1
    }
    
    for k in startIndex..<N {
        if !visited[k] {
            visited[k] = true
            dfs(k + 1, depth + 1, sum + numArray[k])
            visited[k] = false
        }
    }
    
    
}



dfs(0, 0, 0)
print(count)

조합 - 속도 느림.

// MARK: - 1182번(조합)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, S) = (input[0], input[1])
let nums = readLine()!.split(separator: " ").map{Int(String($0))!}
var count: Int = 0

func combi(_ nums: [Int], _ targetNum: Int) -> [[Int]] {
    var result: [[Int]] = []

    func combination(_ index: Int , _ nowCombi: [Int]) {
        if nowCombi.count == targetNum {
            result.append(nowCombi)
            return
        }

        for i in index..<nums.count {
            combination(i + 1, nowCombi + [nums[i]])
        }
    }
    combination(0, [])
    return result
}


for k in 1...N {
    let numArray = combi(nums, k)

    for nums in numArray {
        if nums.reduce(0, +) == S {
            count += 1
        }
    }
}

print(count)

백준 Swift 2512번

문제 유형 : 파라메트릭 서치, Binary Search(이진 탐색)

- 이진탐색문제를 처음 풀어봐서 그런지, 이 문제가 이진탐색을 활용해야 하는지조차 생각하지 못했다.

난이도 : 실버3

// MARK: - 2512번(Binary Search)
let N = Int(readLine()!)!
let moneyArray = readLine()!.split(separator: " ").map{Int(String($0))!}
let M = Int(readLine()!)!
var answerMax: Int = 0

var low = 0
var high = moneyArray.max()!
var middle = (low + high) / 2

func isPossible(_ middle: Int) -> Bool {
    var sum: Int = 0
    for money in moneyArray {
        sum += min(money, middle)
    }
    return sum <= M
}

while low <= high { // Parametric Search & Binary Search
    if isPossible(middle) { // 기준예산(middle)으로 충당이 가능하면,
        low = middle + 1 // 기준예산보다 위로 다시 체크.
        answerMax = middle
    }
    else { // 기준예산(middle)으로 충당이 불가능하면,
        high = middle - 1 // 기준예산보다 밑으로 다시 체크.
    }
    
    middle = (low + high) / 2
}

print(answerMax)

더보기 - 개선전 코드

개선전 코드

// MARK: - 2512번(Binary Search)
let N = Int(readLine()!)!
let moneyArray = readLine()!.split(separator: " ").map{Int(String($0))!}
let M = Int(readLine()!)!
var answerMax: Int = 0

if moneyArray.reduce(0, +) <= M { // 모든 요청이 배정될 수 있는 경우,
    answerMax = moneyArray.max()!
}
else { // 모든 요청이 배정될 수 없는 경우,
    var start: Int = 0
    var end: Int = moneyArray.max()!
    var mid = (start + end) / 2
    
    while start <= end {
        var sum: Int = 0
        mid = (start + end) / 2
        for money in moneyArray {
            sum += money > mid ? mid : money // money가 기준(중간값)보다 크면 기준을 더하고, 기준보다 작거나 같으면 money를 더함.
        }
        if sum > M {
            end = mid - 1
        }
        else {
            start = mid + 1
        }
    }
    answerMax = end
}

print(answerMax) // 배정된 예산들 중 최댓값

백준 Swift 10815번

문제 유형 : 이분탐색(이진탐색)

난이도 : 실버4

// MARK: - 10815번(이진 탐색)
let N = Int(readLine()!)!
let sanggeunCards = readLine()!.split(separator: " ").map{Int(String($0))!}.sorted(by: <)
let M = Int(readLine()!)!
let checkCards = readLine()!.split(separator: " ").map{Int(String($0))!}
var answerArray = Array(repeating: "0", count: M)

for (index, card) in checkCards.enumerated() {
    var lowIndex: Int = 0
    var highIndex: Int = N - 1
    
    while lowIndex <= highIndex { // 이진 탐색
        let middleIndex: Int = (lowIndex + highIndex) / 2
        
        if sanggeunCards[middleIndex] == card {
            answerArray[index] = "1"
            break
        }
        
        if sanggeunCards[middleIndex] < card {
            lowIndex = middleIndex + 1
        }
        else {
            highIndex = middleIndex - 1
        }
    }
    
}

print(answerArray.joined(separator: " "))

백준 Swift 17298번, 2696번, 1715번, 5397번, 10026번, 6593번, 5427번, 3055번, 2206번, 14442번, 7576번, 5014번, 12851번, 16397번, 9019번, 1525번, 1039번, 2412번,

개발자P — Tue, 22 Mar 2022 17:57:43 +0900

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

22.03.22 업데이트

22.03.25 업데이트

22.03.27 업데이트

22.03.28 업데이트

22.03.29 업데이트

22.03.30 업데이트

22.03.31 업데이트

22.04.03 업데이트

22.04.04 업데이트

22.04.13 업데이트

아래 깃허브 주소에서 모든 백준 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

백준 Swift 17298번(시간초과)

// MARK: - 17298번(시간초과)
let N = Int(readLine()!)!
var nge: [Int] = [] // 오큰수 NGE 배열.

let input = readLine()!.split(separator: " ").map{Int(String($0))!}

for i in 0..<N {
    
    var flag: Bool = false
    for j in i+1..<N {
        if input[j] > input[i] { // 오큰수가 있으면,
            nge.append(input[j])
            flag = true
            break // 가장 왼쪽(처음)나오는 수만 있으면 됨.
        }
    }
    
    if !flag {
        nge.append(-1)
    }
    
}

for num in nge {
    print(num, terminator: " ")
}

백준 Swift 17298번(stack 사용)

// MARK: - 17298번(stack 사용)
let N = Int(readLine()!)!
var array = readLine()!.split(separator: " ").map{Int(String($0))!}
var stack: [Int] = [] // 오큰수가 아닌 수의 index를 저장.

for i in 0..<N {
    
    while !stack.isEmpty && (array[stack.last!] < array[i]) {
        array[stack.popLast()!] = array[i]
    }
    
    stack.append(i)
    
}

for index in stack { // 여전히 stack에 남아 있는 index는 오큰수 없음.
    array[index] = -1
}

//for num in array { // 이렇게 출력하면 시간초과
//    print(num, terminator: " ")
//}

print(array.map{String($0)}.joined(separator: " "))

백준 Swift 2696번

// MARK: - 2696번
let T = Int(readLine()!)!

for _ in 0..<T {
    let M = Int(readLine()!)!
    var numArray: [Int] = []
    
    if M <= 10 {
        numArray = readLine()!.split(separator: " ").map{Int(String($0))!}
    }
    else { // 11이상이면,
        var line: Int = 0
        if M % 10 == 0 {
            line = M / 10
        }
        else {
            line = M / 10 + 1
        }
        for _ in 0..<line {
            numArray += readLine()!.split(separator: " ").map{Int(String($0))!}
        }
    }
    
    var middleArray: [Int] = []
    var tempArray: [Int] = []
    for i in 0..<M {
        tempArray.append(numArray[i])
        if i % 2 == 0 { // 홀수번째 수일 때,
            tempArray.sort(by: <)
            middleArray.append(tempArray[(i+1)/2])
        }
    }
    
    print(middleArray.count)
    var answer = ""
    for i in 0..<middleArray.count {
        if (i != 0) && (i % 10 == 0) { // 첫번째 값 아니고, 10개씩 출력.
            answer += "\n"
        }
        answer += String(middleArray[i]) + " "
    }
    print(answer)
}

백준 Swift 1715번

최소값 힙 사용 - 참고 : https://developer-p.tistory.com/196

// MARK: - 1715번 : https://developer-p.tistory.com/196
struct MinHeap<T: Comparable> {
    var heap: [T] = []
    
    var isEmpty: Bool {
        return heap.count <= 1 ? true : false
    }
    
    init() {}
    init(_ element: T) {
        heap.append(element) // 0번 index채우기 용
        heap.append(element) // 실제 Root Node 채움.
    }
    
    mutating func insert(_ element: T) {
        if heap.isEmpty {
            heap.append(element)
            heap.append(element)
            return
        }
        heap.append(element)
        
        func isMoveUp(_ insertIndex: Int) -> Bool {
            if insertIndex <= 1 { // Root Node일 때,
                return false
            }
            let parentIndex = insertIndex / 2
            return heap[insertIndex] < heap[parentIndex] ? true : false
        }
        
        var insertIndex = heap.count - 1
        while isMoveUp(insertIndex) {
            let parentIndex = insertIndex / 2
            heap.swapAt(insertIndex, parentIndex)
            insertIndex = parentIndex
        }
    }
    
    enum moveDownStatus { case left, right, none }
    
    mutating func pop() -> T? {
        if heap.count <= 1 {
            return nil
        }
        let returnData = heap[1]
        heap.swapAt(1, heap.count - 1)
        heap.removeLast()
        
        func moveDown(_ poppedIndex: Int) -> moveDownStatus {
            let leftChildIndex = poppedIndex * 2
            let rightChildIndex = leftChildIndex + 1
            
            // case1. 모든(왼쪽) 자식 노드가 없는 경우(완전이진트리는 왼쪽부터 채워지므로)
            if leftChildIndex >= heap.count {
                return .none
            }
            
            // case2. 왼쪽 자식 노드만 있는 경우
            if rightChildIndex >= heap.count {
                return heap[leftChildIndex] < heap[poppedIndex] ? .left : .none
            }
            
            // case3. 왼쪽&오른쪽 자식 노드 모두 있는 경우
            // case3-1. 자식들이 자신보다 모두 큰 경우(자신이 제일 작은 경우)
            if (heap[leftChildIndex] > heap[poppedIndex]) && (heap[rightChildIndex] > heap[poppedIndex]) {
                return .none
            }
            
            // case3-2. 자식들이 자신보다 모두 작은 경우(왼쪽과 오른쪽 자식 중, 더 작은 자식을 선별)
            if (heap[leftChildIndex] < heap[poppedIndex]) && (heap[rightChildIndex] < heap[poppedIndex]) {
                return heap[leftChildIndex] < heap[rightChildIndex] ? .left : .right
            }
            
            // case3-3. 왼쪽과 오른쪽 자식 중, 한 자식만 자신보다 작은 경우
            if (heap[leftChildIndex] < heap[poppedIndex]) || (heap[rightChildIndex] < heap[poppedIndex]) {
                return heap[leftChildIndex] < heap[rightChildIndex] ? .left : .right
            }
            
            return .none
        }
        
        var poppedIndex = 1
        while true {
            switch moveDown(poppedIndex) {
            case .none:
                return returnData
            case .left:
                let leftChildIndex = poppedIndex * 2
                heap.swapAt(poppedIndex, leftChildIndex)
                poppedIndex = leftChildIndex
            case .right:
                let rightChildIndex = (poppedIndex * 2) + 1
                heap.swapAt(poppedIndex, rightChildIndex)
                poppedIndex = rightChildIndex
            }
        }
    }
}

let N = Int(readLine()!)!
var myMinHeap: MinHeap<Int> = MinHeap()

for _ in 0..<N {
    let input = Int(readLine()!)!
    myMinHeap.insert(input)
}

var result: Int = 0
for _ in 0..<N-1 {
    let first = myMinHeap.pop()!
    let second = myMinHeap.pop()!
    let temp = first + second
    result += temp
    myMinHeap.insert(temp)
}

print(result)

백준 Swift 5397번

// MARK: - 5397번
let T = Int(readLine()!)!

for _ in 0..<T {
    let input = readLine()!.map{String($0)}
    var stack1: [String] = []
    var stack2: [String] = []
    
    for ch in input {
        if ch == "<" {
            if !stack1.isEmpty {
                stack2.append(stack1.popLast()!)
            }
        }
        else if ch == ">" {
            if !stack2.isEmpty {
                stack1.append(stack2.popLast()!)
            }
        }
        else if ch == "-" {
            if !stack1.isEmpty {
                stack1.removeLast()
            }
        }
        else { // 알파벳일 때,
            stack1.append(ch)
        }
    }
    
    let answer = stack1 + stack2.reversed()
    print(answer.joined(separator: ""))
    
}

백준 Swift 10026번(DFS)

// MARK: - 10026번(DFS)
let N = Int(readLine()!)!
var board: [[String]] = []
var colorBoard = Array(repeating: Array(repeating: "", count: N), count: N)
var visited = Array(repeating: Array(repeating: false, count: N), count: N)

var count1: Int = 0
var count2: Int = 0

for _ in 0..<N {
    let input = readLine()!.map{String($0)}
    board.append(input)
}

for i in 0..<N {
    for j in 0..<N {
        if board[i][j] == "G" || board[i][j] == "R" {
            colorBoard[i][j] = "R"
        }
        else {
            colorBoard[i][j] = "B"
        }
    }
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < N)
}
 
let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]

// 적록색약이 아닌 사람
func dfs1(_ y: Int, _ x: Int) {
    for k in 0..<4 {
        let ny = y + dy[k]
        let nx = x + dx[k]
        
        if isValidCoord(ny, nx) && !visited[ny][nx] && (board[y][x] == board[ny][nx]) {
            visited[ny][nx] = true
            dfs1(ny, nx)
        }
    }
}

for y in 0..<N {
    for x in 0..<N {
        if !visited[y][x] {
            visited[y][x] = true
            count1 += 1
            dfs1(y, x)
        }
    }
}

// 적록색약인 사람
visited = Array(repeating: Array(repeating: false, count: N), count: N) // 방문기록 초기화.

func dfs2(_ y: Int, _ x: Int) {
    for k in 0..<4 {
        let ny = y + dy[k]
        let nx = x + dx[k]
        if isValidCoord(ny, nx) && !visited[ny][nx] && ( colorBoard[y][x] == colorBoard[ny][nx]) {
            visited[ny][nx] = true
            dfs2(ny, nx)
        }
    }
}

for y in 0..<N {
    for x in 0..<N {
        if !visited[y][x] {
            visited[y][x] = true
            count2 += 1
            dfs2(y, x)
        }
    }
}

print(count1, count2)

백준 Swift 10026번(BFS)

// MARK: - 10026번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}
let N = Int(readLine()!)!
var board: [[String]] = []
var colorBoard = Array(repeating: Array(repeating: "", count: N), count: N)
var visited = Array(repeating: Array(repeating: false, count: N), count: N)

var count1: Int = 0
var count2: Int = 0

for _ in 0..<N {
    let input = readLine()!.map{String($0)}
    board.append(input)
}

for i in 0..<N {
    for j in 0..<N {
        if board[i][j] == "G" || board[i][j] == "R" {
            colorBoard[i][j] = "R"
        }
        else {
            colorBoard[i][j] = "B"
        }
    }
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < N)
}
 
let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]

// 적록색약이 아닌 사람
func bfs1(_ startY: Int, _ startX: Int) {
    visited[startY][startX] = true
    let q = Dequeue([(startY, startX)])
    
    while !q.isEmpty {
        let (y, x) = q.popFirst()
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            
            if isValidCoord(ny, nx) && !visited[ny][nx] && (board[y][x] == board[ny][nx]) {
                visited[ny][nx] = true
                q.pushLast((ny, nx))
            }
        }
        
    }

}


for y in 0..<N {
    for x in 0..<N {
        if !visited[y][x] {
//            visited[y][x] = true
            count1 += 1
            bfs1(y, x)
        }
    }
}

// 적록색약인 사람
visited = Array(repeating: Array(repeating: false, count: N), count: N) // 방문기록 초기화.

func bfs2(_ startY: Int, _ startX: Int) {
    visited[startY][startX] = true
    let q = Dequeue([(startY, startX)])
    
    while !q.isEmpty {
        let (y, x) = q.popFirst()
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            
            if isValidCoord(ny, nx) && !visited[ny][nx] && (colorBoard[y][x] == colorBoard[ny][nx]) {
                visited[ny][nx] = true
                q.pushLast((ny, nx))
            }
        }
        
    }
    
}

for y in 0..<N {
    for x in 0..<N {
        if !visited[y][x] {
            visited[y][x] = true
            count2 += 1
            bfs2(y, x)
        }
    }
}

print(count1, count2)

백준 Swift 6593번(BFS)

// MARK: - 6593번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}

while true {
    
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (L, R, C) = (input[0], input[1], input[2])
    if (L == 0) && (R == 0) && (C == 0) {
        break
    }
    
    var board = Array(repeating: Array(repeating: Array(repeating: "", count: C), count: R), count: L)
    var visited = Array(repeating: Array(repeating: Array(repeating: false, count: C), count: R), count: L)

    for z in 0..<L {
        for y in 0..<R {
            let input = readLine()!.map{String($0)}
            for x in 0..<C {
                board[z][y][x] = input[x]
            }
        }
        readLine()
    }

    func isValidCoord(_ z: Int, _ y: Int, _ x: Int) -> Bool {
        return (0 <= z && z < L) && (0 <= y && y < R) && (0 <= x && x < C)
    }

    let dz = [0, 0, 0, 0, 1, -1]
    let dy = [0, 1, 0, -1, 0 ,0]
    let dx = [1, 0, -1, 0, 0, 0]
    
    func bfs(_ startZ: Int, _ startY: Int, _ startX: Int) -> Int {
        visited[startZ][startY][startX] = true
        let q = Dequeue([(startZ, startY, startX, 0)])
        
        while !q.isEmpty {
            let (z, y, x, d) = q.popFirst()
            
            for k in 0..<6 {
                let nz = z + dz[k]
                let ny = y + dy[k]
                let nx = x + dx[k]
                let nd = d + 1 // 이동 횟수(시간)
                if isValidCoord(nz, ny, nx) && !visited[nz][ny][nx] && board[nz][ny][nx] == "." { // 통로면,
                    visited[nz][ny][nx] = true
                    q.pushLast((nz, ny, nx, nd))
                }
                else if isValidCoord(nz, ny, nx) && !visited[nz][ny][nx] && board[nz][ny][nx] == "E" { // 탈출통로면,
                    visited[nz][ny][nx] = true
                    return nd // 탈출 시간 return.
                }
            }
        }
         
        return -1 // 탈출 불가 시, -1 return. (Trapped!)
        
    }
    
    var time: Int = 0
outLoop: for z in 0..<L {
        for y in 0..<R {
            for x in 0..<C {
                if !visited[z][y][x] && board[z][y][x] == "S" {
                    visited[z][y][x] = true
                    time = bfs(z, y, x)
                    break outLoop
                }
            }
        }
    }
    
    if time == -1 {
        print("Trapped!")
    }
    else {
        print("Escaped in \(time) minute(s).")
    }
    
}

백준 Swift 5427번(BFS)

// MARK: - 5427번(BFS)
class Dequeue<T> {
    var enQueue: [T] = []
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}

let N = Int(readLine()!)!

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (w, h) = (input[0], input[1])
    var board: [[String]] = []
    var visited = Array(repeating: Array(repeating: -1, count: w), count: h)
    var fireVisited = Array(repeating: Array(repeating: -1, count: w), count: h)
    
    for _ in 0..<h {
        let input = readLine()!.map{String($0)}
        board.append(input)
    }
    
    func isValidCoord(_ y: Int, _ x: Int) -> Bool {
        return (0 <= y && y < h) && (0 <= x && x < w)
    }
    
    let dy = [0, 1, 0, -1]
    let dx = [1, 0, -1 ,0]
    
    let fireQ: Dequeue<(Int, Int)> = Dequeue([])
    
    func fireBfs() {
        
        while !fireQ.isEmpty {
            let (y, x) = fireQ.popFirst()
            
            for k in 0..<4 {
                let ny = y + dy[k]
                let nx = x + dx[k]
                if isValidCoord(ny, nx) && (fireVisited[ny][nx] == -1) && board[ny][nx] != "#" { // 범위 안이고, 불이 방문한 적 없고, 벽이 아니면,
                    fireVisited[ny][nx] = fireVisited[y][x] + 1
                    fireQ.pushLast((ny, nx))
                }
            }
        }
        
    }
    
    
    func bfs(_ startY: Int, _ startX: Int) -> Int {
        let userQ = Dequeue([(startY, startX)])
//        visited[startY][startX] = 0 // 사람 시작하는 곳 0으로 초기화.
        
        while !userQ.isEmpty {
            let (y, x) = userQ.popFirst()
            
            for k in 0..<4 {
                let ny = y + dy[k]
                let nx = x + dx[k]
                
                if (ny < 0 || ny >= h) || (nx < 0 || nx >= w) { // 탈출 성공 시,
                    return (visited[y][x] + 1)
                }
                
                if (visited[ny][nx] == -1) && (board[ny][nx] != "#") { // 사람이 방문한 적 없고, 벽이 아닐 때,
                    if (fireVisited[ny][nx] == -1) || (fireVisited[ny][nx] > visited[y][x] + 1) { // 불이 방문한 적 없거나, 불이 옮겨붙을 때 이동하면,
                        visited[ny][nx] = visited[y][x] + 1
                        userQ.pushLast((ny, nx))
                    }
                }
                
            }
        }
        return -100
    }
    
    var userStartY: Int = 0
    var userStartX: Int = 0
    for y in 0..<h {
        for x in 0..<w {
            if board[y][x] == "*" { // 불은 여러곳일 수 있음.
                fireVisited[y][x] = 0 // 불 붙은 곳 0으로 초기화.
                fireQ.pushLast((y, x))
            }
            else if board[y][x] == "@" { // 사람일 경우,
                visited[y][x] = 0 // 사람 시작하는 곳 0으로 초기화.
                (userStartY, userStartX) = (y, x)
            }
        }
    }
    
    fireBfs() // 불 먼저 붙임.
    let answer = bfs(userStartY, userStartX) // 그 다음, 사람 움직이면서, 괜찮은지 체크.
    
    if answer == -100 {
        print("IMPOSSIBLE")
    }
    else {
        print(answer)
    }
    
}

백준 Swift 5427번(BFS - index사용)

// MARK: - 5427번(BFS - Index 사용)
let N = Int(readLine()!)!

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (w, h) = (input[0], input[1])
    var board: [[String]] = []
    var visited = Array(repeating: Array(repeating: false, count: w), count: h)
    var fireVisited = Array(repeating: Array(repeating: false, count: w), count: h)
    
    for _ in 0..<h {
        let input = readLine()!.map{String($0)}
        board.append(input)
    }
    
    func isValidCoord(_ y: Int, _ x: Int) -> Bool {
        return (0 <= y && y < h) && (0 <= x && x < w)
    }
    
    func isEscape(_ y: Int, _ x: Int) -> Bool {
        return (y == 0 || y == h - 1) || (x == 0 || x == w - 1)
    }
    
    let dy = [0, 1, 0, -1]
    let dx = [1, 0, -1, 0]
    var fireQ: [(Int, Int, Int)] = []
    var userQ: [(Int, Int, Int)] = []
    var isSuccessEscape: Bool = false
    
    func bfs() -> Int {
        var index: Int = 0
        var fireIndex: Int = 0
        var userIndex: Int = 0
        
        while index < userQ.count && !isSuccessEscape {
            index += 1
            
            let fireCount = fireQ.count // fireQ의 카운트를 저장해서 호출해야 함. 그냥 while문에 fireQ.count를 쓰면, 계속 append되면서 오류 발생함.
            while fireIndex < fireCount && !isSuccessEscape {
                let (y, x, d) = fireQ[fireIndex]
                
                for k in 0..<4 {
                    let ny = y + dy[k]
                    let nx = x + dx[k]
                    let nd = d + 1
                    
                    if isValidCoord(ny, nx) && !fireVisited[ny][nx] && board[ny][nx] != "#" {
                        fireVisited[ny][nx] = true
                        fireQ.append((ny, nx, nd))
                    }
                }
                fireIndex += 1
            }
            
            let userCount = userQ.count
            while userIndex < userCount && !isSuccessEscape {
                let (y, x, d) = userQ[userIndex]
                
                if isEscape(y, x) { // 탈출 성공 시,
                    isSuccessEscape = true // 이 부분 없어도 됨.
                    return (d + 1)
                }
                
                for k in 0..<4 {
                    let ny = y + dy[k]
                    let nx = x + dx[k]
                    let nd = d + 1
                    
                    if isValidCoord(ny, nx) && !fireVisited[ny][nx] && !visited[ny][nx] && board[ny][nx] == "." {
                        visited[ny][nx] = true
                        userQ.append((ny, nx, nd))
                    }
                }
                userIndex += 1
            }
            
        }
        
        return -1 // 탈출 실패 시,
        
    }
    
    for y in 0..<h {
        for x in 0..<w {
            if board[y][x] == "*" { // 불은 여러개일 수 있음.
                fireQ.append((y, x, 0))
            }
            else if board[y][x] == "@" { // 사람일 때,
                userQ.append((y, x, 0))
            }
        }
    }
    
    let answer = bfs()
    
    answer != -1 ? print(answer) : print("IMPOSSIBLE")
    
}

백준 Swift 3055번

// MARK: - 3055번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (R, C) = (input[0], input[1])
var board: [[String]] = []
var visited = Array(repeating: Array(repeating: -1, count: C), count: R)
var waterVisited = Array(repeating: Array(repeating: -1, count: C), count: R)

for _ in 0..<R {
    let input = readLine()!.map{String($0)}
    board.append(input)
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < R) && (0 <= x && x < C)
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]
let waterQ: Dequeue<(Int, Int)> = Dequeue([])

func waterBfs() {
    while !waterQ.isEmpty {
        let (y, x) = waterQ.popFirst()
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            
            if isValidCoord(ny, nx) && (waterVisited[ny][nx] == -1) && board[ny][nx] == "." { // 유효한 좌표 범위고, 물이 방문한 적이 없고, 통로면,
                waterVisited[ny][nx] = waterVisited[y][x] + 1
                waterQ.pushLast((ny, nx))
            }
        }
    }
}

func userBfs(_ startY: Int, _ startX: Int) -> Int {
    let userQ = Dequeue([(startY, startX)])
    
    while !userQ.isEmpty {
        let (y, x) = userQ.popFirst()
        
        if board[y][x] == "D" { // 탈출 성공 시,
            return visited[y][x]
        }
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            
            if isValidCoord(ny, nx) && (visited[ny][nx] == -1) && board[ny][nx] != "X" { // 유효한 좌표 범위고, 사람이 방문한 적이 없고, 돌이 아닐 때,
                if (waterVisited[ny][nx] == -1) || waterVisited[ny][nx] > visited[y][x] + 1 { // (물과 독립된 길이라) 물이 방문한 적이 없거나 or (물이 방문하기 전에) 고슴도치가 먼저 방문하면(고슴도치가 가고 물이 차오르는건 상관X),
                    visited[ny][nx] = visited[y][x] + 1
                    userQ.pushLast((ny, nx))
                }
            }
        }
    }
    return -1 // 탈출 실패
}


var userStartY: Int = 0
var userStartX: Int = 0
for y in 0..<R {
    for x in 0..<C {
        if board[y][x] == "*" { // 물은 여러곳일 수 있음.
            waterVisited[y][x] = 0
            waterQ.pushLast((y, x))
        }
        else if board[y][x] == "S" { // 고슴도치면,
            visited[y][x] = 0
            (userStartY, userStartX) = (y, x)
        }
    }
}

waterBfs()
let answer = userBfs(userStartY, userStartX)

if answer == -1 {
    print("KAKTUS")
}
else {
    print(answer)
}

백준 Swift 2206번(BFS)

방문여부를 이렇게 기록해야 하는 이유 - https://www.acmicpc.net/board/view/67446

방문배열은 '모든 경우'를 나타낼 수 있어야 한다.
이 문제에서의 모든 경우는
'해당 위치에 벽을 부쉈던 상태로 이미 왔었거나, 해당 위치에 아직 벽을 부수지 않은 상태로 이미 왔었다.' 임.
이를 표현하기 위해 3차원 배열로 나타냄.
(위 링크의 설명글에서 인용)

풀이 참고 - http://t.ly/QiwU

// MARK: - 2206번(BFS)
// 참고) 방문여부를 이렇게 기록해야 하는 이유 - https://www.acmicpc.net/board/view/67446
// 참고) 풀이 참고 - https://velog.io/@aurora_97/%EB%B0%B1%EC%A4%80-2206%EB%B2%88-%EB%B2%BD-%EB%B6%80%EC%88%98%EA%B3%A0-%EC%9D%B4%EB%8F%99%ED%95%98%EA%B8%B0-Swift
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var board: [[Int]] = []
var visited = Array(repeating: Array(repeating: [0, 0], count: M), count: N) // [0, 0]에서 - 왼쪽은 벽미사용 방문거리, 오른쪽은 벽사용 방문거리

for _ in 0..<N {
    let input = readLine()!.map{Int(String($0))!}
    board.append(input)
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < M)
}

func isEscape(_ y: Int, _ x: Int) -> Bool {
    return (y == N - 1) && (x == M - 1)
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]

func bfs(_ startY: Int, _ startX: Int) -> Int {
    let q = Dequeue([(startY, startX, 0)]) // 0이면 벽 미사용, 1이면 벽 사용
    visited[startY][startX][0] = 1 // 시작하는 칸도 포함.
    
    while !q.isEmpty {
        let (y, x, wall) = q.popFirst()
        
        if isEscape(y, x) {
            return (visited[y][x][wall])
        }
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            
            if isValidCoord(ny, nx) {
                if board[ny][nx] == 1 && wall == 0 { // 벽이 있고, 벽 미사용이면,
                    visited[ny][nx][1] = visited[y][x][0] + 1 // 벽 사용한 방문거리에 저장.
                    q.pushLast((ny, nx, 1))
                }
                else if board[ny][nx] == 0 && visited[ny][nx][wall] == 0 { // 길이고, (벽을 쓰고 or 안쓰고) 미방문일 때,
                    visited[ny][nx][wall] = visited[y][x][wall] + 1
                    q.pushLast((ny, nx, wall))
                }
            }
        }
    }
    return -1
}


let answer = bfs(0, 0)
print(answer)

백준 Swift 14442번(BFS) - 18%에서 시간초과

// MARK: - 14442번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M, T) = (input[0], input[1], input[2]) // K -> T로 임의 변경.
var board: [[Int]] = []
var visited = Array(repeating: Array(repeating: Array(repeating: 0, count: T + 1), count: M), count: N)

for _ in 0..<N {
    let input = readLine()!.map{Int(String($0))!}
    board.append(input)
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < M)
}

func isEscape(_ y: Int, _ x: Int) -> Bool {
    return (y == N - 1) && (x == M - 1)
}


let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]

func bfs(_ startY: Int, _ startX: Int) -> Int {
    let q = Dequeue([(startY, startX, 0)])
    visited[startY][startX][0] = 1 // 시작하는 칸 포함.
    
    while !q.isEmpty {
        let (y, x, wall) = q.popFirst()
        
        if isEscape(y, x) {
            return visited[y][x][wall]
        }
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            
            if isValidCoord(ny, nx) {
                if (board[ny][nx] == 1) && (wall < T) && (visited[ny][nx][wall+1] == 0) { // 벽이 있고, 벽뚫는사용회수가 T보다 적고, (벽+1)이 방문한 적이 없으면.
                    visited[ny][nx][wall + 1] = visited[y][x][wall] + 1 // wall +1 증가.
                    q.pushLast((ny, nx, wall + 1)) // 벽 사용회수 +1 증가.
                }
                else if board[ny][nx] == 0 && visited[ny][nx][wall] == 0 { // 벽이 없고, (벽을 사용했던 or 안했던 그에 맞게) 방문한 적이 없으면,
                    visited[ny][nx][wall] = visited[y][x][wall] + 1
                    q.pushLast((ny, nx, wall))
                }
            }
        }
    }
    return -1
}

let answer = bfs(0, 0)
print(answer)

index 사용코드 (똑같이 18%에서 시간초과.)

// MARK: - 14442번(BFS) - index 사용.
//class Dequeue<T> {
//    var enQueue: [T]
//    var deQueue: [T] = []
//
//    var count: Int {
//        return enQueue.count + deQueue.count
//    }
//
//    var isEmpty: Bool {
//        return enQueue.isEmpty && deQueue.isEmpty
//    }
//
//    init(_ queue: [T]) {
//        enQueue = queue
//    }
//
//    func pushLast(_ element: T) {
//        enQueue.append(element)
//    }
//
//    func pushFirst(_ element: T) {
//        deQueue.append(element)
//    }
//
//    func popLast() -> T {
//        if enQueue.isEmpty {
//            enQueue = deQueue.reversed()
//            deQueue.removeAll()
//        }
//        return enQueue.popLast()!
//    }
//
//    func popFirst() -> T {
//        if deQueue.isEmpty {
//            deQueue = enQueue.reversed()
//            enQueue.removeAll()
//        }
//        return deQueue.popLast()!
//    }
//}
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M, T) = (input[0], input[1], input[2]) // K -> T로 임의 변경.
var board: [[Int]] = []
var visited = Array(repeating: Array(repeating: Array(repeating: 0, count: T + 1), count: M), count: N)

for _ in 0..<N {
    let input = readLine()!.map{Int(String($0))!}
    board.append(input)
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < M)
}

func isEscape(_ y: Int, _ x: Int) -> Bool {
    return (y == N - 1) && (x == M - 1)
}


let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]

func bfs(_ startY: Int, _ startX: Int) -> Int {
//    let q = Dequeue([(startY, startX, 0)])
    var q = [(startY, startX, 0)]
    visited[startY][startX][0] = 1 // 시작하는 칸 포함.
    var index: Int = 0
    
    while index < q.count {
//        let (y, x, wall) = q.popFirst()
        let (y, x, wall) = q[index]
        
        if isEscape(y, x) {
            return visited[y][x][wall]
        }
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            
            if isValidCoord(ny, nx) {
                if (board[ny][nx] == 1) && (wall < T) && (visited[ny][nx][wall+1] == 0) { // 벽이 있고, 벽뚫는사용회수가 T보다 적고, (벽+1)이 방문한 적이 없으면.
                    visited[ny][nx][wall + 1] = visited[y][x][wall] + 1 // wall +1 증가.
//                    q.pushLast((ny, nx, wall + 1)) // 벽 사용회수 +1 증가.
                    q.append((ny, nx, wall + 1)) // 벽 사용회수 +1 증가.
                }
                else if board[ny][nx] == 0 && visited[ny][nx][wall] == 0 { // 벽이 없고, (벽을 사용했던 or 안했던 그에 맞게) 방문한 적이 없으면,
                    visited[ny][nx][wall] = visited[y][x][wall] + 1
//                    q.pushLast((ny, nx, wall))
                    q.append((ny, nx, wall))
                }
            }
        }
        index += 1
    }
    return -1
}

let answer = bfs(0, 0)
print(answer)

백준 Swift 7576번(BFS)

문제 유형 : BFS 최단거리 활용

난이도 : 골드5

// MARK: - 7576번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (M, N) = (input[0], input[1])
var board: [[Int]] = []
var visited = Array(repeating: Array(repeating: -1, count: M), count: N)

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    board.append(input)
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < N) && (0 <= x && x < M)
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1 ,0]
let q: Dequeue<(Int, Int)> = Dequeue([])

func bfs() {
    
    while !q.isEmpty {
        let (y, x) = q.popFirst()
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            
            if isValidCoord(ny, nx) && (visited[ny][nx] == -1) && board[ny][nx] == 0 { // 유효범위고, 방문한 적 없고, 익지 않은 토마토가 근처이면,
                visited[ny][nx] = visited[y][x] + 1
                q.pushLast((ny, nx))
            }
        }
    }
    
}

for y in 0..<N {
    for x in 0..<M {
        if board[y][x] == 1 { // 익은 토마토 발견 시,
            visited[y][x] = 0
            q.pushLast((y, x))
        }
        else if board[y][x] == -1 { // 토마토가 없는 칸 발견 시, 접근 자체가 불가능.
            visited[y][x] = -2 // 나중에 전체 토마토가 익었는지 체크를 위해, 미방문과 구분을 위해 -2로 둠.
        }
    }
}

bfs()

if visited.flatMap({$0}).contains(-1) { // 미방문한 토마토가 있으면,
    print(-1)
}
else { // 모든 토마토가 익었다면,
    print(visited.flatMap{$0}.max()!) // 최대값이 모두를 익게 하는 최소 일수임.
}

백준 Swift 5014번

문제 유형 : BFS 최단거리

난이도 : 골드5

// MARK: - 5014번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (F, S, G, U, D) = (input[0], input[1], input[2], input[3], input[4])
var board = Array(repeating: Array(repeating: 0, count: 1), count: F + 1) // (0층 제외) 1층부터 F층까지 생성.
var visited = Array(repeating: Array(repeating: -1, count: 1), count: F + 1) // (0층 제외) 1층부터 F층까지 생성.
board[0][0] = -1 // 0층은 제외.

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (1 <= y && y <= F) && (x == 0)
}

func isEscape(_ y: Int, _ x: Int) -> Bool {
    return (y == G) && (x == 0) // 목표(G)층에 도달하면 탈출.
}

let dy = [U, (D * -1)] // 위나 아래로만 이동 가능.

func bfs(_ startY: Int, _ startX: Int) -> Int {
    let q = Dequeue([(startY, startX)])
    visited[startY][startX] = 0 // 시작부분 0으로 시작.
    
    while !q.isEmpty {
        let (y, x) = q.popFirst()
        
        if isEscape(y, x) {
            return visited[y][x]
        }
        
        for k in 0..<2 {
            let ny = y + dy[k]
            let nx = x // x는 계속 0
            
            if isValidCoord(ny, nx) && board[ny][nx] == 0 && visited[ny][nx] == -1 { // 유효 범위고, (0층제외한) 1층부터 F층이고, 미방문이면,
                visited[ny][nx] = visited[y][x] + 1
                q.pushLast((ny, nx))
            }
        }
    }
    return -1
}

let answer = bfs(S, 0) // S층에서 시작.
answer == -1 ? print("use the stairs") : print(answer)

백준 Swift 12851번

문제 유형 : BFS - pop을 할 때 방문처리를 해 줘야, 같은 방문횟수level의 방문을 체크할 수 있음.

난이도 : 골드5

// MARK: - 12851번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, K) = (input[0], input[1])
var board = Array(repeating: 0, count: 100001) // 0부터 100000까지.
var visited = Array(repeating: false, count: 100001)

func isValidCoord(_ x: Int) -> Bool {
    return (0 <= x && x <= 100000)
}

func isEscape(_ x: Int) -> Bool { // 수빈이를 만나면 탈출.
    return (x == K)
}

var fastTimeArray: [Int] = []
func bfs(_ startX: Int) {
    let q = Dequeue([(startX, 0)])
    visited[startX] = true // 첫 시작 true로 초기화.
    
    while !q.isEmpty {
        let (x, d) = q.popFirst()
        visited[x] = true // 숨바꼭질1과 다르게, 큐에서 pop할 때 방문처리해줘야 함.
        
        if isEscape(x) { // 탈출 가능인데,
            if fastTimeArray.isEmpty { // 처음이면,
                fastTimeArray.append(d)
            }
            else { // 처음이 아닌데,
                if d == fastTimeArray[0] { // 가장 빠른 시간과 같다면 방법 1개 증가.
                    fastTimeArray.append(d)
                }
            }
        }
        
        if isValidCoord(x + 1) && board[x + 1] == 0 && visited[x + 1] == false { // (x+1) - 유효 범위고, 방문할 수 있는 곳이고, 방문한 적 없으면,
            q.pushLast((x+1, d+1))
        }
        if isValidCoord(x - 1) && board[x - 1] == 0 && visited[x - 1] == false { // (x-1) - 유효 범위고, 방문할 수 있는 곳이고, 방문한 적 없으면,
            q.pushLast((x-1, d+1))
        }
        if isValidCoord(2 * x) && board[2 * x] == 0 && visited[2 * x] == false { // (2*x) - 유효 범위고, 방문할 수 있는 곳이고, 방문한 적 없으면,
            q.pushLast((2*x, d+1))
        }
    }
    
}

bfs(N)
print(fastTimeArray.first!)
print(fastTimeArray.count)

백준 Swift 16397번

문제 유형 : BFS - 최단거리 : board는 필요 없었고, d(버튼 누른 횟수)가 T보다 작다는 조건이 추가로 필요했음.

난이도 : 골드4

// MARK: - 16397번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, T, G) = (input[0], input[1], input[2])
var visited = Array(repeating: false, count: 100000) // 0~99999 미방문 체크.

func isValidCoord(_ x: Int) -> Bool {
    return (0 <= x && x <= 99999)
}

func isEscape(_ x: Int) -> Bool {
    return (x == G)
}

func bfs(_ startX: Int) -> Int {
    let q = Dequeue([(startX, 0)])
    visited[startX] = true
    
    while !q.isEmpty {
        let (x, d) = q.popFirst()
        
        if isEscape(x) {
            return d
        }
        
        if isValidCoord(x + 1) && !visited[x + 1] && (d < T) { // 유효 범위고, 방문한 적 없고, 버튼 누른 회수가 T회 미만이면,
            visited[x + 1] = true
            q.pushLast((x + 1, d + 1))
        }
        
        if isValidCoord(2 * x) { // 2배한 숫자가 유효 범위고,
            var temp = String(2 * x).map{String($0)}
            for i in 0..<temp.count {
                if temp[i] != "0" {
                    temp[i] = String(Int(temp[i])! - 1)
                    break
                }
            }
            let pressB = Int(temp.reduce("", +))! // B를 누른 결과 숫자.
            if !visited[pressB] && (d < T) { // B를 누른 결과의 숫자에 방문한 적 없고, 버튼 누른 회수가 T회 미만이면,
                visited[pressB] = true
                q.pushLast((pressB, d + 1))
            }
        }
    }
    return -1
}

let answer = bfs(N)
answer == -1 ? print("ANG") : print(answer)

백준 Swift 9019번

문제 유형 : BFS인데, 시간초과로 애를 먹었다.

백준 Swift 9019번 - 시간초과 및 해결.

런타임 에러 : 처음에 (n == 0)이 아니라 (n-1 == 0)으로 잘못했었는데, 이 부분만 문제인 줄 알았다. (이 외에, 시간초과를 유발하는 많은 이유가 있었다.)

예상 시간 초과 원인 1. : 직접 만든 Dequeue 클래스를 써서, 기존의 배열(q)보단 빠를 것으로 예상되나, (덱의) q.popFirst() 혹은 q.removeFirst()에서 많은 시간이 쓰이는 것 같았다.

예상 시간 초과 원인 2. : 원인1을 해결하기 위해, index를 도입해 데이터를 접근하는 식으로 변경했으나 여전히 타임 오버.

예상 시간 초과 원인 3. : String d를 둬서 각각의 결과(문자)를 이어 붙이는 과정에서, 많은 질문글을 찾아보니 String이 시간초과를 유발한다고 함. (물론 Swift로 된 질문은 없었...다...ㅠㅠ)

[여담으로, 원인3은 사실 할 말이 많다. 타 블로그에 올라와 있는 C언어나 파이썬으로 된 코드들은 원인3을 해결하지 않아도, 기존에 했던 방식처럼 (d + "S") 이런식으로 해도 문제 없이 통과 되는데, Swift의 상대적으로 느린 속도는 문제다... 추가시간을 달라! 슬프군..]

참고 링크 : https://www.acmicpc.net/board/view/54644 | https://www.acmicpc.net/source/40983157

난이도 : 골드4

// MARK: - 9019번(BFS) - 시간초과 개선
let T = Int(readLine()!)!

for _ in 0..<T {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (A, B) = (input[0], input[1])
    var visited = Array(repeating: false, count: 10000)
    
    func bfs(_ startX: Int) -> String {
        var q: [(Int, Int)] = [(startX, 0)] // (Int, String)으로 하면 시간초과.
        visited[startX] = true
        var index: Int = 0
        var answer: String = ""
        
        while index < q.count {
            let (x, d) = q[index] // d는 원래는 String으로 이어붙이는 식으로 했었는데, 그렇게 하면 시간초과나서 Int로 계산해주고, 마지막에 이어붙이는 식으로 함.
            
            if x == B { // B에 도달하면,
                for ch in String(d) {
                    switch ch {
                    case "1":
                        answer += "D"
                    case "2":
                        answer += "S"
                    case "3":
                        answer += "L"
                    case "4":
                        answer += "R"
                    default:
                        break
                    }
                }
                return answer // 명령어(answer) 반환.
            }
            
            if x*2 > 9999 { // D일 때, - 9999보다 큰 경우.
                let temp = x*2 % 10000
                if !visited[temp] {
                    visited[temp] = true
                    q.append((temp, d * 10 + 1))
                }
            }
            else { // D일 때, - 9999이하인 경우.
                if !visited[x*2] {
                    visited[x*2] = true
                    q.append((x*2, d * 10 + 1))
                }
            }
            
            if x == 0 { // S일 때, - n이 0인 경우. ( x-1이 0일때가 아니라, x가 0일 때임.)
                let temp = 9999
                if !visited[temp] {
                    visited[temp] = true
                    q.append((temp, d * 10 + 2))
                }
            }
            else { // S일 때, - n이 0이 아닌 경우.
                if !visited[x-1] {
                    visited[x-1] = true
                    q.append((x-1, d * 10 + 2))
                }
            }
            
            // L 부분.
            let lFront = x % 1000
            let lBack = x / 1000
            let lNum = (lFront * 10) + lBack // L을 사용시 나오는 숫자.
            if !visited[lNum] {
                visited[lNum] = true
                q.append((lNum, d * 10 + 3))
            }
            
            // R 부분.
            let rFront = x % 10
            let rBack = x / 10
            let rNum = (rFront * 1000) + rBack // R을 사용시 나오는 숫자.
            if !visited[rNum] {
                visited[rNum] = true
                q.append((rNum, d * 10 + 4))
            }
            index += 1
        }
        return "no" // 여기 오는 일은 없음.
    }
    
    let answer = bfs(A)
    print(answer)
}

백준 Swift 1525번

문제 유형 : BFS활용

- BFS의 처음보는 활용이었다. 그 동안은 배열을 이용해 bfs를 풀어왔는데, board배열의 값을 매번 바꿔줘야 하는 점에서 풀이를 생각하지 못했다.

상하좌우 모두 방문하면서, 그 때 마다 board를 바꿔주면, 그 다음부턴 망가져버리기 때문이다. ( 매 방문마다의 배열을 저장할 수도 없는 노릇이니...)

결국엔 다른 사람의 풀이를 참고해서 풀게 됐다.

board를 2차원배열이 아닌 [String]으로 처리해서 시간을 단축시키고, Set으로 방문처리를 해서 시간단축을 하는게 중요했다.

방문처리를 만약 배열로 했다면 contains체크시 O(N)이 걸린다. 하지만 Set의 .contains는 시간복잡도가 O(1)이기 때문에, 큰 시간단축이 됐다.

(https://stackoverflow.com/questions/46385749/swift-3-array-contains-vs-set-contains | https://stackoverflow.com/questions/50240554/swift-set-contains-complexity)

(다른 언어의 풀이들에선 String으로 하던데, Swift는 String을 다루긴 힘들어서 배열String으로 처리했다. 그냥 String은 인덱스 접근이 뭔가 어렵다. 쉽게 하는 방법 아시는 분 있으면 댓글달아주세요...)

난이도 : 골드2

참고 링크 : https://2hs-rti.tistory.com/78

// MARK: - 1525번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}

let target = "123456780"
var board: [String] = []
var visited: Set<[String]> = []

for _ in 0..<3 {
    let input = readLine()!.split(separator: " ").map{String($0)}
    board.append(input[0])
    board.append(input[1])
    board.append(input[2])
}

var startY: Int = 0
var startX: Int = 0

for (index, ch) in board.enumerated() {
    if ch == "0" {
        startY = index / 3
        startX = index % 3
        break
    }
}

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y < 3) && (0 <= x && x < 3)
}

func isEscape(_ arr: [String]) -> Bool {
    return arr.reduce("", +) == target
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]

func bfs(_ startY: Int, _ startX: Int) -> Int {
    let q = Dequeue([(startY, startX, 0, board)])
    visited.insert(board)
    
    while !q.isEmpty {
        var (y, x, d, strArray) = q.popFirst()
//        print("\(y), \(x), \(d), \(visited)")
        
        if isEscape(strArray) {
            return d
        }
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            let nd = d + 1
            
            if isValidCoord(ny, nx) { // 유효한 범위이면서,
                let index = y * 3 + x
                let nextIndex = ny * 3 + nx
                let temp = strArray[index] // swap.
                strArray[index] = strArray[nextIndex]
                strArray[nextIndex] = temp
                
                if !visited.contains(strArray) { // 방문한 적 없으면,
                    visited.insert(strArray)
                    q.pushLast((ny, nx, nd, strArray))
                }
                
                strArray[nextIndex] = strArray[index] // strArray를 망가뜨리면 안되기 때문에 다시 재swap.
                strArray[index] = temp
            }
        }
    }
    return -1
}


let answer = bfs(startY, startX)
print(answer)

백준 Swift 1039번

문제 유형 : BFS 활용

핵심 : 전체 숫자들의 방문체크가 아닌, 각 순차적으로 증가하는 K(depth)일 때의 숫자들의 방문체크를 해야 한다.

- 처음엔 방문체크를 While문 안에 Set<[String]> 으로 했었다. 전역변수로 방문체크를 하면 안되고, 그 depth에 해당하는 숫자들의 방문체크를 해줘야 했기 때문이다.

내가 짠 코드는 근데 그렇게 하면 K-1번째꺼 까지의 방문체크는 되는데, K번째일 때의 방문체크가 안되는 것이다! 이거때문에 계속 고민하고... 근데 결국 못함. (메모리 초과) [이 방법 참고 글 : https://gusdnr69.tistory.com/266]

결국 이 방법으로는 해결하지 못하고, 2차원배열로 방문체크를 하는 방법으로 해결했다.

참고로 index를 활용한 Ver1이 조금 더 빠르다. (근데 난 큐의 isEmpty를 쓰는게 더 편하다.. Ver2)

백준 Swift 1039번

난이도 : 골드3

참고 링크 : https://vapor3965.tistory.com/36

Ver1.

// MARK: - 1039번(BFS)
let input = readLine()!.split(separator: " ").map{String($0)}
let (N, K) = (input[0].map{String($0)}, Int(input[1])!)
var visited = Array(repeating: Array(repeating: false, count: 1000001), count: 11) // 각 depth일 때의 방문체크가 필요함.
//var maxAnswer: Int = 0
var answerArray: [Int] = [] // depth가 K번째일 때의 정답숫자들 모음.

func bfs(_ startX: [String]) {
    var q: [([String], Int)] = [(startX, 0)]
    var index: Int = 0
    
    while index < q.count {
        let (x, d) = q[index]
        
        index += 1 // 그 depth에 해당하는 값들을 비교해야 하기 때문에, index증가부분이 밑이 아니라 여기있어야 함.
        
        if d == K { // K번째일 때,
            answerArray.append(Int(x.reduce("", +))!)
//            maxAnswer = max(maxAnswer, Int(x.reduce("", +))!)
            continue // d가 K번째일 때꺼까지만 필요하고, 더 이상 진행하면 X.
        }
        
        for i in 0..<N.count {
            for j in i+1..<N.count {
                var swapTemp: [String] = x // x의 스왑을 위한 임시변수.
                swapTemp.swapAt(i, j)
                let swapNum = Int(swapTemp.reduce("", +))!
                if swapTemp[0] != "0" && !visited[d][swapNum] {
                    visited[d][swapNum] = true
                    q.append((swapTemp, d + 1))
                }
                
            }
        }
    }
}

bfs(N)

answerArray.isEmpty ? print("-1") : print(answerArray.max()!)

Ver 2.

: 늘 쓰던 큐의 isEmpty를 쓰는 버전.

(index 쓰는 Ver1이 조금 더 빠르다.)

// MARK: - 1039번(BFS) - index 말고 큐 isEmpty쓰는 버전.
let input = readLine()!.split(separator: " ").map{String($0)}
let (N, K) = (input[0].map{String($0)}, Int(input[1])!)
var visited = Array(repeating: Array(repeating: false, count: 1000001), count: 11) // 각 depth일 때의 방문체크가 필요함.
//var maxAnswer: Int = 0
var answerArray: [Int] = [] // depth가 K번째일 때의 정답숫자들 모음.

func bfs(_ startX: [String]) {
    var q: [([String], Int)] = [(startX, 0)]
//    var index: Int = 0
    
    while !q.isEmpty {
        let (x, d) = q.removeFirst()
        
//        index += 1 // 그 depth에 해당하는 값들을 비교해야 하기 때문에, index증가부분이 밑이 아니라 여기있어야 함.
        
        if d == K { // K번째일 때,
            answerArray.append(Int(x.reduce("", +))!)
//            maxAnswer = max(maxAnswer, Int(x.reduce("", +))!)
            continue // d가 K번째일 때꺼까지만 필요하고, 더 이상 진행하면 X.
        }
        
        for i in 0..<N.count {
            for j in i+1..<N.count {
                var swapTemp: [String] = x // x의 스왑을 위한 임시변수.
                swapTemp.swapAt(i, j)
                let swapNum = Int(swapTemp.reduce("", +))!
                if swapTemp[0] != "0" && !visited[d][swapNum] {
                    visited[d][swapNum] = true
                    q.append((swapTemp, d + 1))
                }
                
            }
        }
    }
}

bfs(N)

answerArray.isEmpty ? print("-1") : print(answerArray.max()!)

백준 Swift 2412번

문제 유형 : BFS 활용

- 처음 문제를 보고 BFS문제라는건 파악했다. 최소로 하면서 정상에 올라야 한다는 건, 최단거리라는 뜻이기 때문이다.

처음 풀이는 시간초과가 났다. steps배열을 매번 처음부터 돌면서, visited배열을 체크해서 그런 것 같다.

백준 Swift 2412번 - BFS

다른 블로그의 풀이를 참고해보니, steps를 set로 하면, (홈들의 위치를 받아놓고,) 방문 시 지워주기만 하면 방문체크를 따로 하지 않아도 됐다.

또한 abs(~~)계산을 매번 하게 짜지 않고, dy와 dx로 접근하는 방법을 생각하지 못한 게 아쉬웠다. (비슷한 문제가 나왔을 때 다음부턴 이 방법을 생각하자!)

난이도 : 골드3

참고 링크 : https://t.ly/cf8A

// MARK: - 2412번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        self.enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (n, T) = (input[0], input[1])
//var steps: [(y: Int, x: Int)] = []
var steps: Set<[Int]> = []

var maxTemp: Int = -1
for _ in 0..<n {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (y, x) = (input[1], input[0])
    steps.insert([y, x])
    maxTemp = max(maxTemp, x)
}
//print(steps)


func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y <= T) && (0 <= x && x <= maxTemp)
}

func isEscape(_ y: Int) -> Bool {
    return (y == T) // 정상 도달
}

let dy = [-2, -1, 0, 1, 2]
let dx = [-2, -1, 0, 1, 2]
func bfs(_ startY: Int, _ startX: Int) -> Int {
//    var q: [(Int, Int, Int)] = [(startY, startX, 0)]
    let q = Dequeue([(startY, startX, 0)])
//    visited[startY][startX] = true

    while !q.isEmpty {
        let (y, x, d) = q.popFirst()

        if isEscape(y) {
            return d
        }
        
        for k in 0..<5 { // -2 <= y <= 2
            for v in 0..<5 { // -2 <= x <= 2
                let ny = y + dy[k]
                let nx = x + dx[v]
                let nd = d + 1
                if isValidCoord(ny, nx) && steps.contains([ny, nx]) { // 유효 범위고, 그 자리에 홈이 있으면,
                    steps.remove([ny, nx]) // 홈 방문 했으니, 지움. (=얘가 방문체크를 대체함.)
                    q.pushLast((ny, nx, nd))
                }
            }
        }
    }
    return -1
}

let answer = bfs(0, 0)
print(answer)

시간 초과 코드

시간 초과 코드

// MARK: - 2412번(BFS)
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        self.enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (n, T) = (input[0], input[1])
var steps: [(x: Int, y: Int)] = []

var maxTemp: Int = -1
for _ in 0..<n {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (x, y) = (input[0], input[1])
    steps.append((x, y))
    maxTemp = max(maxTemp, x)
}
steps.sort(by: <)
//print(steps)

var visited = Array(repeating: Array(repeating: false, count: maxTemp + 1), count: T + 1)

func isValidCoord(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y <= T) && (0 <= x && x <= maxTemp)
}

func isEscape(_ y: Int) -> Bool {
    return (y == T) // 정상 도달
}

func bfs(_ startY: Int, _ startX: Int) -> Int {
//    var q: [(Int, Int, Int)] = [(startY, startX, 0)]
    let q = Dequeue([(startY, startX, 0)])
    visited[startY][startX] = true
    
    while !q.isEmpty {
        let (y, x, d) = q.popFirst()
        
        if isEscape(y) {
            return d
        }
        
        for k in 0..<steps.count {
            let ny = steps[k].y
            let nx = steps[k].x
            let nd = d + 1
            if isValidCoord(ny, nx) && !visited[ny][nx] && (abs(ny - y) <= 2) && (abs(nx - x) <= 2) {
                visited[ny][nx] = true
//                q.append((ny, nx, nd))
                q.pushLast((ny, nx, nd))
            }
        }
    }
    return -1
}

let answer = bfs(0, 0)
print(answer)

백준 Swift 1302번, 11047번, 1449번, 11724번, 2178번, 7785번, 1021번, 1158번, 2346번, 1406번, 1935번, 1874번, 1764번, 10799번, 2304번, 2841번, 3986번, 1966번

개발자P — Tue, 15 Mar 2022 20:32:40 +0900

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

22.03.15 업데이트

22.03.16 업데이트

22.03.17 업데이트

22.03.19 업데이트

22.03.20 업데이트

22.03.21 업데이트

22.03.22 업데이트

아래 깃허브 주소에서 모든 백준 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

백준 Swift 1302번

// MARK: - 1302번
let N = Int(readLine()!)!
var books: [String: Int] = [:]

for _ in 0..<N {
    let input = readLine()!

    if books.keys.contains(input) { // 이미 팔린적 있으면
        books[input]! += 1
    }
    else { // 팔린적 없으면, 추가
        books[input] = 1
    }
}

var bestSeller: [String] = []
for book in books {
    if book.value == books.values.max()! { // 가장 많이 팔린 책이면,
        bestSeller.append(book.key)
    }
}

bestSeller.sort(by: <)
print(bestSeller.first!)

백준 Swift 11047번 - 그리디(Greedy)

// MARK: - 11047번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
var (N, K) = (input[0], input[1])

var coins: [Int] = []
for _ in 0..<N {
    coins.append(Int(readLine()!)!)
}

coins.reverse()

var count: Int = 0
for coin in coins {
    count += K / coin
    K = K % coin
}

print(count)

백준 Swift 1449번 - 그리디(Greedy)

// MARK: - 1449번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, L) = (input[0], input[1])
var pipe = Array(repeating: false, count: 1001) // 1부터 1000까지.(index 0은 생략)

let leak: [Int] = readLine()!.split(separator: " ").map{Int(String($0))!}

for index in leak {
    pipe[index] = true
}

var answer: Int = 0
var index: Int = 0
while index <= 1000 {
    if pipe[index] == true { // 새는 곳이면,
        index += L // 테이프의 길이 만큼 움직여 줌.
        answer += 1 // 테이프 1개 추가.
    }
    else { // 새는 곳이 아니면,
        index += 1
    }
}

print(answer)

백준 Swift 11724번(DFS)

// MARK: - 11724번(DFS)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var adj = Array(repeating: Array(repeating: false, count: N + 1), count: N + 1)
var check = Array(repeating: false, count: N + 1) // 방문체크
var answer: Int = 0

for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (u, v) = (input[0], input[1])
    adj[u][v] = true
    adj[v][u] = true
}

func dfs(_ index: Int) {
    for next in 1...N {
        if (index != next) && (adj[index][next] == true) && (check[next] == false) { // 자기자신X, 연결되어 있고, 방문한 적 없으면,
            check[next] = true
            dfs(next)
        }
    }
    
}

for i in 1...N {
    if check[i] == false {
        check[i] = true
        answer += 1
        dfs(i)
    }
    
}

print(answer)

백준 Swift 11724번(BFS)

// MARK: - 11724번(BFS)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var adj = Array(repeating: Array(repeating: false, count: N + 1), count: N + 1)
var check = Array(repeating: false, count: N + 1) // 방문 체크
var answer: Int = 0

for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (u, v) = (input[0], input[1])
    adj[u][v] = true
    adj[v][u] = true
}

class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
}

func bfs(_ startIndex: Int) {
    var q = Dequeue([startIndex])
    
    while !q.isEmpty {
        let now = q.popFirst()
        for next in 1...N {
            if (adj[now][next] == true) && (check[next] == false) { // 연결되어 있고, 방문한 적 없으면,
                check[next] = true
                q.pushLast(next)
            }
        }
    }
    
}

for i in 1...N {
    if check[i] == false {
        check[i] = true
        answer += 1
        bfs(i)
    }
}

print(answer)

백준 Swift 2178번

// MARK: - 2178번
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
    
}

let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var adj: [[Int]] = []

for _ in 0..<N {
    let input = readLine()!.map{Int(String($0))!}
    adj.append(input)
}

let dy = [0, 1, 0, -1]
let dx = [1, 0, -1, 0]
var visited = Array(repeating: Array(repeating: false, count: M), count: N)

func isValid(_ y: Int, _ x: Int) -> Bool {
    return (0 <= y && y <= N - 1) && (0 <= x && x <= M - 1)
}

func bfs(_ startY: Int, _ startX: Int) -> Int {
    visited[startY][startX] = true // 시작위치 방문 포함.
    let q = Dequeue([(startY, startX, 1)])
    
    while !q.isEmpty {
        let (y, x, d) = q.popFirst()
        
        if y == N-1 && x == M-1 { // 끝에 도달했으면,
            return d
        }
        
        for k in 0..<4 {
            let ny = y + dy[k]
            let nx = x + dx[k]
            let nd = d + 1
            if isValid(ny, nx) && !visited[ny][nx] && adj[ny][nx] == 1 { // 정상 좌표고, 방문한 적 없고, 길이 갈 수 있으면(1이면),
                visited[ny][nx] = true
                q.pushLast((ny, nx, nd))
            }
        }
    }
    
    return 1
    
}

let answer = bfs(0, 0)
print(answer)

백준 Swift 7785번

// MARK: - 7785번
let N = Int(readLine()!)!
var names: Set<String> = []

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{String($0)}
    let (name, state) = (input[0], input[1])
    
    if state == "enter" { // enter
        names.insert(name)
    }
    else if state == "leave" { // leave
        if names.contains(name) {
            names.remove(name)
        }
    }
    
}

let temp = names.sorted(by: >)

for name in temp {
    print(name)
}

백준 Swift 1021번

// MARK: - 1021번
class Dequeue<T: Comparable> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
    
    func firstIndex(_ num: T) -> Int {
        let newQue = deQueue.reversed() + enQueue
        if let i = newQue.firstIndex(where: {$0 == num}) {
            return i
        }
        return 0
    }
}

let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
let position = readLine()!.split(separator: " ").map{Int(String($0))!}
var myQ = Dequeue([0])
for i in 1...N {
    myQ.pushLast(i)
}
myQ.popFirst() // 0 제거

var answer: Int = 0
for pos in position {
    let index = myQ.firstIndex(pos) // myQ에서의 그 숫자의 index
    let count = myQ.count
    
    // index기준으로 전체에서 - 왼쪽으로 가는게 짧은지, 오른쪽으로 가는게 짧은지 비교해서 분기.
    
    if index <= (count / 2) { // 2번 케이스 - (절반 기준으로) 왼쪽으로 가는게 짧으면,
        for _ in 0..<index {
            myQ.pushLast(myQ.popFirst()) // 맨 앞을 빼서 맨 뒤에 붙임.
            answer += 1
        }
        myQ.popFirst() // 1번 케이스
    }
    else { // 3번 케이스 - (절반 기준으로) 오른쪽으로 가는게 짧으면,
        for _ in 0..<count-index {
            myQ.pushFirst(myQ.popLast()) // 맨 뒤를 빼서 맨 앞에 붙임.
            answer += 1
        }
        myQ.popFirst()
    }
}

print(answer)

백준 Swift 1158번

Dequeue을 사용하면 되려 시간초과.

그냥 배열 혹은 Arrayslice<Int>(1...N)을 사용해야 함.

// MARK: - 1158번
//class Dequeue<T> {
//    var enQueue: [T]
//    var deQueue: [T] = []
//
//    var count: Int {
//        return enQueue.count + deQueue.count
//    }
//
//    var isEmpty: Bool {
//        return enQueue.isEmpty && deQueue.isEmpty
//    }
//
//    init(_ queue: [T]) {
//        enQueue = queue
//    }
//
//    func pushLast(_ element: T) {
//        enQueue.append(element)
//    }
//
//    func pushFirst(_ element: T) {
//        deQueue.append(element)
//    }
//
//    func popLast() -> T {
//        if enQueue.isEmpty {
//            enQueue = deQueue.reversed()
//            deQueue.removeAll()
//        }
//        return enQueue.popLast()!
//    }
//
//    func popFirst() -> T {
//        if deQueue.isEmpty {
//            deQueue = enQueue.reversed()
//            enQueue.removeAll()
//        }
//        return deQueue.popLast()!
//    }
//}

let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, K) = (input[0], input[1])

var result: [Int] = []
//var myQ = Dequeue(Array(1...N)) // https://stackoverflow.com/questions/34571043/how-to-create-an-array-with-incremented-values-in-swift
//var myQ = ArraySlice<Int>(1...N)
var myQ = Array(1...N)
var index: Int = K - 1 // 빼낼 인덱스.

for _ in 0..<N {

    if index >= myQ.count {
        index %= myQ.count // modulo
    }
    
    let pop = myQ.remove(at: index)
    result.append(pop)
    
    index += K - 1 // 빼낼 인덱스 옮김.
}

print("<" + result.map{String($0)}.joined(separator: ", ") + ">")

백준 Swift 2346번

// MARK: - 2346번
class Dequeue<T> {
    var enQueue: [T]
    var deQueue: [T] = []
    
    var count: Int {
        return enQueue.count + deQueue.count
    }
    
    var isEmpty: Bool {
        return enQueue.isEmpty && deQueue.isEmpty
    }
    
    init(_ queue: [T]) {
        enQueue = queue
    }
    
    func pushLast(_ element: T) {
        enQueue.append(element)
    }
    
    func pushFirst(_ element: T) {
        deQueue.append(element)
    }
    
    func popLast() -> T {
        if enQueue.isEmpty {
            enQueue = deQueue.reversed()
            deQueue.removeAll()
        }
        return enQueue.popLast()!
    }
    
    func popFirst() -> T {
        if deQueue.isEmpty {
            deQueue = enQueue.reversed()
            enQueue.removeAll()
        }
        return deQueue.popLast()!
    }
    
}

let N = Int(readLine()!)!
let balloons = readLine()!.split(separator: " ").map{Int(String($0))!}
var indexBallons: [(index: Int, value: Int)] = []
for i in 0..<N {
    indexBallons.append((i+1, balloons[i]))
}
var myQ = Dequeue(indexBallons)
var answer: [Int] = []

var index: Int = 0

var pop = myQ.popFirst() // 1번 풍선 값.
answer.append(pop.index)

for _ in 1..<N {
    
    if pop.value > 0 { // 풍선이 양수면, 오른쪽으로 이동.
        for _ in 0..<pop.value-1 {
            myQ.pushLast(myQ.popFirst())
        }
        pop = myQ.popFirst()
        answer.append(pop.index)
    }
    else { // 풍선이 음수면, 왼쪽으로 이동.
        for _ in 0..<abs(pop.value)-1 {
            myQ.pushFirst(myQ.popLast())
        }
        pop = myQ.popLast()
        answer.append(pop.index)
    }
    
}

for num in answer {
    print(num, terminator: " ")
}

백준 Swift 1406번

// MARK: - 1406번(stack사용)
var stackL = readLine()!.map{String($0)}
var stackR: [String] = []

let M = Int(readLine()!)!

for _ in 0..<M {
    let input = readLine()!
    // .split이 시간을 잡아 먹음.
//    var (command, char) = ("", "")
//    if input.contains(" ") { // 문자 입력(P)이면,
//        let temp = input.split(separator: " ").map{String($0)}
//        (command, char) = (temp[0], temp[1])
//    }
//    else { // L, D, B 이면,
//        command = input
//    }
    
    switch input {
    case "L":
        if !stackL.isEmpty {
            stackR.append(stackL.popLast()!)
        }
    case "D":
        if !stackR.isEmpty {
            stackL.append(stackR.popLast()!)
        }
    case "B":
        if !stackL.isEmpty {
            stackL.removeLast()
        }
    default: // P일 때,
        stackL.append(String(input.last!))
    }
    
}

let answer = stackL + stackR.reversed()
print(answer.joined(separator: ""))

아래 더보기 - 시간초과 코드

백준 Swift 1406번(시간초과)

// MARK: - 1406번(시간초과)
var input = readLine()!.map{String($0)}
var answer = input
let M = Int(readLine()!)!

var index: Int = input.count

for _ in 0..<M {
    let input = readLine()!
    var (command, char) = ("", "")
    if input.contains(" ") { // 문자 입력(P)이면,
        let temp = input.split(separator: " ").map{String($0)}
        (command, char) = (temp[0], temp[1])
    }
    else { // L, D, B 이면,
        command = input
    }
    
//    print("beforeIndex: \(index)")
    switch command {
    case "P":
        answer.insert(char, at: index)
        index += 1
    case "L":
        if index != 0 { // 커서가 문장의 맨 앞이 아니면,
            index -= 1
        }
    case "D":
        if index != answer.count { // 커서가 문장의 맨 뒤가 아니면,
            index += 1
        }
    case "B":
        if index != 0 { // 커서가 문장의 맨 앞이 아니면,
            answer.remove(at: index-1)
            index -= 1
        }
    default:
        print("default는 없음.")
    }
//    print("afterIndex: \(index)")
    
}

print(answer.joined(separator: ""))

백준 Swift 1935번

// MARK: - 1935번
import Foundation
let N = Int(readLine()!)!
let input = readLine()!.map{String($0)}

var nums: [Double] = Array(repeating: 0.0, count: 26)
for i in 0..<N {
    let num = Double(readLine()!)!
    nums[i] = num
}

var stack: [Double] = []
var index: Int = 0
for i in 0..<input.count {
    
    if Int(UnicodeScalar(input[i])!.value) >= 65 && Int(UnicodeScalar(input[i])!.value) <= 97 { // 알파벳을 만났을 때,
        stack.append(nums[Int(UnicodeScalar(input[i])!.value) - 65])
    }
    else { // 기호를 만났을 때,
        let back: Double = stack.popLast()!
        let front: Double = stack.popLast()!
        
        switch input[i] {
        case "+":
            stack.append(front + back)
        case "-":
            stack.append(front - back)
        case "*":
            stack.append(front * back)
        case "/":
            stack.append(front / back)
        default:
            print("default는 없음.")
        }
    }
    
}

let answer = stack.first!
print(String(format: "%.2f", answer))

백준 Swift 1874번(풀이1)

// MARK: - 1874번(풀이1)
let N = Int(readLine()!)!

var stack: [Int] = []
var op: [String] = []
var num: Int = 1
for _ in 0..<N {
    let input = Int(readLine()!)!
    
    while num <= input {
        stack.append(num)
        op.append("+")
        num += 1
    }
    
    if stack.last! == input {
        stack.removeLast()
        op.append("-")
    }
    else {
        op.append("NO")
        break
    }
}

if op.contains("NO") {
    print("NO")
}
else {
    for o in op { // operator 출력.
        print(o)
    }
}

백준 Swift 1874번(풀이2)

// MARK: - 1874번(풀이2)
let N = Int(readLine()!)!
var numArray: [Int] = []
for _ in 0..<N {
    numArray.append(Int(readLine()!)!)
}

var stack: [Int] = []
var operatorArray: [String] = []
var index: Int = 0

for i in 1...N {
    stack.append(i)
    operatorArray.append("+")
    
    while !stack.isEmpty && stack.last! == numArray[index] { // stack이 비어있지 않고, 스택의 마지막이 pop을 해야하는 정수면,
        stack.removeLast()
        index += 1
        operatorArray.append("-")
    }
    
}

if !stack.isEmpty {
    print("NO")
}
else {
    for op in operatorArray {
        print(op)
    }
}

백준 Swift 1764번

// MARK: - 1764번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var setA: Set<String> = []
var setB: Set<String> = []

for _ in 0..<N {
    setA.insert(readLine()!)
}
for _ in 0..<M {
    setB.insert(readLine()!)
}

var interSet: Set<String> = setA.intersection(setB) // setA와 setB 교집합.
let answer: [String] = Array(interSet).sorted(by: <)

print(answer.count)
for name in answer {
    print(name)
}

백준 Swift 10799번

// MARK: - 10799번
let input = readLine()!.map{String($0)}

var index: Int = 0
var stack: [String] = []
var answer: Int = 0

while index < input.count {
    
    if input[index] == "(" && input[index+1] == ")" { // 레이저일 때,
        answer += stack.count
        index += 2
    }
    else if input[index] == "(" { // 막대 시작일 때,
        stack.append("(")
        index += 1
    }
    else { // 막대 끝일 때,
        stack.removeLast()
        index += 1
        answer += 1 // 막대 값 하나 증가.
    }
    
    
}

print(answer)

백준 Swift 2304번

// MARK: - 2304번
let N = Int(readLine()!)!
var info: [(coord: Int, height: Int)] = []
var array = Array(repeating: 0, count: 1001)

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    info.append((input[0], input[1]))
    array[input[0]] = input[1] // 좌표별 값 대입.
}

info.sort(by: <)
var maxCoord: Int = 0
var maxHeight: Int = 0
for data in info {
    if data.height > maxHeight {
        maxHeight = data.height // 가장 큰 기둥 높이 저장.
        maxCoord = data.coord // 가장 큰 기둥의 위치 저장.
    }
}

var answer: Int = 0
var temp: Int = 0
for i in 0..<maxCoord+1 { // 왼쪽 -> 오른쪽(큰기둥)
    if array[i] > temp { // 더 큰 기둥을 만나면,
        temp = array[i]
    }
    answer += temp
}
temp = 0
for i in stride(from: 1000, to: maxCoord, by: -1) { // 오른쪽 -> 왼쪽(큰기둥)
    if array[i] > temp { // 더 큰 기둥을 만나면,
        temp = array[i]
    }
    answer += temp
}

print(answer)

백준 Swift 2841번

// MARK: - 2841번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, P) = (input[0], input[1])
var lineStack = Array(repeating: Array(repeating: 0, count: 0), count: 7)
var answer: Int = 0

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (line, fret) = (input[0], input[1])
    
    if lineStack[line].isEmpty { // 그 줄의 스택이 비었으면,
        lineStack[line].append(fret)
        answer += 1
    }
    else {
        if lineStack[line].last! < fret { // 새로운 프렛이 더 크면,
            lineStack[line].append(fret)
            answer += 1
        }
        else { // 새로운 프렛이 작은게 들어오면,
            while !lineStack[line].isEmpty && lineStack[line].last! > fret { // 새로운 프렛이 더 커질 때까지,
                lineStack[line].removeLast()
                answer += 1
            }
            if lineStack[line].isEmpty || lineStack[line].last! != fret { // 스택이 비었거나, 프렛이 마지막과 다를때만 넣음.(같을땐 패스.)
                lineStack[line].append(fret) // 새로운 프렛 스택에 추가.
                answer += 1
            }
            
        }
    }
//    print("\(i)번째, 값 : \(answer)")
}


print(answer)

백준 Swift 3986번

// MARK: - 3986번
let N = Int(readLine()!)!
var count: Int = 0

for _ in 0..<N {
    let input = readLine()!.map{String($0)}
    var stack: [String] = []
    
    if input.count % 2 == 1 { // 홀수면, 더 볼 필요도 없이 패스.
        continue
    }
    
    for ch in input {
        if stack.isEmpty { // 스택이 비어있으면,
            stack.append(ch)
        }
        else {
            if stack.last! == ch {
                stack.removeLast()
            }
            else {
                stack.append(ch)
            }
        }
    }
    
    if stack.isEmpty {
        count += 1
    }
    
}

print(count)

백준 Swift 1966번

// MARK: - 1966번
let testCase = Int(readLine()!)!
for _ in 0..<testCase {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (N, M) = (input[0], input[1])
    var importance = readLine()!.split(separator: " ").map{Int(String($0))!}
    var myQ: [(index: Int, priority: Int)] = []
    for i in 0..<N {
        myQ.append((i, importance[i]))
    }
    importance.sort(by: <)

    var printArray: [Int] = []
    
    while !myQ.isEmpty {
        if myQ.first!.priority == importance.max()! { // 중요도가 제일 높은 문서이면,
            printArray.append(myQ.removeFirst().index) // 인쇄.
            importance.removeLast() // 중요도 제일 높은 숫자 삭제.
        }
        else {
            myQ.append(myQ.removeFirst())
        }
    }

    let answer = printArray.firstIndex(of: M)! + 1
    print(answer)
}

백준 Swift 최소 힙, 최대 힙, 절댓값 힙 (백준 Swift 1927번, 11279번, 11286번)

개발자P — Mon, 14 Mar 2022 15:59:56 +0900

백준 Swift 힙(Heap) 세트 문제입니다.

절댓값 힙 문제는 총 3가지의 아이디어로 풀 수 있었습니다. (백준 11286번)

(idea 1 : 단순 값 비교 / idea 2 : 튜플 사용 / idea 3 : 최소힙과 최대힙을 동시 사용)

최소 힙 | 백준 Swift 1927번

우선순위 큐 반례.txt

0.00MB

백준 1927번 MinHeap 반례 추가.

// MARK: - 1927번(최소 힙)
import Foundation

struct MinHeap<T: Comparable> {
    var heap: [T] = []
    
    var isEmpty: Bool {
        return heap.count <= 1 ? true : false
    }
    
    init() {}
    init(_ element: T) {
        heap.append(element) // 0번 index채우기 용
        heap.append(element) // 실제 Root Node 채움.
    }
    
    mutating func insert(_ element: T) {
        if heap.isEmpty {
            heap.append(element)
            heap.append(element)
            return
        }
        heap.append(element)
        
        func isMoveUp(_ insertIndex: Int) -> Bool {
            if insertIndex <= 1 { // Root Node일 때,
                return false
            }
            let parentIndex = insertIndex / 2
            return heap[insertIndex] < heap[parentIndex] ? true : false
        }
        
        var insertIndex = heap.count - 1
        while isMoveUp(insertIndex) {
            let parentIndex = insertIndex / 2
            heap.swapAt(insertIndex, parentIndex)
            insertIndex = parentIndex
        }
    }
    
    enum moveDownStatus { case left, right, none }
    
    mutating func pop() -> T? {
        if heap.count <= 1 {
            return nil
        }
        let returnData = heap[1]
        heap.swapAt(1, heap.count - 1)
        heap.removeLast()
        
        func moveDown(_ poppedIndex: Int) -> moveDownStatus {
            let leftChildIndex = poppedIndex * 2
            let rightChildIndex = leftChildIndex + 1
            
            // case1. 모든(왼쪽) 자식 노드가 없는 경우(완전이진트리는 왼쪽부터 채워지므로)
            if leftChildIndex >= heap.count {
                return .none
            }
            
            // case2. 왼쪽 자식 노드만 있는 경우
            if rightChildIndex >= heap.count {
                return heap[leftChildIndex] < heap[poppedIndex] ? .left : .none
            }
            
            // case3. 왼쪽&오른쪽 자식 노드 모두 있는 경우
            // case3-1. 자식들이 자신보다 모두 큰 경우(자신이 제일 작은 경우)
            if (heap[leftChildIndex] > heap[poppedIndex]) && (heap[rightChildIndex] > heap[poppedIndex]) {
                return .none
            }
            
            // case3-2. 자식들이 자신보다 모두 작은 경우(왼쪽과 오른쪽 자식 중, 더 작은 자식을 선별)
            if (heap[leftChildIndex] < heap[poppedIndex]) && (heap[rightChildIndex] < heap[poppedIndex]) {
                return heap[leftChildIndex] < heap[rightChildIndex] ? .left : .right
            }
            
            // case3-3. 왼쪽과 오른쪽 자식 중, 한 자식만 자신보다 작은 경우
            if (heap[leftChildIndex] < heap[poppedIndex]) || (heap[rightChildIndex] < heap[poppedIndex]) {
                return heap[leftChildIndex] < heap[rightChildIndex] ? .left : .right
            }
            
            return .none
        }
        
        var poppedIndex = 1
        while true {
            switch moveDown(poppedIndex) {
            case .none:
                return returnData
            case .left:
                let leftChildIndex = poppedIndex * 2
                heap.swapAt(poppedIndex, leftChildIndex)
                poppedIndex = leftChildIndex
            case .right:
                let rightChildIndex = (poppedIndex * 2) + 1
                heap.swapAt(poppedIndex, rightChildIndex)
                poppedIndex = rightChildIndex
            }
        }
    }
}

let N = Int(readLine()!)!
var myMinHeap: MinHeap<Int> = MinHeap()

for _ in 0..<N {
    let input = Int(readLine()!)!

    if input == 0 {
        let answer = myMinHeap.pop()
        answer == nil ? print("0") : print(answer!)
    }
    else {
        myMinHeap.insert(input)
    }
}

최대 힙 | 백준 Swift 11279번

// MARK: - 11279번(최대 힙)
struct MaxHeap<T: Comparable> {
    var heap: [T] = []

    var isEmpty: Bool {
        heap.count <= 1 ? true : false
    }

    init() {}
    init(_ element: T) {
        heap.append(element)
        heap.append(element)
    }
    
    mutating func insert(_ element: T) {
        if heap.isEmpty {
            heap.append(element)
            heap.append(element)
            return
        }
        heap.append(element)
        
        func isMoveUp(_ insertIndex: Int) -> Bool {
            if insertIndex <= 1 { // rootNode
                return false
            }
            let parentIndex = insertIndex / 2
            return heap[insertIndex] > heap[parentIndex] ? true : false
        }
        
        var insertIndex: Int = heap.count - 1
        while isMoveUp(insertIndex) {
            let parentIndex = insertIndex / 2
            heap.swapAt(insertIndex, parentIndex)
            insertIndex = parentIndex
        }
    }
    
    enum moveDownStatus {case left, right, none}
    
    mutating func pop() -> T? {
        if heap.count <= 1 {
            return nil
        }
        let returnData = heap[1]
        heap.swapAt(1, heap.count - 1)
        heap.removeLast()
        
        func moveDown(_ poppedIndex: Int) -> moveDownStatus {
            let leftChildIndex = poppedIndex * 2
            let rightChildIndex = leftChildIndex + 1
            
            // case1. 모든(왼쪽) 자식 노드가 없는 경우, (완전이진트리는 왼쪽부터 채워지므로)
            if leftChildIndex >= heap.count {
                return .none
            }
            
            // case2. 왼쪽 자식 노드만 있는 경우,
            if rightChildIndex >= heap.count {
                return heap[leftChildIndex] > heap[poppedIndex] ? .left : .none
            }
            
            // case3. 왼쪽&오른쪽 자식 노드 모두 있는 경우
            // case3-1. 자식들보다 자신이 모두 큰 경우(자신이 제일 큰 경우)
            if (heap[poppedIndex] > heap[leftChildIndex]) && (heap[poppedIndex] > heap[rightChildIndex]) {
                return .none
            }
            
            // case3-2. 자식들이 자신보다 모두 큰 경우(왼쪽과 오른쪽 자식 중, 더 큰 자식을 선별)
            if (heap[poppedIndex] < heap[leftChildIndex]) && (heap[poppedIndex] < heap[rightChildIndex]) {
                return heap[leftChildIndex] > heap[rightChildIndex] ? .left : .right
            }
            
            // case3-3. 왼쪽과 오른쪽 자식 중, 한 자식만 자신보다 큰 경우, (= 둘 중 하나의 자식만 큰 경우)
            if (heap[leftChildIndex] > heap[poppedIndex]) || (heap[rightChildIndex] > heap[poppedIndex]) {
                return heap[leftChildIndex] > heap[rightChildIndex] ? .left : .right
            }
            return .none
        }
        
        var poppedIndex = 1
        while true {
            switch moveDown(poppedIndex) {
            case .none:
                return returnData
            case .left:
                let leftChildIndex = poppedIndex * 2
                heap.swapAt(leftChildIndex, poppedIndex)
                poppedIndex = leftChildIndex
            case .right:
                let rightChildIndex = poppedIndex * 2 + 1
                heap.swapAt(rightChildIndex, poppedIndex)
                poppedIndex = rightChildIndex
            }
        }
        
    }
    
}

let N = Int(readLine()!)!
var myMaxHeap: MaxHeap<Int> = MaxHeap()

for _ in 0..<N {
    let input = Int(readLine()!)!

    if input == 0 {
        let answer = myMaxHeap.pop()
        answer == nil ? print("0") : print(answer!)
    }
    else {
        myMaxHeap.insert(input)
    }
}

절댓값 힙 (1) | 백준 Swift 11286번

접근 아이디어 1 : 최소 힙에서, comparer를 활용해서 비교해주면 됨.

참고 : 글 아래 2번 풀이가 더 쉽고 간편하다.

(참고 : https://www.acmicpc.net/source/37235051)
// MARK: - 11286번(풀이 1 : comparer 추가)
struct MinHeap<T: Comparable> {
    var heap: [Int] = []
    
    var comparer: (Int, Int) -> Bool = {(a, b) in
        if abs(a) == abs(b) {
            return a > b
        }
        else {
            return abs(a) > abs(b)
        }
    }
    
    var isEmpty: Bool {
        return heap.count <= 1 ? true : false
    }
    
    init() {}
    init(_ element: Int) {
        heap.append(element) // 0번 index채우기 용
        heap.append(element) // 실제 Root Node 채움.
    }
    
    mutating func insert(_ element: Int) {
        if heap.isEmpty {
            heap.append(element)
            heap.append(element)
            return
        }
        heap.append(element)
        
        func isMoveUp(_ insertIndex: Int) -> Bool {
            if insertIndex <= 1 { // Root Node일 때,
                return false
            }
            let parentIndex = insertIndex / 2
//            return heap[insertIndex] < heap[parentIndex] ? true : false
            return comparer(heap[parentIndex], heap[insertIndex])
        }
        
        var insertIndex = heap.count - 1
        while isMoveUp(insertIndex) {
            let parentIndex = insertIndex / 2
            heap.swapAt(insertIndex, parentIndex)
            insertIndex = parentIndex
        }
    }
    
    enum moveDownStatus { case left, right, none }
    
    mutating func pop() -> Int? {
        if heap.count <= 1 {
            return nil
        }
        let returnData = heap[1]
        heap.swapAt(1, heap.count - 1)
        heap.removeLast()
        
        func moveDown(_ poppedIndex: Int) -> moveDownStatus {
            let leftChildIndex = poppedIndex * 2
            let rightChildIndex = leftChildIndex + 1
            
            // case1. 모든(왼쪽) 자식 노드가 없는 경우(완전이진트리는 왼쪽부터 채워지므로)
            if leftChildIndex >= heap.count {
                return .none
            }
            
            // case2. 왼쪽 자식 노드만 있는 경우
            if rightChildIndex >= heap.count {
//                return heap[leftChildIndex] < heap[poppedIndex] ? .left : .none
                return comparer(heap[poppedIndex], heap[leftChildIndex]) ? .left : .none
            }
            
            // case3. 왼쪽&오른쪽 자식 노드 모두 있는 경우
            // case3-1. 자식들이 자신보다 모두 큰 경우(자신이 제일 작은 경우)
//            if (heap[leftChildIndex] > heap[poppedIndex]) && (heap[rightChildIndex] > heap[poppedIndex]) {
            if (comparer(heap[leftChildIndex], heap[poppedIndex])) && (comparer(heap[rightChildIndex], heap[poppedIndex])) {
                return .none
            }
            
            // case3-2. 자식들이 자신보다 모두 작은 경우(왼쪽과 오른쪽 자식 중, 더 작은 자식을 선별)
//            if (heap[leftChildIndex] < heap[poppedIndex]) && (heap[rightChildIndex] < heap[poppedIndex]) {
            if (comparer(heap[poppedIndex], heap[leftChildIndex])) && (comparer(heap[poppedIndex], heap[rightChildIndex])) {
//                return heap[leftChildIndex] < heap[rightChildIndex] ? .left : .right
                return comparer(heap[rightChildIndex], heap[leftChildIndex]) ? .left : .right
            }
            
            // case3-3. 왼쪽과 오른쪽 자식 중, 한 자식만 자신보다 작은 경우
//            if (heap[leftChildIndex] < heap[poppedIndex]) || (heap[rightChildIndex] < heap[poppedIndex]) {
            if (comparer(heap[poppedIndex], heap[leftChildIndex])) || (comparer(heap[poppedIndex], heap[rightChildIndex])) {
//                return heap[leftChildIndex] < heap[rightChildIndex] ? .left : .right
                return comparer(heap[rightChildIndex], heap[leftChildIndex]) ? .left : .right
            }
            
            return .none
        }
        
        var poppedIndex = 1
        while true {
            switch moveDown(poppedIndex) {
            case .none:
                return returnData
            case .left:
                let leftChildIndex = poppedIndex * 2
                heap.swapAt(poppedIndex, leftChildIndex)
                poppedIndex = leftChildIndex
            case .right:
                let rightChildIndex = (poppedIndex * 2) + 1
                heap.swapAt(poppedIndex, rightChildIndex)
                poppedIndex = rightChildIndex
            }
        }
    }
}

let N = Int(readLine()!)!
var myAbsHeap: MinHeap<Int> = MinHeap()

for _ in 0..<N {
    let input = Int(readLine()!)!
    
    if input == 0 {
        let answer = myAbsHeap.pop()
        answer == nil ? print("0") : print(answer!)
    }
    else {
        myAbsHeap.insert(input)
    }
}

절댓값 힙 (2) | 백준 Swift 11286번

접근 아이디어 2 : 튜플을 (아래처럼 선언 뒤) 최소힙에 넣고, 튜플을 정렬시킨 뒤, 원본값을 출력한다.

튜플 : (절댓값, 원본값)

알게된 점 : 튜플도 정렬이 된다!

상세 설명

(오름차순 정렬 시) 앞의 값을 기준으로 먼저 정렬되고, 그 다음 뒤의 값을 기준으로 정렬된다.

즉,

이 문제의 조건인 (앞) 절대값을 기준으로 오름차순 정렬되고,

그 다음 (뒤) 원본값도 오름차순으로 (작은 것부터) 정렬되기 때문에,

최소힙에 튜플을 넣음으로써 쉽게 풀 수 있다.

// MARK: - 11286번(풀이 2 - 튜플을 넣어서 비교)
struct MinHeap<T: Comparable> {
    var heap: [(T, T)] = []
    
    var isEmpty: Bool {
        return heap.count <= 1 ? true : false
    }
    
    init() {}
    init(_ element: (T, T)) {
        heap.append(element) // 0번 index채우기 용
        heap.append(element) // 실제 Root Node 채움.
    }
    
    mutating func insert(_ element: (T, T)) {
        if heap.isEmpty {
            heap.append(element)
            heap.append(element)
            return
        }
        heap.append(element)
        
        func isMoveUp(_ insertIndex: Int) -> Bool {
            if insertIndex <= 1 { // Root Node일 때,
                return false
            }
            let parentIndex = insertIndex / 2
            return heap[insertIndex] < heap[parentIndex] ? true : false
        }
        
        var insertIndex = heap.count - 1
        while isMoveUp(insertIndex) {
            let parentIndex = insertIndex / 2
            heap.swapAt(insertIndex, parentIndex)
            insertIndex = parentIndex
        }
    }
    
    enum moveDownStatus { case left, right, none }
    
    mutating func pop() -> (T, T)? {
        if heap.count <= 1 {
            return nil
        }
        let returnData = heap[1]
        heap.swapAt(1, heap.count - 1)
        heap.removeLast()
        
        func moveDown(_ poppedIndex: Int) -> moveDownStatus {
            let leftChildIndex = poppedIndex * 2
            let rightChildIndex = leftChildIndex + 1
            
            // case1. 모든(왼쪽) 자식 노드가 없는 경우(완전이진트리는 왼쪽부터 채워지므로)
            if leftChildIndex >= heap.count {
                return .none
            }
            
            // case2. 왼쪽 자식 노드만 있는 경우
            if rightChildIndex >= heap.count {
                return heap[leftChildIndex] < heap[poppedIndex] ? .left : .none
            }
            
            // case3. 왼쪽&오른쪽 자식 노드 모두 있는 경우
            // case3-1. 자식들이 자신보다 모두 큰 경우(자신이 제일 작은 경우)
            if (heap[leftChildIndex] > heap[poppedIndex]) && (heap[rightChildIndex] > heap[poppedIndex]) {
                return .none
            }
            
            // case3-2. 자식들이 자신보다 모두 작은 경우(왼쪽과 오른쪽 자식 중, 더 작은 자식을 선별)
            if (heap[leftChildIndex] < heap[poppedIndex]) && (heap[rightChildIndex] < heap[poppedIndex]) {
                return heap[leftChildIndex] < heap[rightChildIndex] ? .left : .right
            }
            
            // case3-3. 왼쪽과 오른쪽 자식 중, 한 자식만 자신보다 작은 경우
            if (heap[leftChildIndex] < heap[poppedIndex]) || (heap[rightChildIndex] < heap[poppedIndex]) {
                return heap[leftChildIndex] < heap[rightChildIndex] ? .left : .right
            }
            
            return .none
        }
        
        var poppedIndex = 1
        while true {
            switch moveDown(poppedIndex) {
            case .none:
                return returnData
            case .left:
                let leftChildIndex = poppedIndex * 2
                heap.swapAt(poppedIndex, leftChildIndex)
                poppedIndex = leftChildIndex
            case .right:
                let rightChildIndex = (poppedIndex * 2) + 1
                heap.swapAt(poppedIndex, rightChildIndex)
                poppedIndex = rightChildIndex
            }
        }
    }
}

let N = Int(readLine()!)!
var myMinHeap: MinHeap<Int> = MinHeap()

for _ in 0..<N {
    let input = Int(readLine()!)!
    
    if input == 0 {
        let answer = myMinHeap.pop()
        answer == nil ? print("0") : print(answer!.1) // 튜플의 뒷부분(원본값) 출력.
    }
    else {
        myMinHeap.insert((abs(input), input))
    }
}

절댓값 힙 (3) | 백준 Swift 11286번

접근 아이디어 3

minHeap : 양수 - 양수일 땐, 절댓값이 작은 게 원본값도 작다. -> 따라서 minHeap에서 pop하면, 절댓값이 가장 작은 게 튀어나온다.

maxHeap : 음수 - 음수일 땐, 절댓값이 작은 게 원본값이 크다. -> 따라서 maxHeap에서 pop하면, 절댓값이 가장 작은 게 튀어나온다.

흐름1) 근데 만약, pop한 값이 둘 다 같으면 -> 음수가 들어 있는 maxHeap값을 pop해줘야 함.(원본값이 작은 걸 먼저 출력해야 하기 때문에)

흐름2) 둘 중 하나의 heap이 비어 있으면, 값이 있는 heap에서 pop을 해주면 됨.

흐름3) 둘 다 비어 있으면, 0을 출력 해주면 됨.

// MARK: - 11286번(풀이 3 : minHeap과 maxHeap을 사용)
// minHeap : 양수 - 양수일 땐, 절댓값이 작은 게 원본값도 작다. -> 따라서 minHeap에서 pop하면, 절댓값이 가장 작은 게 튀어나온다.
// maxHeap : 음수 - 음수일 땐, 절댓값이 작은 게 원본값이 크다. -> 따라서 maxHeap에서 pop하면, 절댓값이 가장 작은 게 튀어나온다.
// 흐름1) 근데 만약, pop한 값이 둘 다 같으면 -> 음수가 들어 있는 maxHeap값을 pop해줘야 함.(원본값이 작은 걸 먼저 출력해야 하기 때문에)
// 흐름2) 둘 중 하나의 heap이 비어 있으면, 값이 있는 heap에서 pop을 해주면 됨.
// 흐름3) 둘 다 비어 있으면, 0을 출력 해주면 됨.
struct MinHeap<T: Comparable> {
    var heap: [T] = []

    var isEmpty: Bool {
        return heap.count <= 1 ? true : false
    }

    init() {}
    init(_ element: T) {
        heap.append(element) // 0번 index채우기 용
        heap.append(element) // 실제 Root Node 채움.
    }

    mutating func insert(_ element: T) {
        if heap.isEmpty {
            heap.append(element)
            heap.append(element)
            return
        }
        heap.append(element)

        func isMoveUp(_ insertIndex: Int) -> Bool {
            if insertIndex <= 1 { // Root Node일 때,
                return false
            }
            let parentIndex = insertIndex / 2
            return heap[insertIndex] < heap[parentIndex] ? true : false
        }

        var insertIndex = heap.count - 1
        while isMoveUp(insertIndex) {
            let parentIndex = insertIndex / 2
            heap.swapAt(insertIndex, parentIndex)
            insertIndex = parentIndex
        }
    }

    enum moveDownStatus { case left, right, none }

    mutating func pop() -> T? {
        if heap.count <= 1 {
            return nil
        }
        let returnData = heap[1]
        heap.swapAt(1, heap.count - 1)
        heap.removeLast()

        func moveDown(_ poppedIndex: Int) -> moveDownStatus {
            let leftChildIndex = poppedIndex * 2
            let rightChildIndex = leftChildIndex + 1

            // case1. 모든(왼쪽) 자식 노드가 없는 경우 (완전이진트리는 왼쪽부터 채워지므로)
            if leftChildIndex >= heap.count {
                return .none
            }

            // case2. 왼쪽 자식 노드만 있는 경우
            if rightChildIndex >= heap.count {
                return heap[leftChildIndex] < heap[poppedIndex] ? .left : .none
            }

            // case3. 왼쪽&오른쪽 자식 노드 모두 있는 경우
            // case3-1. 자식들이 자신보다 모두 큰 경우(자신이 제일 작은 경우)
            if (heap[leftChildIndex] > heap[poppedIndex]) && (heap[rightChildIndex] > heap[poppedIndex]) {
                return .none
            }

            // case3-2. 자식들이 자신보다 모두 작은 경우(왼쪽과 오른쪽 자식 중, 더 작은 자식을 선별)
            if (heap[leftChildIndex] < heap[poppedIndex]) && (heap[rightChildIndex] < heap[poppedIndex]) {
                return heap[leftChildIndex] < heap[rightChildIndex] ? .left : .right
            }

            // case3-3. 왼쪽과 오른쪽 자식 중, 한 자식만 자신보다 작은 경우
            if (heap[leftChildIndex] < heap[poppedIndex]) || (heap[rightChildIndex] < heap[poppedIndex]) {
                return heap[leftChildIndex] < heap[rightChildIndex] ? .left : .right
            }

            return .none
        }

        var poppedIndex = 1
        while true {
            switch moveDown(poppedIndex) {
            case .none:
                return returnData
            case .left:
                let leftChildIndex = poppedIndex * 2
                heap.swapAt(poppedIndex, leftChildIndex)
                poppedIndex = leftChildIndex
            case .right:
                let rightChildIndex = (poppedIndex * 2) + 1
                heap.swapAt(poppedIndex, rightChildIndex)
                poppedIndex = rightChildIndex
            }
        }
    }
}

struct MaxHeap<T: Comparable> {
    var heap: [T] = []

    var isEmpty: Bool {
        heap.count <= 1 ? true : false
    }

    init() {}
    init(_ element: T) {
        heap.append(element)
        heap.append(element)
    }
    
    mutating func insert(_ element: T) {
        if heap.isEmpty {
            heap.append(element)
            heap.append(element)
            return
        }
        heap.append(element)
        
        func isMoveUp(_ insertIndex: Int) -> Bool {
            if insertIndex <= 1 { // rootNode
                return false
            }
            let parentIndex = insertIndex / 2
            return heap[insertIndex] > heap[parentIndex] ? true : false
        }
        
        var insertIndex: Int = heap.count - 1
        while isMoveUp(insertIndex) {
            let parentIndex = insertIndex / 2
            heap.swapAt(insertIndex, parentIndex)
            insertIndex = parentIndex
        }
    }
    
    enum moveDownStatus {case left, right, none}
    
    mutating func pop() -> T? {
        if heap.count <= 1 {
            return nil
        }
        let returnData = heap[1]
        heap.swapAt(1, heap.count - 1)
        heap.removeLast()
        
        func moveDown(_ poppedIndex: Int) -> moveDownStatus {
            let leftChildIndex = poppedIndex * 2
            let rightChildIndex = leftChildIndex + 1
            
            // case1. 모든(왼쪽) 자식 노드가 없는 경우, (완전이진트리는 왼쪽부터 채워지므로)
            if leftChildIndex >= heap.count {
                return .none
            }
            
            // case2. 왼쪽 자식 노드만 있는 경우,
            if rightChildIndex >= heap.count {
                return heap[leftChildIndex] > heap[poppedIndex] ? .left : .none
            }
            
            // case3. 왼쪽&오른쪽 자식 노드 모두 있는 경우
            // case3-1. 자식들보다 자신이 모두 큰 경우(자신이 제일 큰 경우)
            if (heap[poppedIndex] > heap[leftChildIndex]) && (heap[poppedIndex] > heap[rightChildIndex]) {
                return .none
            }
            
            // case3-2. 자식들이 자신보다 모두 큰 경우(왼쪽과 오른쪽 자식 중, 더 큰 자식을 선별)
            if (heap[poppedIndex] < heap[leftChildIndex]) && (heap[poppedIndex] < heap[rightChildIndex]) {
                return heap[leftChildIndex] > heap[rightChildIndex] ? .left : .right
            }
            
            // case3-3. 왼쪽과 오른쪽 자식 중, 한 자식만 자신보다 큰 경우, (= 둘 중 하나의 자식만 큰 경우)
            if (heap[leftChildIndex] > heap[poppedIndex]) || (heap[rightChildIndex] > heap[poppedIndex]) {
                return heap[leftChildIndex] > heap[rightChildIndex] ? .left : .right
            }
            return .none
        }
        
        var poppedIndex = 1
        while true {
            switch moveDown(poppedIndex) {
            case .none:
                return returnData
            case .left:
                let leftChildIndex = poppedIndex * 2
                heap.swapAt(leftChildIndex, poppedIndex)
                poppedIndex = leftChildIndex
            case .right:
                let rightChildIndex = poppedIndex * 2 + 1
                heap.swapAt(rightChildIndex, poppedIndex)
                poppedIndex = rightChildIndex
            }
        }
        
    }
    
}

let N = Int(readLine()!)!
var myMinHeap: MinHeap<Int> = MinHeap()
var myMaxHeap: MaxHeap<Int> = MaxHeap()

for _ in 0..<N {
    let input = Int(readLine()!)!

    if input > 0 { // 양수일 때,
        myMinHeap.insert(input)
    }
    else if input < 0 { // 음수일 때,
        myMaxHeap.insert(input)
    }
    else { // input이 0일 때,
        if myMinHeap.isEmpty == false { // 최소힙에 값이 있을 때,
            if myMaxHeap.isEmpty == false { // 최대힙에도 값이 있다면,
                let a = myMinHeap.pop()!
                let b = myMaxHeap.pop()!
                myMinHeap.insert(a) // 비교를 위해 빠진 값은 다시 추가.
                myMaxHeap.insert(b) // 비교를 위해 빠진 값은 다시 추가.
                
                if abs(a) < abs(b) { // a는 어차피 양수라 abs필요 없음.
                    print(myMinHeap.pop()!)
                }
                else { // 값이 같을 때에도, maxHeap(음수)쪽에서 빼줘야 함.
                    print(myMaxHeap.pop()!)
                }
            }
            else if myMaxHeap.isEmpty { // 최대힙엔 값이 없다면,
                print(myMinHeap.pop()!)
            }
        }
        else if myMinHeap.isEmpty { // 최소힙에 값이 없을 때,
            if myMaxHeap.isEmpty == false { // 최대힙에 값이 있으면,
                print(myMaxHeap.pop()!)
            }
            else if myMaxHeap.isEmpty { // 최대힙에도 값이 없으면,
                print(0)
            }
        }
    }
}

회고록, 22일간의 챌린지를 마치며.

개발자P — Mon, 14 Mar 2022 13:22:52 +0900

지금까지 길다면 길고, 짧다면 짧은 22일동안

22일 Basic 챌린지에 참여했습니다. 완주 성공!

https://softsquared.notion.site/22-2-3b1ba9adc1374a44aa8478818436e06f

Day 22

220314 공부 일지 : 챌린지 덕분에 문제 푸는 습관을 기를 수 있는 좋은 기회였습니다.
기존에 목표하던 "하루도 놓치지 않고 문제풀기"를 성공할 수 있어서 더 값졌던 것 같습니다.
이를 토대로, 앞으로 코테 준비를 더 열심히 해야겠습니다.
수고하셨습니다!

220314 공부 일지 / 성공!

https://softsquared.notion.site/Algorithm-5e8a1481b882461dae8d23203932d943

틴틴 Algorithm 챌린지

[챌린저스 스스로를 소개해주세요!]

softsquared.notion.site

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

회고록

챌린지가 참가비가 있거나, 특별한 보상이 있는 건 아니였고,

코딩테스트를 준비하는 과정에서 인증을 하는 과정을 통해 하루도 놓치지 않고 꾸준히 할 수 있을 거 같아서 신청했었습니다.

처음 신청할 때의 마음가짐이었던 '하루도 빠지지 말고, 해당일에 모든 문제를 다 풀어야겠다.' 를 끝까지 놓치지 않고 오늘까지 왔습니다.

어려운 문제들은 아니였으나, 알고리즘 문제를 꾸준히 푸는 습관을 갖게 되었고,

처음 챌린지를 시작할 때만 해도 Swift로 브론즈 문제를 푸는 것도 어색하고 잘 안됐으나,

이젠 실버 4~5까지의 문제들도 풀 수 있는 단계까지 온 것 같습니다.

코딩테스트 합격을 위해선 적어도 골드 상위티어정도까지의 문제를 쉽게 풀 수 있어야 한다고 생각하고 있고,

목표에 도달하기 위해서 앞으로도 매일 문제를 풀 예정입니다.

현재 저는 유데미에서 아래 강의를 보면서 코딩테스트를 공부중입니다.

Swift로 코딩테스트를 준비하면서 Heap, 큐(덱) 등이 없어 직접 구현해야 한다는 점이 힘들긴 합니다만,

알고리즘 기초를 다진다는 생각으로, 알아보고 구현하며 공부하고 있습니다.

알고리즘 코딩 테스트 입문부터 합격까지 : https://www.udemy.com/course/comgong_codingtest/

아래 유튜브 링크들은 코딩테스트, (추후에 있을)면접 대비를 위해

위 강의와 함께 앞으로 자료구조, 알고리즘 공부를 병행하기 위해 모아놓은 유용한 링크들입니다.

자료구조, 알고리즘

https://youtu.be/m-9pAwq1o3w

https://youtu.be/PIidtIBCjEg

컴퓨터구조, 운영체제

https://youtu.be/J06SirxZG7M

https://youtu.be/uMyKBYF48nY

앞으로도 꾸준히 공부하고, 문제 푼 걸 정리하여 기록할 예정입니다!

화이팅!

[22일 Basic 챌린지 참여] 알고리즘 DAY21

개발자P — Sun, 13 Mar 2022 17:57:27 +0900

오늘은 참여한지 21일차 입니다. 브론즈1의 그리디알고리즘, 구현 문제들입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

22 Basic Challenge Algorithm https://softsquared.notion.site/Algorithm-5328fab28619430dae2c782d4db6a556 Algorithm 베이직 챌린지 챌린지 대상 : 코딩 테스트 준비해야하는데, 한 번도 해본적은 없어. 일단..

developer-p.tistory.com

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

Day 21

220313 공부 일지 : 지금까지 모든 문제를 당일에 놓치지 않고 풀어서 기분 좋다!
습관이 든 만큼 앞으로도 매일 꾸준히 해야겠다.

220313 공부 일지

백준 Swift 1652번

// MARK: - 1652번
let N = Int(readLine()!)!
var room: [[String]] = []

for _ in 0..<N {
    room.append(readLine()!.map{String($0)})
}

var rowCount: Int = 0 // 가로 가능 횟수
for i in 0..<N {
    var count: Int = 0 // 2이상인지 체크하기 위해.
    var goCheck: Bool = false
    
    for j in 0..<N {
        if room[i][j] == "." {
            count += 1
        }
        else if room[i][j] == "X" {
            goCheck = true // 지금까지 쌓인 게 2 이상인지 체크하러 감.
        }
        
        if j == N - 1 { // X없이(or 끝에 X가 없이) 인덱스 끝까지 도달했을 떄,
            goCheck = true
        }
        
        if goCheck {
            if count >= 2 {
                rowCount += 1
            }
            count = 0 // X로 인해 체크했기 때문에, 다시 0으로 초기화.
            goCheck = false // check했으니 false.
        }
    }
}

var colCount: Int = 0 // 가로 가능 횟수
for i in 0..<N {
    var count: Int = 0 // 2이상인지 체크하기 위해.
    var goCheck: Bool = false
    
    for j in 0..<N {
        if room[j][i] == "." {
            count += 1
        }
        else if room[j][i] == "X" {
            goCheck = true // 지금까지 쌓인 게 2 이상인지 체크하러 감.
        }
        
        if j == N - 1 { // X없이(or 끝에 X가 없이) 인덱스 끝까지 도달했을 떄,
            goCheck = true
        }
        
        if goCheck {
            if count >= 2 {
                colCount += 1
            }
            count = 0 // X로 인해 체크했기 때문에, 다시 0으로 초기화.
            goCheck = false // check했으니 false.
        }
    }
}

print(rowCount, colCount)

백준 Swift 2167번

// MARK: - 2167번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])

var numArray = Array(repeating: Array(repeating: 0, count: M + 1), count: N + 1)

for i in 1...N { // N행
    let numsInput = readLine()!.split(separator: " ").map{Int(String($0))!}
    
    for j in 1...M { // M열
        numArray[i][j] = numsInput[j-1]
    }

}

let k = Int(readLine()!)!

for _ in 0..<k {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    var sum: Int = 0
    
    for i in input[0]...input[2] {
        for j in input[1]...input[3] {
            sum += numArray[i][j]
        }
    }
    print(sum)
}

백준 Swift 2563번

// MARK: - 2563번
let N = Int(readLine()!)!
var paper = Array(repeating: Array(repeating: 0, count: 101), count: 101)

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (x, y) = (input[0], input[1])
    
    for i in y..<y+10 {
        for j in x..<x+10 {
            paper[i][j] = 1
        }
    }
    
}

print(paper.flatMap{$0}.filter{$0 == 1}.count)

백준 Swift 2750번

// MARK: - 2750번
let N = Int(readLine()!)!
var numArray: [Int] = []

for _ in 0..<N {
    numArray.append(Int(readLine()!)!)
}

numArray.sort(by: <)

for num in numArray {
    print(num)
}

백준 Swift 2851번

// MARK: - 2851번
var mushrooms: [Int] = []
for _ in 0..<10 {
    mushrooms.append(Int(readLine()!)!)
}

var scores: [Int] = []
for i in 0..<10 {
    var sum: Int = 0
    for j in 0...i {
        sum += mushrooms[j]
    }
    scores.append(sum)
}

var distance: [Int] = []
for score in scores {
    distance.append(abs(100 - score))
}

var indexes: [Int] = [] // 100과의 거리가 제일 가까운 index들 모음.
for (index, d) in distance.enumerated() {
    if d == distance.min()! {
        indexes.append(index)
    }
}

var maxScores: [Int] = []

for i in indexes {
    maxScores.append(scores[i])
}

print(maxScores.max()!)

DAY21 인증완료

DAY21 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY20

개발자P — Sat, 12 Mar 2022 22:42:03 +0900

오늘은 참여한지 20일차 입니다. 브론즈1의 그리디알고리즘, 구현 문제들입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

Day 20

220312 공부 일지 : 1384번이 풀리지 않아서 애를 먹었는데, 다행히 해결했다.
이제 하루 남았다! 끝까지 놓치지 않고 해결해야겠다.

220312 공부 일지

백준 Swift 1356번

// MARK: - 1356번
let N = readLine()!.map{String($0)}
var isU: Bool = false // 유진수 유무
var frontNums: [String] = []
var backNums: [String] = []

var index: Int = 0
for _ in 0..<N.count-1 { // 총 (N자리수-1)가지 방법
    index += 1
    
    var frontNum: String = ""
    for i in 0..<index {
        frontNum += N[i]
    }
    frontNums.append(frontNum)
    
    var backNum: String = ""
    for j in index..<N.count {
        backNum += N[j]
    }
    backNums.append(backNum)
}

//print(frontNums)
//print(backNums)

for i in 0..<frontNums.count {
    let chFrontArray = frontNums[i].map{Int(String($0))!}
    let frontValue = chFrontArray.reduce(1, *)
    
    let chBackArray = backNums[i].map{Int(String($0))!}
    let backValue = chBackArray.reduce(1, *)
    
    if frontValue == backValue { // 유진수
        isU = true
        break
    }
    
}

if isU {
    print("YES")
}
else {
    print("NO")
}

백준 Swift 1357번

// MARK: - 1357번
import Foundation
func Rev(_ x: String) -> Int {
    var reverseNum: Int = 0
    var strX = x.map{String($0)}
    strX.reverse()
    
    let num: String = strX.reduce("", +)
    reverseNum = Int(num)!
    
    return reverseNum
}

let input = readLine()!.split(separator: " ").map{String($0)}
let (X, Y) = (input[0], input[1])

print(Rev(String(Rev(X) + Rev((Y)))))

백준 Swift 1384번

이 문제에서, 유용한 반례

6
A N N N N N
B P P P P P
C N N N N P
D P P P P N
E P N P N P
F N P N P N

// MARK: - 1384번
var caseCount: Int = 0
while true {
    let n = Int(readLine()!)!
    
    if n == 0 {
        break
    }
    var names: [String] = []
    var badIndex: [[Int]] = []
    
    for _ in 0..<n {
        let input = readLine()!.split(separator: " ").map{String($0)}
        names.append(input[0])

        var paperMessages: [String] = []
        for i in 1..<n {
            paperMessages.append(input[i])
        }
        
        var tempArray: [Int] = []
        for (index, ch) in paperMessages.enumerated() {
            if ch == "N" {
                tempArray.append(index)
            }
        }
        badIndex.append(tempArray)
    }

    var answerArray: [String] = []
    for i in 0..<n {
        for index in badIndex[i] {
            answerArray.append("\(names[(i + n - index - 1) % n]) was nasty about \(names[i])")
        }
    }

    caseCount += 1
    print("Group \(caseCount)")
    if answerArray.isEmpty {
        print("Nobody was nasty")
    }
    else {
        for ans in answerArray {
            print(ans)
        }
    }
    print()
}

백준 Swift 1453번

// MARK: - 1453번
let N = Int(readLine()!)!
var seat = Array(repeating: 0, count: 101) // 1번부터 100번까지
var answer: Int = 0
let input = readLine()!.split(separator: " ").map{Int(String($0))!}

for i in input {
    seat[i] += 1
}

for people in seat {
    if people >= 2 {
        answer += people - 1
    }
}

print(answer)

백준 Swift 1524번

// MARK: - 1524번
let T = Int(readLine()!)!

for _ in 0..<T {
    readLine()
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (_, _) = (input[0], input[1]) // N, M
    let sejun = readLine()!.split(separator: " ").map{Int(String($0))!}
    let sebi = readLine()!.split(separator: " ").map{Int(String($0))!}
    
    let maxSejun = sejun.max()! // 힘은 바뀌지 않고,
    let maxSebi = sebi.max()! // 제일 센 병사 1개만 있어도 됨.
    
    if maxSejun >= maxSebi {
        print("S")
    }
    else {
        print("B")
    }
    
}

백준 Swift 1526번

// MARK: - 1526번
let N = Int(readLine()!)!

for num in stride(from: N, through: 4, by: -1) {
    let strNum = String(num)
    
    if strNum.contains("0") || strNum.contains("1") || strNum.contains("2") || strNum.contains("3") || strNum.contains("5") || strNum.contains("6") || strNum.contains("8") || strNum.contains("9"){
        continue
    }
    else {
        print(num)
        break
    }
    
}

DAY20 인증완료

DAY20 인증완료

스위프트 | 아스키코드 변경 Char to Ascii / Ascii to Char ( Swift UnicodeScalar 사용, asciiValue)

개발자P — Fri, 11 Mar 2022 16:12:39 +0900

요즘 전 코딩테스트를 준비하면서, 백준 문제를 Swift로 풀고 있습니다. (백준 1157번 - 아스키값이 필요한 문제)

근데 종종 아스키값이 필요할 때가 있습니다.

기억을 하려고 하는데, 매번 쉽게 잊기도 하고 헷갈리기도 해서,

이번 기회에 깔끔하게 정리해두려고 글을 작성합니다.

다양한 방법이 있는데, .asciiValue(), UnicodeScalar()등 섞어서 풀이를 하다보니 헷갈렸습니다.

그래서 전 문제를 풀 때 UnicodeScalar() 하나로 통일하기로 선택했습니다.

( 어차피 1) [Character → 아스키 값]에선 .asciiValue()를 쓰더라도

결국 2) [아스키 값 → Character] 에선 UnicodeScalar()를 써야 하기 때문에,

1) 상황에서도 UnicodeScalara()를 쓰는게 헷갈리지 않더라고요. )

1) [Character(String) → 아스키 값]

⇨ Int(UnicodeScalar(ch)!.value)를 쓰면 됩니다.

반환값이 UInt32이기 때문에, (코딩테스트를 풀 땐 Int로 쓸 일이 많겠죠?)

아래 예시 코드처럼 Int()로 캐스팅 해주면 됩니다.

아래는 백준 1157번 풀이 코드의 일부 입니다.

//var alphabet = Array(repeating: 0, count: 26) // 알파벳 개수 카운팅
//let input = readLine()!.uppercased().map{String($0)}

//for ch in input {
    let index: Int = Int(UnicodeScalar(ch)!.value) - Int(UnicodeScalar("A").value)
//    alphabet[index] += 1
//}

2) [아스키 값 → Character(String)]

⇨ String(UnicodeScalar(65)!) 를 쓰면 됩니다. (예시 아스키 값 : A(65))

UnicodeScalar()는 옵셔널을 반환하기 때문에, 강제 언래핑 !를 썼습니다.

아스키값을 괄호 안에 넣어주면 됩니다.

아래는 백준 1157번 풀이 코드의 일부 입니다.

var maxIndex: Int = 0
// ~~생략~~

let answer = String(UnicodeScalar(65 + maxIndex)!) // 대문자
print(answer)

지금까지 코테 문제를 풀면서 유용한 Swift 아스키코드 값 변환에 대해서 정리했습니다.

다른 문제들을 풀면서, 유용한 자료들은 이 카테고리에 계속 업데이트 할 예정입니다.

참고한 자료 : https://0urtrees.tistory.com/223 | https://stackoverflow.com/questions/24354549/how-to-get-string-from-ascii-code-in-swift | https://zeddios.tistory.com/340

코드 중 이해가 안 되는 부분이 있거나, 잘못된 부분이 있다면 편하게 댓글 부탁드립니다.

[22일 Basic 챌린지 참여] 알고리즘 DAY19

개발자P — Fri, 11 Mar 2022 15:22:20 +0900

오늘은 참여한지 19일차 입니다. 오늘 문제는 실버 문제도 섞여 있습니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

Day 19

220311 공부 일지 : 열심히 해서, 끝까지 마무리 화이팅!
알고리즘 공부도 계속 함께 병행하기!

220311 공부 일지

백준 Swift 1032번

// MARK: - 1032번
let N = Int(readLine()!)!
var standard: [String] = []

for i in 0..<N {
    let input = readLine()!.map{String($0)}
    
    if i == 0 {
        standard = input
        continue
    }
    
    for (index, ch) in input.enumerated() {
        if standard[index] != ch {
            standard[index] = "?"
        }
    }
    
}

print(standard.reduce("", +))

백준 Swift 1110번

// MARK: - 1110번
let N = Int(readLine()!)!
var temp: Int = N
var count: Int = 0

while true {
    
    temp = (temp % 10) * 10 + ((temp / 10 + temp % 10) % 10)
//    print(temp)
    
    count += 1
    
    if temp == N {
        break
    }
    
}

print(count)

백준 Swift 1157번

// MARK: - 1157번
var alphabet = Array(repeating: 0, count: 26) // 알파벳 개수 카운팅

let input = readLine()!.uppercased().map{String($0)}

for ch in input {
    let index: Int = Int(UnicodeScalar(ch)!.value) - Int(UnicodeScalar("A").value)
    alphabet[index] += 1
}

var count: Int = 0
var maxIndex: Int = 0
for (index, num) in alphabet.enumerated() {
    if num == alphabet.max() {
        count += 1
        maxIndex = index
    }
}

if count >= 2 { // 여러개 존재
    print("?")
}
else {
    let answer = String(UnicodeScalar(65 + maxIndex)!) // 대문자
    print(answer)
}

백준 Swift 1193번

// MARK: - 1193번
let X = Int(readLine()!)!
var sum: Int = 0
var groupNumber: Int = 1 // 그룹 위치 찾기
while true {
    sum = (groupNumber * (groupNumber + 1)) / 2 // n*(n+1)/2
    if sum >= X {
        groupNumber -= 1 // 직전 그룹까지
        sum = (groupNumber * (groupNumber + 1)) / 2 // 직전 그룹까지
        break
    }
    groupNumber += 1
}

//print(groupNumber) // 직전 그룹번호
//print(sum) // 직전 그룹까지의 개수 합

groupNumber += 1 // 직전 그룹번호에서 +1 해줘야 -> X가 속한 그룹번호
var index: Int = X - sum // X가 속한 그룹에서, 몇번째인지

var numerator: Int = 1 // 분자
var denominator: Int = 1 // 분모

if groupNumber % 2 == 1 { // X가 속한 그룹번호가 홀수면,
    numerator = groupNumber
    denominator = 1
    
    for _ in 0..<index-1 {
        numerator -= 1
        denominator += 1
    }
    
}
else { // X가 속한 그룹번호가 짝수면,
    numerator = 1
    denominator = groupNumber
    
    for _ in 0..<index-1 {
        numerator += 1
        denominator -= 1
    }
}

print("\(numerator)/\(denominator)")

백준 Swift 1236번

// MARK: - 1236번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])
var castle: [[String]] = []

for _ in 0..<N {
    castle.append(readLine()!.map{String($0)})
}

var rowCount: Int = 0
var colCount: Int = 0

for i in 0..<N {
    var checkFlag: Bool = false // 경비병 유무 체크.
    
    for j in 0..<M {
        if castle[i][j] == "X" { // 경비병 있으면,
            checkFlag = true
            break
        }
    }
    
    if checkFlag == false {
        rowCount += 1
    }
    
}

for i in 0..<M {
    var checkFlag: Bool = false // 경비병 유무 체크.
    
    for j in 0..<N {
        if castle[j][i] == "X" { // 경비병 있으면,
            checkFlag = true
            break
        }
    }
    
    if checkFlag == false {
        colCount += 1
    }
}

print(max(rowCount, colCount))

백준 Swift 1340번

// MARK: - 1340번
import Foundation
var input = readLine()!.components(separatedBy: [",", " ", ":"])
input.remove(at: 2) // 빈 문자열 제거
let (month, day, year, hour, minute) = (input[0], Double(input[1])!, Int(input[2])!, Double(input[3])!, Double(input[4])!)

var isYoon: Bool = false // 윤년인지 아닌지
var fullDay: Double = 365 * 24 * 60 // 평년시, 365일

if (year % 400 == 0) || ((year % 4 == 0) && (year % 100 != 0)) { // 윤년 조건
    isYoon = true
    fullDay = 366 * 24 * 60 // 윤년시, 366일
}

let monthIndexArray: [String: Int] = ["January": 0, "February": 1, "March": 2, "April": 3, "May": 4, "June": 5, "July": 6, "August": 7, "September": 8, "October": 9, "November": 10, "December": 11] // 인덱스 연결
let monthYoonArray: [Double] = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] // 윤년은 2월29일까지
let monthArray: [Double] = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] // 평년

var answer: Double = 0.0 // 몇 퍼센트인지.
var daySum: Double = 0 // 해당 전 월까지의 일자 총합.

if isYoon { // 윤년 시,
    for i in 0..<monthIndexArray[month]! {
        daySum += monthYoonArray[i]
    }
    answer = (((daySum + day - 1) * 1440) + hour * 60 + minute) / fullDay * 100
}
else { // 윤년 아닐 시,
    for i in 0..<monthIndexArray[month]! {
        daySum += monthArray[i]
    }
    answer = (((daySum + day - 1) * 1440) + hour * 60 + minute) / fullDay * 100
}

print(answer)

DAY19 인증완료

DAY19 인증완료

스위프트 | "(최소)힙 구현"하기 (Swift5 | Heap - MinHeap)

개발자P — Thu, 10 Mar 2022 18:49:37 +0900

코테알고리즘 공부를 하던 중, 백준 1927번을 풀기 위해선 최소힙(MinHeap) 구현이 필요했습니다.

Swift엔 힙이 없습니다.

물론 큐, 덱, 순열, 조합 등등 다 없습니다...

최대 힙에 대해선 아래 링크에서 확인하실 수 있습니다.

https://developer-p.tistory.com/196

백준 Swift 최소 힙, 최대 힙, 절댓값 힙 (백준 Swift 1927번, 11279번, 11286번)

백준 Swift 힙(Heap) 세트 문제입니다. 절댓값 힙 문제는 총 3가지의 아이디어로 풀 수 있었습니다. (백준 11286번) (idea 1 : 단순 값 비교 / idea 2 : 튜플 사용 / idea 3 : 최소힙과 최대힙을 동시 사용) 최소

developer-p.tistory.com

https://developer-p.tistory.com/146

스위프트 | "스택, 큐, 덱 구현"하기 (Swift5 | Stack, Queue, Deque)

백준 1935번을 풀다가, 스위프트엔 스택 & 큐가 없다는 사실을 알게 되었습니다. (+ 물론 덱은 당연히 없었습니다..) 지난번 게시글과 똑같은 상황이죠? 네. 구현해야 합니다... (스택은 아닐지도~

developer-p.tistory.com

https://developer-p.tistory.com/145

스위프트 | "순열과 조합 구현"하기 (Swift5 | Permutation, Combination)

백준 10974번을 스위프트로 풀면서 난관에 봉착했습니다. 파이썬에는 간단한 순열 & 조합이 스위프트엔 없다는 것이죠. 스위프트를 공부한 지 얼마 되지 않은 상황에서, 파이썬에선 기본함수인

developer-p.tistory.com

최소 힙(MinHeap)

뭔가 구현이 어려워 보여 미루다가 설명이 잘 되어 있는 글을 보고 공부했습니다.

아래는 위 글의 코드(수정)이고, 부연 설명도 잘 되어 있으니 꼭 한 번 읽어보시길 추천드립니다.

매번 찾기엔 번거로워,

최소 힙과 관련된 문제가 나올 때 유용할만한 코드를 남겨둡니다.

(위 설명 글에 있는 코드 및 주석부분이 잘못된 게 있어 수정했습니다.)

최소 힙(MinHeap) 구현

(오류 수정됨.)

백준 1927번 반례 추가.

// MARK: - MinHeap
import Foundation

struct MinHeap<T: Comparable> {
    var heap: [T] = []
    
    var isEmpty: Bool {
        return heap.count <= 1 ? true : false
    }
    
    init() {}
    init(_ element: T) {
        heap.append(element) // 0번 index채우기 용
        heap.append(element) // 실제 Root Node 채움.
    }
    
    mutating func insert(_ element: T) {
        if heap.isEmpty {
            heap.append(element)
            heap.append(element)
            return
        }
        heap.append(element)
        
        func isMoveUp(_ insertIndex: Int) -> Bool {
            if insertIndex <= 1 { // Root Node일 때,
                return false
            }
            let parentIndex = insertIndex / 2
            return heap[insertIndex] < heap[parentIndex] ? true : false
        }
        
        var insertIndex = heap.count - 1
        while isMoveUp(insertIndex) {
            let parentIndex = insertIndex / 2
            heap.swapAt(insertIndex, parentIndex)
            insertIndex = parentIndex
        }
    }
    
    enum moveDownStatus { case left, right, none }
    
    mutating func pop() -> T? {
        if heap.count <= 1 {
            return nil
        }
        let returnData = heap[1]
        heap.swapAt(1, heap.count - 1)
        heap.removeLast()
        
        func moveDown(_ poppedIndex: Int) -> moveDownStatus {
            let leftChildIndex = poppedIndex * 2
            let rightChildIndex = leftChildIndex + 1
            
            // case1. 모든(왼쪽) 자식 노드가 없는 경우(완전이진트리는 왼쪽부터 채워지므로)
            if leftChildIndex >= heap.count {
                return .none
            }
            
            // case2. 왼쪽 자식 노드만 있는 경우
            if rightChildIndex >= heap.count {
                return heap[leftChildIndex] < heap[poppedIndex] ? .left : .none
            }
            
            // case3. 왼쪽&오른쪽 자식 노드 모두 있는 경우
            // case3-1. 자식들이 자신보다 모두 큰 경우(자신이 제일 작은 경우)
            if (heap[leftChildIndex] > heap[poppedIndex]) && (heap[rightChildIndex] > heap[poppedIndex]) {
                return .none
            }
            
            // case3-2. 자식들이 자신보다 모두 작은 경우(왼쪽과 오른쪽 자식 중, 더 작은 자식을 선별)
            if (heap[leftChildIndex] < heap[poppedIndex]) && (heap[rightChildIndex] < heap[poppedIndex]) {
                return heap[leftChildIndex] < heap[rightChildIndex] ? .left : .right
            }
            
            // case3-3. 왼쪽과 오른쪽 자식 중, 한 자식만 자신보다 작은 경우
            if (heap[leftChildIndex] < heap[poppedIndex]) || (heap[rightChildIndex] < heap[poppedIndex]) {
                return heap[leftChildIndex] < heap[rightChildIndex] ? .left : .right
            }
            
            return .none
        }
        
        var poppedIndex = 1
        while true {
            switch moveDown(poppedIndex) {
            case .none:
                return returnData
            case .left:
                let leftChildIndex = poppedIndex * 2
                heap.swapAt(poppedIndex, leftChildIndex)
                poppedIndex = leftChildIndex
            case .right:
                let rightChildIndex = (poppedIndex * 2) + 1
                heap.swapAt(poppedIndex, rightChildIndex)
                poppedIndex = rightChildIndex
            }
        }
    }
}

코드 사용

// var myMinHeap: MinHeap<Int> = MinHeap() // 값 없이 초기화
var minHeap = MinHeap.init(30) // 값 있게 초기화

minHeap.insert(10)
print(minHeap)

minHeap.insert(7)
print(minHeap)

minHeap.insert(8)
print(minHeap)

minHeap.insert(3)
print(minHeap)

print(minHeap.pop()!)

예시 출력 결과

아래 더보기는, 수정 전 코드입니다.

(오류 수정 전) MinHeap 코드

반례

(백준 최소힙문제 : https://www.acmicpc.net/problem/1927)
(반례 관련 테스트케이스 추가 요청 : https://www.acmicpc.net/board/view/86132)

<안 되는 반례>
11
2
2
3
3
1
0
0
0
0
0
0

// MARK: - MinHeap
import Foundation

struct MinHeap<T: Comparable> {
    var heap: [T] = []
    
    var isEmpty: Bool {
        return heap.count <= 1 ? true : false
    }
    
    init() {}
    init(_ element: T) {
        heap.append(element) // 0번 index채우기 용
        heap.append(element) // 실제 Root Node 채움.
    }
    
    mutating func insert(_ element: T) {
        if heap.isEmpty {
            heap.append(element)
            heap.append(element)
            return
        }
        heap.append(element)
        
        func isMoveUp(_ insertIndex: Int) -> Bool {
            if insertIndex <= 1 { // Root Node일 때,
                return false
            }
            let parentIndex = insertIndex / 2
            return heap[insertIndex] < heap[parentIndex] ? true : false
        }
        
        var insertIndex = heap.count - 1
        while isMoveUp(insertIndex) {
            let parentIndex = insertIndex / 2
            heap.swapAt(insertIndex, parentIndex)
            insertIndex = parentIndex
        }
    }
    
    enum moveDownStatus { case left, right, none }
    
    mutating func pop() -> T? {
        if heap.count <= 1 {
            return nil
        }
        let returnData = heap[1]
        heap.swapAt(1, heap.count - 1)
        heap.removeLast()
        
        func moveDown(_ poppedIndex: Int) -> moveDownStatus {
            let leftChildIndex = poppedIndex * 2
            let rightChildIndex = leftChildIndex + 1
            
            // case1. 모든(왼쪽) 자식 노드가 없는 경우(완전이진트리는 왼쪽부터 채워지므로)
            if leftChildIndex >= heap.count {
                return .none
            }
            
            // case2. 왼쪽 자식 노드만 있는 경우
            if rightChildIndex >= heap.count {
                return heap[leftChildIndex] < heap[poppedIndex] ? .left : .none
            }
            
            // case3. 왼쪽&오른쪽 자식 노드 모두 있는 경우
            // case3-1. 자식들이 자신보다 모두 큰 경우
            if (heap[leftChildIndex] > heap[poppedIndex]) && (heap[rightChildIndex] > heap[poppedIndex]) {
                return .none
            }
            
            // case3-2. 자식들이 자신보다 모두 작은 경우(왼쪽과 오른쪽 자식 중, 더 작은 자식을 선별)
            if (heap[leftChildIndex] < heap[poppedIndex]) && (heap[rightChildIndex] < heap[poppedIndex]) {
                return heap[leftChildIndex] < heap[rightChildIndex] ? .left : .right
            }
            
            // case3-3. 왼쪽과 오른쪽 자식 중, 한 자식만 자신보다 작은 경우
            return heap[leftChildIndex] < heap[poppedIndex] ? .left : .right
            
        }
        
        var poppedIndex = 1
        while true {
            switch moveDown(poppedIndex) {
            case .none:
                return returnData
            case .left:
                let leftChildIndex = poppedIndex * 2
                heap.swapAt(poppedIndex, leftChildIndex)
                poppedIndex = leftChildIndex
            case .right:
                let rightChildIndex = (poppedIndex * 2) + 1
                heap.swapAt(poppedIndex, rightChildIndex)
                poppedIndex = rightChildIndex
            }
        }
    }
}

코드 출처 : https://github.com/sossam/SwiftHeap/blob/main/Heap/MinHeap.swift

참고한 자료 : https://babbab2.tistory.com/109 | https://icksw.tistory.com/216 | https://medium.com/devslopes-blog/swift-data-structures-heap-e3fbbdaa3129 | https://fomaios.tistory.com/entry/Data-Structure-%ED%9E%99Heap%EC%9D%B4%EB%9E%80-feat-Swift

코드 중 이해가 안 되는 부분이 있거나, 잘못된 부분이 있다면 편하게 댓글 부탁드립니다.

[22일 Basic 챌린지 참여] 알고리즘 DAY18

개발자P — Thu, 10 Mar 2022 14:32:48 +0900

오늘은 참여한지 18일차 입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

Day 18

220310 공부 일지 : 3845번 문제가 어려워 결국 못풀었다. 다음에 다시 도전해야겠다.

220310 공부 일지

백준 Swift 2309번

// MARK: - 2309번
var heights: [Int] = []

for _ in 0..<9 {
    heights.append(Int(readLine()!)!)
}
heights.sort(by: <)

func combi(_ nums: [Int], _ targetNum: Int) -> [[Int]] {
    var results: [[Int]] = []
    
    func combination(_ index: Int, _ nowCombi: [Int]) {
        if nowCombi.count == targetNum {
            results.append(nowCombi)
            return
        }
        for i in index..<nums.count {
            combination(i + 1, nowCombi + [nums[i]])
        }
    }
    combination(0, [])
    return results
}

var answerHeights: [Int] = [] // 7명 난쟁이 - 키 합 100

var tempHeights = combi(heights, 7)

for arr in tempHeights {
    if arr.reduce(0, +) == 100 {
        answerHeights = arr
        break
    }
}

for height in answerHeights {
    print(height)
}

백준 Swift 5576번

// MARK: - 5576번
var W: [Int] = []
var K: [Int] = []

for _ in 0..<10 {
    W.append(Int(readLine()!)!)
}
for _ in 0..<10 {
    K.append(Int(readLine()!)!)
}

W.sort(by: >)
K.sort(by: >)

let wSum = W[0] + W[1] + W[2]
let kSum = K[0] + K[1] + K[2]

print(wSum, kSum)

백준 Swift 9076번

// MARK: - 9076번
let T = Int(readLine()!)!

for _ in 0..<T {
    var score = readLine()!.split(separator: " ").map{Int(String($0))!}.sorted(by: <)
    score.removeFirst()
    score.removeLast()
    
    if score.last! - score.first! >= 4 {
        print("KIN")
    }
    else {
        print(score.reduce(0, +))
    }
    
}

백준 Swift 2750번

// MARK: - 2750번
let N = Int(readLine()!)!
var nums: [Int] = []

for _ in 0..<N {
    nums.append(Int(readLine()!)!)
}

nums.sort(by: <)

for num in nums {
    print(num)
}

DAY18 인증완료

DAY18 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY17

개발자P — Wed, 9 Mar 2022 16:47:11 +0900

오늘은 참여한지 17일차 입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

Day 17

220309 공부 일지 : 꾸준히 문제 풀어서, 22일까지 한 번도 놓치지 않고 마무리 잘 하고 싶다!

220309 공부 일지

백준 Swift 1100번

// MARK: - 1100번
var chess: [[String]] = [] // 8x8 체스판

for _ in 0..<8 {
    let input = readLine()!.map{String($0)}
    chess.append(input)
}

var count: Int = 0 // 하얀 칸 위에 말 개수

for i in 0..<8 {
    for j in 0..<8 {
        
        if i % 2 == 0 { // 짝수 행일 땐,
            if j % 2 == 0 { // 짝수 열들이 하얀칸.
                if chess[i][j] == "F" {
                    count += 1
                }
            }
        }
        else { // 홀수 행일 땐,
            if j % 2 == 1 { // 홀수 열들이 하얀칸.
                if chess[i][j] == "F" {
                    count += 1
                }
            }
        }
        
    }
}

print(count)

백준 Swift 1152번

// MARK: - 1152번
let input = readLine()!.split(separator: " ").map{String($0)}
print(input.count)

백준 Swift 1159번

// MARK: - 1159번
let N = Int(readLine()!)!
var alphabet = Array(repeating: 0, count: 26) // a~z 개수

for _ in 0..<N {
    let input = readLine()!.map{String($0)}
    let index = Int(Character(input.first!).asciiValue! - Character("a").asciiValue!)
    
    alphabet[index] += 1
}

let check = alphabet.filter{$0 >= 5}

if check.isEmpty {
    print("PREDAJA")
}
else {
    for (index, count) in alphabet.enumerated() {
        if count >= 5 {
            let answer = Character(UnicodeScalar(97 + index)!) // a의 아스키코드값 + index
            print(answer, terminator: "")
        }
    }
}

백준 Swift 1225번(속도 느림)

// MARK: - 1225번(속도 느림)
let input = readLine()!.split(separator: " ").map{String($0)}
let (A, B) = (input[0].map{String($0)}, input[1].map{String($0)})

var answer: Int = 0

for ch1 in A {
    for ch2 in B {
        answer += Int(ch1)! * Int(ch2)!
    }
}

print(answer)

백준 Swift 1225번 (다시1)

// MARK: - 1225번 다시(1)
let input = readLine()!.split(separator: " ").map{String($0)}
let (A, B) = (input[0], input[1])

var first: Int = 0
var second: Int = 0

for ch1 in A {
    first += Int(String(ch1))!
}

for ch2 in B {
    second += Int(String(ch2))!
}

print(first * second)

백준 Swift 1225번(다시 2)

// MARK: - 1225번 다시(2)
let input = readLine()!.split(separator: " ").map{String($0)}
let (A, B) = (input[0].map{Int(String($0))!}, input[1].map{Int(String($0))!})

let firstSum = A.reduce(0){ (num1: Int, num2: Int) -> Int in
    return num1 + num2
}

let secondSum = B.reduce(0, +)

print(firstSum * secondSum)

백준 Swift 1264번

// MARK: - 1264번
while true {
    let input = readLine()!
    if input == "#" {
        break
    }
    
    let str = input.lowercased().map{String($0)}
    
    let count = str.filter{$0 == "a" || $0 == "e" || $0 == "i" || $0 == "o" || $0 == "u"}.count
    print(count)
}

백준 Swift 1371번

// MARK: - 1371번
var alphabet = Array(repeating: 0, count: 26) // 알파벳 카운팅

while let input = readLine() {
    let str = input.split(separator: " ").map{String($0)}

    for arr in str {
        for ch in arr {
            let index: Int = Int(Character(String(ch)).asciiValue!) - Int(Character("a").asciiValue!)
//            let index2 = Int(UnicodeScalar((String(ch)))!.value) - Int(UnicodeScalar(("a")).value) // 방법 2가지
            alphabet[index] += 1
        }
    }

}

var answerIndexArray: [Int] = []
let maxValue = alphabet.max()!
for (index, num) in alphabet.enumerated() {
    if num == maxValue {
        answerIndexArray.append(index)
    }
}

for i in answerIndexArray {
    let ch = UnicodeScalar(97 + i)!
    print(ch, terminator: "")
}

DAY17 인증완료

DAY17 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY16

개발자P — Tue, 8 Mar 2022 17:42:54 +0900

오늘은 못 풀었던 문제를 다시 푸는 날 입니다.

하지만 특별히 못 풀었던 문제는 없어서, 임의로 약 15문제를 푸려고 합니다. (실버2 ~ 브론즈3 예상)

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

Day 16

220308 공부 일지 : 오늘 꽤 많은 문제를 풀었다.
예전에 못 풀었던 문제도 해결해서 좋았고, 예전의 코드에 비해 개선된 점도 있어서 좋다.

220308 공부 일지

백준 Swift 3009번

// MARK: - 3009번
var input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (x1, y1) = (input[0], input[1])
input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (x2, y2) = (input[0], input[1])
input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (x3, y3) = (input[0], input[1])

var (x4, y4) = (0, 0)

// x4구하는 부분
if x1 == x2 {
    x4 = x3
}
else if x1 == x3 {
    x4 = x2
}
else if x2 == x3 {
    x4 = x1
}
// y4구하는 부분
if y1 == y2 {
    y4 = y3
}
else if y1 == y3 {
    y4 = y2
}
else if y2 == y3 {
    y4 = y1
}

print(x4, y4)

백준 Swift 4153번

// MARK: - 4153번
import Foundation
while true {
    let input = readLine()!.split(separator: " ").map{Double(String($0))!}
    let triangleArray = input.sorted(by: <) // 가장 긴 변이 c
    
    let (a, b, c) = (triangleArray[0], triangleArray[1], triangleArray[2])
    
    if a == 0 && b == 0 && c == 0 {
        break
    }
    
    if pow(c, 2.0) == (pow(a, 2.0) + pow(b, 2.0)) {
        print("right")
    }
    else {
        print("wrong")
    }
    
}

백준 Swift 3053번

// MARK: - 3053번
import Foundation
let R = Double(readLine()!)!
let uclid: Double = Double.pi * R * R
let taxi = 2 * R * R

print(String(format: "%.6f", uclid))
print(String(format: "%.6f", taxi))

백준 Swift 1002번

백준 Swift 1002번 Case 분류

// MARK: - 1002번
import Foundation
let T = Int(readLine()!)!

for _ in 0..<T {
    let input = readLine()!.split(separator: " ").map{Double(String($0))!}
    var (x1, y1, r1) = (input[0], input[1], input[2])
    var (x2, y2, r2) = (input[3], input[4], input[5])
    var answer: Int = 0
    
    let d = sqrt(pow(x2 - x1, 2.0) + pow(y2 - y1, 2.0))
    
    if d > (r1 + r2) { // Case 1
        answer = 0
    }
    else if d == (r1 + r2) { // Case 2
        answer = 1
    }
    
    else {
        if r1 < r2 { // 가정이 r1>=r2이기 때문에, 맞춰주기 위해서 swap.
            swap(&r1, &r2)
        }
        
        if ((r1 - r2) < d) && (d < (r1 + r2)) { // Case 3
            answer = 2
        }
        else if d != 0 && d == (r1 - r2) { // Case 4
            answer = 1
        }
        else if d != 0 && d < (r1 - r2) { // Case 5
            answer = 0
        }
        else if r1 == r2 && d == 0 { // Case 6
            answer = -1
        }
        else if r1 != r2 && d == 0 { // Case 7
            answer = 0
        }
    }
        
    print(answer)
}

백준 Swift 10872번

// MARK: - 10872번
let N = Int(readLine()!)!
var answer: Int = 1

if N != 0 {
    for i in 1...N {
        answer *= i
    }
}

print(answer)

백준 Swift 10989번

// MARK: - 10989번 (참고 : https://blog.naver.com/PostView.nhn?blogId=gustn3964&logNo=222257475333)
import Foundation

// 라이노님의 FileIO 클래스
final class FileIO {
    private var buffer:[UInt8]
    private var index: Int

    init(fileHandle: FileHandle = FileHandle.standardInput) {
        buffer = Array(fileHandle.readDataToEndOfFile())+[UInt8(0)] // 인덱스 범위 넘어가는 것 방지
        index = 0
    }

    @inline(__always) private func read() -> UInt8 {
        defer { index += 1 }

        return buffer.withUnsafeBufferPointer { $0[index] }
    }

    @inline(__always) func readInt() -> Int {
        var sum = 0
        var now = read()
        var isPositive = true

        while now == 10
            || now == 32 { now = read() } // 공백과 줄바꿈 무시
        if now == 45{ isPositive.toggle(); now = read() } // 음수 처리
        while now >= 48, now <= 57 {
            sum = sum * 10 + Int(now-48)
            now = read()
        }

        return sum * (isPositive ? 1:-1)
    }

    @inline(__always) func readString() -> String {
        var str = ""
        var now = read()

        while now == 10
            || now == 32 { now = read() } // 공백과 줄바꿈 무시

        while now != 10
            && now != 32 && now != 0 {
                str += String(bytes: [now], encoding: .ascii)!
                now = read()
        }

        return str
    }
}

let file = FileIO()

let N = file.readInt()
var dp = Array(repeating: 0, count: 10001)
for _ in 0..<N {
    let q = file.readInt()
    dp[q] += 1
}

var answer = ""
for i in 1...10000 {
    answer += String(repeating: "\(i)\n", count: dp[i])
}
print(answer)

백준 Swift 2798번

조합(Combination) 구현 : https://developer-p.tistory.com/145

스위프트 | "순열과 조합 구현"하기 (Swift5 | Permutation, Combination)

developer-p.tistory.com

// MARK: - 2798번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])

let cards = readLine()!.split(separator: " ").map{Int(String($0))!}.sorted(by: <)

func combi(_ nums: [Int], _ targetNum: Int) -> [[Int]] {
    var result = [[Int]]()
    
    func combination(_ index: Int, _ nowCombi: [Int]) {
        if nowCombi.count == targetNum {
            result.append(nowCombi)
            return
        }
        for i in index..<nums.count {
            combination(i + 1, nowCombi + [nums[i]])
        }
    }
    
    combination(0, [])
    
    return result
}

// 3"H"N(3+N-1"C"N) <= M
var sumArray: [Int] = []
for numArray in combi(cards, 3) {
    let sum = numArray.reduce(0, +)
    if sum <= M {
        sumArray.append(sum)
    }
}

print(sumArray.max()!)

백준 Swift 2231번

// MARK: - 2231번
let N = Int(readLine()!)!
var answerArray: [Int] = []

for num in stride(from: N-1, to: 0, by: -1) {
    let numStr = String(num).map{String($0)}
    let numArray = numStr.map{Int(String($0))!}
    
    let sum = num + numArray.reduce(0, +)
    
    if sum == N {
        answerArray.append(num)
    }
    
}

if answerArray.isEmpty {
    print("0")
}
else {
    print(answerArray.min()!)
}

백준 Swift 7568번

// MARK: - 7568번
let N = Int(readLine()!)!
var person: [[Int]] = []
var rank = Array(repeating: 0, count: N) // 순위 배열

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    
    person.append(input)
    
}

for i in 0..<N {
    var rankCount: Int = 0
    
    for j in 0..<N {
        if (person[i].first! < person[j].first!) { // 몸무게
            if (person[i].last! < person[j].last!) { // 키까지 작으면 랭킹 뒤로 밀림.
                rankCount += 1 // 나보다 큰 애가 몇명인지 카운트.
            }
        }
    }
    
    rank[i] = rankCount + 1
}


for num in rank {
    print(num, terminator: " ")
}

백준 Swift 1436번

// MARK: - 1436번
let N = Int(readLine()!)!
var num: Int = 665
var count: Int = 0

while true {
    let numArray = String(num).map{Int(String($0))!}
    
    for i in 0...numArray.count-3 {
        if numArray[i] == 6 {
            if numArray[i+1] == 6 {
                if numArray[i+2] == 6 {
                    count += 1
                    break
                }
            }
        }
    }
    
    if count == N {
        break
    }
    
    num += 1
}

print(num)

백준 Swift 2750번

// MARK: - 2750번
let N = Int(readLine()!)!
var numArray: [Int] = []

for _ in 0..<N {
    numArray.append(Int(readLine()!)!)
}

numArray.sort(by: <)

for num in numArray {
    print(num)
}

백준 Swift 2751번

// MARK: - 2751번
let N = Int(readLine()!)!
var numArray: [Int] = []

for _ in 0..<N {
    numArray.append(Int(readLine()!)!)
}

numArray.sort(by: <)

for num in numArray {
    print(num)
}

백준 Swift 10974번

// MARK: - 10974번
let N = Int(readLine()!)!

func permute(_ nums: [Int], _ targetNum: Int) -> [[Int]] { // 순열
    var results = [[Int]]()
    var visited = Array(repeating: false, count: nums.count)
    
    func permutation(_ nowPermute: [Int]) {
        if nowPermute.count == targetNum {
            results.append(nowPermute)
            return
        }
        for i in 0..<nums.count {
            if visited[i] == false {
                visited[i] = true
                permutation(nowPermute + [nums[i]])
                visited[i] = false
            }
        }
    }
    permutation([])
    return results
}

//func combi(_ nums: [Int], _ targetNum: Int) -> [[Int]] { // 조합
//    var results = [[Int]]()
//
//    func combination(_ index: Int, _ nowCombi: [Int]) {
//        if nowCombi.count == targetNum {
//            results.append(nowCombi)
//            return
//        }
//        for i in index..<nums.count {
//            combination(i + 1, nowCombi + [nums[i]])
//        }
//    }
//
//    combination(0, [])
//    return results
//}

var nums: [Int] = []
for num in 1...N {
    nums.append(num)
}

for numArray in permute(nums, nums.count) {
    for num in numArray {
        print(num, terminator: " ")
    }
    print()
}

백준 Swift 2503번

// MARK: - 2503번(참고 : https://kongpowder.tistory.com/50)
let N = Int(readLine()!)!

func permute(_ nums: [String], _ targetNum: Int) -> [[String]] {
    var results = [[String]]()
    var visited = Array(repeating: false, count: nums.count)
    
    func permutation(_ nowPermute: [String]) {
        if nowPermute.count == targetNum {
            results.append(nowPermute)
            return
        }
        for i in 0..<nums.count {
            if visited[i] == false {
                visited[i] = true
                permutation(nowPermute + [nums[i]])
                visited[i] = false
            }
        }
    }
    permutation([])
    return results
}

var nums = permute(["1", "2", "3", "4", "5", "6", "7", "8", "9"], 3)
var deleteNums: [[String]] = []
//nums.remove(at: nums.firstIndex(of: ["1", "2", "3"])!)

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (num, strike, ball) = (String(input[0]).map{String($0)}, input[1], input[2])

    for i in 0..<nums.count {
        var strikeCount: Int = 0
        var ballCount: Int = 0

        for j in 0..<3 {
            if nums[i][j] == num[j] {
                strikeCount += 1
            }
            else if nums[i].contains(num[j]) {
                ballCount += 1
            }
        }

        if (strike != strikeCount) || (ball != ballCount) {
            deleteNums.append(nums[i])
        }
        
    }

}

deleteNums = Array(Set(deleteNums)) // 지울 배열들의 중복 제거

for delete in deleteNums {
    nums.remove(at: nums.firstIndex(of: delete)!)
}

print(nums.count)

백준 Swift 1182번

// MARK: - 1182번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, S) = (input[0], input[1])

let numArray = readLine()!.split(separator: " ").map{Int(String($0))!}

func combi(_ nums: [Int], _ targetNum: Int) -> [[Int]] {
    var results = [[Int]]()
    
    func combination(_ index: Int, _ nowCombi: [Int]) {
        if nowCombi.count == targetNum {
            results.append(nowCombi)
            return
        }
        for i in index..<nums.count {
            combination(i + 1, nowCombi + [nums[i]])
        }
    }
    
    combination(0, [])
    return results
}

var sumArray: [Int] = []
for i in 1...N {
    
    for arr in combi(numArray, i) {
        sumArray.append(arr.reduce(0, +))
    }
    
}

let answer = sumArray.filter{$0 == S}.count
print(answer)

DAY16 인증완료

DAY16 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY15

개발자P — Mon, 7 Mar 2022 14:43:31 +0900

오늘은 참여한지 15일차 입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

Day 15

220307 공부 일지 : 그리디 알고리즘 문제를 더 풀어봐야겠다.

220307 공부 일지

백준 Swift 8710번

// MARK: - 8710번
import Foundation
let input = readLine()!.split(separator: " ").map{Double(String($0))!}
let(k, w, m) = (input[0], input[1], input[2])
var count: Int = Int(ceil((w - k) / m))

print(count)

백준 Swift 14471번

// MARK: - 14471번
let JOI = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (JOI[0], JOI[1]) // 2N개의 칸, M장의 카드

var wins: [Int] = [] // 당첨 도장 모음
var loses: [Int] = [] // 꽝 도장 모음
var answer: Int = 0

for _ in 0..<M {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    wins.append(input[0])
    loses.append(input[1])
}

wins.sort(by: >) // 내림차순으로 정렬해야 최솟값을 구할 수 있음.
var count = wins.filter{$0 >= N}.count // 기존 입력받은 것들 중, 돈을 내지 않아도 이미 상품수령조건을 만족하는 카드들의 개수.

if count >= M - 1 { // 이미 M-1개 이상의 경품을 얻을 수 있으면,
    answer = 0
}
else {
    for i in count..<wins.count {
        answer += N - wins[i] // 경품 1개 더 얻기 위해 필요한 금액.
        count += 1 // 경품 1개 추가
        
        if count >= M - 1 {
            break
        }
    }
}

print(answer)

백준 Swift 14487번

// MARK: - 14487번
let n = Int(readLine()!)!
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let answer = input.reduce(0, +) - input.max()!

print(answer)

백준 Swift 14659번

// MARK: - 14659번
let N = Int(readLine()!)!
let mountain = readLine()!.split(separator: " ").map{Int(String($0))!}
var killArray: [Int] = []

for i in 0..<N {
    var kill: Int = 0 // 킬 수
    let standard: Int = mountain[i] // 기준 봉우리

    if i == N - 1 { // 마지막 봉우리일 땐,
        killArray.append(0) // 0킬
        break
    }
    else {
        for j in i+1..<N {
            if mountain[j] > standard { // (기준 봉우리보다) 다음 봉우리가 더 높으면 끝.
                break
            }
            kill += 1 // 다음 봉우리가 더 높지 않으면,
        }
        killArray.append(kill)
    }
}

print(killArray.max()!)

백준 Swift 16756번

// MARK: - 16756번
let N = Int(readLine()!)!
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
var minArray: [Int] = []

for i in 0..<N-1 {
    minArray.append(abs(input[i + 1] - input[i]))
}

print(minArray.min()!)

DAY15 인증완료

DAY15 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY14

개발자P — Sun, 6 Mar 2022 15:36:28 +0900

오늘은 참여한지 14일차 입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

Day 14

220306 공부 일지 : 그리디 유형 문제가 확실히 시간이 좀 더 걸리는 것 같다. 브론즈2 문제들도 뿌시자!

220306 공부 일지

백준 Swift 1434번

// MARK: - 1434번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])

let A = readLine()!.split(separator: " ").map{Int(String($0))!}
let B = readLine()!.split(separator: " ").map{Int(String($0))!}

let aSum = A.reduce(0, +)
let bSum = B.reduce(0, +)

print(aSum - bSum)

백준 Swift 2810번

// MARK: - 2810번
import Foundation

let N = Int(readLine()!)!
var seat = readLine()!.replacingOccurrences(of: "LL", with: "L")

if N <= seat.count + 1 {
    print(N)
}
else {
    print(seat.count + 1)
}

백준 Swift 2864번

// MARK: - 2864번
import Foundation
let input = readLine()!.split(separator: " ").map{String($0)}
let maxArray = input.map{(num: String) -> String in
    let maxNum = num.replacingOccurrences(of: "5", with: "6")
    
    return maxNum
}

let minArray = input.map{(num: String) -> String in
    let minNum = num.replacingOccurrences(of: "6", with: "5")
    
    return minNum
}

let numMaxArray = maxArray.map{Int($0)!}
let numMinArray = minArray.map{Int($0)!}

let answerMax = numMaxArray.reduce(0, +)
let answerMin = numMinArray.reduce(0, +)

print(answerMin, answerMax)

백준 Swift 2930번

// MARK: - 2930번
let R = Int(readLine()!)!
let sanguen = Array(readLine()!).map{String($0)}
let N = Int(readLine()!)!
var friends: [[String]] = Array(repeating: Array(repeating: "", count: R), count: N) // N행 R열

for i in 0..<N {
    var j: Int = 0
    let input = readLine()!.map{String($0)}
    
    for ch in input {
        friends[i][j] = ch
        j += 1
    }
    
}

var score: Int = 0

for i in 0..<N { // 가로로 루프 돎.
    for j in 0..<R {
        if (sanguen[j] == "S" && friends[i][j] == "P") || (sanguen[j] == "P" && friends[i][j] == "R") || (sanguen[j] == "R" && friends[i][j] == "S") { // 상근이가 이길 때,
            score += 2
        }
        else if (sanguen[j] == friends[i][j]) { // 비길 때,
            score += 1
        }
        else { // 질 때, (이 부분은 없어도 됨.)
            score += 0
        }
    }
}

print(score)

var maxScore: Int = 0

for i in 0..<R { // 세로로 루프 돎.
    var counting = [0, 0, 0] // S(가위), P(보), R(바위)
    for j in 0..<N {
        if friends[j][i] == "S" {
            counting[0] += 1
        }
        else if friends[j][i] == "P" {
            counting[1] += 1
        }
        else if friends[j][i] == "R" {
            counting[2] += 1
        }
    }
    
    var scoreArray: [Int] = []
    // 상근이가 S(가위)를 냈다면,
    scoreArray.append((counting[0] * 1) + (counting[1] * 2) + (counting[2] * 0))
    // 상근이가 P(보)를 냈다면,
    scoreArray.append((counting[0] * 0) + (counting[1] * 1) + (counting[2] * 2))
    // 상근이가 R(바위)를 냈다면,
    scoreArray.append((counting[0] * 2) + (counting[1] * 0) + (counting[2] * 1))
    
    maxScore += scoreArray.max()!
}

print(maxScore)

백준 Swift 5585번

// MARK: - 5585번
let N = 1000 - Int(readLine()!)!
var coinArray = Array(repeating: 0, count: 6) // 500엔, 100엔, 50엔, 10엔, 5엔, 1엔

coinArray[0] = N / 500
coinArray[1] = (N % 500) / 100
coinArray[2] = ((N % 500) % 100) / 50
coinArray[3] = (((N % 500) % 100) % 50) / 10
coinArray[4] = ((((N % 500) % 100) % 50) % 10) / 5
coinArray[5] = (((((N % 500) % 100) % 50) % 10) % 5) / 1

let sum = coinArray.reduce(0, +)

print(sum)

DAY14 인증완료

DAY14 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY13

개발자P — Sat, 5 Mar 2022 14:00:13 +0900

오늘은 참여한지 13일차 입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

Day 13

220305 공부 일지 : reduce나 filter 등 처음엔 어색했던 것들이, 자주 쓰다 보니 이젠 익숙해졌다.

220305 공부 일지

백준 Swift 2720번

// MARK: - 2720번
let T = Int(readLine()!)!

for _ in 0..<T {
    let input = Int(readLine()!)!
    
    let quarter = input / 25
    let dime = (input % 25) / 10
    let nickel = ((input % 25) % 10) / 5
    let penny = (((input % 25) % 10) % 5) / 1
    
    print(quarter, dime, nickel, penny)
    
}

백준 Swift 10162번

// MARK: - 10162번
let T = Int(readLine()!)!

if T % 10 != 0 {
    print("-1")
}
else {
    let A = T / 300
    let B = (T % 300) / 60
    let C = ((T % 300) % 60) / 10
    
    print(A, B, C)
    
}

백준 Swift 11034번(1)

// MARK: - 11034번(1)
while let input = readLine() {
    
    let numArray = input.split(separator: " ").map{Int(String($0))!}
    
    let (A, B, C) = (numArray[0], numArray[1], numArray[2])
    var count: Int = 0
    
    if B - A > C - B { // 오른쪽에서 왼쪽으로 점프 시,
        count = B - A - 1
    }
    else if B - A <= C - B { // 왼쪽에서 오른쪽으로 점프 시,
        count = C - B - 1
    }

    print(count)
    
}

백준 Swift 11034번(2)

// MARK: - 11034번(2)
while true {
    let input = readLine()
    
    if input == nil {
        break
    }
    
    let numArray = input!.split(separator: " ").map{Int(String($0))!}
    
    let (A, B, C) = (numArray[0], numArray[1], numArray[2])
    var count: Int = 0
    
    if B - A > C - B { // 오른쪽에서 왼쪽으로 점프 시,
        count = B - A - 1
    }
    else if B - A <= C - B { // 왼쪽에서 오른쪽으로 점프 시,
        count = C - B - 1
    }

    print(count)
        
}

백준 Swift 14720번

// MARK: - 14720번
let N = Int(readLine()!)!
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let milk = [0, 1, 2] // 딸기우유, 초코우유, 바나나우유
var j: Int = 0
var count: Int = 0


for i in 0..<N {
    if input[i] == milk[j] {
        if j == 2 { // milk의 끝에 도달했으면,
            j = 0 // 첫행으로 이동.
        }
        else { // milk의 끝이 아니면,
            j += 1 // 다음행으로 이동.
        }
        count += 1
    }
    
}

print(count)

백준 Swift 21420번

// MARK: - 21420번
let N = Int(readLine()!)!
var coinArray: [Int] = []
var countNum0 = 0 // 뒷면 개수
var countNum1 = 0 // 앞면 개수

for _ in 0..<N {
    coinArray.append(Int(readLine()!)!)
}

countNum0 = coinArray.filter{$0 == 0}.count
countNum1 = coinArray.filter{$0 == 1}.count

print(min(countNum0, countNum1))

DAY13 인증완료

DAY13 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY12

개발자P — Fri, 4 Mar 2022 14:00:33 +0900

오늘은 참여한지 12일차 입니다. 오늘의 문제들은 모두 별찍기 관련된 문제입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

Day 12

220304 공부 일지 : 별찍기문제는 오랜만인데, for문을 익히기에 좋았다.

220304 공부 일지

백준 Swift 2438번

// MARK: - 2438번
let N = Int(readLine()!)!

for i in 0..<N {
    for _ in 0...i {
        print("*", terminator: "")
    }
    print()
}

백준 Swift 2439번

// MARK: - 2439번
let N = Int(readLine()!)!

for i in 0..<N {
    
    for _ in stride(from: N-i, to: 1, by: -1) {
        print(" ", terminator: "")
    }
    
    for _ in 0...i {
        print("*", terminator: "")
    }
    
    print()
}

백준 Swift 2440번

// MARK: - 2440번
let N = Int(readLine()!)!

for i in 0..<N {
    var answer = ""
    for _ in stride(from: N, to: i, by: -1) {
        answer += "*"
    }

    print(answer)
}

백준 Swift 2441번

// MARK: - 2441번
let N = Int(readLine()!)!

for i in 0..<N {
    var answer = ""
    
    for _ in 0..<i {
        answer += " "
    }
    
    for _ in stride(from: N, to: i, by: -1) {
        answer += "*"
    }
    
    print(answer)
}

백준 Swift 2442번

// MARK: - 2442번
let N = Int(readLine()!)!

for i in 0..<N {
    var answer = ""
    
    for _ in stride(from: N - 1, to: i, by: -1) {
        answer += " "
    }
    
    for _ in 0..<(2 * i + 1) {
        answer += "*"
    }
    print(answer)
}

백준 Swift 2443번

// MARK: - 2443번
let N = Int(readLine()!)!

for i in 0..<N {
    var answer = ""
    
    for _ in 0..<i {
        answer += " "
    }
    
    for _ in 0..<(2 * N) - (2*i + 1) {
        answer += "*"
    }
    
    print(answer)
}

백준 Swift 2444번

// MARK: - 2444번
let N = Int(readLine()!)!

for i in 0..<N { // 위쪽 5칸
    var answer = ""
    
    for _ in stride(from: N-i-1, to: 0, by: -1) {
        answer += " "
    }
    
    for _ in 0..<2 * i + 1 {
        answer += "*"
    }
    
    print(answer)
}

for i in 0..<N-1 { // 아래쪽 4칸
    var temp = ""
    
    for _ in 0...i {
        temp += " "
    }
    
    for _ in stride(from: 2*(N-1)-2*i-1, to: 0, by: -1) {
        temp += "*"
    }
    
    print(temp)
}

백준 Swift 2445번

// MARK: - 2445번
let N = Int(readLine()!)!

for i in 0..<N { // 윗쪽 5줄
    var answer = ""
    
    for _ in 0...i {
        answer += "*"
    }
    
    for _ in 0..<2*(N-i-1) {
        answer += " "
    }
    
    for _ in 0...i {
        answer += "*"
    }

    print(answer)
}

for i in 0..<N-1 { // 아래쪽 4줄
    var temp = ""
    
    for _ in 0..<N-i-1 {
        temp += "*"
    }
    
    for _ in 0..<2*(i+1) {
        temp += " "
    }
    
    for _ in 0..<N-i-1 {
        temp += "*"
    }
    
    print(temp)
}

백준 Swift 2446번

// MARK: - 2446번
let N = Int(readLine()!)!

for i in 0..<N { // 위쪽 5줄
    var answer = ""
    
    for _ in 0..<i {
        answer += " "
    }
    
    for _ in 0..<2*(N-i)-1 {
        answer += "*"
    }
    
    print(answer)
}

for i in 0..<N-1 { // 아래쪽 4줄
    var answer = ""
    
    for _ in stride(from: N-2, to: i, by: -1) {
        answer += " "
    }
    
    for _ in 0..<2 * (i + 1) + 1 {
        answer += "*"
    }
    
    print(answer)
}

DAY12 인증완료

DAY12 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY11

개발자P — Thu, 3 Mar 2022 14:00:37 +0900

오늘은 참여한지 11일차 입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

Day 11

220303 공부 일지 : 매일매일 푸는 덕분에, 자주 쓰이는 문법은 충분히 익힌 것 같다.

220303 공부 일지

백준 Swift 17009번

// MARK: - 17009번
var appleScore: [Int] = []
var bananaScore: [Int] = []

for _ in 0..<3 {
    appleScore.append(Int(readLine()!)!)
}
for _ in 0..<3 {
    bananaScore.append(Int(readLine()!)!)
}

let appleSum = (appleScore[0] * 3) + (appleScore[1] * 2) + appleScore[2]
let bananaSum = (bananaScore[0] * 3) + (bananaScore[1] * 2) + bananaScore[2]

if appleSum > bananaSum {
    print("A")
}
else if appleSum < bananaSum {
    print("B")
}
else {
    print("T")
}

백준 Swift 11282번

구글링을 통해 해결했다. 44032부터 "가" 라고 한다.

// MARK: - 11282번
let N = Int(readLine()!)!
print(UnicodeScalar(44031 + N)!)

백준 Swift 16199번

// MARK: - 16199번
let bornYear = readLine()!.split(separator: " ").map{Int(String($0))!}
let standardYear = readLine()!.split(separator: " ").map{Int(String($0))!}


let yearLaw: Int = standardYear[0] - bornYear[0] // 연 나이
let yearKorea: Int = 1 + yearLaw // 세는 나이
var yearGlobal: Int = 0 // 만 나이

if standardYear[0] > bornYear[0] { // 년 지났을 때,
    if standardYear[1] > bornYear[1] { // 월 지났을 때,
        yearGlobal = standardYear[0] - bornYear[0]
    }
    else if standardYear[1] < bornYear[1] { // 월 안 지났을 때,
        yearGlobal = standardYear[0] - bornYear[0] - 1
    }
    else { // 월 같을 때,
        if standardYear[2] >= bornYear[2] { // 일 같거나 지났을 때,
            yearGlobal = standardYear[0] - bornYear[0]
        }
        else { // 일 안 지났으면,
            yearGlobal = standardYear[0] - bornYear[0] - 1
        }
    }
}
else { // 연도가 같으면,
    yearGlobal = 0 // 만 나이는 0살
}

print(yearGlobal)
print(yearKorea)
print(yearLaw)

백준 Swift 1212번

// MARK: - 1212번 (참고 : https://didu-story.tistory.com/210)
let N = readLine()!.map{Int(String($0))!}

for i in 0..<N.count {
    var num = N[i]
    var answer = ""

    if num == 0 {
        answer += "0"
    }
    else {
        while num != 1 {
            answer += String(num % 2)
            num /= 2
        }
        answer += "1" // 2진수로 변경 시, 역순 시 가장 첫부분은 1이 돼야 해서 1 붙여줌.
    }

    if i > 0 && answer.count == 1 { // 첫번째가 아니고, 한자리라면 2자리 더 채워줌.
        answer += "00"
    }
    else if i > 0 && answer.count == 2 { // 첫번째가 아니고, 두자리라면 1자리 더 채워줌.
        answer += "0"
    }

    print(String(answer.reversed()), terminator: "")

}

백준 Swift 2754번

// MARK: - 2754번
let score: [String: Double] = ["A+": 4.3, "A0": 4.0, "A-": 3.7, "B+": 3.3, "B0": 3.0, "B-": 2.7, "C+": 2.3, "C0": 2.0, "C-": 1.7, "D+": 1.3, "D0": 1.0, "D-": 0.7, "F": 0.0]

let input = readLine()

print(score[input!]!)

백준 Swift 3028번

// MARK: - 3028번
let input = readLine()!.map{String($0)}
var ball = ["O", "X", "X"]

for ch in input {
    
    switch ch {
    case "A":
        ball.swapAt(0, 1)
    case "B":
        ball.swapAt(1, 2)
    case "C":
        ball.swapAt(2, 0)
    default:
        print("default는 없음.")
    }
    
}

for (index, ch) in ball.enumerated() {
    if ch == "O" {
        print(index + 1)
        break
    }
}

백준 Swift 3029번

// MARK: - 3029번
import Foundation
let timeNow = readLine()!.split(separator: ":").map{Int(String($0))!} // 현재 시간
let (nowH, nowM, nowS) = (timeNow[0], timeNow[1], timeNow[2])
let timeThrow = readLine()!.split(separator: ":").map{Int(String($0))!} // 던질 시간
var (throwH, throwM, throwS) = (timeThrow[0], timeThrow[1], timeThrow[2])

var totalTime: Int = 0

if (throwH == nowH) && (throwM == nowM) && (throwS == nowS) { // 시각이 같다면, 최대 24시간 기다림.
    print("24:00:00")
}
else {
    
    if throwH < nowH {
        throwH += 24
    }
    
    totalTime = ((throwH - nowH) * 3600) + ((throwM - nowM) * 60) + (throwS - nowS)
    
    let answerH = totalTime / 3600
    let answerM = (totalTime % 3600) / 60
    let answerS = (totalTime % 3600) % 60
    
    print("\(String(format: "%02d", answerH)):\(String(format: "%02d", answerM)):\(String(format: "%02d", answerS))")
    
}

백준 Swift 11718번

// MARK: - 11718번
while true {
    let input = readLine()
    
    if input == nil {
        break
    }
    else {
        print(input!)
    }
    
}

백준 Swift 16316번

// MARK: - 16316번
let n = Int(readLine()!)!
var input = readLine()!.split(separator: " ").map{String($0)}
var answerArray: [String] = []

for i in 0..<n {
    answerArray.append(String(i + 1))
}

for (index, ch) in input.enumerated() {
    if ch == "mumble" {
        input[index] = String(index + 1)
    }
}

if input == answerArray {
    print("makes sense")
}
else {
    print("something is fishy")
}

백준 Swift 16408번

// MARK: - 16408번
let input = readLine()!.split(separator: " ").map{String($0)}
var countArray = Array(repeating: 0, count: 13)
let temp = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K"]

for chFirst in input {
    
    let first: String = String(chFirst.first!)
    
    for (index, ch) in temp.enumerated() {
        if ch == first {
            countArray[index] += 1
        }
    }
    
}

print(countArray.max()!)

DAY11 인증완료

DAY11 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY10

개발자P — Wed, 2 Mar 2022 15:04:15 +0900

오늘은 참여한지 10일차 입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

Day 10

220302 공부 일지 : 어렵진 않은데 아직 문제 푸는 속도가 느린 것 같다. 더 빠르고 정확해질 수 있도록 노력해야겠다.

220302 공부 일지

백준 Swift 17388번

// MARK: - 17388번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let sum = input.reduce(0, +)

if sum >= 100 {
    print("OK")
}
else {
    let index = input.firstIndex(of: input.min()!)
    switch index {
    case 0:
        print("Soongsil")
    case 1:
        print("Korea")
    case 2:
        print("Hanyang")
    default:
        print("default 없음.")
    }
}

백준 Swift 13866번

// MARK: - 13866번
var input = readLine()!.split(separator: " ").map{Int(String($0))!}.sorted(by: <)
let sum1: Int = input[0] + input[3]
let sum2: Int = input[1] + input[2]

print(abs(sum1 - sum2))

백준 Swift 5893번(런타임 오류)

// MARK: - 5893번(런타임 오류)
let N = readLine()!
var dec = Int(N, radix: 2)! // 2진수 -> 10진수
dec *= 17

var answer = String(dec, radix: 2) // 10진수 -> 2진수
print(answer)

백준 Swift 16431번

// MARK: - 16431번
let bessie = readLine()!.split(separator: " ").map{Int(String($0))!}
var (bessieX, bessieY) = (bessie[0], bessie[1])
let daisy = readLine()!.split(separator: " ").map{Int(String($0))!}
var (daisyX, daisyY) = (daisy[0], daisy[1])
let john = readLine()!.split(separator: " ").map{Int(String($0))!}
var (johnX, johnY) = (john[0], john[1])

var countBessie: Int = max(abs(johnX - bessieX), abs(johnY - bessieY))
var countDaisy: Int = abs(johnX - daisyX) + abs(johnY - daisyY)

if countBessie > countDaisy {
    print("daisy")
}
else if countBessie < countDaisy {
    print("bessie")
}
else {
    print("tie")
}

백준 Swift 14470번

// MARK: - 14470번
let A = Int(readLine()!)!
let B = Int(readLine()!)!
let C = Int(readLine()!)!
let D = Int(readLine()!)!
let E = Int(readLine()!)!

var time: Int = 0

if A < 0 { // 고기가 얼어 있다면,
    time += D + (abs(A) * C) + (B * E) // 해동 + 0도까지 올리는 데 걸리는 시간 + 목표 온도(B도)까지 올리는 데 걸리는 시간.
}
else { // 고기가 녹아 있다면,
    time += (B - A) * E // 목표 온도(B도)까지 올리는 데 걸리는 시간.
}

print(time)

백준 Swift 19944번

// MARK: - 19944번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])

if M == 1 || M == 2 {
    print("NEWBIE!")
}
else if M <= N {
    print("OLDBIE!")
}
else {
    print("TLE!")
}

백준 Swift 14935번

// MARK: - 14935번
let x = readLine()!.map{Int(String($0))!}
// NFA일 때는 없으니,
print("FA")

백준 Swift 11549번

// MARK: - 11549번
let T = Int(readLine()!)!
let answer = readLine()!.split(separator: " ").map{Int(String($0))!}.filter{$0 == T}.count

print(answer)

백준 Swift 16204번

// MARK: - 16204번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M, K) = (input[0], input[1], input[2])

let countO = min(M, K)
let countX = min(N - M, N - K)

print(countO + countX)

백준 Swift 14623번

// MARK: - 14623번
let B1 = readLine()!
let B2 = readLine()!
let decB1 = Int(B1, radix: 2)!
let decB2 = Int(B2, radix: 2)!

let temp = decB1 * decB2
let answer = String(temp, radix: 2)
print(answer)

DAY10 인증완료

DAY10 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY9

개발자P — Tue, 1 Mar 2022 17:09:12 +0900

오늘은 참여한지 9일차 입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

Day 9

220301 공부 일지 : reduce, filter에 어느정도 적응이 되는 거 같다. 더 연습해야겠다.

220301 공부 일지

백준 Swift 2420번

// MARK: - 2420번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])

var answer = abs(N - M)
print(answer)

백준 Swift 10101번

// MARK: - 10101번
var angle: [Int] = []
var sum = 0

for _ in 0..<3 {
    angle.append(Int(readLine()!)!)
}

//sum = angle.reduce(0) { (num1: Int, num2: Int) -> Int in
//    return num1 + num2
//}
sum = angle.reduce(0, +)

if sum != 180 {
    print("Error")
}
else {
    let temp = angle.filter{$0 == 60}.count
    if temp == 3 {
        print("Equilateral")
    }
    else {
        if (angle[0] == angle[1]) || (angle[0] == angle[2]) || (angle[1] == angle[2]){
            print("Isosceles")
        }
        else {
            print("Scalene")
        }
    }
}

백준 Swift 5596번

// MARK: - 5596번
let S = readLine()!.split(separator: " ").map{Int(String($0))!}.reduce(0, +)
let T = readLine()!.split(separator: " ").map{Int(String($0))!}.reduce(0, +)

if S >= T {
    print(S)
}
else {
    print(T)
}

백준 Swift 15680번

// MARK: - 15680번
let N = Int(readLine()!)!

N == 0 ? print("YONSEI") : print("Leading the Way to the Future")

백준 Swift 11943번

// MARK: - 11943번
let basket1 = readLine()!.split(separator: " ").map{Int(String($0))!}
var (A, B) = (basket1[0], basket1[1])

let basket2 = readLine()!.split(separator: " ").map{Int(String($0))!}
var (C, D) = (basket2[0], basket2[1])

var answer: [Int] = []

// (basket1: 사과, basket2: 오렌지)일 때
answer.append(C + B)

// (basket1: 오렌지, basket2: 사과)일 때
answer.append(A + D)

print(answer.min()!)

백준 Swift 15963번

// MARK: - 15963번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (N, M) = (input[0], input[1])

if N == M {
    print("1")
}
else {
    print("0")
}

백준 Swift 10768번

// MARK: - 10768번
let month = Int(readLine()!)!
let day = Int(readLine()!)!

if month < 2 {
    print("Before")
}
else if month >= 3 {
    print("After")
}
else { // 2월일 때,
    if day < 18 {
        print("Before")
    }
    else if day == 18 {
        print("Special")
    }
    else {
        print("After")
    }
}

백준 Swift 5575번

// MARK: - 5575번
for _ in 0..<3 {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    
    let startTime = (input[0] * 3600) + (input[1] * 60) + input[2]
    let endTime = (input[3] * 3600) + (input[4] * 60) + input[5]
    
    let workTime = endTime - startTime
    
    let hour = workTime / 3600
    let minute = (workTime % 3600) / 60
    let sec = (workTime % 3600) % 60
    
    print("\(hour) \(minute) \(sec)")
    
}

백준 Swift 11948번

// MARK: - 11948번
var subjects1: [Int] = [] // (물리, 화학, 생물, 지구과학) 중 3개 선택
var subjects2: [Int] = [] // (역사, 지리) 중 1개 선택

for _ in 0..<4 {
    subjects1.append(Int(readLine()!)!)
}

for _ in 0..<2 {
    subjects2.append(Int(readLine()!)!)
}

subjects1.sort(by: >)
subjects2.sort(by: >)

subjects1.removeLast()
subjects2.removeLast()

var sum: Int = 0
sum += subjects1.reduce(0, +)
sum += subjects2.reduce(0, +)

print(sum)

백준 Swift 10179번

// MARK: - 10179번
import Foundation
let N = Int(readLine()!)!

for _ in 0..<N {
    let input = Double(readLine()!)!
    
    let temp = input * 0.8
    let answer = String(format: "%.2f", temp)
    print("$\(answer)")
    
}

DAY9 인증완료

DAY9 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY8

개발자P — Mon, 28 Feb 2022 16:48:17 +0900

오늘은 참여한지 8일차 입니다. DAY8은 지금까지 못 풀었던 문제(1212번, 2935번)를 다시 풀어보는 날입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

Day 8

220228 공부 일지 : 못 푼 문제를 다시 시도해서 해결했다. 다른 사람 코드를 참고하면서 배우는 점이 많은 것 같다.

220228 공부 일지

백준 Swift 1212번(런타임 오류)

// MARK: - 1212번(런타임 오류)
import Foundation
let N = readLine()!.map{Double(String($0))!}

var digit: Double = 0 // 10진수
var num: Double = 0.0

for i in stride(from: N.count-1, through:0, by: -1) { // 8진수 -> 10진수
    digit += N[i] * pow(8.0, num)

    num += 1.0 // 8^0, 8^1, 8^2, ...

}

let answer = String(Int(digit), radix: 2) // 10진수 -> 2진수
print(answer)

백준 Swift 1212번

(참고 : https://www.acmicpc.net/source/31035491)

// MARK: - 1212번 ( 참고 : https://www.acmicpc.net/source/31035491)
let N = readLine()!.map{Int(String($0))!}
var result = ""

let arr = ["000", "001", "010", "011", "100", "101", "110", "111"]

for num in N {
    result += arr[num]
}

while result.first == "0" {
    result.removeFirst()
}

if result.isEmpty {
    result = "0"
    print(result)
}
else {
    print(result)
}

백준 Swift 2935번

// MARK: - 2935번
let A = readLine()!.count
let oper = readLine()!
let B = readLine()!.count

var result = "1"

if oper == "*" { // *일 때,
    result += String(repeating: "0", count: A - 1) + String(repeating: "0", count: B - 1)
}
else { // +일 때,
    if A > B {
        result += String(repeating: "0", count: A - B - 1) + "1" + String(repeating: "0", count: B - 1)
    }
    else if A < B {
        result += String(repeating: "0", count: B - A - 1) + "1" + String(repeating: "0", count: A - 1)
    }
    else {
        result = "2" + String(repeating: "0", count: A - 1)
    }
}

print(result)

DAY8 인증완료

DAY8 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY7

개발자P — Sun, 27 Feb 2022 16:30:42 +0900

오늘은 참여한지 7일차 입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

Day 7

220227 공부 일지 : 영어문제여도 당황하지 않고 풀 수 있도록 적응해야겠다.

220227 공부 일지

백준 Swift 13297번

// MARK: - 13297번
//let N = Int(readLine()!)!
//
//for _ in 0..<N {
//    let input = readLine()!.map{String($0)}
//    print(input.count)
//}

백준 Swift 16316번

// MARK: - 16316번
let N = Int(readLine()!)!
var input = readLine()!.split(separator: " ").map{String($0)}
var answerArray: [String] = Array(repeating: "0", count: N)

var index: Int = 1

for i in 0..<N {
    if input[i] == "mumble" {
        input[i] = String(index)
    }
    answerArray[i] = String(index)
    index += 1
}

if input == answerArray {
    print("makes sense")
}
else {
    print("something is fishy")
}

백준 Swift 16316번

// MARK: - 16316번
let N = Int(readLine()!)!
var input = readLine()!.split(separator: " ").map{String($0)}
var answerArray: [String] = Array(repeating: "0", count: N)

var index: Int = 1

for i in 0..<N {
    if input[i] == "mumble" {
        input[i] = String(index)
    }
    answerArray[i] = String(index)
    index += 1
}

if input == answerArray {
    print("makes sense")
}
else {
    print("something is fishy")
}

백준 Swift 16408번

// MARK: - 16408번
let input = readLine()!.split(separator: " ").map{String($0)}
var countArray = Array(repeating: 0, count: 13)
let temp = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K"]


for ch in input {

//    print(ch[ch.index(ch.startIndex, offsetBy: 1)])
    
    let comparisonCh = ch.first! // 혹은 이렇게 ch[ch.index(ch.startIndex, offsetBy: 0)]
    
    for (index, t) in temp.enumerated() {
        if String(comparisonCh) == t {
            countArray[index] += 1
        }
    }

}

print(countArray.max()!)

백준 Swift 21553번 - 런타임오류

// MARK: - 21553번
let A = Int(readLine()!)!
let P = Int(readLine()!)!

print(P) // B = P

백준 Swift 23343번

// MARK: - 23343번
let input = readLine()!.split(separator: " ").map{String($0)}
let (x, y) = (input[0], input[1])

var checkX: Bool = false
var checkY: Bool = false

if Int(x) != nil { // 숫자로 바꿀 수 있으면,
    checkX = true
}

if Int(y) != nil { // 숫자로 바꿀 수 있으면,
    checkY = true
}

if checkX == true && checkY == true { // 둘 다 숫자로 바꿀 수 있으면,
    print(Int(x)! - Int(y)!)
}
else {
    print("NaN")
}

백준 Swift 1008번

// MARK: - 1008번
let input = readLine()!.split(separator: " ").map{Double(String($0))!}
print(input[0] / input[1])

백준 Swift 9498번

// MARK: - 9498번
let score = Int(readLine()!)!

switch score {
case 90...100:
    print("A")
case 80...89:
    print("B")
case 70...79:
    print("C")
case 60...69:
    print("D")
default:
    print("F")
}

백준 Swift 1330번

// MARK: - 1330번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (A, B) = (input[0], input[1])

if A > B {
    print(">")
}
else if A < B {
    print("<")
}
else {
    print("==")
}

백준 Swift 2753번

// MARK: - 2753번
let year = Int(readLine()!)!

if (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 {
    print("1")
}
else {
    print("0")
}

백준 Swift 14681번

// MARK: - 14681번
let x = Int(readLine()!)!
let y = Int(readLine()!)!

if x > 0 && y > 0 {
    print("1")
}
else if x < 0 && y > 0 {
    print("2")
}
else if x < 0 && y < 0 {
    print("3")
}
else if x > 0 && y < 0 {
    print("4")
}

백준 Swift 10797번(1)

// MARK: - 10797번(1)
let input = Int(readLine()!)!
let numArray = readLine()!.split(separator: " ").map{Int(String($0))!}
var count: Int = 0

for num in numArray {
    if input == num {
        count += 1
    }
}

print(count)

백준 Swift 10797번(2)

// MARK: - 10797번(2)
let input = Int(readLine()!)!
let answer = readLine()!.split(separator: " ").filter{Int($0) == input}
print(answer.count)

백준 Swift 10162번

// MARK: - 10162번
let T = Int(readLine()!)!
var (countA, countB, countC) = (0, 0, 0)

if T % 10 != 0 {
    print("-1")
}
else {
    countA = T / 300
    countB = (T % 300) / 60
    countC = ((T % 300) % 60) / 10
    print("\(countA) \(countB) \(countC)")
}

DAY7 인증완료

DAY7 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY6

개발자P — Sat, 26 Feb 2022 22:43:00 +0900

오늘은 참여한지 6일차 입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

Day 6

220226 공부 일지 : 1212번, 2935번 못 풀었으니 DAY8(못 푼 문제 재도전 하는 날)에 다시 풀어봐야겠다.

220226 공부 일지

백준 Swift 11718번

// MARK: - 11718번
while true {
    let input = readLine()

    if input == nil {
        break
    }
    else {
        print(input!)
    }
}

백준 Swift 2754번

// MARK: - 2754번
let score: [String : Double] = ["A+": 4.3, "A0": 4.0, "A-": 3.7,
                                "B+": 3.3, "B0": 3.0, "B-": 2.7,
                                "C+": 2.3, "C0": 2.0, "C-": 1.7,
                                "D+": 1.3, "D0": 1.0, "D-": 0.7,
                                "F": 0.0]

let input = readLine()!

for key in score.keys {
    if key == input {
        print(score[key]!)
        break
    }
}

백준 Swift 3028번

// MARK: - 3028번
let input = readLine()!
var ball = ["O", "X", "X"] // 제일 처음

func A() {
    ball.swapAt(0, 1)
}

func B() {
    ball.swapAt(1, 2)
}

func C() {
    ball.swapAt(0, 2)
}

for ch in input {
    if ch == "A" {
        A()
    }
    else if ch == "B" {
        B()
    }
    else {
        C()
    }
}

for (index, ch) in ball.enumerated() {
    if ch == "O" {
        print(index + 1)
    }
}

백준 Swift 3029번

// MARK: - 3029번
import Foundation
let nowTime = readLine()!.split(separator: ":").map{Int(String($0))!}
let throwTime = readLine()!.split(separator: ":").map{Int(String($0))!}

var (nowHour, nowMinute, nowSec) = (nowTime[0], nowTime[1], nowTime[2])
var (throwHour, throwMinute, throwSec) = (throwTime[0], throwTime[1], throwTime[2])


if throwHour < nowHour {
    throwHour += 24
}

else if (throwHour == nowHour) && (nowMinute == throwMinute) && (throwSec == nowSec) {  // 반례) 00:00:00 - 00:00:00일 때도 포함.
    throwHour += 24
}

var nowAllTime: Int = nowHour * 3600 + nowMinute * 60 + nowSec
var throwAllTime: Int = throwHour * 3600 + throwMinute * 60 + throwSec

let allTime: Int = throwAllTime - nowAllTime
var answerHour: Int = allTime / 3600
var answerMinute: Int = (allTime % 3600) / 60
var answerSec: Int = (allTime % 3600) % 60

let answerH = String(format: "%02d", answerHour)
let answerM = String(format: "%02d", answerMinute)
let answerS = String(format: "%02d", answerSec)
print("\(answerH):\(answerM):\(answerS)")

백준 Swift 17863번(1)

// MARK: - 17863번(1)
let input = readLine()!.map{Int(String($0))!}

if (input[0] == 5) && (input[1] == 5) && (input[2] == 5) {
    print("YES")
}
else {
    print("NO")
}

백준 Swift 17863번(2)

// MARK: - 17863번(2)
let input = readLine()!

if input.hasPrefix("555") {
    print("YES")
}
else {
    print("NO")
}

백준 Swift 20540번(1)

// MARK: - 20540번
let input = readLine()!.map{String($0)}
var answer: String = ""

if input[0] == "E" {
    answer += "I"
}
else {
    answer += "E"
}

if input[1] == "S" {
    answer += "N"
}
else {
    answer += "S"
}

if input[2] == "T" {
    answer += "F"
}
else {
    answer += "T"
}

if input[3] == "J" {
    answer += "P"
}
else {
    answer += "J"
}

print(answer)

백준 Swift 20540번(2)

// MARK: - 20540번(2)
let input = readLine()!.map{String($0)}
let category1 = ["E", "S", "T", "J"]
let category2 = ["I", "N", "F", "P"]
var answer: String = ""

for (index, ch) in input.enumerated() {
    
    ch == category1[index] ? (answer += category2[index]) : (answer += category1[index])
    
}

print(answer)

백준 Swift 20944번

// MARK: - 20944번
let input = Int(readLine()!)!
let answer = String(repeating: "a", count: input)

print(answer)

DAY6 인증완료

DAY6 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY5

개발자P — Sat, 26 Feb 2022 19:57:06 +0900

오늘은 참여한지 5일차의 내용입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

Day 5

220225 공부 일지 : 꾸준히 하는 게 중요한 것 같다. 조건체크 잘 하기.

220225 공부 일지

백준 Swift 2752번

// MARK: - 2752번
var intArray = readLine()!.split(separator: " ").map{Int(String($0))!}
intArray.sort(by: <)
print(intArray[0], intArray[1], intArray[2])

백준 Swift 2959번

// MARK: - 2959번
var input = readLine()!.split(separator: " ").map{Int(String($0))!}
input.sort(by: <)

print(input[0] * input[2])

백준 Swift 13771번

// MARK: - 13771번
import Foundation

let N = Int(readLine()!)!
var numArray: [Double] = []

for _ in 0..<N {
    numArray.append(Double(readLine()!)!)
}
numArray.sort(by: <)

let answer = String(format: "%.2f", numArray[1])
print(answer)

백준 Swift 2309번

// MARK: - 2309번
var heights: [Int] = []

var sumHeights = 0

for _ in 0..<9 {
    heights.append(Int(readLine()!)!)
}

sumHeights = heights.reduce(0, +)

outLoop: for i in 0...9-2 {
    for j in i+1...9-1 {

        if sumHeights - (heights[i] + heights[j]) == 100 {
            heights[i] = 0
            heights[j] = 0
            break outLoop
        }

    }
}

heights.sort(by: <)

for i in 2..<9 {
    print(heights[i])
}

백준 Swift 5576번

// MARK: - 5576번
var collegeW: [Int] = []
var collegeK: [Int] = []

for _ in 0..<10 {
    collegeW.append(Int(readLine()!)!)
}
for _ in 0..<10 {
    collegeK.append(Int(readLine()!)!)
}

collegeW.sort(by: >)
collegeK.sort(by: >)

let scoreW = collegeW[0] + collegeW[1] + collegeW[2]
let scoreK = collegeK[0] + collegeK[1] + collegeK[2]

print(scoreW, scoreK)

백준 Swift 9076번

// MARK: - 9076번
let T = Int(readLine()!)!

for _ in 0..<T {
    var input = readLine()!.split(separator: " ").map{Int(String($0))!}

    input.sort(by: <)
    
    input.removeLast()
    input.removeFirst()
    
    if input.last! - input.first! >= 4 {
        print("KIN")
    }
    else {
        let sum: Int = input.reduce(0, +)
        print(sum)
    }

}

백준 Swift 16770번

// MARK: - 16770번
let N = Int(readLine()!)!

var time = Array(repeating: 0, count: 1001) // 1 ~ 1000
var result: Int = 0

for _ in 0..<N {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let(s, t, b) = (input[0], input[1], input[2])
    
    for i in s...t {
        time[i] += b
    }
    
}
print(time.max()!)

백준 Swift 20650번

// MARK: - 20650번
var input = readLine()!.split(separator: " ").map{Int(String($0))!}
input.sort(by: <)

var A: Int = 0
var B: Int = 0
var C: Int = 0

let sum = input.max()! // A + B + C
A = input.min()! // A
B = input[1] // B
let BC = input[5] // B + C
C = BC - B // C

print(A, B, C)

백준 Swift 19604번

// MARK: - 19604번
let N = Int(readLine()!)!
var arrayX: [Int] = []
var arrayY: [Int] = []


for _ in 0..<N {
    let input = readLine()!.split(separator: ",").map{Int(String($0))!}
    arrayX.append(input[0])
    arrayY.append(input[1])
}

print("\(arrayX.min()! - 1),\(arrayY.min()! - 1)")
print("\(arrayX.max()! + 1),\(arrayY.max()! + 1)")

DAY5 인증완료

DAY5 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY4

개발자P — Thu, 24 Feb 2022 18:17:44 +0900

오늘은 참여한지 4일차 입니다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있습니다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

Day 4

220224 공부 일지 : 쉬운 문제들이였다. 기초를 튼튼하게. 실수하지 않게 주의.

220224 공부 일지

백준 Swift 1008번

// MARK: - 1008번
let input = readLine()!.split(separator: " ").map{Double(String($0))!}
print(input[0] / input[1])

백준 Swift 1330번

// MARK: - 1330번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (A, B) = (input[0], input[1])

if A == B {
    print("==")
}
else if A > B {
    print(">")
}
else {
    print("<")
}

백준 Swift 2753번

// MARK: - 2753번
let year = Int(readLine()!)!

if year % 4 == 0 && ((year % 100 != 0) || (year % 400 == 0)) {
    print("1")
}
else {
    print("0")
}

백준 Swift 9498번

// MARK: - 9498번
let score = Int(readLine()!)!

switch score {
case 90...100:
    print("A")
case 80...89:
    print("B")
case 70...79:
    print("C")
case 60...69:
    print("D")
default:
    print("F")
}

백준 Swift 2438번

// MARK: - 2438번
let input = Int(readLine()!)!

for i in 0..<input {
    for _ in 0...i {
        print("*", terminator: "")
    }
    print()
}

백준 Swift 2439번

// MARK: - 2439번
let N = Int(readLine()!)!

for i in 0..<N {
    
    for _ in stride(from: N-1, to: i, by: -1) {
        print(" ", terminator: "")
    }
    for _ in 0...i {
        print("*", terminator: "")
    }
    
    print()
}

백준 Swift 2739번

// MARK: - 2739번
let N = Int(readLine()!)!

for i in 1...9 {
    print("\(N) * \(i) = \(N * i)")
}

백준 Swift 2741번

// MARK: - 2741번
let N = Int(readLine()!)!
for i in 1...N {
    print(i)
}

백준 Swift 2742번

// MARK: - 2742번
let N = Int(readLine()!)!

for i in stride(from: N, through: 1, by: -1) {
    print(i)
}

백준 Swift 2884번

// MARK: - 2884번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
var (H, M) = (input[0], input[1])
var minute: Int = 0

if H == 0 {
    minute = 24 * 60 + M - 45 // H = 24
}
else {
    minute = H * 60 + M - 45
}

H = minute / 60

if H == 24 {
    H = 0
}

M = minute % 60

print(H, M)

백준 Swift 10818번

// MARK: -  10818번
let N = Int(readLine()!)!

let numArray = readLine()!.split(separator: " ").map{Int(String($0))!}

print(numArray.min()!, numArray.max()!)

DAY4 인증완료

DAY4 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY3

개발자P — Wed, 23 Feb 2022 17:49:01 +0900

오늘은 참여한지 3일차다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

Day 3

220223 공부 일지 : Swift를 더 잘 활용하고 싶다.
reduce / map 을 적극활용해야겠다.

220223 공부 일지

백준 Swift 15740번

// MARK: - 15740번 (75점)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (A, B) = (input[0], input[1])

print(A + B)

백준 Swift 15964번

// MARK: - 15964번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (A, B) = (input[0], input[1])
let answer: Int = (A + B) * (A - B)
print(answer)

백준 Swift 2475번(1)

// MARK: - 2475번(1)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
var sum: Int = 0

for num in input {
    sum += num * num
}

print(sum % 10)

백준 Swift 2475번(2)

// MARK: - 2475번(2)
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let sum = input.reduce(0){$0 + ($1 * $1)}
print(sum % 10)

백준 Swift 2920번

// MARK: - 2920번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let ascending: [Int] = [1, 2, 3, 4, 5, 6, 7, 8]
let descending: [Int] = [8, 7, 6, 5, 4, 3, 2, 1]

if input == ascending {
    print("ascending")
}
else if input == descending {
    print("descending")
}
else {
    print("mixed")
}

백준 Swift 2908번

// MARK: - 2908번
let input = readLine()!.split(separator: " ").map{String($0)}
let (A, B) = (input[0], input[1])
let newA: Int = Int(String(A.reversed()))!
let newB: Int = Int(String(B.reversed()))!

newA > newB ? print(newA) : print(newB)

백준 Swift 1157번(1)

// MARK: - 1157번(1)
import Foundation
let input = readLine()!.map{String($0).uppercased()}
var alphabet = Array(repeating: 0, count: 26)

for ch in input {
    let index: Int = Int(Character(ch).asciiValue!) - Int(Character("A").asciiValue!)
    alphabet[index] += 1
}

let max: Int = alphabet.max()!
var answerIndex: Int = 0
var answer: String = ""

var check: Int = 0
for (index, num) in alphabet.enumerated() {
    if num == max {
        answerIndex = index
        check += 1
    }
    if check >= 2 {
        answer = "?"
        break
    }
}

if answer == "?" {
    print(answer)
}
else {
    answer = String(UnicodeScalar(Int(Character("A").asciiValue!) + answerIndex)!)
    print(answer)
}

백준 Swift 1157번(2)

// MARK: - 1157번(2)
let input = readLine()!.map{String($0).uppercased()}
var dict: [String: Int] = [:]
var result: [String] = []

for ch in input {
    if dict[ch] == nil {
        dict[ch] = 1
    }
    else {
        dict[ch]! += 1
    }
}

for key in dict.keys {
    if dict[key] == dict.values.max() {
        result.append(key)
    }
}

result.count >= 2 ? print("?") : print("\(result[0])")

백준 Swift 2675번

// MARK: - 2675번
let T = Int(readLine()!)!

for _ in 0..<T {
    let input = readLine()!.split(separator: " ").map{String($0)}
    let R: Int = Int(input[0])!
    let S: String = input[1]
    
    for ch in S {
        for _ in 0..<R {
            print(ch, terminator: "")
        }
    }
    print()
}

백준 Swift 3052번

// MARK: - 3052번
var numSet: Set<Int> = []

for _ in 0..<10 {
    numSet.insert(Int(readLine()!)! % 42)
}

print(numSet.count)

백준 Swift 10809번

// MARK: - 10809번
let S = readLine()!.map{String($0)}
var checkArray = Array(repeating: -1, count: 26)

for (index, ch) in S.enumerated() {
    let temp: Int = Int(Character(ch).asciiValue!) - Int(Character("a").asciiValue!)
    
    if checkArray[temp] == -1 {
        checkArray[temp] = index
    }
    
}

for num in checkArray {
    print(num, terminator: " ")
}

백준 Swift 1152번

// MARK: - 1152번
let input = readLine()!.split(separator: " ").map{String($0)}
print(input.count)

DAY3 인증완료

DAY3 인증완료

백준 Swift 2869번, 10250번, 2775번, 1085번, 2309번

개발자P — Wed, 23 Feb 2022 00:30:32 +0900

문제 풀이를 할 때 마다 계속 추가됩니다.

cmd + F 를 통해 문제번호 찾기를 추천드립니다.

풀이글이 길어짐에 따라 글을 나눕니다. 지난번 글은 아래 링크에서 확인하실 수 있습니다.

https://developer-p.tistory.com/166

백준 Swift 1000번, 1001번, 1008번, 2557번, 10718번, 10171번, 10998번, 10869번, 10430번, 2588번, 1330번, 9498번, 27

문제 풀이를 할 때 마다 계속 추가됩니다. cmd + F 를 통해 문제번호 찾기를 추천드립니다. 22.02.10 최초 게시 22.02.11 업데이트 22.02.16 업데이트 22.02.21 업데이트 22.02.22 업데이트 백준 Swift 1000번, 10..

developer-p.tistory.com

22.02.23 최초 게시

22.02.23 업데이트

22.03.07 업데이트

22.03.16 업데이트

아래 깃허브 주소에서 백준 Swift 문제풀이를 확인하실 수 있습니다.

https://github.com/SuminPark-developer/BaekJoonPS

GitHub - SuminPark-developer/BaekJoonPS: 백준 Swift PS

백준 Swift PS. Contribute to SuminPark-developer/BaekJoonPS development by creating an account on GitHub.

github.com

백준 Swift 2869번

// MARK: - 2869번
import Foundation

let input = readLine()!.split(separator: " ").map{Double(String($0))!}
let (A, B, V) = (input[0], input[1], input[2])
var sum: Double = 0.0
var count: Double = 0.0 // 일자

// 이렇게 하면 시간이 너무 오래 걸림.
//while true {
//    sum += A
//    count += 1
//
//    if sum >= V {
//        break
//    }
//
//    sum -= B
//}
//
//print(count)

if A == V { // 높이V와 올라가는A가 똑같으면 한번만에 올라감.
    count = 1
}
else { // 여러날이 필요한 상황이라면,
    let va: Double = V - A // V - A
    let ab: Double = A - B // A - B
    
    count = 1 + ceil(va / ab)
}

print(Int(count))

백준 Swift 10250번

let T = Int(readLine()!)!

for _ in 0..<T {
    let input = readLine()!.split(separator: " ").map{Int(String($0))!}
    let (H, W, N) = (input[0], input[1], input[2]) // H: 높이(층 수), W: 가로(방 수), N: 몇 번째 손님
    
    var xx: Int = 0
    var yy: Int = 0
    var answer: String = ""
    
//    if H == N { // 꼭대기층이면,
//        yy = H // 층 수
//        xx = (N / H) // 호실
//    }
    if N % H == 0 { // 꼭대기층이면,
        yy = H // 층 수
        xx = (N / H) // 호실
        
        if (N / H) >= 10 {
            answer = String(yy) + String(xx)
        }
        else {
            answer = String(yy) + "0" + String(xx)
        }
    }
    else { // 꼭대기 아닐 때,
        yy = N % H // 층 수
        xx = (N / H) + 1 // 호실
        
        if (N / H) + 1>= 10 {
            answer = String(yy) + String(xx)
        }
        else {
            answer = String(yy) + "0" + String(xx)
        }
    }

    print(answer)
    
}

백준 Swift 2775번(1) - 재귀함수 사용

// MARK: - 2775번(1) - 재귀함수
let T = Int(readLine()!)!

func getCitizen(_ k: Int, _ n: Int) -> Int {
    if k == 0 || n == 1 {
        return n
    }
    
    return getCitizen(k - 1, n) + getCitizen(k, n - 1) // (k-1층의 n호), (k층의 n-1호)
}

for _ in 0..<T {
    let k = Int(readLine()!)!
    let n = Int(readLine()!)!
    
    print(getCitizen(k, n))
}

백준 Swift 2775번(2) - 2차원배열 사용

// MARK: - 2775번(2) - 2차원배열
let T = Int(readLine()!)!

for _ in 0..<T {
    let k = Int(readLine()!)!
    let n = Int(readLine()!)!
    
    var apart: [[Int]] = Array(repeating: Array(repeating: 0, count: n + 1), count: k + 1)
    
    for i in 0...k { // 각 층을 돌면서,
        for j in 0...n { // 각 호를 돌면서,
            if i == 0 { // 0층일 땐,
                apart[i][j] = j + 1
            }
            else { // 다른 층일 땐,
                if j == 0 { // 1호일 땐,
                    apart[i][j] = 1
                }
                else { // 2호이상일땐,
                    apart[i][j] = apart[i-1][j] + apart[i][j-1]
                }
            }
            
        }
        
    }
    print(apart[k][n-1])
}

백준 Swift 1085번

// MARK: - 1085번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (x, y, w, h) = (input[0], input[1], input[2], input[3])

let distanceArray = [x, y, w - x, h - y]

print(distanceArray.min()!)

백준 Swift 2309번

// MARK: - 2309번
func combi(_ nums: [Int], _ targetNum: Int) -> [[Int]] {
    var results: [[Int]] = []
    
    func combination(_ index: Int, _ nowCombi: [Int]) {
        if nowCombi.count == targetNum {
            results.append(nowCombi)
            return
        }
        
        for i in index..<nums.count {
            combination(i + 1, nowCombi + [nums[i]])
        }
    }
    combination(0, [])
    return results
}


var heights: [Int] = [] // 키 모두 입력받음.
for _ in 0..<9 {
    heights.append(Int(readLine()!)!)
}
heights.sort(by: <)
var satisfyHeights = combi(heights, 7) // 키 들 중, 난쟁이(7명) 가능한 조합 다 구함.

for height in satisfyHeights {
    if height.reduce(0, +) == 100 { // 난쟁이들의 키의 합이 100이면,
        for k in height {
            print(k)
        }
        break
    }
}

[22일 Basic 챌린지 참여] 알고리즘 DAY2

개발자P — Tue, 22 Feb 2022 21:32:34 +0900

오늘은 참여한지 2일차다.

22일 Basic 챌린지에 대한 상세한 내용은 아래 링크에서 확인할 수 있다.

https://developer-p.tistory.com/171

[22일 Basic 챌린지 참여] 알고리즘 DAY1

developer-p.tistory.com

Day 2

220222 공부 일지 : 기초를 잊지 않게 하는 데 도움이 되는 거 같다. 문제 양이 늘어난 만큼 미리 해야겠다.

220222 공부 일지

백준 Swift 2914번

// MARK: - 2914번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (A, B) = (input[0], input[1])

print(A * (B - 1) + 1)

백준 Swift 1550번(1)

// MARK: - 1550번(1)
let input = Array(readLine()!)
var sum: Int = 0
var deci: Int = 1

for i in stride(from: input.count-1, through: 0, by: -1) {
    var num: Int = 0
    
    switch input[i] {
    case "A":
        num = 10
    case "B":
        num = 11
    case "C":
        num = 12
    case "D":
        num = 13
    case "E":
        num = 14
    case "F":
        num = 15
    default:
        num = Int(String(input[i]))!
    }
    
    sum += num * deci
    deci *= 16
    
}

print(sum)

백준 Swift 1550번(2)

// MARK: - 1550번(2)
let input = readLine()!
let answer: Int = Int(input, radix: 16)!
print(answer)

백준 Swift 2845번

// MARK: - 2845번
var input = readLine()!.split(separator: " ").map{Int(String($0))!}
let (L, P) = (input[0], input[1])
let standard: Int = L * P

input = readLine()!.split(separator: " ").map{Int(String($0))!}

for num in input {
    print(num - standard, terminator: " ")
}

백준 Swift 3003번

// MARK: - 3003번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let standard: [Int] = [1, 1, 2, 2, 2, 8] // 킹 1개, 퀸 1개, 룩 2개, 비숍 2개, 나이트 2개, 폰 8개
var answer: [Int] = []

for (index, num) in input.enumerated() {
    answer.append(standard[index] - num)
}

for num in answer {
    print(num, terminator: " ")
}

백준 Swift 5554번

// MARK: - 5554번
var sec: Int = 0
var min: Int = 0

for _ in 0..<4 {
    sec += Int(readLine()!)!
}

min = sec / 60
sec = sec % 60

print(min)
print(sec)

백준 Swift 5522번

// MARK: - 5522번
var sum: Int = 0

for _ in 0..<5 {
    sum += Int(readLine()!)!
}

print(sum)

백준 Swift 1271번 (런타임 오류)

// MARK: - 1271번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
let(n, m) = (input[0], input[1])

print(n / m)
print(n % m)

백준 Swift 16394번

// MARK: - 16394번
let year = Int(readLine()!)!
print(year - 1946)

백준 Swift 15894번

// MARK: - 15894번
let n = Int(readLine()!)!
print(n * 4)

백준 Swift 2338번 (런타임 오류)

// MARK: - 2338번
let A = Int(readLine()!)!
let B = Int(readLine()!)!

print(A + B)
print(A - B)
print(A * B)

DAY2 인증완료

DAY2 인증완료

[22일 Basic 챌린지 참여] 알고리즘 DAY1

개발자P — Mon, 21 Feb 2022 17:28:05 +0900

회고록

22일간의 챌린지를 마치며.

https://developer-p.tistory.com/195

[22일 Basic 챌린지 참여] 22일간의 챌린지를 마치며, 회고록

지금까지 길다면 길고, 짧다면 짧은 22일동안 22일 Basic 챌린지에 참여했습니다. Day 22 220314 공부 일지 : 챌린지 덕분에 문제 푸는 습관을 기를 수 있는 좋은 기회였습니다. 기존에 목표하던

developer-p.tistory.com

22 Basic Challenge Algorithm

https://softsquared.notion.site/Algorithm-5328fab28619430dae2c782d4db6a556

Algorithm 베이직 챌린지

챌린지 대상 : 코딩 테스트 준비해야하는데, 한 번도 해본적은 없어. 일단 코테 푸는 습관 부터 기를까? 하는 분 해당 챌린지는 코딩테스트 준비를 시작하는 사람들에게 추천합니다.

softsquared.notion.site

22일동안 정해진 알고리즘 문제를 꾸준히 푸는 챌린지가 있길래 참여했다.

어려운 문제들은 아니고, 백준의 브론즈 문제들을 꾸준히 풀게됨으로써 습관을 형성하는데 도움이 될 것 같았다.

백준 문제번호 참고.

아래는 규칙인데, 매일 진행하고 간단히 인증하면 된다.

https://softsquared.notion.site/22-RULE-da479d46c1e043eb8b7e24258bb2c261

22 베이직 챌린지 RULE

구글폼을 작성했던 마음 그대로 22일간 뭉쳐서 달려봅시다 : ) 아래 규칙을 확인해주세요

softsquared.notion.site

Day 1

220221 공부 일지 : 코테 공부 열심히 해야겠다!

220221 공부 일지

백준 Swift 1000번

// MARK: - 1000번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
print(input[0] + input[1])

백준 Swift 1001번

// MARK: - 1001번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
print(input[0] - input[1])

백준 Swift 10998번

// MARK: - 10998번
let input = readLine()!.split(separator: " ").map{Int(String($0))!}
print(input[0] * input[1])

[iOS 스터디/week5] Unsplash Open API 사진 검색 앱(Photo Search App with Unsplash Image Open API) / 네이버 로그인 api / 카카오톡 로그인 api

개발자P — Tue, 15 Feb 2022 15:00:33 +0900

네이버 로그인 API / 카카오톡 로그인 API / Unsplash Open API

를 사용한 사진 검색 앱에 대한 기록입니다.

Photo Search - 사용한 open api : Unsplash Image API

https://unsplash.com/developers

Unsplash Image API | Free HD Photo API

Codepen To make adding images into prototypes and code examples, Codepen integrates the Unsplash library, making finding and adding an image super easy.

unsplash.com

최종 결과물

Photo Search 최종 완성.

메인 화면

메인 화면 - 사진 검색 기능

참고 자료

https://www.youtube.com/watch?v=IQ4jh4EfVOM

구현 화면
- 런치 스크린
- 로그인 화면(카카오, 네이버)
- 메인 화면 - 사진 검색 기능. | Unsplash Image Open API
- 사진 디테일 화면 - 사진 클릭 시 크게 볼 수 있음. ~~하트 버튼 누르면 저장.~~
- ~~랜덤 사진 화면 - 랜덤 키워드 추가해야 함.~~
- ~~하트 누른 사진 화면~~
- 프로필 화면 - 로그인api 유저 정보 가져옴 : 프로필사진, 이름, 이메일, 닉네임, 로그아웃

프로젝트에 사용된 전체 코드는 아래 링크에서 확인할 수 있습니다.

https://github.com/SuminPark-developer/5week_PhotoSearchProject

GitHub - SuminPark-developer/5week_PhotoSearchProject: iOS 5주차 스터디 - 사진 검색 앱(Photo Search Open API)

iOS 5주차 스터디 - 사진 검색 앱(Photo Search Open API). Contribute to SuminPark-developer/5week_PhotoSearchProject development by creating an account on GitHub.

github.com

[iOS 스터디/week4-2] 순발력 구분 게임 앱(Game App that distinguish quickly)

개발자P — Mon, 14 Feb 2022 14:26:24 +0900

순발력 구분 게임 어플 만들기에 대한 기획서 내용은 아래 링크에서 확인하실 수 있습니다.

https://developer-p.tistory.com/168

[iOS 스터디/week4-1] 순발력 구분 게임 어플 만들기 기획서(Game App Proposal that distinguish quickly)

순발력 구분 게임 어플 만들기에 대한 기획서입니다. 순발력 구분 게임 화면에 보이는 캐릭터를 같은 시간내에 빠르게 구별해서 최대한 높은 점수를 내는 게임. 전체 로직 사용자는 start버튼

developer-p.tistory.com

최종 결과물

순발력 구분 게임 최종 완성.

개발하면서 참고했던 링크들도 모두 함께 첨부합니다.

구현페이지

첫 번째 페이지(StartViewController - StartVC)

Navigation Controller - 네비게이션 바 숨기기

// 참고 : https://faith-developer.tistory.com/31
    // StartVC에선 네비게이션바가 안보이게 하고,
    override func viewWillAppear(_ animated: Bool) {
        self.navigationController?.setNavigationBarHidden(true, animated: animated)
    }
    // gameVC에선 네비게이션바가 보이게 설정.
    override func viewWillDisappear(_ animated: Bool) {
        self.navigationController?.setNavigationBarHidden(false, animated: animated)
    }

두 번째 페이지(ViewController - gameVC)

액션퍼즐패밀리 게임 참고.

타이머 재생 방법

https://stackoverflow.com/questions/50032532/swift-4-how-can-i-add-a-countdown-timer-inside-of-my-uibutton-settitle/50032608

Swift 4: How can I add a Countdown timer inside of my UIbutton .settitle?

I am trying to add a Countdown timer inside of my UIButton in the .settitle. How can I do this? The image below is what I am trying to accomplish. Then once the timer gets to 0, I want the backgro...

stackoverflow.com

Q. 타이머 메모리 누수가 있는 거 같다. 아닌가?

→ 누수 있는 거 맞다. 누수를 잡기 위해선 self.weak (?) 약한참조를 해주면 된다. 이 부분에 대해선 추후에 말할 기회가 있을 것. 약한참조를 해주면 많은 부분이 해결된다.

(아래는 제공받은) 타이머 코드

// MARK: - Properties
    
    var vTimer: Timer?          // 인증번호 타이머
    var totalTime: Int = 180    // 인증번호 시작 03:00

/** 타이머 시작버튼 클릭 */
    @objc func onTimerStart(_ sender: Any) {
        if let timer = vTimer {
            //timer 객체가 nil 이 아닌경우에는 invalid 상태에만 시작한다.
            if !timer.isValid {
                /** 1초마다 timerCallback함수를 호출하는 타이머 */
                vTimer = Timer.scheduledTimer(timeInterval: 1, target: self, selector: #selector(timerCallback), userInfo: nil, repeats: true)
            } else {    // 타이머 실행중에 다시 타이머를 실행했다면, 기존의 타이머를 멈추고 난 후, 실행한다.
                timer.invalidate()
                self.totalTime = 180
                vTimer = Timer.scheduledTimer(timeInterval: 1, target: self, selector: #selector(timerCallback), userInfo: nil, repeats: true)
            }
        }else{
            //timer 객체가 nil 인 경우에 객체를 생성하고 타이머를 시작한다.
            /** 1초마다 timerCallback함수를 호출하는 타이머 */
            vTimer = Timer.scheduledTimer(timeInterval: 1, target: self, selector: #selector(timerCallback), userInfo: nil, repeats: true)
        }
    }
    
    /** 타이머 종료버튼 클릭 */
    func onTimerEnd(_ sender: Any) {
        if let timer = vTimer {
            if(timer.isValid){
                timer.invalidate()
            }
        }
        
        totalTime = 0
    }
    
    //타이머가 호출하는 콜백함수
    @objc func timerCallback(){
        totalTime -= 1
        print("DEBUG: \(totalTime)")
    }
}

이미지 같은지 비교 시, (기준이미지 ↔ queueElement1 비교 시)

같은 이미지를 보이고 있어도, 값이 다르다! .pngData()를 통해 비교해줘야 함!

// leftStandard.image == queueElement1.image로 하면 안되고,
if leftStandard.image?.pngData() == self.queueElement1.image?.pngData() { // 좌측 기준과 맨밑이미지가 같다면,
                score += 100 // 득점.
                print(score)
}

https://stackoverflow.com/questions/54818497/swift-compare-multiple-images-to-an-array-of-images

swift compare multiple images to an array of images

I have 2 UIImageViews connected to an array of images I'm trying compare both once they are displayed but doesn't seems to work. I tried using imageArray[Image Literal] and also imageArray[image1.p...

stackoverflow.com

Q. 화면을 그리는 작업은 DispatchQueue.main.async에서 해야 한다고 배웠는데, (저 코드를 쓰지 않고) 그냥 클릭할 때 마다 이미지 변경을 해도 똑같이 잘 된다. 혹시 차이가 무엇인가?

→ uicomponent 값이 바꼈다는건 이미 메인쓰레드다. 따라서 디스패치큐를 하지 않아도, ios에서 메인쓰레드가 알아서 해준다.

But,
메인쓰레드에 위치해 있지 않고, (백그라운드 같은) 다른 쓰레드에 가 있을 때 DispatchQueue.main.async를 통해 화면을 그려줌. (네트워크 등에서 활용될 일이 많다.)

참고 : 메인 액터

오디오 파일 재생 방법

https://zeddios.tistory.com/269

iOS ) local에 있는 오디오파일 재생하기

안녕하세요 :) Zedd입니다. 네..............리젝이 벌써 4번째인가요..?네.....다른앱을 만들어야 하는지 ㅠㅠㅠ 열심히 만든건데.. 이것때문에 하루종일 메일함만 들여다보고 있네요 XD.... 이제 iOS글

zeddios.tistory.com

세번째 페이지

? 버튼 클릭 시, 알람 띄우기 - 최종점수 계산식 표시

: 최종 점수 = 획득 점수 + 게임 진행 시간(1초당 1점 | 최소 0점 ~ 최대 60점)

https://urbangy.tistory.com/21

간단한 Swift 알람 띄우기

간단한 알림 메세지를 띄우는 방법을 알아보쟈! 먼저 알림에 띄우고 싶은 메세지를 정의한다. key, value 를 받아서 보여줄 메세지를 정의해보았다. let msg = "key : \(key) , value : \(value)" 이제 UIAlertCon..

urbangy.tistory.com

프로젝트에 사용된 전체 코드는 아래 링크에서 확인할 수 있습니다.

https://github.com/SuminPark-developer/4week_DivisionGame

GitHub - SuminPark-developer/4week_DivisionGame: iOS 4주차 스터디 - 순발력 구분 게임(Thread : DispatchQueue)

iOS 4주차 스터디 - 순발력 구분 게임(Thread : DispatchQueue). Contribute to SuminPark-developer/4week_DivisionGame development by creating an account on GitHub.

github.com

[iOS 스터디/week4-1] 순발력 구분 게임 어플 만들기 기획서(Game App Proposal that distinguish quickly)

개발자P — Mon, 14 Feb 2022 14:00:01 +0900

순발력 구분 게임 어플 만들기에 대한 기획서입니다.

순발력 구분 게임

화면에 보이는 캐릭터를 같은 시간내에 빠르게 구별해서 최대한 높은 점수를 내는 게임.

전체 로직

사용자는 start버튼을 눌러서 게임을 시작할 수 있다.
시작되면 게임 배경 음악이 나온다.
게임이 시작하면 타이머가 작동한다. (60초부터 1초씩 감소)
올바르게 구분할 때 마다 점수가 증가한다.
틀리게 구분하면 (시간이 남았더라도) 바로 게임이 종료된다.
시간이 다 되면 게임이 종료되고, 지금까지 획득한 점수가 사용자의 최종 점수가 된다.

스레드 개념 활용부분

타이머 작동 부분.
score가 계속 증가하는 부분.
가운데 이미지 큐 계속 업데이트 해주는 부분.

구현해야 할 것

Start 화면 - 첫 화면에서는 게임 난이도 설정과 start버튼을 누를 수 있다.
게임 중 화면 - 가운데 이미지 큐, 좌우버튼, 타이머, 점수판
게임 결과 화면 - 최종 점수 표시, reStart : 1번화면으로 돌아감

제작 참고 이미지

액션퍼즐패밀리 게임.

페이지별 진행상황 및 전체 코드는 아래 링크에서 확인하실 수 있습니다.

https://developer-p.tistory.com/169

[iOS 스터디/week4-2] 순발력 구분 게임 앱(Game App that distinguish quickly)

순발력 구분 게임 어플 만들기에 대한 기획서 내용은 아래 링크에서 확인하실 수 있습니다. https://developer-p.tistory.com/168 [iOS 스터디/week4-1] 순발력 구분 게임 어플 만들기 기획서(Game App Propo..

developer-p.tistory.com

최종 결과물

순발력 구분 게임 최종 결과물