728x90
반응형
728x90
반응형

프로그래머스 > 월간 코드 챌린지 시즌1 > 내적 문제풀이 공유드립니다.

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

  • 문제
문제 설명
길이가 같은 두 1차원 정수 배열 a, b가 매개변수로 주어집니다. a와 b의 내적을 return 하도록 solution 함수를 완성해주세요.
이때, a와 b의 내적은 a[0]*b[0] + a[1]*b[1] + ... + a[n-1]*b[n-1] 입니다. (n은 a, b의 길이)
제한사항
  • a, b의 길이는 1 이상 1,000 이하입니다.
  • a, b의 모든 수는 -1,000 이상 1,000 이하입니다.
입출력 예

입출력 예 설명
입출력 예 #1
  • a와 b의 내적은 1*(-3) + 2*(-1) + 3*0 + 4*2 = 3 입니다.
입출력 예 #2
  • a와 b의 내적은 (-1)*1 + 0*0 + 1*(-1) = -2 입니다.
  • 풀이
class Solution {
    public int solution(int[] a, int[] b) {
        int answer = 0;
        int[] c = new int[a.length];
        for(int i=0; i<a.length; i++){
            c[i] = a[i] * b[i];
            answer += c[i];
        }
        return answer;
    }
}
728x90
반응형
728x90
반응형

프로그래머스 > 월간 코드 챌린지 시즌2 > 음양 더하기 문제 풀이 공유드립니다.

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

 

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

  • 문제
문제 설명
어떤 정수들이 있습니다. 이 정수들의 절댓값을 차례대로 담은 정수 배열 absolutes와 이 정수들의 부호를 차례대로 담은 불리언 배열 signs가 매개변수로 주어집니다. 실제 정수들의 합을 구하여 return 하도록 solution 함수를 완성해주세요.
제한사항
  • absolutes의 길이는 1 이상 1,000 이하입니다.
    • absolutes의 모든 수는 각각 1 이상 1,000 이하입니다.
  • signs의 길이는 absolutes의 길이와 같습니다.
    • signs[i] 가 참이면 absolutes[i] 의 실제 정수가 양수임을, 그렇지 않으면 음수임을 의미합니다.
입출력 예

입출력 예 설명
입출력 예 #1
  • signs가 [true,false,true] 이므로, 실제 수들의 값은 각각 4, -7, 12입니다.
  • 따라서 세 수의 합인 9를 return 해야 합니다.
입출력 예 #2
  • signs가 [false,false,true] 이므로, 실제 수들의 값은 각각 -1, -2, 3입니다.
  • 따라서 세 수의 합인 0을 return 해야 합니다.
 
  • 풀이
class Solution {
    public int solution(int[] absolutes, boolean[] signs) {
        int answer = 0;
        for(int i=0; i<absolutes.length; i++){
            if(!signs[i]){
                absolutes[i] = -absolutes[i];
            }
            answer += absolutes[i];
        }
        return answer;
    }
    
}
728x90
반응형
728x90
반응형

프로그래머스 > 연습탐욕법(Greedy) > 체육복 자바 문제 풀이 공유드립니다.

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

 

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

 

  • 문제
문제 설명
점심시간에 도둑이 들어, 일부 학생이 체육복을 도난당했습니다. 다행히 여벌 체육복이 있는 학생이 이들에게 체육복을 빌려주려 합니다. 학생들의 번호는 체격 순으로 매겨져 있어, 바로 앞번호의 학생이나 바로 뒷번호의 학생에게만 체육복을 빌려줄 수 있습니다. 예를 들어, 4번 학생은 3번 학생이나 5번 학생에게만 체육복을 빌려줄 수 있습니다. 체육복이 없으면 수업을 들을 수 없기 때문에 체육복을 적절히 빌려 최대한 많은 학생이 체육수업을 들어야 합니다.
전체 학생의 수 n, 체육복을 도난당한 학생들의 번호가 담긴 배열 lost, 여벌의 체육복을 가져온 학생들의 번호가 담긴 배열 reserve가 매개변수로 주어질 때, 체육수업을 들을 수 있는 학생의 최댓값을 return 하도록 solution 함수를 작성해주세요.
제한사항
  • 전체 학생의 수는 2명 이상 30명 이하입니다.
  • 체육복을 도난당한 학생의 수는 1명 이상 n명 이하이고 중복되는 번호는 없습니다.
  • 여벌의 체육복을 가져온 학생의 수는 1명 이상 n명 이하이고 중복되는 번호는 없습니다.
  • 여벌 체육복이 있는 학생만 다른 학생에게 체육복을 빌려줄 수 있습니다.
  • 여벌 체육복을 가져온 학생이 체육복을 도난당했을 수 있습니다. 이때 이 학생은 체육복을 하나만 도난당했다고 가정하며, 남은 체육복이 하나이기에 다른 학생에게는 체육복을 빌려줄 수 없습니다.
입출력 예

입출력 예 설명
예제 #1
1번 학생이 2번 학생에게 체육복을 빌려주고, 3번 학생이나 5번 학생이 4번 학생에게 체육복을 빌려주면 학생 5명이 체육수업을 들을 수 있습니다.

예제 #2
3번 학생이 2번 학생이나 4번 학생에게 체육복을 빌려주면 학생 4명이 체육수업을 들을 수 있습니다.

문제가 잘 안풀린다면😢힌트가 필요한가요? [코딩테스트 연습 힌트 모음집]으로 오세요! → 클릭
출처
※ 공지 - 2019년 2월 18일 지문이 리뉴얼되었습니다.
※ 공지 - 2019년 2월 27일, 28일 테스트케이스가 추가되었습니다.
※ 공지 - 2021년 7월 28일 테스트케이스가 추가되었습니다.
※ 공지 - 2021년 8월 30일 테스트케이스가 추가되었습니다.
  • 풀이
    public static int solution(int n, int[] lost, int[] reserve) {
        int answer = n - lost.length;
        Arrays.sort(lost);
        Arrays.sort(reserve);
        
        //여벌 체육복을 가져온 학생이 도난당한 경우
        for(int i=0; i<lost.length; i++) {
        	for(int j=0; j<reserve.length; j++) {
        		if(lost[i] == reserve[j]) {
        			answer++;
        			lost[i] = -1;
        			reserve[j] = -1;
        			break;
        		}
        	}
        }
        // 도난당한 학생에게 체육복을 빌려주는 경우
        for(int i=0; i<lost.length; i++) {
        	for(int j=0; j<reserve.length; j++) {
        		//여벌 체육복을 가져온 학생이 자기번호 앞, 뒤 학생에게 체육복을 빌려줌
        		if((lost[i]-1 == reserve[j]) || (lost[i]+1 == reserve[j])){
        			answer++;
        			reserve[j] = -1;
        			break;
        		}
        	}
        }
        
        return answer; 
    }
	
	public static void main(String[] args) {
		int a = 5;
		int[] a2 = {2, 4};
		int[] a3 = {1, 3, 5};
		System.out.println(solution(a, a2, a3));
		
		int b = 5;
		int[] b2 = {2, 4};
		int[] b3 = {3};
		System.out.println(solution(b, b2, b3));

		int c = 3;
		int[] c2 = {3};
		int[] c3 = {1};
		System.out.println(solution(c, c2, c3));

	}
728x90
반응형
728x90
반응형

프로그래머스 2022 KAKAO BLIND 테스트 문제였던 "신고 결과 받기" 자바 문제 풀이 공유드립니다.

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

 

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

  • 문제
신입사원 무지는 게시판 불량 이용자를 신고하고 처리 결과를 메일로 발송하는 시스템을 개발하려 합니다. 무지가 개발하려는 시스템은 다음과 같습니다.
  • 각 유저는 한 번에 한 명의 유저를 신고할 수 있습니다.
    • 신고 횟수에 제한은 없습니다. 서로 다른 유저를 계속해서 신고할 수 있습니다.
    • 한 유저를 여러 번 신고할 수도 있지만, 동일한 유저에 대한 신고 횟수는 1회로 처리됩니다.
  • k번 이상 신고된 유저는 게시판 이용이 정지되며, 해당 유저를 신고한 모든 유저에게 정지 사실을 메일로 발송합니다.
    • 유저가 신고한 모든 내용을 취합하여 마지막에 한꺼번에 게시판 이용 정지를 시키면서 정지 메일을 발송합니다.
다음은 전체 유저 목록이 ["muzi", "frodo", "apeach", "neo"]이고, k = 2(즉, 2번 이상 신고당하면 이용 정지)인 경우의 예시입니다.



각 유저별로 신고당한 횟수는 다음과 같습니다.

위 예시에서는 2번 이상 신고당한 "frodo"와 "neo"의 게시판 이용이 정지됩니다. 이때, 각 유저별로 신고한 아이디와 정지된 아이디를 정리하면 다음과 같습니다.


따라서 "muzi"는 처리 결과 메일을 2회, "frodo"와 "apeach"는 각각 처리 결과 메일을 1회 받게 됩니다.
이용자의 ID가 담긴 문자열 배열 id_list, 각 이용자가 신고한 이용자의 ID 정보가 담긴 문자열 배열 report, 정지 기준이 되는 신고 횟수 k가 매개변수로 주어질 때, 각 유저별로 처리 결과 메일을 받은 횟수를 배열에 담아 return 하도록 solution 함수를 완성해주세요.
ㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡㅡ
제한사항
  • 2 ≤ id_list의 길이 ≤ 1,000
    • 1 ≤ id_list의 원소 길이 ≤ 10
    • id_list의 원소는 이용자의 id를 나타내는 문자열이며 알파벳 소문자로만 이루어져 있습니다.
    • id_list에는 같은 아이디가 중복해서 들어있지 않습니다.
  • 1 ≤ report의 길이 ≤ 200,000
    • 3 ≤ report의 원소 길이 ≤ 21
    • report의 원소는 "이용자id 신고한id"형태의 문자열입니다.
    • 예를 들어 "muzi frodo"의 경우 "muzi"가 "frodo"를 신고했다는 의미입니다.
    • id는 알파벳 소문자로만 이루어져 있습니다.
    • 이용자id와 신고한id는 공백(스페이스)하나로 구분되어 있습니다.
    • 자기 자신을 신고하는 경우는 없습니다.
  • 1 ≤ k ≤ 200, k는 자연수입니다.
  • return 하는 배열은 id_list에 담긴 id 순서대로 각 유저가 받은 결과 메일 수를 담으면 됩니다.




입출력 예 설명
입출력 예 #1
문제의 예시와 같습니다.
입출력 예 #2
"ryan"이 "con"을 4번 신고했으나, 주어진 조건에 따라 한 유저가 같은 유저를 여러 번 신고한 경우는 신고 횟수 1회로 처리합니다. 따라서 "con"은 1회 신고당했습니다. 3번 이상 신고당한 이용자는 없으며, "con"과 "ryan"은 결과 메일을 받지 않습니다. 따라서 [0, 0]을 return 합니다.
  • 풀이

중복 신고를 제거하기 위해서 HashMap과 HashSet을 사용했습니다.

  • Set : 데이터를 중복 저장할 수 없음
  • HashSet : Set 인터페이스를 사용, 중복된 값을 저장할 수 없음, put() 메소드를 사용해 데이터를 저장
  • HashMap : Map 인터페이스를 사용, 중복된 값을 저장할 수 있음, add() 메소드를 사용해 데이터를 저장
package algorithms;

import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;

/*
 * 코딩테스트 연습 > 2022 KAKAO BLIND RECRUITMENT >신고 결과 받기
 */
public class S12 {
	
	public static int[] solution(String[] id_list, String[] report, int k) {
        int[] answer = new int[id_list.length];
        
        //동일한 유저ID에 대한 신고횟수는 1회로 처리하기 때문에 중복을 허용하지 않는 HashSet을 value로 사용.
        Map<String, HashSet<String>> reportMap = new HashMap<>(); // [신고한ID, [신고된ID]]
        Map<String, Integer> answerMap = new HashMap<>(); // [신고된ID, 메일수]
        
        //1. reportMap, answerMap 초기화
        for(int i=0; i<id_list.length; i++) {
        	HashSet<String> reportingId = new HashSet<>();
        	reportMap.put(id_list[i], reportingId); // 유저ID, 신고한ID로 초기 셋팅
        	answerMap.put(id_list[i], 0); // 유저ID, 메일수 0으로 셋팅 
        }
        //System.out.println("reportMap : " + reportMap ); // {muzi=[], neo=[], frodo=[], apeach=[]}
        //System.out.println("answerMap : " + answerMap ); // {muzi=0, neo=0, frodo=0, apeach=0}
        
        //2. [신고한ID, [신고된ID]]으로 reportMap 맵에 추가.
        for(int i=0; i<report.length; i++) {
        	String[] reportArr = report[i].split(" ");
        	String userId = reportArr[0]; //신고한ID
        	String reportId = reportArr[1]; //신고된ID
        	reportMap.get(reportId).add(userId);//신고된ID를 key값으로 신고한ID 배열을 value로 셋팅
        }
        //System.out.println("reportMap " + reportMap); // reportMap {muzi=[apeach], neo=[muzi, frodo], frodo=[muzi, apeach], apeach=[]}
       

        //3. 유저가 받은 이용 정지 결과 메일 셋팅
        for(String reportId : reportMap.keySet()) { // reportId는 신고된 유저ID
        	HashSet<String> userMailSend = reportMap.get(reportId); // userMailSend는 신고된유저ID(reportId)를 신고한 유저ID
//        	System.out.println("reportId: "+ reportId+ " userMailSend: " + userMailSend + " userMailSend.size(): "+userMailSend.size());
//        	reportId: muzi userMailSend: [apeach] userMailSend.size(): 1
//        	reportId: neo userMailSend: [muzi, frodo] userMailSend.size(): 2
//        	reportId: frodo userMailSend: [muzi, apeach] userMailSend.size(): 2
//        	reportId: apeach userMailSend: [] userMailSend.size(): 0
        	
        	//신고된 횟수가 K번 이상인 경우
        	if(userMailSend.size()>=k) {
        		for(String userId : userMailSend) {
        			//answerMap에 신고된Id별로 메일 수 넣기
        			answerMap.put(userId, answerMap.get(userId)+1);
        		}
        	}
//        	System.out.println("answerMap: " +answerMap);
//        	answerMap: {muzi=0, neo=0, frodo=0, apeach=0}
//        	answerMap: {muzi=1, neo=0, frodo=1, apeach=0}
//        	answerMap: {muzi=2, neo=0, frodo=1, apeach=1}
//        	answerMap: {muzi=2, neo=0, frodo=1, apeach=1}
        }
        
        // 4. id_list별 받은 메일수 answer에 셋팅
        for(int i=0; i<id_list.length; i++) {
        	answer[i] = answerMap.get(id_list[i]);
        }
        
        return answer;
    }
	

	 
	public static void main(String[] args) {
		String[] id_list = {"muzi", "frodo", "apeach", "neo"};
		String[] report = {"muzi frodo","apeach frodo","frodo neo","muzi neo","apeach muzi"};
		int k = 2;
		
		String[] id_list2 = {"con", "ryan"};
		String[] report2 = {"ryan con", "ryan con", "ryan con", "ryan con"};
		int k2 = 2;
		
		System.out.println(Arrays.toString(solution(id_list, report, k)));
		System.out.println(Arrays.toString(solution(id_list2, report2, k2)));
	}

}
  • 실행결과

728x90
반응형
728x90
반응형
정렬 : 데이터를 순서대로 나열하는 방법

1. 버블 정렬(Bubble Sort)


2. 선택 정렬(Select Sort)


3. 삽입 정렬(Insert sort)


4. 퀵 정렬(Quick Sort)


5. 머지 정렬(Merge sort)



1. 버블 정렬(Bubble sort)

매번 연속된 두 개 인덱스를 비교하여, 정한 기준의 값을 뒤로 넘겨 정렬하는 알고리즘

시간복잡도가 높아 실제로 잘 사용되지 않는 정렬

2. 선택 정렬(Selection sort)

주어진 리스트에 최소값을 찾아 맨 앞에 위치한 값과 교체하며 리스트를 반복해 교체하는 알고리즘

정렬되지 않은 배열 인덱스의 맨 앞에서부터 포함한 이후의 배열 값 중 가장 작은 값을 찾아 정렬하는 알고리즘

3. 삽입 정렬(Insertion sort)

자료 배열의 모든 요소를 앞에서부터 차례대로 이미 정렬된 배열 부분과 비교하여자신의 위치를 찾아 삽입함으로써 정렬을 완성하는 알고리즘이다.

4. 퀵 정렬(Quick sort)

분할 정복 알고리즘의 종류로 pivot을 선정하여 pivot을 기준으로 좌측과 우측으로 pivot보다 작은 값을 왼쪽, pivot보다 큰 값을 오른쪽으로 재배치를 하고 계속하여 분할하여 정렬하는 알고리즘

*pivot : 리스트 가운데서 고른 하나의 원소

*분할정복 : 커다란 문제를 잘게 나눠서 작은 문제를 극복

5. 머지 정렬(Merge sort)

분할 정복 알고리즘의 종류로 큰 문제를 반으로 쪼개 문제를 해결해 나가는 방식으로 배열의 크기가 1보다 작거나 같을 때까지 반복해 정렬하는 알고리즘

두 개의 배열을 비교하여, 기준에 맞는 값을 다른 배열에 저장해 나가는 방식

머지 정렬 와 퀵 정렬의 차이

병합 정렬은 정확하게 이분할을 하는 반면에 퀵 정렬의 경우에는 정확하게 이분할되지 않는 차이가 있습니다.







출처 : 생활코딩

728x90
반응형
728x90
반응형

문제는 다음과 같습니다.

https://www.acmicpc.net/problem/14502

 
import java.util.Scanner;

public class Test14502 {
	static int N, M;
	static int totalCNT;
	static int[] dx = {0, -1, 0, 1};
	static int[] dy = {-1, 0, 1, 0};
	static int[][] adMatrix, visit;
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		M = sc.nextInt();
		adMatrix = new int[N][M];
		visit = new int[N][M];
		for(int i=0; i<N; i++) {
			for(int j=0; j<M; j++) {
				adMatrix[i][j] = sc.nextInt();
			}
		}
		//알고리즘 풀이
		for(int i=0; i<N*M; i++) {
			int row = i/M;
			int col = i%M;
			if(adMatrix[row][col]==0) {
				adMatrix[row][col]=1;
				DFS(i, 1);
				adMatrix[row][col]=0;
			}
		}
		System.out.println(totalCNT);
	}
	//벽 3개 세우기
	static void DFS(int v, int cnt) {
		int row = v/M;
		int col = v%M;
		if(cnt==3) {
			for(int i=0; i<N; i++) {
				for(int j=0; j<M; j++) {
					visit[i][j]=adMatrix[i][j];
				}
			}
			for(int i=0; i<N; i++) {
				for(int j=0; j<M; j++) {
					if(visit[i][j]==2) {
						spreadVirus(i, j);
					}
				}
			}
			safetyArea();
		}else {
			for(int i=v+1; i<N*M; i++) {
				int row2 = i/M;
				int col2 = i%M;
				if(adMatrix[row2][col2]==0) {
					adMatrix[row2][col2]=1;
					DFS(i, cnt+1);
				}
			}
		}
		adMatrix[row][col]=0;
	}
	//바이러스 확산 메소드
	static void spreadVirus(int row, int col) {
		for(int i=0; i<4; i++) {
			int nextRow = dx[i]+row;
			int nextCol = dy[i]+col;
			if(nextRow>=0 && nextRow<N && nextCol>=0 && nextCol<M) {
				if(visit[nextRow][nextCol]==0) {
					visit[nextRow][nextCol]=2;
					spreadVirus(nextRow, nextCol);
				}
			}
		}
	}
	//안정 영역 크기 구하기
	static void safetyArea() {
		int cnt=0;
		for(int i=0; i<N; i++) {
			for(int j=0; j<M; j++) {
				if(visit[i][j]==0) {
					cnt++;
				}
			}
		}
		if(totalCNT<cnt) {
			totalCNT = cnt;
		}
	}
}

 





결과입니다.


728x90
반응형
728x90
반응형

문제는 다음과 같습니다.

https://www.acmicpc.net/problem/2667


 
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

public class Test{
	static int N;
	static int[][] adMatrix;
	static int[][] visit;
	static int dx[] = {0, -1, 0, 1};
	static int dy[] = {-1, 0, 1, 0};
	static ArrayList<Integer> list = new ArrayList<Integer>();
	
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		adMatrix = new int[N+1][N+1];
		visit = new int[N+1][N+1];
		String[] s = new String[N+1];
		for(int i=1; i<=N; i++) {
			s[i] = sc.next();
			for(int j=1; j<=N; j++) {
				adMatrix[i][j] = s[i].charAt(j-1)-'0';
			}
		}
		
		int totalCNT=0;
		for(int i=1; i<=N; i++) {
			for(int j=1; j<=N; j++) {
				if(adMatrix[i][j]==1 && visit[i][j]==0) {
					totalCNT++;
					int cnt = DFS(i,j, totalCNT, 0);
					list.add(cnt);
				}
			}
		}
		Collections.sort(list); //오름차순 정렬함수
		System.out.println(totalCNT);
		for(int x : list) {
			System.out.println(x);
		}
	}
	static int DFS(int row, int col, int totalCNT, int cnt) {
		cnt++;
		visit[row][col] = 1; //1 true, 0 false
		for(int i=0; i<4; i++) {
			int nextRow = row + dx[i];
			int nextCol = col + dy[i];
			if(nextRow>0 && nextRow<=N && nextCol>0 && nextCol<=N) {
				if(adMatrix[nextRow][nextCol]==1 && visit[nextRow][nextCol]==0) {
					cnt = DFS(nextRow, nextCol, totalCNT, cnt);
				}
			}
		}
		return cnt;
	}
	
	
}
 






결과입니다.



728x90
반응형
728x90
반응형


문제는 다음과 같습니다.

https://www.acmicpc.net/problem/11403

 
import java.util.Scanner;

public class Test11403 {
	static int N;
	static int[][] adMatrix;
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		adMatrix = new int[N+1][N+1];
		for(int i=1; i<=N; i++) {
			for(int j=1; j<=N; j++) {
				adMatrix[i][j] = sc.nextInt();
			}
		}
		//알고리즘 풀이
		for(int i=1; i<=N; i++) {
			int[] visit = new int[N+1];
			DFS(i, visit, false);
			for(int j=1; j<=N; j++) {
				System.out.print(visit[j]+" ");
			}System.out.println();
		}
	}
	static void DFS(int x, int[] visit, Boolean isFirst) {
		if(isFirst) { 
			visit[x] = 1;
		}
		for(int i=1; i<=N; i++) {
			if(adMatrix[x][i]==1 && visit[i]==0) {
				DFS(i, visit, true);				
			}
			
		}
	}
}
 
 
import java.util.Scanner;

public class Test11403{
	static int N;
	static int[][] adMatrix;
	static void DFS(int x, int[] visit, boolean isFirst) {
		if(!isFirst) { //isFirst가 false일 경우
			visit[x]=1;
		}
		for(int i=1; i<=N; i++) {
			if(adMatrix[x][i]==1 && visit[i]==0) {
				DFS(i, visit, false);
			}
		}
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		adMatrix = new int[N+1][N+1];
		//행렬 입력받기
		for(int i=1; i<=N; i++) {
			for(int j=1; j<=N; j++) {
				adMatrix[i][j] = sc.nextInt();
			}
		}
		//알고리즘 풀이
		for(int i=1; i<=N; i++) {
			int[] visit = new int[N+1];
			DFS(i, visit, true);
			for(int j=1; j<=N; j++) {
				System.out.print(visit[j]+" ");
			}System.out.println();
		}
		
	}
	
}
 


 
import java.util.Scanner;

public class Test11403{
	static int N;
	static int[][] adMatrix;
	static int[][] result;
	
	static void DFS(int x, int[] visit, boolean isFirst) {
		if(!isFirst) { //isFirst가 false일 경우
			visit[x]=1;
		}
		for(int i=1; i<=N; i++) {
			if(adMatrix[x][i]==1 && visit[i]==0) {
				DFS(i, visit, false);
			}
		}
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		adMatrix = new int[N+1][N+1];
		result = new int[N+1][N+1];
		//행렬 입력받기
		for(int i=1; i<=N; i++) {
			for(int j=1; j<=N; j++) {
				adMatrix[i][j] = sc.nextInt();
			}
		}
		//알고리즘 풀이
		for(int i=1; i<=N; i++) {
			int[] visit = new int[N+1];
			DFS(i, visit, true);
			result[i] = visit;
		}
		//출력하기
		for(int i=1; i<result.length; i++) {
			for(int j=1; j<result.length; j++) {
				System.out.print(result[i][j]+" ");
			}
			if(i != result.length-1) {
				System.out.println();
			}
		}
	}
	
}
 






결과입니다.


728x90
반응형
728x90
반응형

+ Recent posts