유에스비 어딨니?

[VS Code] Emmet 사용하기

머어하지 — Tue, 11 Jan 2022 22:59:01 +0900

Front 단 작업을 위해 VS Code를 사용하려고 했지만 집에서 사용하는 VS Code에서 !+Tab이 먹히질 않아서 설정하는 법에대한 글을 작성해본다.

1) 좌측 상단 메뉴에서 [파일] - [기본 설정] - [설정]

2) 나온 창에서 [확장] - [Emmet]

3) Emmet 창에서 [Trigger Expansion On Tab] 항목에 체크해주면

4) html 파일에서 [!]를 입력한 뒤

5) Tab을 눌러주면 자동으로 양식이 완성된다.

이런 표현법들은 개발시에 많은 노가다를 줄여주므로 사용중인 에디터가 Emmet 기능이 있다면 Enable 후 사용하면 편해진다.

[안드로이드] 주차 위치 앱(주차 위치)

머어하지 — Mon, 6 Dec 2021 22:14:32 +0900

차가 생긴 뒤, 주차장을 이용하는 나는

건물의 주차장 중 B2층 아니면 B3층을 사용한다.

하지만 내려갈 때마다 B2층인지, B3층인지 한 번 씩 잘 못 가서 다시 다른 층을 가는 일이 일어났고,

주차장 위치를 기록하는 어플이 있는지 찾아보았다.

결과적으로 주차장에서의 위치를 기록하는 어플은 있었는데, 광고가 붙어있는게 마음에 안 들었다.

그래서 광고도 싫고 오랜만에 앱 하나 만들게 되었다.

Google Play 주소 : https://play.google.com/store/apps/details?id=com.foryou.parking

주차 위치 - Google Play 앱

주차 위치를 간단히 기록할 수 있습니다.

play.google.com

아주 간단하게 주차장의 층과 기둥에 적혀있는 구역을 버튼으로 빠르게 눌러 저장하기를 누르면 알림으로 떠있도록 만들었다.

지워지지 않는 알림으로 나중에 다른 곳에 주차하였을 때, 해당 알림을 누르면 바로 입력을 또 할 수 있도록 하였다.

이렇게 원하는 기능이 있을 때 바로바로 만들어 볼 수 있는게 개발의 신기하고도 좋은 점인 것 같다.

[팬스타크루즈] 투나잇크루즈 체험 후기!

머어하지 — Mon, 15 Jul 2019 13:12:21 +0900

팬스타 크루즈의 투나단!

투나단이란 투나잇 크루즈 체험단의 줄임말임과 동시에 팬스타 크루즈의 29주년을 기념하여 만들어진 체험단으로 2가지의 의미를 지니고있는 체험단입니다.

체험단에 선정되고나서 이렇게 배를 오랫동안 타본적은 없었기때문에 뱃멀미를 심하게하면 어쩌지란 생각과 동시에 설레는 마음으로 부산으로 가는 기차에 몸을 실었습니다. 고속 열차를 타고 부산에 가보는게 정말 오랫만이였는데 2시간 10분 밖에 걸리지 않은걸 보고 세상 좋아졌다는걸 느낄 수 있었습니다.

수서에서 출발해서 부산역에 도착해서 맛있는 돼지 불백도 점심으로 먹었습니다. 크루즈를 타러오기도 했지만 부산까지 온김에 맛난 음식들도 먹어줘야죠ㅎㅎ

불백을 먹고나니 부산항 국제여객터미널 까지 가야하는 시간이 얼마 남지 않아서 후다닥 달려갔습니다. 부산역에서 걸어갈 수 있을 정도로 가까웠기 때문에 밥먹고 가볍게 걸어갈 수 있었습니다.

도착을 하고나서 크루즈 티켓을 받아야지 탑승할 수 있으므로 팬스타 크루즈가 있는 3층으로 이동해서 팬스타 크루즈 매표소 앞에서 티켓을 수령하였습니다.

티켓에는 저녁 뷔페와 조식 뷔페 티켓까지 함께 있었습니다. 벌써 맛있는 느낌이 느껴지네요!!!! 해외로 나가는것이므로 여권은 필!!!수!! 입니다!!

다른 사람들의 뒤를 졸졸 따라가서 배에 들어가는데 에스컬레이터도 있고, 들어갈때 메인 홀에서는 바이올린과 피아노 연주까지!!! 해주는 이게 크루즈인가 하면서 감탄을 했습니다. 신기해서 둘러보기 바빠서 사진 찍을 생각도 못했네요ㅠ 정말 좋았습니다. 어디선가 들어본 음악들이라 더 흥겨웠던것 같습니다!!! :)

흥겨운 음악을 뒤로하고 배정받은 방으로 들어가니 창문이 크게 하나가있는데 오션뷰가 쫘~악! 보이는게 정말 좋았습니다. 하지만 크루즈에 처음 타본사람으로서 객실은 뒷전이고, 바로 갑판에 나가서 주변 구경을 했습니다 ㅎㅎ

배에서 바라보는 바다는 또 특유의 감성이 있는것 같았습니다. 배의 감성이야기를 하면 반나절이 걸릴 수 있으므로 사진 몇개로 대체해봅니다ㅎㅎ

창문으로 바라본 바다부터 대교를 지나가는 모습을 지나 선상 노을까지!!! 직접보면 더 웅장하고 아름답습니다!!

경치도 볼거리지만 투나잇 크루즈 선내에는 다양한 시설이 있습니다.

편의점과 바다를 보면서 라면을 먹을 수 있는 편의점 내의 라면명당, 그 옆의 스시바, 마사지샵, 로비에서 항해복을 입고 찍을 수 있는 포토존, 배를 타고가면서 여러 대교를 가장 멋지게 볼 수 있는 대교 포토존까지!! 투나단 답게 여러 장소에 인증샷을 찍으로 돌아다녔습니다. 특히 위층에는 카페 유메에서 맛난 음료와 와이파이까지 쓸 수 있어서 카페에 자주 들렸습니다ㅎㅎ 거기에더해 투나단은 파라다이스 라운지(와이파이 무료!!)를 사용할 수 있었습니다. (카드로 문을 열어야만 들어갈 수 있는 라운지였습니다)

파라다이스 라운지에는 티비와 밖을 편하게 볼 수 있는 라운지 그리고 여러 다과와 드립 커피가 제공됩니다. 특히!! 안마 의자 2개가 구비되어있어서 사람들이 없는 저녁에는 안마 의자에서 살았습니다.

파라다이스의 행복을 뒤로하고.. 여행에 빠질 수 없는 코스는 바로 먹는 즐거움입니다. 팬스타 크루즈 드림호의 뷔페는 정말 맛있게 먹을 수 있는 다양한 음식들과 후식들까지 제공되어 먹는 즐거움까지 있었던 여행이였습니다. 뷔페식으로 원형 테이블에 앉아서 이야기를 하면서 편히 먹을 수 있었습니다.

마지막으로 크루즈의 장점은 공연이 가능하단 것입니다. 위 사진의 알림으로 사용하던 스테이지가 저녁에는 멋진 공연장으로 변해서 웰컴 연주를 해주시던 분들의 악기 연주와 직원분들의 재미있는 댄스와 노래, 마지막으로는 마술쇼까지!!! 정말 재미있은 공연들이였습니다. 특히 돌아올때는 노래 대회가 열려서 1등에게는 객실 업그레이드를 시켜주는 이벤트도 있었습니다. 노래를 흥있게 잘 부르신다 생각하시면 적극 참가 추천드립니다!! 꼬마부터 어르신들까지 다양하게 참가해서 아주 재미났습니다ㅎㅎ(마술쇼는 정말 재밌었습니다!!!!! )

이러한 재미있는 크루즈를 뒤로하고 도착한 오사카에서 투나잇 쿠르즈는 반나절을 머물게 됩니다. 일본 관광에 필요한 버스는 준비가 되어있기 때문에 와이파이가 제공되는 버스를 타고 오사카의 유명 관광지에 편안하게 갈 수 있습니다.

짧긴 했지만 정말 재밌었던 크루즈 여행!!! 다음에 또 기회가 온다면 배편을 길게잡아 한 번 가보고싶습니다!!

p.s 뱃멀미를 하는 편인데 배가 워낙 커서 처음에 출항 할 때를 제외하고는 멀미가 전혀 나지 않았습니다.

[SW Expert] 7728. 다양성 측정

머어하지 — Mon, 24 Jun 2019 23:22:07 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/swexpert/d3/Q7728.java 숫자가 주어진다 얼마나 다양한 숫자로 이루어져있는지 개수를 출력하여라.

처음 생각

문자열로 주어지는 숫자의 각 자리수를 다룰수 있는지를 보는 문제인것 같다.

다음 생각

문자열의 각자리를 charAt을 통해 읽으면서 해당 값은 아스키코드이므로 '0'을 빼주어 원래 숫자를 얻을 수 있도록 하였다.

▶ 해당 숫자가 이미 사용된 숫자인지를 파악하기위해서 int[10] 즉, 0~9까지 체크할 수 있는 배열을 만들어 문자열에서 해당 숫자가 이미 사용되어있는지를 체크해주었다.

▶ 이경우 숫자의 체크를 위해 배열값을 바꿔주어야하는데 배열을 매번 초기화하면 배열이 클경우 효율이 떨어지므로 매번 바뀌는 값인 테스트 케이스 값을 통해 사용한 숫자인지 체크를 해주었다.

방안

1) Java 풀이

package swexpert.d3;
 
import java.io.BufferedReader;
import java.io.InputStreamReader;
 
public class Q7728 {
    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
 
        int[] arr = new int[10];
        int tc = Integer.parseInt(br.readLine());
        for(int z = 1; z <= tc; z++){
            String n = br.readLine();
            int len = n.length();
            int result = 0;
 
            for(int i = 0; i < len; i++){
                int t = n.charAt(i)-'0';
                if(arr[t]!=z){
                    result++;
                    arr[t] = z;
                }
            }
 
            sb.append('#').append(z).append(' ').append(result).append('\n');
        }
        System.out.println(sb);
    }// end of main
}// end of class
 

Colored by Color Scripter

[SW Expert] 7732. 시간 개념

머어하지 — Sun, 23 Jun 2019 22:52:01 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/swexpert/d3/Q7732.java 시작 시간과 끝나는 시간의 시간차를 xx:xx:xx 형식으로 나타내어라.

처음 생각

처음에는 문자열을 어떻게 분리 시킬까를 생각해보았다. 입력이 정해진 형식으로 들어오기때문에 Index로 접근해도 괜찮지만 String Class의 split 사용하면 좀 더 편하게 시:분:초를 분리시킬 수 있다.

▶ split(":")을 사용하면 :로 문자열을 분리해준뒤 해당값을 배열로 return 해준다.

다음 생각

그 다음으로는 시간차를 출력하는 것이므로 분리된 시, 분, 초를 각 단위에 맞게 [끝나는 시간 - 처음 시간]으로 계산을 해주었다.

▶ 이렇게 끝나는 시간 - 처음 시간을 해주니 예제에서 - 시간 값을 가지는 경우가 나왔다.

다다음 생각

24시간 체계로 표현이 되지만 시작시간이 02:00:00이고 끝나는 시간이 01:00:00이라면 23시간이 흘러버린 것이다. 따라서 - 값을 처리해주기 위해서 초, 분, 시간 순으로 - 값인지 확인 한 후 처리를 해주었다.

▶ 초 값이 - 가 나왔다면 초는 60 초까지이므로 +60을 해주어 양수로 만들어 주었다. - 값이라는건 분단위가 하나 빨라져야한다는 것이므로 분을 -1 해주었다.

▶ 이후 분 값을 판단하여 분이 - 가 나왔다면 분은 60분 까지이므로 +60을 해주어 양수로 만들어주었다. 분이 - 값이라는건 시간이 1시간 빨라져야 한다는 것이므로 시간을 -1 해주었다.

▶ 마지막으로 시간을 체크해서 시간이 - 라면 시간은 24시간 까지이므로 +24를 해주었다.

다다다음 생각

시, 분, 초를 위와같은 과정으로 다 계산한 뒤 출력의 형식은 xx:xx:xx을 맞춰야하므로 숫자가 1자리 일때 앞에 0을 붙여주는 작업을 한뒤 출력해주었다.

방안

1) Java 풀이

package swexpert.d3;
 
import java.io.BufferedReader;
import java.io.InputStreamReader;
 
public class Q7732 {
    static int n;
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
 
        n = Integer.parseInt(br.readLine());
        for(int z = 1; z <= n; z++) {
            String[] sTime = br.readLine().split(":");
            String[] eTime = br.readLine().split(":");
 
            // 초 따져주기
            int second = Integer.parseInt(eTime[2])
                    -Integer.parseInt(sTime[2]);
            // 분 따져주기
            int minute = Integer.parseInt(eTime[1])
                    -Integer.parseInt(sTime[1]);
            // 시간 따져주기
            int hour = Integer.parseInt(eTime[0])
                    -Integer.parseInt(sTime[0]);
 
            // - 따져주기
            if(second<0) {
                second+=60;
                minute-=1;
            }
 
            if(minute<0) {
                minute+=60;
                hour-=1;
            }
 
            if(hour<0) hour+=24;
 
            sb.append('#').append(z).append(' ');
            if(hour<10) sb.append('0').append(hour);
            else sb.append(hour);
            sb.append(':');
 
            if(minute<10) sb.append('0').append(minute);
            else sb.append(minute);
            sb.append(':');
 
            if(second<10) sb.append('0').append(second);
            else sb.append(second);
 
            sb.append('\n');
        }
        System.out.println(sb);
    }// end of main
}// end of class
 

Colored by Color Scripter

[해외연수] SSAFY 폴란드 해외 연수 후기

머어하지 — Fri, 14 Jun 2019 18:51:47 +0900

싸피(SSAFY)란?

싸피(SSAFY)란 Samsung SW Academy For Youth 즉, 삼성 청년 SW 아카데미의 약자입니다. 삼성에서 주관하는 청년들을 위한 SW 교육입니다. 자세한 사항 및 신청은 싸피 홈페이지(https://www.ssafy.com/ksp/jsp/swp/swpMain.jsp )에서 직접 확인해 보실 수 있습니다.

나에게 싸피란?

나에게 싸피란 2018년 말부터 2019년도까지 가장 잘 선택한 일 중 하나라고 당당히 말할 수 있을 것 같습니다. 싸피 1기에 지원해서 합격하여 양질의 교육, 그리고 이를위한 여러 지원들 마지막으로 해외연수의 기회까지 많은걸 배울 수 있었습니다.

해외 연수!!!

싸피로부터 다양한 지원들이 있었지만 가기전까지 가장 궁금하기도 했고, 선정된 후에는 살짝 두렵기도 했던게 바로 해외 연수였습니다. 싸피 해외 연수 대상자로 선정되었다는 소식을 들었을 때에도 "엥??? 내가?!?!" 라는 생각을 했었습니다. 베트남, 인도, 우크라이나, 중국, 폴란드의 총 5개국 중 '폴란드'로 해외 연수 국가가 확정이 났고 걱정 반 기대 반.. 생각을 하면서 폴란드로 가는 비행기에 몸을 실었습니다! (인천 공항에서 출국전에 밥먹다가 우연히 컬링 팀인 팀킴을 만나기도 했습니다ㅎㅎ)

비행기를 타고 11시간 정도를 날아가 도착한 폴란드..! 연수!! 즉, 일하러 온것인 만큼 다음날 부터 2주간의 업무가 시작되었습니다. 등장부터 웅장해보이는 건물이 저희 일행을 반겨주었습니다. 전체를 SRPOL(삼성 리서치 폴란드)이 사용하는 것은 아니지만 상당 부분을 사용하고 있습니다.

건물에있던 서울 미팅룸이 2주간 저희만 사용할 수 있도록 배정이 되어있어서 연수생들을 위한 준비가 많이 되어있구나를 처음부터 느낄 수 있었습니다. 업무를 배정받고.. 그날부터 외국인 멘토분과 업무를 진행하게 되었습니다.

국내에서 해도 긴장이 많이되고 걱정도 많이 되었겠지만, 해외로 연수를 와서 외국인 멘토분과 진행을 한다고 생각할 때마다 '잘 할 수 있을까??' 라는 걱정이 엄청나게 들었던 저였습니다. 하지만 멘토와 2주간의 업무를 진행하면서 내린 결론은 '모르는 것이 있을 때 이끌어 주는 멘토분이 있다는 것은 참 든든하다' 였습니다.

프로젝트를 진행하면서 프로그래밍을 알려주시는 역할로서도 많은 배움도 얻었지만, 그 과정에서 외국인 멘토분과 의사소통을 진행하면서 언어가 다르기에 100% 이해할 수는 없었지만 저를 이해시키기 위해서 손짓 발짓 다해가시면서 프로젝트를 진행하면서 말로는 잘 표현할 수 없는 다양한 경험을 얻게 된 것 같습니다ㅎㅎ 메모장으로도 대화를 시도해주시고 문서를 가져와서 보여주시면서 흐름을 알려주시고.. Maciej Jurewicz 멘토님.. 다시금 생각하니 저때문에 고생을 정말 많이 한 것 같습니다! 요런 것만으로도 멘토님이 저를 잘 챙겨주시고 있다는게 느껴졌었는데, 귀국 전 마지막 업무날에는 같은 층에있던 다른 팀에 양해를 구하셔서 저를 데리고 다니면서 로봇 체험도 하면서 정말 다른 나라에서 온 연수생이지만 저를 챙겨주고 계신다는 것을 몸으로 느껴보았습니다.

2주간 업무를 진행하면서 멘토님과 보안 외적으로 업무적인 사진도 하나 찍고~! 일도 배우고자 연수를 온것이니 최선을 다해 열시미 하니 빠르게 2주가 지나가버렸습니다.

취준생의 입장에서 '현장에서는 어떻게 업무를 진행할 까?' 라는 생각을 한 번쯤은 해보셨을 수 있습니다. 저는 이번 싸피 해외 연수에서 과제를 진행하면서 회사에서 협업을 위해 사용하는 툴들을 보고 또, 사용해보면서 협업의 중요성을 더 느껴본게 가장 큰 성과중 하나가 아닐까 생각했습니다. 자그마한 일에도 여러 분류로 나누어져 각각의 역할을 맡아 진행하는 것을 보며, 연수 중에 저도 제가 맡은 일을 잘 하고 싶다는 생각이 들기도 하였습니다ㅎㅎ 또, 제가 작성한 코드를 지라와 같은 협업 툴을 통해 리뷰를 보내 코드 리뷰를 받으면서, 개성있는 스타일이 아닌 다른 사람들도 알아보기 쉽도록 클린 코드를 작성하는 법을 배우면서 회사에서는 나만의 코드가 아닌 서로 이해할 수 있는 코드를 작성하는 법과 그 중요성을 알게 되었습니다. 또, 현장에서 가장 큰 장애물로 다가왔던게 있다면 바로 업무에서 진행했던 언어들이 제가 알고있었던 언어가 아닌 다른 언어를 사용해서 프로젝트를 진행하고 있었다는 것입니다. 이러한 문제들에 대해서 멘토님에게 질문을 드리면 좋은 답변들을 많이 해주셨고, 한 가지 언어에 대한 깊은 이해가 있다면 다른 언어들도 좀 더 수월하게 배울 수 있다는 것을 직접 체감하면서 기초를 좀 더 튼튼히 다져 놓아야 겠다는 생각이 많이 들었던 연수였습니다.

처음에는 '잘 할 수 있을까?'라는 생각으로 갔던 연수였지만 제 생각보다 몇 배는 얻을게 많았던 싸피 해외 연수!! 후에 이 글을 읽으시는 싸피생분이 계시다면 교육 꼭꼭 열시미 받으셔서 해외 연수에 가보시길 정말 추천드립니다 :)!!! 폴란드 연수생분들과 멘토들 그리고 프로젝트 외적인 문제들에 대해서 항상 신경써주셔서 감사한 담당 주재원님 분들과의 사진으로 글을 마무리 하겠습니다.

2주동안 다들 정말 감사했습니다!!!

[백준] 6593번 상범 빌딩

머어하지 — Tue, 2 Apr 2019 23:46:59 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q1000/Q6593.java 상범이가 빌딩을 탈출할 수 있다면 양식에 맞춰 최단 시간을 출력하고 탈출할 수 없다면 탈출 불가일 때의 문자를 출력하여라.

처음 생각

이전에 풀었던 문제인 [백준] 7569번 토마토 와 비슷하게 풀어볼 수 있는 문제이다.

다음 생각

여러개의 케이스가 주어지고 입력이 조금 특이하게 라인 단위로 띄워져 있기 때문에 입력을 받을 때 이부분을 조심해야한다.

다다음 생각

3차원 적으로 생각을 해야하기에 3차원 배열을 생성해서 길을 찾아갈 수 있도록 해주었다.

▶ 다차원 배열은 메모리를 많이 잡아먹기 때문에 따로 visited 배열을 만들어 주지않고, 원본 배열을 갈 수 있는 길인 '.'을 '#'로 바꿔주어 방문처리를 해주었다.

다다다음 생각

3차원 배열로 빌딩의 상태를 모두 받았다면 queue를 이용해서 BFS 탐색을 통해 최단거리로 탈출구를 만날 수 있는가를 판단해주었고, BFS 탐색이 끝나서 while문을 빠져나온 경우는 탈출에 실패한 경우이므로 탈출 불가를 출력해주었다.

다다다다음 생각

배열로 쓸 queue를 생성할 때는 맵의 크기가 최대 30*30*30이므로 그보다 큰 값으로 적당히 만들어 주었다.

방안

1) Java 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
package baekjoon.q1000;
 
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class Q6593 {
    static int l,r,c;
    static int[][] q = new int[29000][3];
    static int[][][] arr = new int[30][30][30];
    static int[] dx = {1,0,-1,0,0,0};
    static int[] dy = {0,1,0,-1,0,0};
    static int[] dz = {0,0,0,0,1,-1};
    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
 
xx:        while(true) {
            StringTokenizer st = new StringTokenizer(br.readLine(), " ");
            l = Integer.parseInt(st.nextToken());
            r = Integer.parseInt(st.nextToken());
            c = Integer.parseInt(st.nextToken());
            if(l==0) {
                break;
            }
            int sx = 0,sy = 0, sz = 0;
            for(int i=0;i<l;i++) {
                for(int j=0;j<r;j++) {
                    String t = br.readLine();
                    for(int k=0;k<c;k++) {
                        char tt = t.charAt(k);
                        arr[i][j][k] = tt;
                        if(tt=='S') {
                            sx = j;
                            sy = k;
                            sz = i;
                        }
                    }
                }
                br.readLine();
            }
            int front = 0,rear = 0;
            q[++rear][0] = sx;
            q[rear][1] = sy;
            q[rear][2] = sz;
            int time = 0;
            while(front<rear) {
 
                time++;
                int size = rear-front;
                for(int i=0;i<size;i++) {
                    int x = q[++front][0];
                    int y = q[front][1];
                    int z = q[front][2];
 
                    for(int j=0;j<6;j++) {
                        int tx = x+dx[j];
                        int ty = y+dy[j];
                        int tz = z+dz[j];
                        if(tx<0||ty<0||tz<0||tx>=r||ty>=c||tz>=l) continue;
                        if(arr[tz][tx][ty]!='#') {
                            if(arr[tz][tx][ty]=='E') {
                                sb.append(String.format("Escaped in %d minute(s).", time)).append('\n');
                                continue xx;
                            }
                            q[++rear][0] = tx;
                            q[rear][1] = ty;
                            q[rear][2] = tz;
                            arr[tz][tx][ty] = '#';
                        }
                    }
                }
            }// end of while(front<rear)
            sb.append("Trapped!").append('\n');
        }// end of while(true)
        System.out.println(sb);
    }// end of main
} // end of class

[Java] 배열로 Stack을 구현해보자!

머어하지 — Tue, 26 Feb 2019 23:47:46 +0900

[Java] 배열로 Queue를 구현해보자!에서 배열을 사용해 다른 자료구조(Queue) 처럼 이용할 수 있었습니다.

Stack도 Queue와 마찬가지로 배열로 해당 자료구조 처럼 사용할 수 가 있습니다.

물론 선행으로 배열의 크기를 정해주어야하니 최대로 들어올 자료의 수를 알고있어야 합니다.

그럼 배열로 간단하게 Stack을 구현해 보겠습니다.

배열을 이용한 Stack이므로 배열을 만들어 주었습니다.

1
int[] stack = new int[100];

Stack은 FILO(First In Last Out) 구조이므로 꺼낼 자료는 항상 top에 있는 자료 입니다. 따라서 꼭대기를 가리킬 top 변수를 선언해 주겠습니다.

1
int top = -1;

이제 배열로 만든 stack에 자료를 넣어보겠습니다. 일반적인 stack의 사용인 push 메서드의 호출은 필요없습니다. 그저 넣을 배열의 index인 top 변수를 이용하면 됩니다.

1
stack[++top] = 3;

배열로 만든 stack에 3을 넣었습니다. 조금 더 넣어보겠습니다.

1
2
stack[++top] = 4;
stack[++top] = 5;

3이후로 4와 5를 더 넣어주었습니다. 그럼 넣어둔 자료를 사용해보겠습니다. pop 메서드의 호출은 필요없습니다.

1
2
3
System.out.println(stack[top--]);
System.out.println(stack[top--]);
System.out.println(stack[top--]);

top 변수를 이용해 꼭대기에 있는 자료를 꺼낸뒤 top의 값을 -1 처리해주면됩니다. 좀 더 일반적인 Stack 처럼 만들고 싶드면 push()와 pop() 메서드를 따로 만들어서 변수를 받아 위의작업을 해주거나 return 값을 돌려주면 됩니다.

위의 예제에서 사용한 코드는 맨 아래있으며 그 출력은 다음과 같습니다.

1
2
3
4
5
6
3 넣음
4 넣음
5 넣음
5 나옴
4 나옴
3 나옴

아주 간단하게 Stack을 구현했지만 약간의 의구심이 들수도 있습니다. "왜 배열을 이용해서 자료구조를 구현해보는 걸까요?" 답은 간단합니다. 빠릅니다. 자료수의 최대값 이상으로 배열을 만들어서 메모리를 낭비하고 스피드를 얻는 전략? 입니다. 배열은 자료구조 중 읽기 쓰기가 가장 빠른 자료구조에 속하기 때문입니다.

배열로 만들어 쓰는 Queue와 Stack은 항상 index를 넘어가지 않도록 관리를 잘 해주기만 한다면 완성한 알고리즘의 속도를 조금은 더 빠르게 해줄 것 입니다!

<예제 코드>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Main {
    public static void main(String[] args) {
        int[] stack = new int[100];
        int top = -1;
        
        stack[++top] = 3;
        System.out.println("3 넣음");
        stack[++top] = 4;
        System.out.println("4 넣음");
        stack[++top] = 5;
        System.out.println("5 넣음");
        
        System.out.println(stack[top--]+" 나옴");
        System.out.println(stack[top--]+" 나옴");
        System.out.println(stack[top--]+" 나옴");
    }
}// end of class

[SW Expert] 6959. 이상한 나라의 덧셈게임

머어하지 — Sat, 16 Feb 2019 22:55:44 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/swexpert/d4/Q6959.java 양수가 주어진다. 예를들어 1234가 주어지면 연달아 있는 두개의 숫자를 선택한다. 23을 선택했으면 154로 만들 수 있고, 34를 선택했으면 127을 만들 수 있다. 이런식으로 두사람이 숫자를 더해주면서 번갈아 게임을 진행했을 때 1자리 숫자가 남게되면 그 차례 사람이 진다. 이긴 사람을 출력하여라.

처음 생각

다양한 풀이가 있을것 같다는 생각이든다. A,B 엘리스와 토끼가 번갈아가면서 게임을 진행하고 최선을 다해 게임에 임한다고 한다.

▶ 최선을 다하든 최선을 다하지 않고 게임에 임하든 한 자리가 될 때까지 게임의 진행 횟수는 같다.

다음 생각

그래서 처음에는 각 자리수를 모두 더한다음 그 수를 10으로 나누어 몇 번 10이상이 반복되는지 찾으려고 했지만 다음과 같은 반례가 있었다.

▶ 1189 이면 각 수를 다더하면 19가 나오고 /10을 하면 1 그리고 4자리 수이므로 기본 3번은 합쳐야 하므로 1+3으로 총 4번으로 판단을 했었다.

▶ 하지만 1189같은 수는 다음과 같이 자리수가 바뀌지 않는 즉, 수를 합쳤을 때 10이상이 되는 구간이 2번 진행이된다.

1189

289

109

다다음 생각

수학적으로 생각해보려다 잘 안됐지만 어찌어찌하면 위 방법으로도 풀 수는 있을 것 같다. 다시 문제로 돌아와서 어떤 숫자를 가지고 앞에서부터 더하든 뒤에서부터 더하든 중간에서부터 더하든 게임의 횟수는 같다. 더하기 연산 이기 때문이다.

다다다음 생각

따라서 앞에서부터 게임을 진행해주면서 더했을 때 10이상이라면 그 수를 더해준뒤 다음 수를 더해주는 방식으로 게임 횟수를 카운트 하였다.

방안

1) Java 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package swexpert.d4;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class Q6959 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        int tc = Integer.parseInt(br.readLine());
 
        for(int z=1;z<=tc;z++) {
            sb.append('#').append(z).append(' ');
            String t = br.readLine();
            int len = t.length();
            int sum = 0;
 
            // 어차피 수는 똑같으므로 앞에서부터 단계만 따져주자.
            int cnt = 0;
            for(int i=0;i<len;i++){
                sum += t.charAt(i)-'0';
                cnt++;
                // 2개를 더해서 2자리가 나오면 더해주기
                if(sum>=10){
                    sum = sum/10 + sum%10;
                    cnt++;
                }
            }
            // 짝수번 진행이 아니면 B의 승리 (A부터 시작이니)
            if(cnt%2!=0) sb.append('B').append('\n');
            else sb.append('A').append('\n');
        }
        System.out.println(sb);
    }// end of main
}// end of class

[SW Expert] 6782. 현주가 좋아하는 제곱근 놀이

머어하지 — Thu, 7 Feb 2019 23:54:52 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/swexpert/d5/Q6782.java 2이상의 정수 N이 주어진다. N은 다음 2개의 규칙으로 바꿀 수 있다. 1) sqrt(N)이 정수라면 N을 sqrt(N)으로 바꿀 수 있다. 2) 그렇지 않다면 N을 N+1로 바꿀 수 있다.

처음 생각

처음엔 생각나는데로 풀이를 시작했다. 규칙대로 루트 N 값이 정수라면 N을 루트 N으로 바꿔주고, 그렇지 않다면 1씩 증가시켜주었다.

▶ N이 최대 10^12으로 숫자가 상당히 커서 시간 초과가 났다.

▶ 루트 N이 정수인지 확인한 방법은 간단하게 다음과 같이 확인하였다.

1 2	double t = Math.sqrt(n); if((int)t == t) {}

▶ Java에서 제공해주는 Math class의 sqrt 메소드를 사용해서 루트 n을 구한뒤, 이값을 정수형으로 type casting 해주어 둘이 같다면 원래부터 정수인 것으로 판단하였다.

다음 생각

시간 초과가 나는 부분은 1씩 증가하는 부분이라는 생각이 들어 해당 부분을 줄일 방법을 생각해 보았다.

▶ 첫 번째 생각은 테스트 케이스가 총 10000개이므로 배열에 모든 가능성을 미리 구해두고 꺼내는 방법이였다.

▶ 두 번째 생각은 결국 루트를 취했을 때, 정수가 될때까지 1씩 증가시키는 것이였으므로 현 루트를 취한 값에서 올림을 하여 다음 번 정수가 만들어지는 루트값을 찾는 방법이였다. 구현은 요 방법으로 하였다.

다다음 생각

작은 숫자로 생각을 해보자. 예를들어 11 이라는 숫자가 있다. sqrt(11) = 3.xxx 이 나올 것이다. 이 상태에서 올림을 해주면 정수 4가 되고, 이를 제곱해주면 16이 나오게된다. 따라서 11이 루트를 취하고 싶으면 16까지 1씩 증가해야한다.

▶ 여기서 (int)sqrt(11)+1을 통해서 4를 찾았고 11이 루트를 취하기 위해서는 16이 되어야한다는 사실을 이미 알고 있으므로 16-11을 통해서 5번의 과정을 거쳐야 하는 것을 단 번에 알 수 있다. 수가 커질 수록 제곱의 차이도 커지므로 1씩 더하는 과정을 크게 생략할 수 있다.

다다다음 생각

N의 범위가 10^12 이므로 long 타입으로 선언을 해준 뒤, 루트 N이 정수라면 바로 N을 루트 N으로 바꿔주고 그렇지 않다면 위의 과정을 통해서 (int)sqrt(N)+1의 제곱에서 N을 빼준 뒤 N을 (int)sqrt(N)+1로 바꿔주었다.

다다다다음 생각

이렇게 해서도 시간 초과가 나면 모두 미리 구해놓고 답만 쏙쏙 출력할 생각이였으나 숫자가 커도 sqrt(N)으로 수가 작아지기 때문에 시간이 조금 밖에 안걸렸다.

▶ 루트씩 크기가 작아지기 때문에 시간 복잡도는 O(logN) 일 것이다.

방안

1) Java 풀이

package swexpert.d5;
 
import java.io.*;
 
public class Q6782 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
 
        int tc = Integer.parseInt(br.readLine());
        for(int z=1;z<=tc;z++) {
            // 10^12
            long n = Long.parseLong(br.readLine());
            int result = 0;
            while(n!=2) {
                double t = Math.sqrt(n);
                if((int)t == t) {
                    n = (int)t;
                }else {
                    t = (int)t;
                    result += ((t+1)*(t+1)-n);
                    n = (int)Math.sqrt((t+1)*(t+1));
                }
                result++;
            }
            bw.write("#"+z+" "+result+"\n");
        }
        bw.flush();
    }// end of main
}// end of class

[Java] 배열로 Queue를 구현해보자!

머어하지 — Thu, 31 Jan 2019 23:45:56 +0900

Queue는 FIFO(First In First Out)의 구조를 가진 자료구조로 BFS를 구현할 때 많이 사용이 됩니다. 라이브러리가 있다면 사용하면 간단하게 Queue를 이용할 수 있지만 라이브러리를 쓰지 못하는 곳에서는 Queue를 구현해야만 합니다.

그렇다고 Queue를 구현하기에는 먼가 벅차게 느껴질 때!!! Queue에 들어가는 자료의 개수가 어느정도 일지 대략적으로라도 알 수 있을 경우는 배열을 이용해서 Queue처럼 사용할 수 있습니다!

1
int[] queue = new int[100];

예제로 사용할 queue라는 이름의 배열을 만들었습니다. 이제 queue 배열 안의 index를 가르킬 2개의 변수를 선언하겠습니다.

1
2
int front = -1;
int end = -1;

front는 queue 배열의 앞부분 즉, FIFO 를 구현하기 위해서 앞에서부터 자료를 선택하기 위한 변수입니다.

end는 queue 배열의 빈 공간 즉, 후에 들어온 자료를 넣어주기 위한 변수입니다.

queue에 자료를 넣어보겠습니다. int형 배열이므로 int형 변수를 넣어주었습니다.

1
queue[++end] = 3;

3을 넣어주었습니다. 몇 개의 자료를 더 넣어줘 보겠습니다.

1
2
3
4
queue[++end] = 7;
queue[++end] = 8;
queue[++end] = 1;
queue[++end] = 2;

빈 공간을 가리키는 end 변수를 +1 씩 시켜주면서 배열의 빈공간에 변수들을 넣어주었습니다. 이제 넣은 변수들을 꺼내보겠습니다.

1
int data = queue[++front];

간단하게 앞쪽부터 자료를 가리키는 front 변수를 +1 시켜줌으로서 처음 넣었던 자료에 접근하였습니다. 나머지 자료들도 모두 꺼내보겠습니다.

1
2
3
4
data = queue[++front];
data = queue[++front];
data = queue[++front];
data = queue[++front];

나머지 자료들도 front 값을 +1 씩 시켜줌으로서 FIFO 구조에 알맞게 앞서 넣은 자료에 먼저 접근하도록 하였습니다.

위의 배열이 queue와 같이 FIFO 구조로 잘 동작하고 있는지 출력을 해보았습니다. 최종 코드는 다음과 같습니다.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
int[] queue = new int[100];
int front = -1;
int end = -1;
 
System.out.println("3 넣음");
queue[++end] = 3;
System.out.println("7 넣음");
queue[++end] = 7;
System.out.println("8 넣음");
queue[++end] = 8;
System.out.println("1 넣음");
queue[++end] = 1;
System.out.println("2 넣음");
queue[++end] = 2;
 
int data = queue[++front];
System.out.println(data+" 뻄");
data = queue[++front];
System.out.println(data+" 뻄");
data = queue[++front];
System.out.println(data+" 뻄");
data = queue[++front];
System.out.println(data+" 뻄");
data = queue[++front];
System.out.println(data+" 뻄");

출력은 다음과 같이 잘 나왔습니다.

1
2
3
4
5
6
7
8
9
10
3 넣음
7 넣음
8 넣음
1 넣음
2 넣음
3 뻄
7 뻄
8 뻄
1 뻄
2 뻄

queue에 넣을 자료의 개수만 대략적으로 알 수 있다면 그보다 넉넉히 배열을 선언해서 Queue의 역활로 사용할 수 있는 것에 대해 알아보았습니다! 다음엔 Class를 이용해서 실제 Queue를 구현해 보겠습니다.

[SW Expert] 6731. 홍익이의 오델로 게임

머어하지 — Mon, 14 Jan 2019 21:34:44 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/swexpert/d4/Q6731.java 오델로의 판이 주어진다. 한 칸을 선택하면 해당 칸의 가로줄 세로줄이 모두 뒤집힌다. 초기 상태(모두 흰색)로 만들 경우 뒤집어야하는 최소 칸수를 선택하여라.

처음 생각

몇 몇 질문들을 보면서 글을 작성해본다.

문제를 보면 우선적으로 드는 생각은 DFS를 이용하는 방법이다. 조합을 만들거나 DFS를 통해 검은돌이나 흰돌을 선택해 나가면서 진행을 하고자하는 생각이 무럭무럭 든다.

▶ 하지만 배열이 최대 1000*1000 이다. 따라서 모든 경우를 따져주기에는 시간이 많이 부족하다. 조합을 만들어 주는 경우도 몇 십개만 되도 많은 시간이 걸리므로 모든 경우를 따져주는 생각을 버려야했다.

다음 생각

그럼 시간을 어떻게 줄일 수 있을까? 고급 알고리즘을 모르는 상태에서 생각나는건

1) DP

2) 수학적인 방법으로 접근

3) 규칙 찾기

정도를 생각해 볼 수 있다.

▶ 오델로 문제의 경우는 수식 풀이가 아니므로 DP와 수학 방법을 제쳐두고 규칙을 찾아보자는 생각을 하였다.

다다음 생각

과연 규칙은 어떻게 찾아야 할까? 모든 오델로 판의 상태에서 적용이 가능해야 하기때문에 단계별로 공통점을 찾고자 하였다. 4칸의 오델로 상태를 예로들어보자.

▶ 초기 상태에서 그냥 아무칸이나 선택했을 경우의 판은 다음과 같다.

오델로1

▶ 거기서 그냥 아무칸이나 또 선택했을 경우의 판은 다음과 같다.

오델로2

▶ 또 이어서 그냥 아무칸이나 또 선택했을 경우의 판은 다음과 같다.

오델로3

▶ 딱보고 공통점이 보인다면 이미 상당한 실력자임이 틀림없을 것이다. 더군다나 표시한다고 빨간 펜까지 더해져서 지저분한 저 그림을 보면서 드는 생각은 없을 수 도 있다...

▶ 그렇다면 어떻게 해야할까? 위의 과정을 거치면서 했던 일은 한 가지이다. v표시를 한 곳을 선택하면 그곳의 가로줄과 세로줄을 뒤집어 주었다. 즉, v 표시를 한 곳을 기점으로 주변의 상태가 변한다는 것이다.

다다다음 생각

오델로.. 판.. 검정색.. 흰색... 한 곳을 기점으로 상태가 바뀐다.. 수식을 쓸 수도 없고 멀 해볼 수도 없고 단순히 변화의 중심을 기점으로 개수를 세기 시작했다. 다시 위 사진 3개를 보면서 개수를 세어보자. 초기상태에서 변화하는 과정을 찾아내는게 문제이므로 중점을 기준으로 바뀌는 검은돌을 세아렸다.

▶ 첫번째

오델로4

▶ 두번째

오델로5

▶ 세번째

오델로6

▶ 앞에서 뒤집었던걸 까먹었을 수도 있으니 개수를 센 각 사진에 뒤집힘을 표시해보자.

오델로7

▶ 놀랍게도 오델로를 뒤집은 칸은 주변 검은색 개수가 홀수개인 것을 볼 수 있었다.

▶ 조금 생각을 해보면 주어지는 N이 무조건 짝수이므로 가로 세로가 겹치는 구간인 뒤집은 부분은 홀수의 개수를 얻을 수 밖에 없다!!!!!

다다다다음 생각

이제 오델로를 뒤적거리며 개수를 세어주어야한다. 입력이 최대 1000*1000이므로 한칸 한칸 모든 칸을 이중 반복문으로 확인을 하면 최대값일 경우만 따져도 엄청난 시간이 걸리게된다. 따라서 다음과 같이 해결하였다.

▶ 같은 가로줄 한 줄의 검은돌의 개수는 모두 같다.

▶ 같은 세로줄 한 줄의 검은돌의 개수는 모두 같다.

▶ 즉, 가로줄을 한 번만 탐색해서 돌의 개수를 모두 찾은 뒤, 해당 가로줄의 개수 배열에 모두 같은 값을 넣어 주었다.(세로줄도 마찬가지이다.)

다다다다다음 생각

앞서 각 가로줄과 세로줄은 모두 같은 개수를 가지고 있으므로, 시간을 좀 더 줄여보기위해서 일차 배열 2개(garo[n],sero[n] 크기)를 만들어서 입력을 받으면서 바로 개수를 카운트 해주었다.

▶ 가로 세로의 합계를 계산할 때, 해당 칸이 흰색이냐 검은색이냐도 판단을 해주어야한다. 검은색일 경우는 카운트가 한 번 중복되서 들어가기 때문에 -1을 해주어야한다.

방안

1) Java 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package swexpert.d4;
 
import java.io.*;
 
public class Q6731 {
    static int n;
    static char[] garo,sero;
    static boolean[][] arr;
    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        int tc = Integer.parseInt(br.readLine());
 
        for(int z=1;z<=tc;z++){
            n = Integer.parseInt(br.readLine().trim());
            arr = new boolean[n][n];
            garo = new char[n];
            sero = new char[n];
            // W = false, B = true
            for(int i=0;i<n;i++){
                String t = br.readLine();
                // 입력 하면서 가로 세로 개수 세기
                for(int j=0;j<n;j++) {
                    if (t.charAt(j) == 'B') {
                        arr[i][j] = true;
                        garo[i]++;
                        sero[j]++;
                    }
                }
            }
 
            int result = 0;
            for(int i=0;i<n;i++){
                for(int j=0;j<n;j++){
                    int t = garo[i]+sero[j];
                    if(arr[i][j]){
                        // 검은색일 경우 -1해주기
                        if(--t%2!=0) result++;
                    }else{
                        if(t%2!=0) result++;
                    }
                }
            }
            bw.write("#"+z+" "+result+"\n");
        }// end of tc
        bw.flush();
    } // end of main
}// end of class
 

[SW Expert] 3752. 가능한 시험 점수

머어하지 — Sun, 13 Jan 2019 20:03:38 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/swexpert/d4/Q3752.java 시험 점수가 주어진다. 해당 점수들을 가지고 가능한 시험점수들의 개수를 출력하여라. 모든 점수를 선택하지 않은 0점도 시험점수이다.

처음 생각

SW Expert의 D3 몇 개 부터 최적화를 상관안하고 풀면 못푸는 문제들이 나오기 시작한다.

▶ 글쓴이는 그런걸 잘 못합니다!

▶ 최근 DP에 관한 기초적인 문제를 풀지 못해서 기초 DP 문제들을 풀어보면서 익혀보고 있었는데 마침 문제를 둘러보다가 DP로 풀면 될것 같아서 풀어보았다.

다음 생각

주어진 시험 점수를 가지고 가능한 시험점수들을 모두 만들어주어야한다. 일반적인 접근을 했다면 모든 조합을 만들어주어서 점수들을 더해 주었을 것이다.

▶ 그리고는 시간초과를 얻었을 것이다!

다다음 생각

다이나믹 적으로 접근을해보면 단순히 시험 점수들을 점점 누적시켜주면 된다. 그렇다면 어떻게 누적시켜 주어야 할 까?가 문제가 된다.

▶ 점수의 개수를 바탕으로 각 점수별로 만들 수 있는 점수를 누적해 나갔다.

▶ 우선, 만들 수 있는 점수의 개수를 카운트하면 되므로 boolean형 배열을 들어온 점수로 만들 수 있는 최대 값 + 여분 만큼 만들어 주었다.

다다다음 생각

0점도 점수이므로 dp[0] = true를 기본으로 해준 뒤, 모든 점수 값을 더한 sum부터 0점 까지 각 점수마다 돌면서 dp[점수] = true 일 경우 현 기준이 되는 점수를 더해주어 새로운 점수를 true로 만들어 주었다.

▶ dp[점수 + 현 기준 점수] = true

▶ 0~sum이 아닌 sum~0으로 반복문을 돌아야한다. 0 부터 반복문을 돌릴경우 true로 만들어준 점수가 계속해서 누적이 되기 때문이다. 예를들어 현 기준점수가 1점일 경우, 맨 처음의 0점일 때와 만나

dp[0+현 기준 점수 1점] = dp[1] = true가 된다.

그리고 반복의 index가 올라가면서(2,3,4...sum) 모든 점수가 true가 될 것이다.

dp[1+현 점수 1점] = dp[2] = true

dp[2+현 점수 1점] = dp[3] = true.. 가 끝까지 반복 될 것이다. 한개의 점수를 무제한으로 사용할 수 있다면 상관이 없지만 1번 씩 사용가능하니 이 경우는 틀린 경우가 된다.

▶ 반대로 sum~0으로 뒤에서부터 진행을 해주면 0점일 때, dp[0+현 점수 1점] = dp[1] = true가 진행되고 현 점수에 대한 반복문이 끝나게 된다.

다다다다음 생각

무작정 푸는 문제는 점점 사라지고 있는 현 시대에서 여러 최적화 방법들이 조금은 어렵더라도 부딪혀봐야겠다.

방안

1) Java 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package swexpert.d4;
 
import java.io.*;
import java.util.StringTokenizer;
 
public class Q3752 {
    static int n;
    static int[] arr;
    static int sum,result;
    static boolean[] dp;
    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        int tc = Integer.parseInt(br.readLine());
        for(int z=1;z<=tc;z++){
            n = Integer.parseInt(br.readLine());
            arr = new int[n];
            StringTokenizer st = new StringTokenizer(br.readLine());
 
            sum = 0;
            for(int i=0;i<n;i++) {
                arr[i] = Integer.parseInt(st.nextToken());
                sum += arr[i];
            }
 
            dp = new boolean[sum+10];
            dp[0] = true;
            // 각 점수별로 만들 수 있는 점수를 만들어 주자.
            for(int i=0;i<n;i++){
                for(int j=sum;j>=0;j--){
                    // 가능한 점수를 만나면 현 점수 더해주기
                    if(dp[j])
                        dp[arr[i]+j] = true;
                }
            }
            result = 0;
            for(int i=0;i<=sum;i++)
                if(dp[i]) result++;
            System.out.println("#"+z+" "+result);
        }
    }
}
 

[Java] 다중 반복문에서 라벨(label)을 사용해보자

머어하지 — Sun, 6 Jan 2019 22:50:18 +0900

알고리즘 문제를 풀다보면 2차 이상 배열의 탐색을 위해 다중 반복문을 쓰는 경우가 많습니다. 예를들어 아래와 같은 경우입니다.

1
2
3
4
5
6
7
int[][] arr = new int[n][n];
 
for(int i=0;i<n;i++){
    for(int j=0;j<n;j++){
                
    }
}

간단한 예제로 위의 2차 배열에서 1을 찾았을 경우 전체 반복문을 빠져나오는 코드를 작성해 보겠습니다.

1
2
3
4
5
6
7
8
9
10
11
12
int[][] arr = new int[n][n];
 
boolean flag = false;
for(int i=0;i<n;i++){
    for(int j=0;j<n;j++){
        if(arr[i][j]==1){
            flag = true;
            break;
        }
    }
    if(flag) break;
}

boolean형 변수 flag를 선언하여 1을 발견했을 시에 flag의 값을 바꿔준 후 안쪽 반복문을 빠져나온 뒤 다시 flag 변수를 확인해서 바깥쪽 반복문의 break 처리를 해주었습니다.

방법이 잘 못 된것은 아니지만 Java에서는 좀 더 편하게 다중 반복문을 빠져나올 수 있는 방법이 있습니다. goto 문을 이용하는 법도 있지만 권장 사항은 아니므로 반복문에 라벨(Label)을 붙여 즉, 반복문에 이름을 부여하여 다중 반복문을 빠져나올 수 있습니다.

위의 예제에서 첫 번째 반복문에 xx란 라벨을 부여해보겠습니다.

1
2
3
4
5
xx:     for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                
            }
        }

첫 반복문 앞쪽에 '(이름):' 을 붙여주면 라벨이 부여되어 이제 저 반복문을 xx로 부를 수 있게됩니다. 그렇다면 이 라벨 붙인걸 어떻게 써먹을 수 있을까요? 마찬가지로 1을 찾을경우 전체 반복문을 빠져나가는 코드를 작성해 보겠습니다.

1
2
3
4
5
xx:     for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(arr[i][j]==1) break xx;
            }
        }

아주 간단하게 break xx;를 통해서 '1을 찾았을경우 가장 바깥쪽 반복문인 라벨이 xx를 빠져나가라' 라는 코드를 작성할 수 있습니다. 마찬가지로 다중 반복문에서 안쪽 내용을 무시하고 다시 위로 돌아가고 싶을 경우 continue 문도 이용 가능합니다.

1
2
3
4
5
xx:     for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(arr[i][j]==1) continue xx;
            }
        }

위와 같이 continue 문도 정상적으로 작동이 됩니다.

flag 변수를 이용해서 작성하는것도 좋지만 문제를 풀때는 시간적인 문제도 있으므로 이해할 수 있는 범위에서 최대한 간결히 작성하는게 좋다고 생각하므로 앞으로 라벨을 적극적으로 사용할 것 같습니다.

[SW Expert] 6019. 기차 사이의 파리

머어하지 — Mon, 24 Dec 2018 19:10:13 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/swexpert/d3/Q6019.java 기차 A,B가 A,B의 속력으로 서로를 향해 달리고 있으며, 파리가 A기차 시작점에있다. D A B F가 주어진다. D는 기차 사이의 거리 A는 A기차의 속력 B는 B기차의 속력 F는 그 사이에 있는 파리의 속력이다. A 기차에서 출발한 파리는 B기차에 닿을 때까지 F의 속력으로 이동한 후, 다시 A기차를 향해 날아간다. 그리고 A 기차에 닿으면 다시 B기차를 향해 날아간다. A,B 기차가 만나서 파리가 죽을 때까지 파리가 이동한 거리를 구하여라.

처음 생각

파리가 죽는다니! 끔찍한 문제지만 문제를 간단하게 생각하면 끔찍하지만은 않은 문제다.

▶ 수학적인 접근을 해야하는 문제들은 간단한 것 같으면서도 어렵다.

다음 생각

문제에서 다음과 같은 용어가 있다. <무한 급수> 급수를 배운지도 오래지났고 등비 등차의 공식도 곧바로 기억이 나지 않는다.

▶ 그래서 문제에서 힌트로 일반화된 버전을 구해보라고 준 것 같다.

다다음 생각

간단하게 생각해보면 A,B 기차가 만나기 전까지 파리가 F의 속력으로 날아다니면 된다. 그래도 아직 까먹지 않은 공식이 있다. [거리 = 속력 * 시간] 이다. 이 식을 변형해서 구할 수 있는건 다음과 같다.

▶ 거리 = 속력 * 시간

▶ 속력 = 거리 / 시간

▶ 시간 = 거리 / 속력

다다다음 생각

문제에서 거리와 속력이 주어졌기 때문에 위의 공식들을 사용해서 문제를 풀어보자.

▶ [시간 = 거리 / 속력]

▶ 우선 기차의 속력 A,B를 총 거리 D로 나누면 D/(A+B) 가 되고 이는 각 기차가 만나기 전까지의 시간이 된다.

▶ [거리 = 속력 * 시간]

▶ 파리가 날아다니는 시간은 각 기차가 만나기 전까지이다. 즉, 각 기차가 이동한 시간동안 파리가 날라다닐 수 있는것이다. 이를 공식에 대입해서 [파리가 날라다닌 시간 = 파리 속력 * 기차가 만나기까지 시간] 으로 간략히 할 수 있다.

다다다다음 생각

예시로 주어진 답이 200.000000로 소수 6번째 자리 까지이므로 printf를 이용해 출력해주었다.

▶

1
System.out.printf("#%d %.6f\n",i,result);

방안

1) Java 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.Scanner;
 
public class Solution {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int tc = sc.nextInt();
        for(int i=1;i<=tc;i++){
            int d = sc.nextInt();
            double a = sc.nextDouble();
            double b = sc.nextDouble();
            double f = sc.nextDouble();
            double mok = d/(a+b);
            double result = mok*f;
            System.out.printf("#%d %.6f\n",i,result);
        }
    }
}

[SW Expert] 5789. 현주의 상자 바꾸기

머어하지 — Sun, 16 Dec 2018 14:56:15 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/swexpert/d3/Q5789.java n개의 상자에대해서 q개의 작업을 준다. q개의 작업은 L R로 주어지며 1번째 작업일 경우 L부터 R까지 번째의 상자를 1번으로 3번째 작업일 경우는 L부터 R까지 번째의 상자를 3번으로 바꾼다. 최종 작업이 끝났을 때 상자의 상태를 출력하여라.

처음 생각

특정 구간에대해 주기적으로 상태를 바꿔주어야한다. Python으로 풀면 굉장히 쉽게 풀 수 있다. 하지만 일단 Java로 접근을 해보자.

다음 생각

크기가 n인 배열을 선언해준 뒤, q개의 작업을 받아 반복문의 범위를 L-1<= j <R 로 해주어 L-1부터 R-1까지의 상자들이 현 작업의 번호로 바뀌게 해주었다.

▶ 배열의 index가 0부터 시작해서 범위를 잘 봐주어야한다.

다다음 생각

q개의 작업이 끝나면 배열을 출력 조건에 맞게 출력해 주었다.

다다다음 생각

Python은 슬라이싱을 통해서 특정 구간의 값을 바꾸기가 매우쉽다.

▶ Python에서도 index의 시작이 0이므로 arr[L-1:R] 을 통해 배열에서 해당 구간을 슬라이싱 한다.

▶ arr[L-1:R] = [j]*(R-L+1) 을 통해서 슬라이스한 구간을 작업 번호를 나타내는 j로 R-L+1개 만큼 치환해준다.

▶ 이 두 줄로 끝이난다. 문제를 보고 Python으로 간단하게 구현할 수 있다면 Python으로 제출하는것도 좋은것 같다.

방안

1) Java 풀이

package swexpert.d3;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class Q5789 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        int tc = Integer.parseInt(br.readLine());
        for(int i=1;i<=tc;i++){
            StringTokenizer st = new StringTokenizer(br.readLine());
            int n = Integer.parseInt(st.nextToken());
            int q = Integer.parseInt(st.nextToken());
            // n 크기의 배열 선언
            int[] arr = new int[n];
            // q개의 작업이 주어진다.
            for(int j=1;j<=q;j++){
                st = new StringTokenizer(br.readLine());
                int l = Integer.parseInt(st.nextToken());
                int r = Integer.parseInt(st.nextToken());
                // L~R 까지 작업 번호로 바뀜.
                // 배열이 0부터 시작이니 L-1~R-1까지
                for(int k=l-1;k<r;k++)
                    arr[k] = j;
            }
            sb.append("#"+i);
            for(int j=0;j<n;j++)
                sb.append(" "+arr[j]);
            sb.append("\n");
        }
        System.out.println(sb);
    }
}

2) Python 풀이

tc = int(input())
for i in range(1,tc+1):
    n,q = map(int,input().split())
    arr = [0]*n
    for j in range(1,q+1):
        l,r = map(int,input().split())
        arr[l-1:r] = [j]*(r-l+1)
    print('#'+str(i)," ".join([str(i) for i in arr]))

[SW Expert] 5948. 새샘이의 7-3-5 게임

머어하지 — Sun, 16 Dec 2018 01:27:15 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/swexpert/d3/Q5948.java 7개의 숫자가 주어질 때 3개의 수를 더하여 만들 수 있는 수중 5번째로 큰 수를 출력하여라. 중복 숫자는 1개로 친다.

처음 생각

중복을 없앨 생각으로 Set 자료 구조를 생각하였다. Set은 중복을 불허하는 자료구조이다. Set에 담긴 자료들을 정렬하기 위해 List로 바꿔주기 위해 List도 선언해 주었다.

다음 생각

7개중 3개의 숫자 조합이므로 반복문 변수 j,k,z를 사용하였다.

▶ k의 경우는 j+1 부터 시작을, z의 경우는 k+1부터 시작을 하게 하였다.

▶ 이럴경우 중복된 숫자가 골라지지는 않겠지만 더했을 경우 같은 숫자들이 나올 수 있으므로 Set을 이용해 주는게 맞다.

다다음 생각

7개중 순서 상관없이 서로다른 3개를 뽑아 더하는 것이므로 최대 7C3 = 35개의 경우의 수가 생기므로 배열로 관리해도 충분 할 것 같다.

다다다음 생각

Python으로 문제를 풀경우 set 자료형이 존재하기 때문에 Java보다 조금 더 쉽게 처리를 할 수 있었다.

방안

1) Java 풀이

package swexpert.d3;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
 
public class Q5948 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int tc = Integer.parseInt(br.readLine());
        // 정렬을 위해서
        List<Integer> list = new ArrayList<>();
        // 중복 방지를 위해서
        HashSet<Integer> set = new HashSet<>();
        StringBuilder sb = new StringBuilder();
        int[] arr;
        for(int i=1;i<=tc;i++){
            StringTokenizer st = new StringTokenizer(br.readLine());
            arr = new int[7];
            for(int j=0;j<7;j++)
                arr[j] = Integer.parseInt(st.nextToken());
 
            // 초기화
            list.clear();
            set.clear();
            for(int j=0;j<7;j++){
                for(int k=j+1;k<7;k++){
                    for(int z=k+1;z<7;z++)
                        // 3개를 더한 값을 만들어 준다.
                        // 중복 제거를 위해 set을 사용
                        set.add(arr[j]+arr[k]+arr[z]);
                }
            }
            // 정렬을 위해 set의 자료들을 list로 만들어주기
            list.addAll(set);
            Collections.sort(list,Collections.reverseOrder());
            // 제일 큰거에서 5번째
            sb.append("#"+i+" "+list.get(4)+"\n");
        }
        System.out.println(sb);
    }
}

2) Python 풀이

▶ Python의 경우 itertools의 combinations를 이용하면 쉽게 해결할 수 있다.

from itertools import combinations
tc = int(input())
for i in range(tc):
    tList = list(map(int,input().split()))
    result = list(set(i[0]+i[1]+i[2] for i in combinations(tList,3)))
    result.sort()
    print("#"+str(i+1),result[len(result)-5])

[SW Expert] 6190. 정곤이의 단조 증가하는 수

머어하지 — Sat, 15 Dec 2018 19:02:38 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/swexpert/d3/Q6190.java n개의 수가 주어진다. 두 수를 곱한수가 단조 증가하는 수인 경우 그 최대값을 출력하여라. 단조 증가하는 수가 없다면 -1을 출력하여라. 단조 증가하는 수란 111122345 처럼 계속해서 증가하는 수다 1111144442, 12345675같은 수는 단조 증가하는 수가 아니다.

처음 생각

조합을 짜야하나 생각했지만 2개의 수만 곱하면 되므로 2중 반복문을 통해서 배열에 저장해둔 수들을 곱해주었다.

▶ 2중 반복문 구현시 각각의 변수를 i,j라 한다면 중복된 경우를 피하기 위해 j의 시작은 i+1부터 시작해 주면된다.

▶ 예를들어 1 2 3 4 가 주어졌다면 1*2나 2*1이나 같은 수이기 때문이다.

다음 생각

결과변수 result보다 두 수의 곱이 작다면 그 수가 단조 증가하는 수여도 결과값을 갱신할 필요가 없으므로 결과변수보다 두 수의 곱이 작은경우는 단조 증가하는 수 검사를 하지 않았다.

다다음 생각

반대로 두 수의 곱이 결과 변수보다 클경우 이 수가 단조 증가하는 수인지 검사를 해주었다.

▶ 나머지 연산을 통해서 확인하는 방법도 있겠지만 String으로 변환해서 앞에서부터 수를 확인해 감소하는 수가 있다면 false를 return하도록 하였다.

다다다음 생각

위의 확인 메소드가 true를 return 해주면 결과 변수 result를 갱신해주었다.

▶ 초기에 result 변수를 0으로 초기화 했었는데 문제상 증가하는 수가 없다면 -1을 출력해야하므로 -1 초기화로 바꿔주었다.

다다다다음 생각

위와같이 풀고나서 단조 증가하는 수를 찾는 방법을 나머지 연산으로 바꿔보았다. 문자열로 처리시에는 케이스가 많을경우 메모리와 시간이 더 걸리기 때문에 숫자로 처리를 해보았다. 결과는 아래와 같다.

▶

▶ 최적화의 중요성을 알 수 있었다.

방안

1) Java 풀이

package swexpert.d3;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class Q6190 {
    static int[] arr;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int tc = Integer.parseInt(br.readLine());
        for(int i=1;i<=tc;i++){
            int n = Integer.parseInt(br.readLine());
            arr = new int[n];
            StringTokenizer st = new StringTokenizer(br.readLine());
            for(int j=0;j<n;j++)
                arr[j] = Integer.parseInt(st.nextToken());
 
            // 2개의 곱이므로 2중 포문을 이용해 구해보자.
            // 두번째 곱해지는건 앞선것보다 인자가 크게한다(중복 방지)
            // 전부 양수이므로 초기값은 -1(수가 없다면 -1 출력이라)
            int result = -1;
            for(int j=0;j<n;j++){
                for(int k=j+1;k<n;k++){
                    // 결과 값보다 큰 값만 단조 증가 수 체크하자
                    if(result<arr[j]*arr[k])
                        if(solve(arr[j]*arr[k]))
                            result = arr[j]*arr[k];
                }
            }
            System.out.println("#"+i+" "+result);
        }
    }
 
    // 단조 증가하는 수 확인
    private static boolean solve(int n){
        int t = n%10;
        n /=10;
        while(n!=0){
            if(n%10>t) return false;
            t = n%10;
            n /=10;
        }
        return true;
    }
}

2) Python 풀이

def solve(n):
    t = n%10
    n = int(n/10)
    while n!=0:
        if n%10>t:
            return False
        t = n%10
        n = int(n/10)
    return True
 
tc = int(input())
for z in range(1,tc+1):
    n = int(input())
    arr = list(map(int,input().split()))
    result = -1
    for i in range(n):
        for j in range(i+1,n):
            if result<arr[i]*arr[j]:
                if solve(arr[i]*arr[j]):
                    result = arr[j]*arr[i]
    print('#'+str(z),result)

[SW Expert] 6718. 희성이의 원근법

머어하지 — Fri, 14 Dec 2018 21:34:09 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/swexpert/d3/Q6718.java 물건의 거리가 주어졌을 때, 주어진 방식으로 거리에 따라 수치를 매겨 출력하여라.

처음 생각

우선, 테스트케이스의 개수가 100,000개 이므로 StringBuilder를 통해 출력을 해주어야겠다고 생각하였다.

다음 생각

문제는 간단하다. 거리가 주어지면 그 거리에 해당하는 주어진 수치를 출력하면 된다. 조금 까다로운 점이라면 문제에서 거리는 m 단위로 주어지고 구분해야하는 수치는 km 를 기준으로 수치를 분류해놓았다.

▶ 1km는 1000m 임을 기억하면서 문제를 풀면된다.

다다음 생각

입력으로 들어오는 거리가 int형 범위를 넘지 않으므로 int로 입력을 받아주었다. 구분해야할 거리의 수치가 6개 밖에 되지 않으므로 조건문을 통해 해당 케이스들을 모두 분리해주었다.

▶ 조심해야할 점은 x이상 y미만 이므로 이상과 미만을 잘 보면서 km를 m로 변환하여 작성해주었다.

방안

1) Java 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package swexpert.d3;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
 
public class Q6718 {
    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();
        for(int i=0;i<n;i++){
            sb.append("#"+(i+1)+" ");
            int t = Integer.parseInt(br.readLine());
            // 1km = 1000m 모든 범위가 적으므로 분류해주자.
            if(t<100) sb.append(0);
            else if(t>=100&&t<1000) sb.append(1);
            else if(t>=1000&&t<10000) sb.append(2);
            else if(t>=10000&&t<100000) sb.append(3);
            else if(t>=100000&&t<1000000) sb.append(4);
            else sb.append(5);
            sb.append("\n");
        }
        System.out.println(sb);
    }
}

[백준] 15552번 빠른 A+B

머어하지 — Tue, 11 Dec 2018 22:07:05 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q10000/Q15552.java 각 A+B의 결과를 출력한다.

처음 생각

입력으로 받고 계산후 출력해야하는 개수가 최대 100만개로 매우 많으므로 Java의 경우 Scanner, Python의 경우 input() 을 그대로 사용하면 시간 초과가 날 가능성이 매우 크다.

▶ Java의 경우는 BufferedReader, Python의 경우에는 sys.stdin 을 이용해서 입력을 받아주면 된다.

▶ Java의 경우 StringBuilder나 BufferedWriter를 통해 입력을 누적해서 한 번에 출력을 해주어야 메모리 초과가 나오지 않는다.

방안

1) 방안

입력과 출력이 많다고 생각되는경우 이 문제와 같이 BufferedReader와 StringBuilder를 사용하면 메모리와 시간이 크게 줄어든다.

2) Java 풀이

package baekjoon.q10000;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class Q15552 {
    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();
        for(int i=0;i<n;i++){
            StringTokenizer st = new StringTokenizer(br.readLine());
            sb.append(Integer.parseInt(st.nextToken())+Integer.parseInt(st.nextToken())+"\n");
        }
        System.out.println(sb);
    }
}

3) Python 풀이

import sys
n = int(input())
for i in range(n):
    a,b = map(int,sys.stdin.readline().split())
    print(a+b)

[백준] 1978번 소수 찾기

머어하지 — Mon, 10 Dec 2018 23:42:14 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q1000/Q1978.java 주어진 숫자들 중 소수의 개수를 출력하여라.

처음 생각

소수를 구할 수 있는 다양한 방법들이 있지만 에라토스테네스 체를 사용하는것이 가장 간단하면서 괜찮은 속력을 보장해주는것 같다. 특히, 이처럼 다양한 숫자들을 검사해야할 때는 매번 소수 판별을 하는 것보다 에라토스테네스 체를 이용해서 한 번에 구해놓는것이 좋다.

▶ 범위가 1000까지 이므로 1000이하의 모든 소수를 구해놓은 뒤, 주어진 숫자들중 소수의 개수를 세어 출력해주었다.

방안

1) Java 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package baekjoon.q1000;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class Q1978 {
    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());
        int[] arr = new int[1001];
        // 1은 소수가 아니다
        arr[1] = 1;
        // 에라토스테네스 체(미리 구해놓기)
        for(int i=2;i<=1000;i++){
            for(int j=2;i*j<=1000;j++)
                arr[i*j]=1;
        }
 
        int result = 0;
        StringTokenizer st = new StringTokenizer(br.readLine());
        while(st.hasMoreTokens()){
            int t = Integer.parseInt(st.nextToken());
            if(arr[t]==0) result++;
        }
        System.out.println(result);
    }
}
 

2) Python 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
n = int(input())
 
# 1000 이하 소수 미리 찾기
arr = [0 for i in range(1001)]
 
for i in range(2,1001):
    if arr[i]!=0:
        continue
    for j in range(2,1001):
        if i*j>1000:
            break
        arr[i*j]=1
result = 0
# 1은 소수가 아니다
arr[1] = 1
t = list(map(int,input().split()))
for i in range(n):
    if arr[t[i]]==0:
        result+=1
print(result)

[백준] 1476번 날짜 계산

머어하지 — Sun, 9 Dec 2018 01:19:29 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q1000/Q1476.java 준규가 사는 나라는 다른 연도 계산법을 사용한다. E S M 으로 나눠지며 각 년도의 시작은 1이다. E는 1~15, S는 1~28, M은 1~19를 반복하며 1년이 지나면 각년도가 1씩 올라간다. 준규가 사는 나라의 년도가 주어졌을 때, 우리의 년도로 몇 년인지 출력하여라.

처음 생각

카잉 달력 문제 같은 경우랑 같은 풀이법을 적용하면된다. 다만 카잉 달력 같은 경우는 범위가 무척 크기 때문에 정직하게 풀 수 없었지만 이번 날짜 계산 문제는 제한 숫자가 적으므로 정직하게 풀어주었다.

▶ te,ts,tm 변수를 초기값 1로 선언해주고, e,s,m과 같아질 때까지 +1을 해주었다.

다음 생각

조건문을 통해 te는 15가 넘으면 다시 1로 ts는 28이 넘으면, tm은 19가 넘으면 1로 만들어 주었다.

▶ 위와같이 한 번 반복 할 때마다 우리가 사용하는 년수를 +1을 해주었다.

▶ te,ts,tm이 e,s,m과 같아지면 result 변수를 출력하고 반복문을 빠져나오게 하였다.

방안

1) Java 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package baekjoon.q1000;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
 
public class Q1476 {
    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        int e = Integer.parseInt(st.nextToken()); // 1~15
        int s = Integer.parseInt(st.nextToken()); // 1~28
        int m = Integer.parseInt(st.nextToken()); // 1~19
 
        // 변하는 각 변수 초기화
        int te = 1;
        int ts = 1;
        int tm = 1;
        int result = 0;
        while(true){
            result++; // 년도 증가
            // 입력값과 같아진 다면 년도 출력 후 종료
            if(e==te&&s==ts&&m==tm){
                System.out.println(result);
                break;
            }
            te++; ts++; tm++;
            // 각 범위를 넘어서면 1로 초기화
            if(te>15) te=1;
            if(ts>28) ts=1;
            if(tm>19) tm=1;
        }
    }
}
 

2) Python 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
e,s,m = map(int,input().split())
 
te=1
ts=1
tm=1
result=0
while True:
    result+=1
    if e==te and s==ts and m==tm:
        print(result)
        break
    te+=1
    ts+=1
    tm+=1
    if te>15:
        te=1
    if ts>28:
        ts=1
    if tm>19:
        tm=1

[일상] 2018년 에일리 콘서트(I AM AILEE) 를 갔다오다

머어하지 — Sun, 9 Dec 2018 00:44:21 +0900

오늘은 생애 첫 콘서트를 가보았다!! 그것도 디바로 소문난 에일리의 콘서트를!!

다음 주 월요일부터 교육을 다녀야 하기 때문에 마지막으로 논다는 생각으로 갔다왔다ㅎㅎ

학교 축제 같은 공연 말고 이렇게 정식으로 콘서트를 가보는건 처음이라 출발 전부터 준비물이 있어야하나 찾아보기도 하였지만 결론은 그냥 맘 편히 갔다오면 된다는걸 배웠다.

콘서트장에 도착하고 처음에는 그냥 바닥에 오밀조밀하게 놓여있는 플라스틱 의자를 보면서 값비싼 티켓의 값어치에대해서 살짝 실망을 했다. (참! 사람 엄청 밀리고 그럴거 같아서 돌아다니다 40분이나 일찍 갔는데 그냥 시작 5~10분 정도에 가면 충분할 것 같다.)

오랜 기다림 끝에 공연이 시작되고 웅장한 음악들과 레이저들이 나는 가만히 있는데 진동과 퍼포먼스로 몸을 울려댔다. 에일리님의 노래는 반주가 있으면 반주가 있는데로 반주가 없으면 반주가 없는데로 엄청난 가창력을 가지고 계셨고, 저 정도 실력을 가지고 있어야 가수로서 활동할 수 있겠구나 라는 생각을 들게할 정도로 엄청났다. 괜히 디바 소리를 들으시는게 아닌것 같았다.

다른 가수들 분도 오셔서 몇 곡 하고 가시고 특히 관중석 쪽으로 돌아다니면서 공연도 해주셔서 더 실감났던거 같다. 다음에 다른 좋은 분이 있으면 또 가고 싶다는 생각이 들게 해준 콘서트였다!

[백준] 4673번 셀프 넘버

머어하지 — Fri, 7 Dec 2018 23:03:54 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q1000/Q4673.java 양의 정수 n에대해서 n과 n의 각 자리수를 더하여 새로운 수를 만들 수 있다. 예를들어 33 이면 33+3+3=39, 39+3+9=51.... 이런 식으로 쭉 만들 수 있다. 이런식으로 만들 수 없는 수를 셀프 넘버라고 한다. 10000 이하의 셀프 넘버를 출력하여라.

처음 생각

입력이 주어지지 않고 10000 이하의 셀프 넘버를 구해서 출력 하기만 하면 된다. 셀프 넘버란 위의 조건으로 만들어 지지 않는 수이므로 조건으로 만들어지는 수들을 구해서 그 수들을 제외한 수를 답으로 선택하면된다.

▶ 1~10000까지의 숫자중 답을 내어야하므로 arr[10001]을 생성해 주었다.

다음 생각

반복문을 통해 1부터 10000까지 해당 숫자로 조건에 해당하는 숫자를 만들어준뒤 arr[해당숫자]=1로 이 숫자는 셀프 넘버가 아니라는 표시를 해주었다.

▶ 반복문을 돌 때 이미 arr[i]가 1이라면 이미 거쳐갔던 숫자이므로 이 숫자는 continue를 통해 패스해 주었다.

다다음 생각

조건을 통해 언제까지 숫자가 만들어질지 모르므로 while문을 통해 만들어지는 숫자가 10000을 넘을 때 break를 해주었다.

▶ 10000을 넘어갈 때와 마찬가지로 새로만들어진 숫자의 배열 값이 1인 경우에도 break문을 통해 빠져나와 주었다.

다다다음 생각

1~10000 까지의 숫자들 중 배열 값이 0인 즉, 조건을 통해 만들어 줄 수 없는 수들을 출력하였다.

방안

1) Java 풀이

package baekjoon.q1000;
 
import java.io.IOException;
 
public class Q4673 {
    public static void main(String args[]) throws IOException {
        int[] arr = new int[10001];
        // 1~10000
        arr[0]=1;
        for(int i=0;i<10001;i++){
            if(arr[i]!=0) continue;
            int tn = i;
            // 셀프 넘버가 아닌것 골라주기
            while(true){
                int size = (tn+"").length();
                int t = tn;
                for(int j=0;j<size;j++)
                    tn += (t+"").charAt(j)-'0';
                if(tn>10000 || arr[tn]!=0) break;
                arr[tn] = 1;
            }
        }
        // 셀프 넘버 출력
        for(int i=0;i<10001;i++)
            if(arr[i]==0) System.out.println(i);
    }
}
 

2) Python 풀이

arr = [0 for i in range(10001)]
arr[0] = 1
for i in range(10001):
    if arr[i]!=0:
        continue
    t = i
    while True:
        tn = t
        for j in str(t):
            tn += int(j)
        if tn>10000:
            break
        arr[tn]=1
        t = tn
for i in range(10001):
    if arr[i]==0:
        print(i)

[백준] 9095번 1, 2, 3 더하기(DP)

머어하지 — Thu, 6 Dec 2018 00:21:52 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q1000/Q9095.java n이 주어질 때, 1과 2와 3을 이용해서 n을 만들 수 있는 경우의 수를 출력하여라. 더하는 순서에 따라 다른 가지수로 인정한다. 예를들어 1+2와 2+1은 다른 가지수이다. n의 최대값은 11까지 주어진다.

처음 생각

이전에는 재귀를 통한 DFS 완전 탐색을 통해 문제를 풀었었다. [백준] 9095번 1, 2, 3 더하기 이번에는 풀고보니 DP로 푼걸로 봐서 이전 보다는 풀이 접근이 좋아진것 같다는 생각이 든다.

▶ 이전에 풀었던 완전탐색의 경우는 N의 크기가 커질경우 스택 초과 에러나 시간 초과를 받을 수도 있지만 DP는 O(N)으로 접근이 가능하기 때문에 그럴 문제가 없을 것이다.

다음 생각

DP적인 접근은 우선 쪼개서 생각하는 것이다. 따라서 주어진 1,2,3으로 쪼개보자.

▶ 1을 만들 수 있는 경우는 (1) 1개이다. 즉, arr[1] = 1

▶ 2을 만들 수 있는 경우는 (1+1) (2) 2개이다. 즉, arr[2] = 2

▶ 3을 만들 수 있는 경우는 (1+1+1) (2+1) (1+2) (3) 4개이다. 즉, arr[3] = 4

다다음 생각

N이 최대 11이므로 크기가 11인 배열을 미리 만들어 놓은 후, 작게 쪼갰을 경우 나오는 값을 위의 값으로 미리 넣어 주었다.

다다다음 생각

미리 값을 넣어준 후 반복문의 초기값을 4부터 주어진 n까지 진행을 한다. 만약 n이 4보다 작다면 반복문이 실행되지 않을 것이다. 4보다 큰 i에 대해서 arr[i]는 다음과 같이 구할 수 있다.

▶ i-1 값에서 +1 을 하면 i를 만들 수 있다. arr[i] = arr[i-1]

▶ i-2 값에서 +2 을 하면 i를 만들 수 있다. arr[i] = arr[i-2]+arr[i-1]

▶ i-3 값에서 +3 을 하면 i를 만들 수 있다. arr[i] = arr[i-3]+arr[i-2]+arr[i-1]

▶ 1개의 예로 살펴보자면 arr[4]의 경우는 arr[3]+arr[2]+arr[1]이 될 것이다. 이중 arr[3]을 봐보자. 3을 만들 수 있는 경우의 수는 4가지 인것을 위에서 살펴보았다. 이 3에서는 +1을 해서만 4를 만들 수 있다. 따라서 3의 만들 때의 가지수인 (1+1+1) (2+1) (1+2) (3) 에서 각 각의 경우에 +1을 한 (1+1+1+1) (2+1+1) (1+2+1) (3+1)가 4를 만들 수 있는 경우이므로, arr[3]에서의 변화는 없다. 4를 만들 경우 arr[2]와 arr[1]의 경우도 마찬가지이다.

다다다다음 생각

구하고자하는 수 n까지 반복문이 돌았다면 arr[n]을 통해 답을 출력하였다.

방안

1) Java 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package baekjoon.q1000;
 
import java.io.IOException;
import java.util.Scanner;
 
public class Q9095 {
    public static void main(String args[]) throws IOException {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for (int i = 0; i < n; i++) {
            int t = sc.nextInt();
            int[] arr = new int[12];
            // 1
            arr[1] = 1;
            // 1+1,2
            arr[2] = 2;
            // 1+1+1, 1+2, 2+1, 3
            arr[3] = 4;
            for (int j = 4; j <= t; j++)
                arr[j] = arr[j - 1] + arr[j - 2] + arr[j - 3];
            System.out.println(arr[t]);
        }
    }
}
 

2) Python 풀이

1
2
3
4
5
6
7
8
9
10
tc = int(input())
for i in range(tc):
    n = int(input())
    a =[0 for x in range(12)]
    a[1]=1
    a[2]=2
    a[3]=1+2+1
    for j in range(4,n+1):
        a[j] = a[j-1]+a[j-2]+a[j-3]
    print(a[n])

[백준] 1463번 1로 만들기

머어하지 — Tue, 4 Dec 2018 15:07:34 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q1000/Q1463.java 다음 3가지 연산을 이용해서 1로 만들 수 있는 최소의 연산 수를 구하여라. 1) 3으로 나눠 떨어진다면 3으로 나눈다. 2) 2로 나눠 떨어진다면 2로 나눈다. 3) 1을 뺀다.

처음 생각

생각나는건 2가지 방법이였다. BFS를 이용해서 3개의 연산을 차례로 진행해 나가면서 1로 만들어졌을 때 카운트 변수를 출력하는 방법과 다이나믹 프로그래밍을 이용해서 값을 찾는 방법이였다.

▶ 문제 분류가 DP로 되어있으므로 DP 식으로 풀어보았다.

다음 생각

생각을 단순히 하면서 접근을 해보자. 1로 만들수 있는 최소 연산 수를 구하는 법이다. Bottom Up 과 Top Down중 Bottom Up 방식을 사용하였다. 0~n의 index를 가지고있는 크기가 int[n+1]인 배열을 만들어 주었다.

▶ 1은 바로 1이므로 arr[1] = 0 이다.

▶ 최소값을 찾는 것이므로 모든 배열의 값은 큰 값으로 초기화를 시켜놓았다.

다다음 생각

index 1은 이미 0이므로 2부터 주어진 숫자 n까지 반복문을 통해 계산을 시작해주었다.

▶ i 번째 index인 arr[i]에 대해서 3가지 계산을 모두 해준다.

▶ i가 2로 나누어떨어진다면 arr[i]는 arr[i/2]+1 과 자기 자신인 arr[i] 중 작은 값을 취한다.

▶ i가 3으로 나누어떨어진다면 arr[i]는 arr[i/3]+1과 자기 자신인 arr[i] 중 작은 값을 취한다.

▶ arr[i]는 arr[i-1]+1과 자기 자신인 arr[i] 중 작은 값을 취한다.

▶ 연산 배열에 +1을 해주는 이유는 연산을 한 번 했기에 결과값을 +1 시켜준 것이다. 3개의 연산을 모두 진행하면서 i를 n까지 진행하면 arr[n] 즉 1부터 n을 만들 때 최소로 과정으로 n을 만들 수 있는 값이 저장된다.

방안

1) Java 풀이

package baekjoon.q1000;
 
import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;
 
public class Q1463 {
    public static void main(String args[]) throws IOException {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] arr = new int[n+1];
        // 최소값을 찾는 것이므로 최대값으로 채워놓기.
        Arrays.fill(arr,99999999);
        // Bottom Up 방식으로 아래서 부터 올라가보자.
        // 1로 만들기 이므로 자기자신은 0번 싸이클
        arr[1] = 0;
        for(int i=2;i<=n;i++){
            // 2로 나눠질 경우
            if(i%2==0) arr[i] = Math.min(arr[i],arr[i/2]+1);
            // 3으로 나눠질 경우
            if(i%3==0) arr[i] = Math.min(arr[i],arr[i/3]+1);
            // -1 경우
            arr[i] = Math.min(arr[i],arr[i-1]+1);
            // 세가지 케이스중 가장 작은 값을 같도록 한다.
        }
        System.out.println(arr[n]);
    }
}
 

[백준] 16637번 괄호 추가하기

머어하지 — Sun, 2 Dec 2018 23:09:31 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q10000/Q16637.java 괄호를 추가하여 식의 최대값을 얻어내라. 괄호 안에는 1개의 연산자만 있을 수 있으며 괄호는 1중으로만 칠 수 있다. 즉, 2중 괄호 이상은 안된다. 연산자의 기호에 상관없이 앞에서부터 연산을 한다.

처음 생각

어디서 풍문으로 듣기로는 11월 삼성 SW 역량테스트 A형 문제와 비슷하다고합니다.

다음 생각

평범한 식이 주어지면 괄호를 쳐서 최대값이 되도록 만들어야한다. 즉, 식을 계산해 주어야한다.

▶ 따라서 숫자와 식을 분리해서 각각의 List에 넣어주었다.

▶ 식은 숫자가 먼저 시작되므로 부호의 i 번째 index는 식의 i+1 번째 index와 연관이 된다.

다다음 생각

많은 방법이 있겠지만 우선, 어떻게 괄호를 쳤을 때 식이 최대값이 되는지 모르므로 모든 경우를 살펴보았다.

▶ n이 19로 작으므로 비트마스크를 통한 조합을 만들어주었다.

다다다음 생각

Queue나 Stack을 이용해서 숫자와 부호들을 집어넣어주면서 만들어진 조합을 토대로 부호의 해당 index의 상태 배열의 값이 1이라면 이전 숫자를 뽑아 해당 계산을 해준 뒤, 다시 넣어주고 상태 배열값이 0이라면 계산없이 바로 넣어주었다.

▶ 우선 계산의 경우 괄호가 중복되면 안되므로 만약 (x + ( y - z) 와 같은 경우라면 조합을 통해 만들어진 상태 배열값이 연속으로 1 1 로 나타날 것이다. 따라서 앞서 우선 연산을 해주었다면 다음번 상태배열 즉, i 번째라면 i+1 번째의 상태 배열값을 0으로 만들어 주었다. 이를통해 중복 괄호를 없앴다.

▶ 연산자에 상관없이 앞에서부터 계산을 한다 정보가 주어졌으므로 Queue를 이용해서 담아주었다.

다다다다음 생각

상태 배열값이 1인 경우를 모두 계산하였다면, 이제 Queue에 들어가 있던 내용들을 빼내주면서 순서대로 계산을 해주었다.

방안

1) Java 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
package baekjoon.q10000;
 
import java.io.IOException;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
 
public class Q16637 {
    public static void main(String args[]) throws IOException {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String t = sc.next();
 
        int[] arrN = new int[n/2+1];
        int[] buho = new int[n/2];
        int idx1 = 0;
        int idx2 = 0;
        // 숫자와 부호 나눠서 받기
        for(int i=0;i<t.length();i++){
            if(i%2==0) arrN[idx1++] = t.charAt(i)-'0';
            else buho[idx2++] = t.charAt(i);
        }
        // 앞에서 부터 연산이니 Queue를 이용해보자
        makePowerSet(n/2,arrN,buho);
        System.out.println(result);
    }
 
    static int result = Integer.MIN_VALUE;
    private static void solve(boolean[] preCul,int[] arrN,int[] arrBuho){
        Queue<Integer> queue = new LinkedList<>();
        // 첫 숫자 담기
        queue.add(arrN[0]);
        // 우선 연산해주기
        for(int i=0;i<preCul.length;i++){
            // 우선 연산이라면 앞의 숫자를 빼서 연산해주기
            if(preCul[i]){
                int tN = ((LinkedList<Integer>) queue).pollLast();
                switch (arrBuho[i]){
                    case '+':
                        queue.add(tN+arrN[i+1]);
                        break;
                    case '-':
                        queue.add(tN-arrN[i+1]);
                        break;
                    case '*':
                        queue.add(tN*arrN[i+1]);
                        break;
                }
                if(i<preCul.length-1) preCul[i+1] = false;
            }else {
                queue.add(arrBuho[i]);
                queue.add(arrN[i+1]);
            }
        }
        // 남은 연산해주기
        int tResult = queue.poll();
        while(!queue.isEmpty()){
            int buho = queue.poll();
            int tN = queue.poll();
            switch (buho){
                case '+':
                    tResult += tN;
                    break;
                case '-':
                    tResult -= tN;
                    break;
                case '*':
                    tResult *= tN;
                    break;
            }
        }
        result = Math.max(result,tResult);
    }
    private static void makePowerSet(long n,int[] arrN,int[] arrBuho){
        boolean[] preCul = new boolean[(int)n];
 
        for(long i=0;i<(1<<n);i++){
            // 조합 만들기
            for(long j=0;j<n;j++){
                if(((1<<j)&i)>0){
                    preCul[(int)j] = true;
                }
            }
            // 만든 조합으로 연산하기
            solve(preCul,arrN,arrBuho);
            for(int j=0;j<n;j++)
                preCul[j] = false;
        }
    }
}

[백준] 7569번 토마토

머어하지 — Thu, 29 Nov 2018 23:53:29 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q1000/Q7569.java 이전 토마토 문제의 확장 문제이다. 상자가 여러겹 쌓여있으며 익은 토마토가 위 아래 상자의 토마토에까지 영향을 끼친다.

처음 생각

우선 이전 토마토 문제인 [백준] 7576번 토마토 와 풀이를 똑같이 했다.

▶ 다른점이라면 위 아래 상자를 생각해줘야 한다는 것이였다.

다음 생각

한 상자를 사용할 때 2차 배열로 표현할 수 있었다. 그럼 문제가 간단해진다. 층을 표현할 위치를 추가해서 3차 배열로 표현을 해주었다.

▶ [층][그 층의 토마토 x 위치][그 층의 토마토 y 위치]로 배열을 사용하였다.

▶ 기존의 문제에서 배열로 주변 토마토들의 BFS 탐색을 진행하였듯이 다른 상자의 탐색도 미리 배열로 좌표를 만들어 놓고 탐색을 진행하였다.

다다음 생각

기존 입력을 Scanner를 사용해서 문제를 풀었었고, 주어지는 배열의 크기가 최대 100 x 100이므로 입력을 BufferedReader로 바꾸어 메모리 감소와 시간 단축을 시켰다.

▶ 입력이 확실히 많은경우는 BufferedReader를 사용하는 것이 효율적이다.

방안

1) Java 풀이

package baekjoon.q1000;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.StringTokenizer;
 
public class Q7569 {
    static int m,n,h;
    static int[][][] arr;
    static Queue<Pair> queue = new LinkedList<>();
    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        m = Integer.parseInt(st.nextToken()); // 상자 가로칸
        n = Integer.parseInt(st.nextToken()); // 세로
        h = Integer.parseInt(st.nextToken()); // height
        arr = new int[h][n][m];
 
        for(int i=0;i<h;i++){
            for(int j=0;j<n;j++){
                st = new StringTokenizer(br.readLine());
                for(int k=0;k<m;k++) {
                    arr[i][j][k] = Integer.parseInt(st.nextToken());
                    if(arr[i][j][k]==1) queue.add(new Pair(i,j,k));
                }
            }
        }
 
        solve();
    }
 
    static int[] dirH = {1,-1};
    static int[][] dir = {{1,0},{0,1},{-1,0},{0,-1}};
    private static void solve(){
        int result = -1;
        while(!queue.isEmpty()){
            int size = queue.size();
            result++;
            for(int i=0;i<size;i++){
                Pair t = queue.poll();
                // 주변 토마토
                for(int j=0;j<4;j++){
                    int tx = t.n + dir[j][0];
                    int ty = t.m + dir[j][1];
                    if(tx<0 || ty<0 || tx>=n || ty>=m) continue;
                    if(arr[t.h][tx][ty]!=0) continue;
                    arr[t.h][tx][ty] = 1;
                    queue.add(new Pair(t.h,tx,ty));
                }
                // 위 아래 토마토
                for(int j=0;j<2;j++){
                    int th = t.h+dirH[j];
                    if(th<0 || th>=h) continue;
                    if(arr[th][t.n][t.m]!=0) continue;
                    arr[th][t.n][t.m] = 1;
                    queue.add(new Pair(th,t.n,t.m));
                }
            }
        }
        // 토마토가 남아있는지 탐색
        for(int i=0;i<h;i++){
            for(int j=0;j<n;j++){
                for(int k=0;k<m;k++) {
                    // 안 익은 토마토가 있다면 -1 출력
                    if(arr[i][j][k]==0){
                        System.out.println(-1);
                        return;
                    }
                }
            }
        }
        System.out.println(result);
    }
 
    static class Pair{
        int h,n,m;
        Pair(int h,int n,int m){
            this.h = h;
            this.n = n;
            this.m = m;
        }
    }
}

[백준] 7576번 토마토

머어하지 — Thu, 22 Nov 2018 01:49:22 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q1000/Q7576.java 토마토가 담겨있는 박스의 상태를 준다. 0은 익지않은 토마토, 1은 익은 토마토, -1은 토마토가 없는 공간을 나타낸다. 익은 토마토의 주변에 익지않은 토마토가 있다면 그 토마토를 하루 뒤에 익게만든다. 이 때, 박스 안의 모든 토마토를 익게 만드는 때까지 걸리는 날짜를 출력하여라. 모든 토마토를 익게만들수 없다면 -1을 출력하여라.

처음 생각

익은 토마토(1)을 기준으로 상 하 좌 우 탐색을하고 또 익은 토마토로 인해 익게된 토마토로 부터 탐색을 해나가면서 진행을 해야하므로 4방향 모두를 살피면서 탐색할 수 있는 BFS 탐색을 이용하여 풀었다.

다음 생각

입력을 받을 때 모든 익은 토마토를 queue에 넣어준 뒤, 탐색을 해나가면서 진행을 하였다.

▶ 익지 않은 토마토만 진행해 나가면 되기때문에 따로 방문 배열을 만들어 줄 필요없이 입력으로 받은 배열의 익지않은 토마토를 1로 만들어주면서 방문 체크를 대신하였다.

다다음 생각

배열이 공백으로 주어지고 최대 1000x1000의 배열이므로 입력의 개수가 많다. Scanner와 BufferedReader의 비교로 좋다고 생각해서 입력을 바꿔서 풀어보았다. 결과는 아래와 같았다.

▶ BufferedReader 사용시 메모리와 시간의 절약이 2배 이상 되는것을 볼 수 있었다. 만약 Scanner를 사용해서 문제풀이시 TLE(시간 초과)가 뜬다면 입력을 확인해보고 입력이 많을 경우 바꿔보는걸 가장 먼저 고려해 보아야한다는걸 볼 수 있었다!

방안

1) Java 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
package baekjoon.q1000;
 
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.StringTokenizer;
 
public class Q7576 {
    static int n,m;
    static int[][] arr;
    public static void main(String args[]) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        m = Integer.parseInt(st.nextToken());
        n = Integer.parseInt(st.nextToken());
        arr = new int[n][m];
        for(int i=0;i<n;i++){
            st = new StringTokenizer(br.readLine());
            for(int j=0;j<m;j++) {
                arr[i][j] = Integer.parseInt(st.nextToken());
                // 초기 익은 토마토 queue에 넣어주기
                if(arr[i][j]==1) queue.add(new Pair(i,j));
            }
        }
        System.out.println(solve());
    }
 
    static Queue<Pair> queue = new LinkedList<>();
    static int[][] dir = {{1,0},{0,1},{-1,0},{0,-1}};
    private static int solve(){
        int result = -1;
        while(!queue.isEmpty()){
            int size = queue.size();
            result++;
            // 모든 익은 토마토에 대해서 하루씩 진행을 해야하기 때문에
            // queue의 size를 미리 받아서 반복문을 통해 딱 그날 익었던 토마토만 탐색
            for(int i=0;i<size;i++){
                Pair t = queue.poll();
                for(int j=0;j<4;j++){
                    int tx = t.x+dir[j][0];
                    int ty = t.y+dir[j][1];
                    if(tx<0 || ty<0 || tx>=n || ty>=m) continue;
                    if(arr[tx][ty]!=0) continue;
                    // 익은 토마토로 만들어주기(방문 표시)
                    arr[tx][ty] = 1;
                    queue.add(new Pair(tx,ty));
                }
            }
        }
        // 익지 않은 토마토가 있나 찾기
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++)
                if(arr[i][j]==0) return -1;
        }
        return result;
    }
 
    static class Pair{
        int x,y;
        Pair(int x,int y){
            this.x = x;
            this.y = y;
        }
    }
}
 

[백준] 2589번 보물섬

머어하지 — Thu, 22 Nov 2018 01:15:57 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q1000/Q2589.java 바다와 섬의 정보가 주어진다 섬들 중 최단거리로 이동했을 때, 가장 거리가 먼 2섬이 보물섬이 된다. 이 때 보물섬이 되는 섬들의 거리를 구하여라.

처음 생각

두 섬의 최단거리를 구해야한다. 따라서 BFS를 이용해서 탐색을 진행하였다.

다음 생각

어떤 두 섬이 보물섬이 될지 모르므로 모든 섬에 대해서 거리를 따져주었다.

▶ 입력 받은 배열을 탐색하면서 섬 표시이 L이 보이면 그 L부터 BFS를 시작하여 거리를 판단하고, 그 거리를 계속 최대값과 비교하였다.

▶ 항상 새로운 BFS를 진행하는것이므로 방문 배열도 항상 초기화 시켜주어야한다.

방안

1) Java 풀이

package baekjoon.q1000;
 
import java.io.IOException;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
 
public class Q2589 {
    static int n,m;
    static char[][] arr;
    public static void main(String args[]) throws IOException {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        m = sc.nextInt();
        arr = new char[n][m];
        for(int i=0;i<n;i++){
            String t = sc.next();
            for(int j=0;j<m;j++)
                arr[i][j] = t.charAt(j);
        }
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(arr[i][j]=='L') solve(i,j);
            }
        }
        System.out.println(result);
    }
 
    static int result;
    static int[][] dir = {{1,0},{0,1},{-1,0},{0,-1}};
    private static void solve(int x,int y){
        Queue<Pair> queue = new LinkedList<>();
        queue.add(new Pair(x,y,0));
        boolean[][] visited = new boolean[n][m];
        visited[x][y] = true;
        while(!queue.isEmpty()){
            Pair t = queue.poll();
            result = max(result,t.cnt);
            for(int i=0;i<4;i++){
                int tx = t.x+dir[i][0];
                int ty = t.y+dir[i][1];
                if(tx<0 || ty<0 || tx>=n || ty>=m) continue;
                if(arr[tx][ty]=='W') continue;
                if(visited[tx][ty]) continue;
                visited[tx][ty]= true;
                queue.add(new Pair(tx,ty,t.cnt+1));
            }
        }
    }
 
    private static int max(int a,int b){return a>b?a:b;}
    static class Pair{
        int x,y,cnt;
        Pair(int x,int y,int cnt){
            this.x = x;
            this.y = y;
            this.cnt = cnt;
        }
    }
}
 

[백준] 10799번 쇠막대기

머어하지 — Mon, 19 Nov 2018 23:27:05 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q10000/Q10799.java 쇠막대기의 정보와 레이저의 정보를 준다. 레이저는 무조건 ()로 표시된다. '('는 쇠막대기의 시작을 ')'는 쇠막대기의 끝을 의미한다. 쇠막대기가 놓아져 있을때 '()' 즉 레이저를 만나면 쇠막대기가 쪼개진다. 쇠막대기와 레이저의 정보를 주었을 때 총 몇 조각의 쇠막대기가 나오는지 구하여라.

처음 생각

어디서 풀어본 문제라 생각해서 찾아보니 SW Expert에서 풀어본 문제였다.

▶ [SW Expert] 5432. 쇠막대기 자르기

다음 생각

문제 분류가 Stack이기도하고, 기존에 풀이는 변수로 관리해주었으므로 이번엔 Stack으로 관리해보았다.

▶ 변수를 다루던게 Stack으로 바뀌었으므로 Stack의 size로 현 막대기 개수를 처리해주면된다.

▶ 막대기의 끝나는 의미로 ')'를 만났을 경우 잘린 끝 조각이 하나가 있는 것이므로 전체 결과에 더해주는것을 조심해야한다.

방안

1) Java 풀이

package baekjoon.q10000;
 
import java.util.Scanner;
import java.util.Stack;
 
public class Q10799 {
    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        Stack stack = new Stack();
        String t = sc.next();
        int result = 0;
        for(int i=0;i<t.length();i++){
            if(t.charAt(i)=='('){
                if(t.charAt(i+1)==')'){
                    i++;
                    result += stack.size();
                    continue;
                }
                // 막대기 개수 +1
                stack.push(1);
            }else{
                // 막대기 개수 -1
                stack.pop();
                // 총 막대 개수 +1
                result++;
            }
        }
        System.out.println(result);
    }
}
 

2) C++ 풀이

#include<iostream>
#include<string>
 
using namespace std;
 
int main(){
    int cnt=0,result=0;
    string t;
    cin>>t;
    for(int i=0;i<t.length();i++){
        if(t[i]=='('){
            if(t[i+1]==')'){
                i++;
                result+=cnt;
                continue;
            }
            cnt++;
        }else{
            cnt--;
            result++;
        }
    }
    cout<<result;
    return 0;
}

[백준] 9012번 괄호

머어하지 — Sun, 18 Nov 2018 20:38:48 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q1000/Q9012.java 괄호의 짝이 맞는지 판단하여 맞다면 'YES' 맞지 않다면 'NO'를 출력하여라.

처음 생각

꼭 Stack으로 풀지 않아도 상관없지만 분류가 Stack으로 되어있으므로 구현하여 풀었다. '('가 들어온다면 push를 ')'가 들어온다면 pop을 해주었다. ')'가 들어왔을 때 Stack의 size가 0이면 짝이 맞지 않는걸로 판단하였다.

▶ 모든 기능이 필요한게 아니므로 push, pop, size만 구현하였다.

방안

1) Java 풀이

package baekjoon.q1000;
 
import java.util.Scanner;
 
public class Q9012 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Stack<Integer> stack = new Stack<>();
        int tc = sc.nextInt();
        for(int i=0;i<tc;i++){
            String t = sc.next();
            stack.clear();
            for(int j=0;j<t.length();j++){
                if(t.charAt(j)=='('){
                    stack.push(1);
                }else{
                    // 항상 짝이 있어야하므로 미리 ( 가 들어와있지 않았다면 실패
                    if(stack.size()==0){
                        stack.push(1);
                        // 실패시 바로 종료시키기
                        break;
                    }else stack.pop();
                }
            }
            if(stack.size()!=0) System.out.println("NO");
            else System.out.println("YES");
        }
    }
}
 
// 필요한 기능만 구현
class Stack<T>{
    private Node<T> top;
    private int size;
 
    void clear(){
        size = 0;
        top = null;
    }
    int size(){
        return size;
    }
    void push(T data){
        if(size==0) top = new Node(data,null);
        else top = new Node(data,top);
        size++;
    }
 
    T pop(){
        if(size==0) return null;
        else{
            T t = top.data;
            top = top.prev;
            size--;
            return t;
        }
    }
 
    private class Node<T>{
        T data;
        Node prev;
        Node(T data, Node prev){
            this.data = data;
            this.prev = prev;
        }
    }
}
 

[백준] 10953번 A+B -6

머어하지 — Fri, 16 Nov 2018 18:35:17 +0900

생각

주어진 a와 b를 더한 값을 출력한다. a b는 a,b 형태로 주어진다.

처음 생각

Java에서는 splite(",")을 이용하여 접근할 수 있었다. C++에서는 getline()을 이용해서 cin의 종료시점을 ,로 정해줄 수 있다.

▶ getline(cin,a,',');를 통해서 ','를 만나면 입력을 종료시킬 수 있다.

▶ 원래 getline()은 \n를 만나면 종료되기 때문에 b의 입력은 getline(cin,b)로 받아올 수 있다.

다음 생각

string으로 받은 값을 int형으로 변환시켜 주어야한다. C++은 string일 경우 stoi(value)를 통해서 string을 int형으로 변환 시킬 수 있다.

▶ Java는 Integer.parseInt(value)를 이용하였다.

방안

1) 구분자를 이용한 입력받기와 string의 int형 변환을 배워볼 수 있다.

2) Java 풀이

1
2
3
4
5
6
7
8
9
10
11
12
import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        for(int i=0;i<n;i++){
            String[] arr = sc.next().split(",");
            System.out.println(Integer.parseInt(arr[0])+Integer.parseInt(arr[1]));
        }
    }
}

3) C++ 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
#include <string>
 
using namespace std;
 
int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);
    cout.tie(NULL);
    int n;
    string a,b;
    cin>>n;
    for(int i=0;i<n;i++){
        getline(cin,a,',');
        getline(cin,b);
        cout<<stoi(a)+stoi(b)<<endl;
    }
    return 0;
}

C++의 namespace

머어하지 — Fri, 16 Nov 2018 18:05:46 +0900

C++의 namespace

namespace는 효율적인 코드의 작성을 위해서 등장한 개념입니다. 큰 프로젝트가 진행될 경우 여러 팀에서 한 프로그램을 만들것입니다. 이 때, 서로다른 팀에서 만든 코드에 gogo()라는 함수가 중복되어 있다면 어떨까요? 합쳐서 사용하기 위해서는 한 쪽의 함수를 모두 바꿔주면 될 것 같지만 큰 프로젝트에서 모두 수정하기에는 힘들 것이고 함수의 이름이 바뀌면 그 의미를 반영하는것도 바뀌기 때문에 곤란해 질 수도있습니다.

이 때, namespace를 적용해주면 각 함수를 영역접근연산자인 '::'를 사용해서 접근할 수 있습니다. 간단한 예를 보겠습니다. namespace A로 ex() 함수를 감싸주었습니다. 이제 함수 ex()를 호출하려면 ::를 통해 접근을 해주어야합니다.

1
2
3
4
5
namespace A {
    void ex() {
 
    }
}

main() 함수에서 사용하기 위해서는 다음과 같이 호출해주어야합니다.

1
2
3
4
int main(){
    A::ex();
    return 0;
}

간단하게 namespace에 대해서 알아보았습니다. 실제로 PS 풀이를 할 때는 사용할 일이 거의 없을 겁니다.

앞서 cin과 cout을 사용할 때 std::cin, std::cout으로 영역접근연산자(::)를 사용해서 cin과 cout을 사용하였습니다. 매번 std::라는 반복적인 작업을 하면 귀찮아 지기 때문에 다음과 같이 std라는 namespace를 사용한다고 선언하여 생략을 할 수 있습니다.

1
using namespace std;

작성 후에는 std::를 생략하여 사용할 수 있습니다.

1
2
3
4
5
6
7
8
9
10
#include <iostream>
 
using namespace std;
 
int main(){
    int a;
    cin>>a;
    cout<<a;
    return 0;
}

C++에서의 입출력

머어하지 — Fri, 16 Nov 2018 16:27:38 +0900

C++에서의 입출력

PS 풀이를 위해 가장 중요한 입력과 출력입니다. Java에서는 Scanner를 주로 사용하였다면 C++에서는 무엇을 사용할 까요?

바로 cin 과 cout입니다. 특히, 이 cin과 cout은 알아서 타입을 추론하여 결과를 반영해 주기 때문에 사용자가 따로 타입변환을 해줄 필요가 없다는게 큰 장점인것 같습니다.

cin과 cout을 사용하기위해서는 iostream이라는 헤더 파일을 include 시켜주어야합니다.

1
#include <iostream>

입력을 받아보겠습니다.

1
2
3
4
5
6
7
#include <iostream>
 
int main(){
    int a;
    std::cin>>a;
    return 0;
}

scanf와 비교해서 아주 간단하게 입력을 받을 수 있습니다!! 이제 입력받은 값을 출력해보겠습니다.

1
2
3
4
5
6
7
8
#include <iostream>
 
int main(){
    int a;
    std::cin>>a;
    std::cout<<a;
    return 0;
}

15를 입력했을때 결과는 다음과 같습니다.

15
15
Process finished with exit code 0

C++에서의 입출력에대해서 알아보았습니다.

간단한 문제에서 사용을 해보았습니다. [백준] 10951번 A+B - 4

C++ 공부 시작

머어하지 — Fri, 16 Nov 2018 16:01:34 +0900

Why C++?

우선, 예전에 C를 배운적은 있으나 몇 년이 지난지금 생각은 많이 안나고 C++과 C의 문법차이가 있으므로 C를 다시 보기보다는 C++을 보기로 마음을 먹었습니다.

PS(Problem Solving)를 하시는 분들 중에서도 C++로 풀이를 하시는 분들이 굉장히 많습니다. 고수분들이 해논 풀이를 따라해보려면 C++을 알면 좋을겁니다ㅎㅎ (제 생각에는 Java를 사용해도 큰 불이익은 없다고 생각합니다. 고수분들 중에서도 Java만 사용하시는 분들도 계시구요!)

로봇쪽이나 임베디드 쪽에서는 C++이나 C를 이용해서 SW를 만들고 있습니다. 작은 HW 단에서 속도의 차이는 무시할 수 없어서 그런것 같습니다. 실제로 Java를 구동하는 JVM도 내부는 C나 C++로 이루어져 있다고 합니다. 아직 공부를 하는 입장에서 다양한걸 경험해보고 마음에 맞는 쪽을 택하고 싶습니다. 임베디드 SW 예전에 재밌게 해본적이 있어서 그동안 생각만 하고있었던 C++ 공부를 시작해보려고 합니다.

그럼 기념 코드를 올리면서 시작 글의 마무리를 해보겠습니다.

1
2
3
4
5
#include <iostream>
 
int main(){
    std::cout<<"Hello C++!!!";
}

[백준] 10951번 A+B - 4

머어하지 — Fri, 16 Nov 2018 01:23:35 +0900

생각

입력으로 주어진 a와 b를 더한 값인 a+b를 출력한다.

처음 생각

C++을 공부하면서 cin에 대한 내용을 위해 글을 썼습니다. Java의 경우는 Scanner의 다음 읽을것이 있나를 따져주는 hasNext()를 통해 입력의 끝을 알 수 있었지만 C++의 경우는 어떻게 해야할까 생각을 해보다 답을 보았습니다.

▶ C++의 경우 반복문이 positive값이 들어가면 true로 판단을 해주기 때문에 반복문 조건을 cin>>a>>b;로 넣어주면 값이 있을경우만 반복문이 작동하게 됩니다.

방안

1) Java 풀이

import java.util.*;
 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int a = sc.nextInt();
            int b = sc.nextInt();
            System.out.println(a+b);
        }
    }
}

2) C++ 풀이

#include <iostream>
 
using namespace std;
 
int main() {
    int a,b;
    while(cin>>a>>b)
        cout<<a+b;
    return 0;
}

[백준] 2839번 설탕 배달

머어하지 — Fri, 16 Nov 2018 00:52:52 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q1000/Q2839.java N을 준다. 3kg과 5kg의 설탕 봉지를 이용해서 N을 만들 때 최소의 개수를 사용하는 경우를 구하여라. N을 만들 수 없을 경우 -1을 출력한다.

처음 생각

이전에 풀어본것 같아서 검색을 해보니 풀어본 적이 있긴했었다. 보지는 않고 푼 후 비교를 해보니 접근 방식이 달리지긴 했다.([알고리즘/백준] - [문제] 백준 2839번(설탕 배달))

▶ 이전엔 그리디 적으로 수식으로 접근했었다.

다음 생각

이번에는 DP로 접근해서 풀이를 했다. N까지 접근을 하면서 3kg 짜리로 N에 접근할 수 있는 N-3에서의 값과 5kg 짜리로 N에 접근할 수 있는 N-5에서의 값 중 최소 개수이므로 작은 값을 택하면서 Bottom-up 방식으로 N까지 접근한다.

▶ 작은 값을 택해야하므로 배열의 초기화를 나올 수 없는 값인 9999로 해주었다.(최대 N이 5000이므로 9999는 나올 수 없다) 즉, 결과값인 dp[N]이 9999이거나 10000일 경우 불가능으로 -1을 출력해주었다.

▶ 10000을 제외 조건으로 포함시킨 이유는 둘 중 작은 값을 택한 후 +1을 해주어 설탕 묶음을 더해주었기 때문에 9999에서 +1한 값인 10000도 제외조건으로 해주었다.

방안

1) 수학적으로 접근해도 좋고 DP로 접근해도 좋고 다양한 방법이 더 있을 것 같다.

2) Java 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package baekjoon.q1000;
 
import java.util.Arrays;
import java.util.Scanner;
 
public class Q2839 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] dp = new int[n+10];
        Arrays.fill(dp,9999);
        dp[3] = 1;
        dp[5] = 1;
        // 3 짜리를 더해서 만들 수 있는 경우와
        // 5 짜리를 더해서 만들 수 있는 경우 중 작은 경우 선택
        for(int i=6;i<=n;i++)
            dp[i] = min(dp[i-3],dp[i-5])+1;
        if(dp[n]==10000 || dp[n]==9999) System.out.println(-1);
        else System.out.println(dp[n]);
    }
    private static int min(int x,int y){return x>y?y:x;}
}
 

3) C++ 풀이(Java 풀이를 토대로 짜보는 중인데 배우는 중이라 어색한 표현이 있을 수 있습니다!)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>
 
using namespace std;
 
int main() {
    int n;
    cin >> n;
    int dp[n+10];
    for(int i=0;i<n+10;i++)
        dp[i] = 9999;
    dp[3] = 1;
    dp[5] = 1;
 
    for(int i=6;i<=n;i++)
        dp[i] = min(dp[i-3],dp[i-5])+1;
    if(dp[n]==9999 || dp[n]==10000) cout << -1;
    else cout << dp[n];
    return 0;
}

[백준] 1700번 멀티탭 스케줄링

머어하지 — Mon, 12 Nov 2018 23:28:59 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q1000/Q1700.java 멀티탭의 꼿을 수 있는 개수와 사용되어야할 기기가 순서대로 주어진다. 멀티탭에서 제품을 뽑는것을 최소화 할 때, 몇 번 뽑아야하는지 출력하여라.

처음 생각

콘센트의 꼽을 수 있는 수도 100개 꼽는 기기의 수도 최대 100개이다. 수가 작으므로 다 살펴보면서 진행을 하였다.

▶ 현재 꼿혀있는데 똑같은게 들어올 경우는 바로 다음 기기를 봐도 상관없으므로 HashSet을 이용해서 꼿힌 기기들을 관리해 주었다.

다음 생각

꼿혀있지 않을경우 2가지로 나눠진다. 1) 콘센트에 자리가 없을경우 2) 콘센트에 자리가 있을경우 로 나눠진다.

▶ 1)의 경우는 HashSet에 있는 기기들을 가지고 현재 idx 이후로 해당 기기가 있는지 없는지를 판단한다. 만약 해당 기기가 사용안되면 바로 그 기기를 제거해준 후 새로운 기기를 꼽는다.

▶ 해당기기가 또 사용된다면 index를 비교해서 가장 큰 index를 가지고 있는 기기를 제거해준다.

▶ 2)의 경우는 바로 HashSet에 넣어주었다.

다다음 생각

뽑는 경우의 수를 출력하는 것이므로 HashSet에서 remove를 해줄 때 결과값을 +1 시켜주었다.

방안

1) 처음에는 PrioirtyQueue등을 이용해서 효율적으로 구현을 해보려고했었는데 개수가 최대 100개 밖에 안되므로 모든 경우를 살펴보았다.

package baekjoon.q1000;
 
import java.util.HashSet;
import java.util.Scanner;
 
public class Q1700 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); // 구멍의 개수
        int m = sc.nextInt(); // 제품 수
        int[] arr = new int[m];
        for(int i=0;i<m;i++)
            arr[i] = sc.nextInt();
 
        int result = 0;
        HashSet<Integer> set = new HashSet<>();
        for(int i=0;i<m;i++){
            int t = arr[i];
            // 이미 꼽혀있는 거면 그대로 가져간다
            if(set.contains(t)) continue;
            // 새로 꼽아야할 경우
            // 1) 다 꼽혀있다면
            if(set.size()==n){
                int idx = -3, target = 0;
                for(int tt:set){
                    int tIdx = 9999;
                    // 제일 안쓰이는 걸 찾자.
                    for(int j=i+1;j<m;j++){
                        // 똑같은게 있다면 해당 index 저장
                        if(tt==arr[j]){
                            tIdx = j;
                            break;
                        }
                    }
                    // tIdx가 변하지 않았다면 이 뒤로 사용되지 않는다는 것이다.
                    if(tIdx==9999){
                        target = tt;
                        break;
                    }else{
                        // 가장 나중에 사용되는걸 찾자.
                        if(tIdx>idx){
                            idx = tIdx;
                            target = arr[tIdx];
                        }
                    }
                }
                // 콘센트 빼주기
                set.remove(target);
                result++;
            }
            // 2) 남는 곳이 있다면
            set.add(t);
        }
        System.out.println(result);
    }
}

[백준] 11000번 강의실 배정

머어하지 — Mon, 12 Nov 2018 20:52:29 +0900

생각

Github - https://github.com/hellojdh/Code/blob/master/src/baekjoon/q10000/Q11000.kt 최소한의 강의실로 모든 강의를 들을 수 있도록 하여라. 강의실의 수업이 끝나자마자 바로 다음 강의를 시작할 수 있다.

처음 생각

이전에 풀어본 [백준] 1931번 회의실배정 보다 살짝 어려워졌다. 접근은 비슷한 방식으로 진행하지만 처리를 해주어야하는 부분에 있어서 고민을 조금 하였다.

▶ 회의실 배정처럼 한 개의 방이아닌 다양한 방을 처리해 주어야하므로 일찍 끝나는 회의실을 우선적으로 처리를 해주었고, 끝나는 시간이 같을 경우에는 시작 시간이 빠른 순서대로 처리를 해주었다.

다음 생각

하나의 방이 사용중이면 새로운 방을 늘려주어야한다. List를 가지고 구현을 하려다가 PriorityQueue(우선 순위 큐)가 생각이나서 PriorityQueue를 사용하였다.(물론 방의 순서가 앞서 이야기한 순서대로 넣어주어야 한다.)

▶ 방의 끝나는 시간만 가지고 있으면 되므로 Integer 타입으로 선언 해주었다.

▶ PriorityQueue를 사용한 이유는 끝나는 시간이 빠른 순서대로 방을 교체해 주기 위해서다.

다다음 생각

PrioirtyQueue의 가장 우선순위의 끝나는 시간과 새로 비교해야할 강의의 시작시간을 비교해서 기존 강의를 끝내고 새로운 강의를 시작해 줄지, 기존 강의가 아직 끝나지 않았으니 새로운 강의를 새로 넣어줄 지를 결정한다. 새로운 강의가 들어가도 PriorityQueue이기 때문에 끝나는 시간이 빠른 강의가 우선 순위로 채택된다.

다다다음 생각

모든 비교를 마치고 PriorityQueue에 남아있는 자료의 양이 필요한 강의실의 수가 된다.

방안

1) Kotlin 풀이(Java 풀이와 비교해서 코드가 짧긴하나 Kotlin 컴파일러를 거쳐서 실행되서 그런가 살짝 더 느린감이 있었다.)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package baekjoon.q10000
 
import java.util.*
import kotlin.Comparator
 
fun main(args:Array<String>){
    var sc : Scanner = Scanner(System.`in`)
    var n = sc.nextInt()
    var arr : Array<Pair> = Array(n,{Pair(0,0) })
    for(i in 0..(n-1))
        arr[i] = Pair(sc.nextInt(),sc.nextInt())
 
    Arrays.sort(arr, Comparator { o1: Pair, o2: Pair ->
        if(o1.e==o2.e) o1.s.compareTo(o2.s)
        else o1.e.compareTo(o2.e) })
    var result = 1
    var end = arr[0].e
    for(i in 1..(n-1)){
        if(arr[i].s>=end){
            result++
            end = arr[i].e
        }
    }
    println(result)
}
class Pair(val s: Int, val e: Int)

2) Java 풀이

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        Pair[] arr = new Pair[n];
        for(int i=0;i<n;i++)
            arr[i] = new Pair(sc.nextInt(),sc.nextInt());
        Arrays.sort(arr,Pair.comparator);
        pq.add(arr[0].e);
        for(int i=1;i<n;i++){
            // 새로운 시작시간이 pq의 빨리끝나는 시간보다 같거나 크다면 기존 강의실 이용
            if(pq.peek()<=arr[i].s) pq.poll();
            pq.add(arr[i].e);
        }
        System.out.println(pq.size());
    }
 
    static class Pair{
        int s,e;
        Pair(int s,int e){
            this.s = s;
            this.e = e;
        }
        static Comparator<Pair> comparator = new Comparator<Pair>() {
            @Override
            public int compare(Pair o1, Pair o2) {
                if(o1.s==o2.s) return Integer.compare(o1.e,o2.e);
                else return Integer.compare(o1.s,o2.s);
            }
        };
    }
}