Mini

[그래프] 프로그래머스 전력망을 둘로 나누기 // 자식수 세기는 dfs, 직접나누지말고 자식수를 계산하라

Mini_96 — Wed, 20 Aug 2025 21:45:33 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/86971

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

* 풀이1

직접 연결을 1개씩 지운후 탐색하는 방법

tip) 2차원 행렬그래프 => 쉽게 연결정보 삭제가능

2차원 인접리스트 => 삭제,복원 어려움

import java.util.*;

class Solution {
    static ArrayList<Integer>[] adj = new ArrayList[104];
    static int[][] graph = new int[104][104];
    static boolean[] vis = new boolean[104];
    static int n;
    
    int dfs(int node){
        vis[node]=true;
        
        int ret=1;
        for(int i=1;i<=n;++i){
            if(vis[i]) continue;
            
            if(graph[node][i]==1){
                ret+=dfs(i);
            }
        }
        return ret;
        
    }
    
    public int solution(int N, int[][] wires) {
        int answer = Integer.MAX_VALUE;
        n=N;
        for(int i=0;i<104;++i){
            adj[i]=new ArrayList<>();
        }
        for(var wire : wires){
            int from = wire[0];
            int to  = wire[1];
            adj[from].add(to);
            adj[to].add(from);
            graph[from][to]=1;
            graph[to][from]=1;
        }
        // for(int i=1;i<n;++i){
        //     System.out.println(adj[i]);
        // }
        
        // 연결끊을 index 고르기
        // 연결끊기
        // dfs
        // 원상복구
        for(int i=0;i<wires.length;++i){
            int from = wires[i][0];
            int to = wires[i][1];
            
            graph[from][to]=0;
            graph[to][from]=0;
            
            Arrays.fill(vis,false);
            var v = new ArrayList<Integer>();
            for(int j=1;j<=n;++j){
                if(vis[j]) continue;
                
                v.add(dfs(j));
            }
            
            graph[from][to]=1;
            graph[to][from]=1;
            
            // System.out.println(v.get(0) +" " + v.get(1));
            answer = Math.min(answer,Math.abs(v.get(0)-v.get(1)));
        }
        return answer;
    }
}

* 풀이2

연결을 제거X,

자식수를 세고, 그때그떄 분리하면서 정답갱신

리프노드에서 ret 1 되는것부터 해봐야 한다.

return 되기 직전에 그래프를 나누고 정답을 갱신한다.

(n-child) - child 의 식을 도출해야 한다.

* 코드

import java.util.*;

class Solution {
    static ArrayList<Integer>[] adj = new ArrayList[104];
    static int[][] graph = new int[104][104];
    static boolean[] vis = new boolean[104];
    static int n;
    static int answer = Integer.MAX_VALUE;
    
    int dfs(int node){
        vis[node]=true;
        
        int child=1; // 자기자신 카운팅
        
        for(var nxt : adj[node]){
            if(vis[nxt]) continue;
            
            child+=dfs(nxt);
        }
        
        answer = Math.min(answer,Math.abs((n-child)-child));
        return child;
    }
    
    public int solution(int N, int[][] wires) {
        
        n=N;
        for(int i=0;i<104;++i){
            adj[i]=new ArrayList<>();
        }
        for(var wire : wires){
            int from = wire[0];
            int to  = wire[1];
            adj[from].add(to);
            adj[to].add(from);
        }

        dfs(1);
        
        return answer;
    }
}

[bfs] 프로그래머스 경주로 건설 // 비용이 다른 bfs

Mini_96 — Wed, 20 Aug 2025 15:50:53 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/67259?gad_source=1&gad_campaignid=22215033033&gbraid=0AAAAAC_c4nBlID9vwkMGhM_WoWpCYr7Dp&gclid=Cj0KCQjwwZDFBhCpARIsAB95qO1He7OHX_5_IaiJjSiwxyHw43QNn5aUmvATCKQ3nQd3kQrvFXAkvdcaAtGWEALw_wcB

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

* 풀이

비용이 다른 그래프를 bfs 로 푸는 방법

vis에 방향정보도 저장해야함, 값 : 그떄의 비용

방문을 안했거나, 방문했어도 (저장된비용 보다 계산한) 비용이 더 싸다면 탐색

목적지에 도달했어도 바로 return X -> 나중도착이 최적일 수있음.

* 코드

import java.util.*;

class Solution {
    static class Info{
        int y,x,cost,dir;
        Info(int y, int x, int cost, int dir){
            this.y=y;
            this.x=x;
            this.cost=cost;
            this.dir=dir;
        }
        
        public String toString(){
            return this.y+" "+this.x+" "+this.cost+" "+this.dir;
        }
    }
    static int[] dy = {1,0,-1,0}; //아래, 오른쪽, 위, 좌
    static int[] dx = {0,1,0,-1};

    
    public int solution(int[][] board) {
        int answer = Integer.MAX_VALUE;
        int n = board.length;
        int[][][] vis = new int[n][n][4]; // 방향정보도 추가해야함! (다른방향이면 다른상태임)
        var q = new ArrayDeque<Info>();
        q.add(new Info(0,0,0,0)); //아래
        q.add(new Info(0,0,0,1)); //오른쪽
        vis[0][0][0]=0;
        vis[0][0][1]=0;
        
        while(q.size()>0){
            var cur = q.poll();
            int y = cur.y;
            int x = cur.x;
            int cost = cur.cost;
            int dir = cur.dir;
            
            // System.out.println(cur);
            
            // 비용이다른 bfs : 바로 리턴하면 안됨!, 나중도착이 최적해일 수 있음.
            if(y==n-1 && x==n-1){
                answer = Math.min(answer,cost);
                // return cost;
            }
            
            for(int i=0;i<4;++i){
                int ny=y+dy[i];
                int nx=x+dx[i];
                if(ny<0 || ny>=n || nx<0 || nx>=n) continue;
                if(ny==0 && nx==0) continue; // 시작점
                if(board[ny][nx]==1) continue; // 벽
                if(Math.abs(i-dir)==2) continue; // 반대방향
                
                
                int nextCost=0;
                if(dir != i){
                    nextCost = cost + 600; // 직선도로도 만들어야함 -> 100 + 500
                }
                else{
                    nextCost = cost + 100;
                }
                
                // 이미 방문했어도, 비용이 작다면 재방문 필요!!!
                if(vis[ny][nx][i]==0 || vis[ny][nx][i] > nextCost) {
                    q.add(new Info(ny,nx,nextCost, i));
                    vis[ny][nx][i]=nextCost;
                }
                
                
            }
        }
        
        return answer;
    }
}

[틀림] 프로그래머스 메뉴리뉴얼 // 자바, 람다, 해시

Mini_96 — Fri, 8 Aug 2025 02:06:53 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/72411?language=java

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

* c++ 풀이

freq[길이] 별 map이 키포인트

과거에 머리가 더 잘돌아갔네..

#include <bits/stdc++.h>

using namespace std;

map<string,int> freq[11];

vector<string> solution(vector<string> orders, vector<int> course) {
    vector<string> answer;
    map<string, int> m; //코스이름, 등장횟수
    
    for(auto order : orders){ //ABCFG
        sort(order.begin(),order.end());
        for(int subset=1;subset<(1<<order.size());++subset){ // A, AB, ABC, ...
            string menu;
            for(int j=0;j<order.size();++j){
                if(subset & (1<<j)) menu+=order[j];
            }
            freq[menu.size()][menu]++;
        }
    }
    
    vector<string> ans;
    for(auto i : course){
        int mxfreq=0;
        for(auto p : freq[i])
            mxfreq=max(mxfreq,p.second);
        if(mxfreq<2) continue;
        for(auto p : freq[i]){
            if(p.second==mxfreq) ans.push_back(p.first);
        }
    }

    sort(ans.begin(),ans.end());
    return ans;
}

* 자바풀이

~~람다지옥~~

람다연습 // .map을 하면 유사 배열 stream이 되는군

주문을 정렬해야함에 주의.

subset & (1<<i) 기억 // 비트켜져있는지 하나씩 검사

import java.util.*;
import java.util.stream.Collectors;

class Solution {
    public String[] solution(String[] orders, int[] course) {
        
        var m1 = new HashMap<String, Integer>(); // <조합, 등장횟수>
        
        for(var order : orders) {
            // 각 주문을 정렬하여 일관성 보장
            char[] chars = order.toCharArray();
            Arrays.sort(chars);
            String sortedOrder = new String(chars);
            
            int n = sortedOrder.length();
            
            // 모든 부분집합 생성 (공집합 제외)
            for(int subset = 1; subset < (1 << n); subset++) {
                var sb = new StringBuilder();
                
                for(int i = 0; i < n; i++) {
                    if((subset & (1 << i)) > 0) {
                        sb.append(sortedOrder.charAt(i));
                    }
                }
                
                String combination = sb.toString();
                
                m1.put(combination, m1.getOrDefault(combination, 0) + 1);
                // course 배열에 포함된 길이만 고려 (없어도 통과하긴함)
                // if(Arrays.stream(course).anyMatch(c -> c == combination.length())) {
                //     m1.put(combination, m1.getOrDefault(combination, 0) + 1);
                // }
            }
        }
        
        var answer = new ArrayList<String>();
        
        // 각 코스 길이별로 처리
        for(int courseLength : course) {
            // 해당 길이의 조합들 중 최대 빈도 찾기
            int maxCount = m1.entrySet().stream()
            .filter(e -> e.getKey().length() == courseLength)  // "AB":3, "BC":2, "AC":3
            .filter(e -> e.getValue() >= 2)         // "AB":3, "BC":2, "AC":3 (모두 2 이상)
            .mapToInt(Map.Entry::getValue)          // [3, 2, 3]
            .max()                                  // OptionalInt[3]
            .orElse(0);                            // 3
            
            // 최대 빈도를 가진 모든 조합 추가
            if(maxCount >= 2) {
                m1.entrySet().stream()
                    .filter(e -> e.getKey().length() == courseLength) // "AB":3, "BC":2, "AC":3
                    .filter(e -> e.getValue() == maxCount)           // "AB":3,"AC":3 (maxCount=3)
                    .map(Map.Entry::getKey)                          // ["AB", "AC"]
                    .forEach(answer::add);
            }
        }
        
        Collections.sort(answer);
        return answer.toArray(new String[0]);
    }
}

[틀림] 프로그래머스 베스트 앨범 // 해시맵, 구현, 스트림, 리스트 정렬

Mini_96 — Wed, 30 Jul 2025 02:20:11 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/42579?language=java

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

* 풀이

m1 <장르, List<재생횟수, index>>

m2 <장르, 총 재생횟수>

맵 2개를 만든다.

m2를 정렬하고 그 키값에 대해 정렬된순서로 순회하면서

m1을 꺼낸다.

m1을 정렬한다. (재생횟수기준 내림차순)

2개를 뽑고 정답에 추가한다.

* 전체코드

import java.util.*;

class pair{
    int idx, cnt;
    pair(int idx, int cnt){
        this.idx=idx;
        this.cnt=cnt;
    }
    
    public String toString(){
        return this.idx+" "+this.cnt;
    }
}

class Solution {
    public int[] solution(String[] genres, int[] plays) {
        ArrayList<Integer> ret = new ArrayList<>();
        
        HashMap<String,ArrayList<pair>> m1 = new HashMap<>(); //<장르, 곡정보들(cnt,index>)
        HashMap<String,Integer> m2 = new HashMap<>(); // <장르, 재생횟수>
        
        int n = genres.length;
        for(int i=0;i<n;++i){
            //최초 삽입인경우 초기화, 값 삽입은 아래서 진행!
            if(!m1.containsKey(genres[i])){
                ArrayList<pair> tmp = new ArrayList<>();
                // tmp.add(new pair(plays[i],i));
                m1.put(genres[i],tmp);
                m2.put(genres[i],0);
            }
            var tmp = m1.get(genres[i]);
            tmp.add(new pair(i,plays[i]));
            m1.put(genres[i],tmp);
            m2.put(genres[i],m2.get(genres[i])+plays[i]);
        }
        // System.out.println(m1);
        // System.out.println(m2);
        
        //<장르, 재생횟수를 내림차순 정렬>
        var sortedGen = m2.entrySet().stream()
            .sorted((a,b)-> Integer.compare(b.getValue(), a.getValue()));
        
        // 정렬된 <장르, 재생횟수> 순회하면서
        sortedGen.forEach(e -> {
            // 내부 리스트에서 cnt기준 내림차순정렬, 2개 가져오기
            var sortedSong = m1.get(e.getKey()).stream()
                .sorted((a,b)->Integer.compare(b.cnt,a.cnt))
                .limit(2);
            // 가져온것의 index를 정답에 추가
            sortedSong.forEach(song -> ret.add(song.idx));
        });
        
        return ret.stream().mapToInt(Integer::intValue).toArray();
    }
}

[스택] 프로그래머스 크레인 인형뽑기 // 배열을 스택으로 바꿔라

Mini_96 — Sun, 6 Jul 2025 15:15:55 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/64061?language=java

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

*풀이1

배열을 탐색하면서 0이 아닌원소를 찾고

stk에 pop하는 방식

import java.util.*;

class Solution {
    static int[][] board;
    static ArrayDeque<Integer> stk = new ArrayDeque<>();
    static int answer;
    
    void findAndRemove(int move){
        int i=0;
        while(i<board.length && board[i][move-1]==0){
            // System.out.println(board[i][move-1]);
            i++;
        }
        
        
        if(i==board.length) i--;
        
        
        if(board[i][move-1]!=0){
            
            // System.out.println(board[i][move-1]);
            if(stk.size()>0 && stk.peek()==board[i][move-1]){
                // System.out.println(board[i][move-1]);
                stk.pop();
                answer+=2;
            }
            else stk.push(board[i][move-1]); //stack에는 offer 금지!
            
            board[i][move-1]=0; //제거표시
        }
    }
    
    public int solution(int[][] _board, int[] moves) {
        board=_board;
        // System.out.println(Arrays.deepToString(board));
        
        for(int move : moves){
            findAndRemove(move);
        }
        // System.out.println(stk);
        return answer;
    }
}

* 풀이2

배열을 스택으로 변경하는 방법

import java.util.*;

class Solution {
    static int[][] board;
    static ArrayDeque<Integer> stk = new ArrayDeque<>();
    static int answer;
    
    
    public int solution(int[][] _board, int[] moves) {
        board=_board;
        // System.out.println(Arrays.deepToString(board));
        
        int n=board.length;
        int m=board[0].length;
        
        ArrayDeque<Integer>[] lanes = new ArrayDeque[m];
        for(int i=0;i<m;++i){
            lanes[i]=new ArrayDeque<>();
        }
        
        for(int j=0;j<m;++j){
            for(int i=n-1;i>=0;--i){
                if(board[i][j]==0) break;
                lanes[j].push(board[i][j]);
            }
        }
        // for(int i=0;i<m;++i){
        //     System.out.println(lanes[i]);
        // }
        
        ArrayDeque<Integer> bucket = new ArrayDeque<>();
        for(int move:moves){
            if(lanes[move-1].isEmpty()) continue;
            int cur = lanes[move-1].pop();
            
            if(bucket.isEmpty()){
                bucket.push(cur);
                continue;
            }
            
            if(bucket.peek()==cur){
                answer+=2;
                bucket.pop();
            }
            else{
                bucket.push(cur);
            }
        }
        
        // System.out.println(bucket);
        
        return answer;
    }
}

객체지향으로 할인요구사항 구현하기

Mini_96 — Sat, 5 Jul 2025 19:58:09 +0900

객체지향으로 할인요구사항 구현하기

jpashop에 아이템을 할인할수있게 해달라는 요구사항이 들어왔습니다.

이를 객체지향을 이용하여 확장에는 열려있고 수정에는 닫혀있는 코드를 구현해 보겠습니다.

먼저 메시지를 결정하고, 이를 처리할 객체를 결정합니다. 이때, 메시지를 처리하기 위해 정보를 많이 알고있는 객체를 선택합니다.

상속을 이용한 방법

할인정책 세부 클래스를 구현할때 어떤 방법이 있는지 보겠습니다.

단점 : 할인정책 변경을 위해, 새로운 Item 인스턴스를 만들고 필요한 정보 복사가 필요합니다.

상속대신 합성을 사용하라

장점 : 할인정책이 추가 되더라도 새로운 할인정책 클래스를 추가하고,이를 Item 생성시 전달하면 됩니다.

즉 Item에 연결된 DiscountPolicy 인스턴스만 바꾸면 되므로, 이 방법을 선택하겠습니다.

할인정책을 누가 가지고 있을것인가

order vs item vs orderItem

order : 주문 전체에 대해 동일한 할인정책을 적용할때

item : 아이템 별로 할인정책을 적용할때

orderItem : 주문상품별로 각각 다른 할인정책을 적용할때

-> 네이버 페이의 경우 item 별로 할인정책이 적용된것을 볼 수 있음. ->

정보전문가에게 책임을 할당하라. 가격 정보를 알고있는 item 객체를 선택!

new는 해롭지만, 가끔은 생성해도 무방하다

Item이 대부분의 경우에 NoneDiscountPolicy와 협력하고, 가끔씩만 AmountDiscountPolicy 또는 PercentDiscountPolicy와 협력하는 경우, 클라이언트에게 생성하는 책임을 모두 넘긴다면, 중복되는 new NoneDiscountPolicy 코드가 많아지게 됩니다.

이럴 때 생성자 체이닝을 이용하면 좋습니다.

protected Item(String name , int price, int stockQuantity, DiscountPolicy discountPolicy) {
    this.name=name;
    this.price=price;
    this.stockQuantity=stockQuantity;
    this.discountPolicy= discountPolicy;
}

protected Item(String name, int price, int stockQuantity) {
    this(name, price, stockQuantity, new NoneDiscountPolicy());
}

할인정책, 할인조건을 어떻게 영속화 할 것인가

한테이블 전략 vs Joined 전략

기본적으로 Joined를 선택하고, 조인에 성능상 이슈가 있거나 요구사항이 매우간단한 경우에만 한테이블 전략을 선택하면 좋습니다.

참고 : 영속화를 위해 interface에서 abstract class로 변경해야 하는 단점이 존재합니다. (jpa가 interface를 지원하지않음)

@Entity
@Table(name = "discount_policy")
@Inheritance(strategy = JOINED)
public abstract class DiscountPolicy {

    @OneToMany(
            cascade = CascadeType.ALL,
            orphanRemoval = true
    )
    @JoinColumn(name = "policy_id", nullable = false)
    private List<DiscountCondition> conditions = new ArrayList<>();

양방향 vs 단방향 연관관계

기본적으로 단방향 연관관계로 설정하고, 할인조건에서 할인정책을 참고해야하는 상황이 생기는 경우에만 양방향 연관관계를 추가합니다.

이 설계가 유연하고 재사용 가능 한가? (검증)

할인혜택을 제공하지 않아도 된다는 요구사항 추가

먼저 문제가 있었던 구현방식을 먼저 보겠습니다.

class Item{
...

    public Money calculateItemFee() {
        if(discountpolicy==null) return price;
        return Money.of(price).minus(discountPolicy.calculateDiscountAmount(this));
    }

위 코드의 문제점은 할인정책의 변경으로 인해 Item 클래스를 수정해야 한다는 점입니다.

이는 버그의 발생 가능성을 높이게 됩니다.

해결하는 방법은 할인정책이 없다는 사실을 할인정책으로 추가하는 것입니다.

@Entity
@DiscriminatorValue("NONE")
public class NoneDiscountPolicy extends DiscountPolicy {
    @Override
    protected Money getDiscountAmount(Item item) {
        return Money.ZERO;
    }
}

클래스를 단1개만 추가 하였습니다. OCP 원칙을 준수하는 설계라고 할수 있습니다.

중복할인 정책 요구사항 추가

아이템 1개에 대해 비율할인, 정률할인을 모두 할 수 있어야 한다는 요구사항이 추가되었습니다.

public class OverlappedDiscountPolicy extends DiscountPolicy {

    private List<DiscountPolicy> discountPolicies = new ArrayList<>();

    public OverlappedDiscountPolicy(DiscountPolicy... policies) {
        super(new NoneCondition());
        this.discountPolicies = Arrays.asList( policies);
    }

    @Override
    protected Money getDiscountAmount(Item item) {
        Money result = Money.ZERO;
        for (DiscountPolicy each : discountPolicies) {
            result = result.plus(each.calculateDiscountAmount(item));
        }
        return result;
    }
}

클래스 1개를 추가하는것만으로 요구사항 구현이 완료되었습니다!

@Test
@DisplayName("중복할인 정책이 적용되어 상품의 가격에서 각각 1000원이 할인되고, 원가의 30%가 추가 할인된다.")
void createItem5() {
    //given
    Book book = new Book("Test Item", 10000, 10, "조영호", "오브젝트",
            new OverlappedDiscountPolicy(
                    new AmountDiscountPolicy(Money.of(1000),
                            new NoneCondition()
                    ),
                    new PercentDiscountPolicy(0.3,
                            new NoneCondition()
                    )
            ));

    ...

    //when
    Money discountMoney = book.calculateItemFee();

    //then
    assertEquals(Money.of(6000), discountMoney);
    assertEquals(Money.of(18000), order.getTotalPrice());
}

결과 (30000의 30%인 9000원할인, 1000원 할인)

결론

변하는 부분과 변하지 않는 부분을 분리하고, 변하는 부분(할인정책, 할인조건)을 추상화 하였습니다.

이로 인해 새로운 요구사항이 추가되더라도 클래스 1개를 추가하는것만으로 개발이 완료되는 코드를 만들었습니다.

이때까지 과제테스트를 제출할때 위와 같은 할인, 쿠폰등과 같은 요구사항이 있는경우, DiscountType같은 필드변수와 if else 문으로 문제를 해결하려고 했습니다. 하지만 이를 객체지향적으로 해결하는 방법을 배웠고, 코드를 짤때 객체지향적인지 변화에 대응이 되는지 생각하면서 코드를 짜야겠습니다.

레퍼런스

https://product.kyobobook.co.kr/detail/S000001766367

오브젝트 | 조영호 - 교보문고

오브젝트 | 역할, 책임, 협력을 향해 객체지향적으로 프로그래밍하라!객체지향으로 향하는 첫걸음은 클래스가 아니라 객체를 바라보는 것에서부터 시작한다. 객체지향으로 향하는 두번째 걸음

product.kyobobook.co.kr

[스택] 프로그래머스 괄호회전하기 // 회전하지 말고 뒤에붙여라

Mini_96 — Fri, 4 Jul 2025 13:46:06 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/76502?gad_source=1&gad_campaignid=22199869887&gbraid=0AAAAAC_c4nDqT-kGu7HDiWreRKNyvkYUK&gclid=Cj0KCQjw1JjDBhDjARIsABlM2St3rddqiQ5vq_1tewqUOwj4SfVP6m4BAGqsMZ-_YLamLn7pOQO_k5QaAub0EALw_wcB

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

* 풀이1

직접회전

[이면 push 아니면 pop

반례 -> }}} 만 오는 경우 true 가 되버림 -> leftCnt로 left의 갯수가 없다면 false 리턴

import java.util.*;

class Solution {
    String rotate(String s){
        return s.substring(1) + s.charAt(0);
    }
    boolean check(String s){
        int leftCnt=0;
        Stack<Character> stk = new Stack<>();
        for(int i=0;i<s.length();++i){
            char cur = s.charAt(i);
            if(s.charAt(i)=='[' || s.charAt(i)=='(' || s.charAt(i)=='{'){
                leftCnt++;
                stk.push(s.charAt(i));
            }
            else if(stk.size()>0 && cur==']' && stk.peek()=='['){
                stk.pop();
            }
            else if(stk.size()>0 && cur==')' && stk.peek()=='('){
                stk.pop();
            }
            else if(stk.size()>0 && cur=='}' && stk.peek()=='{'){
                stk.pop();
            }
        }
        return stk.isEmpty() && leftCnt!=0;
    }
    public int solution(String s) {
        int answer = 0;
        int n=s.length();
        for(int i=0;i<n;++i){
            // System.out.println(s);
            if(check(s)) answer++;
            s=rotate(s);
        }
        return answer;
    }
}

* 풀이2

회전하지말고 뒤에 붙여라!

s+=s (문자열 뒤에 자기자신 붙이는법)

Stack대신 ArrayDequeue를 써라

if문대신 map을 사용하라.

반복문에 이름붙이는법.

우측괄호가 in -> stk가 빔 -> false!

import java.util.*;

class Solution {

    public int solution(String s) {
        int answer=0;
        int n=s.length(); //window size
        s+=s; // 회전하지말고 붙여라.
        
        HashMap<Character,Character> m = new HashMap<>();
        m.put(')','(');
        m.put(']','[');
        m.put('}','{');
        
        A:for(int i=0;i<n;++i){ //반복문 바로 break 하는방법
            ArrayDeque<Character> stk = new ArrayDeque<>(); //Stack대신 ArrayDequeue를 사용하라.
            for(int j=i;j<i+n;++j){
                char cur = s.charAt(j);
                if(!m.containsKey(cur)){ // 좌측괄호인경우
                    stk.push(cur);
                }
                else if(stk.isEmpty() || stk.pop()!=m.get(cur)){ //우측괄호} 들어옴 -> 스택이 빔 or 같지않음 -> 무효
                    continue A; //A로 이동
                }
                
            }
            if(stk.isEmpty()) answer++; // else if문에 안걸리고 stk가 빈경우, 올바른 괄호
        }
        
        return answer;
    }
}

[구현] 프로그래머스 방문길이 // set

Mini_96 — Thu, 3 Jul 2025 14:13:09 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/49994?gad_source=1&gad_campaignid=22199869887&gbraid=0AAAAAC_c4nB6yISFBx5mGvyOG08zAQ87t&gclid=CjwKCAjwsZPDBhBWEiwADuO6y9aUyXD7gRRtDHQNWI8nlF7PY_7YefwJekHo0m-V-AOfGdA5TBefwxoCEsgQAvD_BwE

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

* 풀이

좌표를 (0,0)으로 변경

set에 from, to를 정렬후 넣기 (좌->우, 위->아래 순서)

set.size가 정답일것

import java.util.*;

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

class Solution {
    
    static void print(Object o){
       System.out.println(o);
    }
    
    public int solution(String dirs) {
        int answer = 0;
        int[][] arr = new int[11][11];
        // print(Arrays.deepToString(arr));
        
        Set<String> s = new HashSet<>();
        
        Pos cur = new Pos(5,5);
        for(int i=0;i<dirs.length();++i){
            var a = dirs.charAt(i);
            if(a=='U'){
                int nx = cur.x;
                int ny=cur.y-1;
                if(nx<0 || ny<0 || nx>=11 || ny>=11) continue;
                var sb = new StringBuilder();
                sb.append(ny);
                sb.append(nx);
                sb.append(cur.y);
                sb.append(cur.x);
                s.add(sb.toString());
                cur = new Pos(ny,nx);
            }
            else if(a=='D'){
                int nx = cur.x;
                int ny=cur.y+1;
                if(nx<0 || ny<0 || nx>=11 || ny>=11) continue;
                var sb = new StringBuilder();
                sb.append(cur.y);
                sb.append(cur.x);
                sb.append(ny);
                sb.append(nx);
                s.add(sb.toString());
                cur = new Pos(ny,nx);
            }
            else if(a=='L'){
                int nx = cur.x-1;
                int ny=cur.y;
                if(nx<0 || ny<0 || nx>=11 || ny>=11) continue;
                var sb = new StringBuilder();
                sb.append(ny);
                sb.append(nx);
                sb.append(cur.y);
                sb.append(cur.x);
                s.add(sb.toString());
                cur = new Pos(ny,nx);
            }
            else if(a=='R'){
                int nx = cur.x+1;
                int ny=cur.y;
                if(nx<0 || ny<0 || nx>=11 || ny>=11) continue;
                var sb = new StringBuilder();
                sb.append(cur.y);
                sb.append(cur.x);
                sb.append(ny);
                sb.append(nx);
                s.add(sb.toString());
                cur = new Pos(ny,nx);
            }

        }
        return s.size();
    }
}

* 개선

사실 정렬할필요없이 <from,to> <to,from>을 모두 넣고 size/2 하면 코드가 더 간단해진다.

[배열] 프로그래머스 행렬의 곱셉

Mini_96 — Wed, 2 Jul 2025 14:01:54 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/12949?language=java

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

* 풀이

answer 배열의 1칸씩 계산한다.

k가 핵심!

ex) 15 = 1*3 + 4*3 =

answer[0][0] = arr1[0][0] * arr2[0][0] + arr1[0][1] * arr2[1][0]

answer[i][j] = for(k=0 to c1) arr[i][k] * arr2[k][j]

class Solution {
    public int[][] solution(int[][] arr1, int[][] arr2) {
        int[][] answer = new int[arr1.length][arr2[0].length];

        for(int i=0;i<arr1.length;++i){
            for(int j=0;j<arr2[0].length;++j){
                for(int k=0;k<arr1[0].length;++k){
                    answer[i][j] += arr1[i][k]*arr2[k][j];
                }
            }
        }
        
        return answer;
    }
}

리트코드 169 다수원소 // 배열, 투표알고리즘

Mini_96 — Thu, 5 Jun 2025 22:18:22 +0900

https://leetcode.com/problems/majority-element/description/

* 풀이1

절반이상인 원소가 반드시 존재함을이용

정렬 -> 중간지점의 원소가 다수원소임

class Solution {
    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        return nums[nums.length/2];
    }
}

O(nlgn)

* 풀이2

투표 알고리즘 이용

O(n)

class Solution {
    public int majorityElement(int[] nums) {
        int king=nums[0];
        int cnt=1;

        for(var num : nums){
            if(num==king){
                cnt++;
                continue;
            }
            cnt--;
            if(cnt==0){
                king=num;
                cnt=1;
            }
        }
        return king;
    }
}