[문제]

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

 

16235번: 나무 재테크

부동산 투자로 억대의 돈을 번 상도는 최근 N×N 크기의 땅을 구매했다. 상도는 손쉬운 땅 관리를 위해 땅을 1×1 크기의 칸으로 나누어 놓았다. 각각의 칸은 (r, c)로 나타내며, r은 가장 위에서부터

www.acmicpc.net

[풀이]

N,M,K가 주어지고 K년 후에 남아있는 나무의 수를 출력하면 된다.

따라서 for 문을 K년 동안 돌리고 for문에서 봄, 여름, 가을, 겨울에 대한 함수를 호출했다.

 

봄 - 에는 나무가 영양분을 먹는다. 단, 한 좌표에 나무가 2개 이상이면 나이가 어린 순서부터 영양분을 먹는다.

영양분이 부족하다면 먹지 못하고 나무는 죽는다.

 

여름 - 봄에 죽은 나무가 양분으로 변하게 된다. 해당 좌표에 나이/2 만큼 양분을 남긴다.

 

가을 - 나이가 5의 배수인 나무가 번식한다.

 

겨울 - input으로 주어진 양분이 추가된다.

 

 


봄,여름에 대한 함수를 하나로 묶고 가을,겨울에 대한 함수를 하나로 묶었다.

map을 벡터로 선언해 해당 좌표에 존재하는 나무의 나이를  벡터에 저장해줬다.

 

봄,여름 함수에서는 해당 좌표에 나무가 존재한다면 양분을 먹는다.

( 하나의 좌표에 여러개의 나무가 존재한다면 나이순을 오름차순 정렬)

양분이 부족해 나무가 먹지 못한다면 해당 idx를 기준으로 뒤에 있는 나무들은 모두 죽게된다. ( 오름차순으로 정렬된 상태이므로)

 

가을, 겨울 함수에서는 map에 벡터 사이즈를 기준으로 나무가 존재한다면 나무의 나이가 5의 배수인지 확인

5의 배수라면 나무는 번식한다. 따라서 주변 좌표에 나이가 1인 나무를 추가.

또한 양분을 추가해준다.(겨울)

 

 

 

[코드]

 

 

 

 

 

 

#include <iostream>
#include <vector>
#include <algorithm>

#define MAX 11

using namespace std;

int N,M,K;
int A[MAX][MAX]={0,};//추가되는 양분
int nutrient[MAX][MAX]={0,}; // 현재 양분
vector<int> map[MAX][MAX];

int dx[8] = {-1,-1,-1,0,0,1,1,1};
int dy[8] = {-1,0,1,-1,1,-1,0,1};

void SpringSummer()
{
    int visited[MAX][MAX]={0,}; // 현재 양분

    for(int i=1;i<=N;i++){
        for(int j=1;j<=N;j++){
            
            int _size = map[i][j].size();
            
            if(_size==0)    continue;
            else if(_size > 1)  sort(map[i][j].begin(), map[i][j].end());
            
            int idx=0;
            while(idx < _size){
                if(map[i][j][idx] <= nutrient[i][j]) {
                    nutrient[i][j]-=map[i][j][idx];
                    map[i][j][idx]++;
                }
                else    break;
                idx++;
            }
            
            if(idx != _size){
                
                for(int k=_size-1; k>=idx ; k--){
                    nutrient[i][j] += map[i][j][k]/2;
                    map[i][j].pop_back();
                    M--;
                }
            }
        }
    }
}

void FallWinter()
{
    int num = M;
    
    for(int i=1;i<=N;i++){
        for(int j=1;j<= N;j++){
            if(map[i][j].size() ==0)    continue;
            
            for(int k=0;k<map[i][j].size();k++){
                int age = map[i][j][k];
                
                if(age%5 == 0){
                    for(int l=0;l<8;l++){
                        int nx = i + dx[l];
                        int ny = j + dy[l];
                        
                        if(nx < 1 || ny < 1 || nx > N || ny > N)    continue;
                        
                        map[nx][ny].push_back(1);
                        M++;
                    }
                }
            }
        }
    }

    
    for(int i=1;i<=N;i++){
        for(int j=1;j<=N;j++)   nutrient[i][j]+=A[i][j];
    }
}

int main(void)
{
    scanf("%d %d %d",&N,&M,&K);
    
    for(int i=1;i<=N;i++){
        for(int j=1; j<= N;j++) scanf("%d",&A[i][j]);
    }
    
    for(int i=1;i<=N;i++){
        for(int j=1; j<= N;j++) nutrient[i][j]=5;
    }
    
    for(int i=0;i<M;i++)
    {
        int x,y,age;
        scanf("%d %d %d",&x,&y,&age);
        map[x][y].push_back(age);
    }
    
    for(int i=0;i<K;i++){
        SpringSummer();
        FallWinter();
    }
    
    printf("%d",M);
    return 0;
    
}

 

지적, 조언, 질문 환영입니다.

댓글 남겨주세요~

 

'알고리즘 > 백준' 카테고리의 다른 글

[백준] 4195. 친구 네트워크  (0) 2020.10.01
[백준] 16236. 아기상어  (0) 2020.10.01
[백준] 16234. 인구이동  (0) 2020.09.28
[백준]15683. 감시  (0) 2020.09.21
[백준] 14890. 경사로  (0) 2020.09.17

[문제]

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

 

16234번: 인구 이동

N×N크기의 땅이 있고, 땅은 1×1개의 칸으로 나누어져 있다. 각각의 땅에는 나라가 하나씩 존재하며, r행 c열에 있는 나라에는 A[r][c]명이 살고 있다. 인접한 나라 사이에는 국경선이 존재한다. 모��

www.acmicpc.net

[풀이]

 

인구 차가 L 이상, R 이하라면 queue와 vector에 넣어서

인구 이동 할 수 있는 좌표 모두 구하고 

마지막에 인구 평균 구하고 map을  평균 값으로 update 해준다. 

 

queue는 BFS로 풀기 위해서 사용

vector는 나중에 인구 이동 하고 인구 수 update 하기 위한  좌표들 저장

 

solve 함수에서 평균 인구 수 구하고 vector에 저장된 좌표들 update

 

시간 : 108ms

 

[코드]

#include <iostream>
#include <queue>
#include <vector>

#define MAX 50

using namespace std;


int N,L,R;
int map[MAX][MAX]={0,};
int sum=0;

int dx[4] = {-1,0,1,0};
int dy[4] = {0,1,0,-1};

struct pos{
    int x,y;
};
vector <pos> v;

void solve()
{
    int _size = v.size();
    int avg = sum/_size;
    
    for(int i=0;i<v.size();i++){
        int x = v[i].x;
        int y = v[i].y;
        map[x][y]= avg;
    }
}

int main(void)
{
    cin >> N>>L>>R;
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++)    cin >> map[i][j];
    }
    int cnt =0;
    queue <pos> q;
    
    
    while(1){
        
        bool flag = false;
        int visited[MAX][MAX]={0,};

        for(int i=0;i<N;i++){
            for(int j=0;j<N;j++){
                    
                if(visited[i][j]==0){
                    q.push({i,j});
                    v.push_back({i,j});
                    visited[i][j]=1;
                    sum += map[i][j];
                }
                
                while(!q.empty()){
                    
                    int x = q.front().x;
                    int y = q.front().y;
                    
                    q.pop();
                                        
                    for(int k=0;k<4;k++){
                        
                        int nx =x+dx[k];
                        int ny =y+dy[k];
                        
                        if(nx < 0 || ny <0 || nx >= N || ny >= N || visited[nx][ny])   continue;
                        int comp= map[x][y] > map[nx][ny] ? map[x][y] - map[nx][ny] : map[nx][ny]-map[x][y];
                        
                        if(L <= comp && comp <= R){
                            q.push({nx,ny});
                            v.push_back({nx,ny});
                            visited[nx][ny]=1;
                            sum += map[nx][ny];
                        }
                    }
                }
                
                if(v.size() > 1){
                    solve();
                    flag = true;
                }
                v.clear();
                sum=0;
                
            }
        }
        if(!flag )  break;
        else    cnt++;

    }
    printf("%d",cnt);
    return 0;
    
}

 

지적, 조언, 질문 환영입니다.

댓글 남겨주세요~

 

'알고리즘 > 백준' 카테고리의 다른 글

[백준] 16236. 아기상어  (0) 2020.10.01
[백준] 16235. 나무 재테크  (0) 2020.09.30
[백준]15683. 감시  (0) 2020.09.21
[백준] 14890. 경사로  (0) 2020.09.17
[백준] 14889.스타트와 링크  (0) 2020.09.14

[문제]

https://programmers.co.kr/learn/courses/30/lessons/59410

 

코딩테스트 연습 - NULL 처리하기

ANIMAL_INS 테이블은 동물 보호소에 들어온 동물의 정보를 담은 테이블입니다. ANIMAL_INS 테이블 구조는 다음과 같으며, ANIMAL_ID, ANIMAL_TYPE, DATETIME, INTAKE_CONDITION, NAME, SEX_UPON_INTAKE는 각각 동물의 아이디

programmers.co.kr

[풀이]

sql 문제로 IFNULL을 사용해 이름이 NULL이면 "No name"으로 채워줬다.

또한 ANIMAL_ID를 기준으로 오름차순으로 정렬 

 

IFNULL(필드명, "대체할 값") : 필드가 Null이면 대체할 값으로 채운다.

 

[코드]

SELECT ANIMAL_TYPE,IFNULL(NAME, "No name") ,SEX_UPON_INTAKE from ANIMAL_INS
order by ANIMAL_ID ASC

[문제]

https://programmers.co.kr/learn/courses/30/lessons/42884

 

코딩테스트 연습 - 단속카메라

[[-20,15], [-14,-5], [-18,-13], [-5,-3]] 2

programmers.co.kr

[풀이]

 

 

차량 이동경로를 sort 함수를 사용해 오름차순으로 정렬한다.

첫번째 이동경로의 진출 지점을  CCTV의 위치로 초기화

 

두번째 이동경로부터 마지막 이동경로까지 

현재 이동경로의 진출 지점이 CCTV의 위치보다 앞에 있는 경우 => CCTV의 위치만 update

현재 이동경로의 진입 지점이 CCTV의 위치보다 뒤에 있는 경우 => CCTV의 위치 update, CCTV 설치 갯수 1 증가.

 

[코드]

 

#include <string>
#include <vector>
#include <algorithm>

using namespace std;

int solution(vector<vector<int>> routes) {
    int answer = 1;
    sort(routes.begin(), routes.end());
    
    int pos = routes[0][1];
    
    for(int i=1;i<routes.size();i++){
        if(routes[i][1] < pos)  pos = routes[i][1];
        else if(routes[i][0] > pos){
            answer++;
            pos = routes[i][0];
        }
    }
    return answer;
}

 

진짜 간단하게 풀 수 있는 문제인데 처음에 너무 복잡하게 생각했다.

[문제]

 

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

 

15683번: 감시

스타트링크의 사무실은 1×1크기의 정사각형으로 나누어져 있는 N×M 크기의 직사각형으로 나타낼 수 있다. 사무실에는 총 K개의 CCTV가 설치되어져 있는데, CCTV는 5가지 종류가 있다. 각 CCTV가 감��

www.acmicpc.net

 

[풀이]

 

 DFS를 사용해 각 CCTV에 대해 모든 경우의 수를 따져주고 최솟값을 구하면 된다. 

 

[그림 1]

 

[그림 1]과 같이 DFS 함수에서 visited 배열에 CCTV가 감시할 방향을 저장해놓고

모든 CCTV에 대해 저장했다면 solve 함수에서 방향에 맞게 감시 진행

 

 

이런 방식으로  spread 함수에서 좌표랑 방향을 인자 값으로 넘겨주고

벽을 만나기 전까지 감시할 수 있는 좌표에 -1을 저장해준다.

모든 CCTV에 대해 확인하면 마지막으로 0의 갯수를  count

 

현재 사각지대의 최솟값이랑 비교하면 더 작으면 최솟값을 update

[코드]

#include <iostream>
#include <vector>

#define MAX 8
using namespace std;
/*
지도에서 0은 빈 칸, 6은 벽, 1~5는 CCTV의 번호
 */

int N,M;
int map[MAX][MAX]={0,};
int tmp[MAX][MAX]={0,};
int visited[8]={0,};

int dx[4] = {-1,0,1,0};
int dy[4] = {0,1,0,-1};

struct pos {
    int x,y;
    int num;
};

int cnt=0;
vector <pos> CCTV;
int MIN =1e9;

void spread(int x, int y, int dir)
{
    while(1){
        if(tmp[x][y]==6)    return;
        if(x < 0 || y < 0 || x >= N || y >= M ) return;
        tmp[x][y]=-1;
        
        x += dx[dir];
        y+= dy[dir];
    }
}


void solve()
{
    for(int i=0;i<N;i++){
        for(int j=0;j<M;j++)    tmp[i][j] = map[i][j];
    }
    
    for(int i=0;i<cnt;i++){
        
        int x = CCTV[i].x;
        int y = CCTV[i].y;
        
        if(CCTV[i].num==1){
            spread(CCTV[i].x, CCTV[i].y, visited[i]-1);
        }
        else if(CCTV[i].num==2){
            if(visited[i]==1){
                spread(x, y, 1);
                spread(x, y, 3);
            }
            else{
                spread(x, y, 0);
                spread(x, y, 2);
            }
        }
        else if(CCTV[i].num==3){
            if(visited[i]==1){
                spread(x, y, 0);
                spread(x, y, 1);
            }
            else if(visited[i]==2){
                spread(x, y, 1);
                spread(x, y, 2);
            }
            else if(visited[i]==3){
                spread(x, y, 2);
                spread(x, y, 3);
            }
            else if(visited[i]==4){
                spread(x, y, 3);
                spread(x, y, 0);
            }
        }
        else if(CCTV[i].num==4){
            if(visited[i]==1){
                spread(x, y, 0);
                spread(x, y, 1);
                spread(x, y, 2);
            }
            else if(visited[i]==2){
                spread(x, y, 1);
                spread(x, y, 2);
                spread(x, y, 3);

            }
            else if(visited[i]==3){
                spread(x, y, 2);
                spread(x, y, 3);
                spread(x, y, 0);

            }
            else if(visited[i]==4){
                spread(x, y, 3);
                spread(x, y, 0);
                spread(x, y, 1);

            }
        }
        else if(CCTV[i].num==5){
            spread(x, y, 0);
            spread(x, y, 1);
            spread(x, y, 2);
            spread(x, y, 3);

        }
    }
    int tmp1=0;
    for(int i=0;i<N;i++){
        for(int j=0;j<M;j++){
            if(tmp[i][j]==0)    tmp1++;
        }
    }
    
    if(tmp1 < MIN)  MIN = tmp1;
}

void DFS(int idx)
{
    if(idx == cnt)
    {
        solve();
        return;
    }
    
    if(CCTV[idx].num == 1){
        for(int i=1;i<=4;i++){
            visited[idx]=i;
            DFS(idx+1);
        }
    }
    else if(CCTV[idx].num == 2){
        for(int i=1;i<=2;i++){
            visited[idx]=i;
            DFS(idx+1);
        }
    }
    else if(CCTV[idx].num == 3){
        for(int i=1;i<=4;i++){
            visited[idx]=i;
            DFS(idx+1);
        }
    }
    else if(CCTV[idx].num == 4){
        for(int i=1;i<=4;i++){
            visited[idx]=i;
            DFS(idx+1);
        }
    }
    else if(CCTV[idx].num == 5) DFS(idx+1);
    
    return;
    
}
int main(void)
{
    cin >> N >> M;
    
    for(int i=0;i<N;i++){
        for(int j=0;j<M;j++)
        {
            cin >> map[i][j];
            if(map[i][j] != 0 && map[i][j]!=6){
                CCTV.push_back({i,j,map[i][j]});
                cnt++;
            }
        }
    }
    
    DFS(0);
    
    cout << MIN << endl;
    
    
    return 0;
    
}

 

지적, 조언, 질문 환영입니다.

댓글 남겨주세요~

 

'알고리즘 > 백준' 카테고리의 다른 글

[백준] 16235. 나무 재테크  (0) 2020.09.30
[백준] 16234. 인구이동  (0) 2020.09.28
[백준] 14890. 경사로  (0) 2020.09.17
[백준] 14889.스타트와 링크  (0) 2020.09.14
[백준] 14503.로봇 청소기  (0) 2020.07.30

[문제]

 

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

 

14890번: 경사로

첫째 줄에 N (2 ≤ N ≤ 100)과 L (1 ≤ L ≤ N)이 주어진다. 둘째 줄부터 N개의 줄에 지도가 주어진다. 각 칸의 높이는 10보다 작거나 같은 자연수이다.

www.acmicpc.net

 

시뮬레이션 문제로 

 

높이가 같은 경우 -> 다음 index로 넘어감

높이가 다른 경우 -> 차이가 1보다 큰지 확인 

 

행과 열을 올렸다 하나의 일차원 배열에 옮겨서 확인 

(어차피 행과 열 확인하는 방법은 같으니까)

 

 

[풀이]

 

1. check 함수

 

 

다음 인덱스랑 높이 비교  

높이차가 같은 경우 다음 인덱스로 넘어감. 

높이차가 1보다 크다면 check 함수 바로 return.

높이차가 1인 경우 comp 함수 호출.

 

0부터 N-1까지 확인 

N-1까지 도달한 경우 cnt (지나갈 수 있는 길의 갯수 ) 1 증가 

 

 

2. comp 함수

 

경사로를 추가할 수 있는지 확인

 

추가할 부분의 길이가 경사로의 길이보다 짧으면 안된다.

 

 

 

[그림 1]

 

조심해야될 부분은 위의 [그림 1]과 같이 경우에는 경사로를 무조건 2개 추가하는 경우부터 가능하다. 

(코드 25번째 line에서 처리 ) 

 

 

 

[ 그림 2]

또 [그림 2]의 경우 return tmp+1을 해줬는데 

 

 

4 4 3 3 3 2 2 , 경사로 : 3 

 

위의 경우 통과하지 못하는 케이스인데 tmp+1 (arr[5])부터 체크하므로 통과하게 된다.

=> 따라서 return tmp로 바꿔서 arr[4]부터 체크하도록 해줬다. (코드 24번째 line) 

(이 부분 놓쳐서 계속 틀렸다.) 

 

 

[코드]

 

시간 : 0ms

#include <iostream>
#define MAX 100

using namespace std;

int N,L;
int map[MAX][MAX]={0,};
int cnt =0;

int comp(int pos , int arr[100])
{
    int tmp;
    
    if ( arr[pos] > arr[pos+1]){
        tmp = pos+1;
        int len=1;
        while(tmp < N-1){
            if(arr[tmp] != arr[tmp+1])  break;
            len++;
            tmp++;
        }
        if(len < L )    return 0;
        else if(tmp == N-1)  return N-1;
        else if((arr[pos]-arr[tmp+1])== 2)   return tmp;
        else if((len/L) >= 2 &&  (arr[pos] == arr[tmp+1]))  return tmp+1;
        else  return 0;
    }
    else {
        tmp = pos;
        int len =1;
        while(tmp > 0){
            if(arr[tmp] != arr[tmp-1])  break;
            len++;
            tmp--;
        }
        if(len < L )    return 0;
        else    return pos+1;
    }
}

void check(int idx,bool flag)
{
    
    int arr[N];
    
    if(flag)    for(int i=0;i<N;i++)    arr[i] = map[i][idx];
    else    for(int i=0;i<N;i++)    arr[i] = map[idx][i];
    
    int pos =0;
    
    while(pos < N-1 ){
        
        int diff = arr[pos] - arr[pos+1];
        
        if( diff == 0)  pos++;
        else if(diff==1 || diff == -1){
            pos = comp(pos , arr);
            if(pos ==0) return ;
        }
        else    return ;
    }
    
    cnt++;
}

int main(void)
{
    cin >> N >> L;
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++)    cin >> map[i][j];
    }
    
    for(int i=0;i<N;i++){
        check(i,0); // row
        check(i,1); // col
    }
    
    cout << cnt;
    
    return 0;
}

 

조언, 질문 환영입니다!

댓글 남겨주세요~

'알고리즘 > 백준' 카테고리의 다른 글

[백준] 16234. 인구이동  (0) 2020.09.28
[백준]15683. 감시  (0) 2020.09.21
[백준] 14889.스타트와 링크  (0) 2020.09.14
[백준] 14503.로봇 청소기  (0) 2020.07.30
14499-주사위 굴리기  (0) 2020.07.24

[문제]

https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AWXRUN9KfZ8DFAUo&categoryId=AWXRUN9KfZ8DFAUo&categoryType=CODE

 

 

SW Expert Academy

SW 프로그래밍 역량 강화에 도움이 되는 다양한 학습 컨텐츠를 확인하세요!

swexpertacademy.com

 

[풀이]

시뮬레이션 문제인 것 같다.

문제 조건만 잘 따져주면서 풀면 된다. 

 

N개의 숫자를 입력 받아서 사각형 각 변에 존재하는 숫자 조합 중에서 K번째로 큰 수를 구하면 된다.

(숫자 조합이 중복되는 것이 없도록 주의)

 


 

1. 회전하기

사각형에 존재하는 각 숫자들은 시계방향으로 한칸씩 이동한다. 

=> 총 N/4 번 회전하면 처음 상태로 돌아온다. 

 

2. 각 변에 있는 문자들의 합 구하기 

16진수이므로 N/4번째 자리수부터 16씩 곱해주어 더하여 전체 합을 구한다.

 

3. 최댓값 구하기 

2번에서 구한 값을 벡터에 넣어준다. ( 중복 없이 )

벡터에 다 넣어준 뒤  sort 함수를 사용해 K번째로 작은 수 출력.

 

 

[코드]

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int N,K;
char map[4][8]={0,};
vector <int> num;

bool comp(int a, int b)
{
    return a>b;
}
void calc()
{
    int idx = N/4-1; // 2~8

    for(int i=0;i<4;i++){
     
        int sum=0;
        int tmp = 1;
        
        
        for(int j=idx;j>=0;j--){
            
            if(48<=map[i][j] && map[i][j] <=57){ //아스키코드 0~9
                sum += tmp * (map[i][j]-48);
            }
            else    sum += tmp * (map[i][j] - 55); // 아스키코드 A~F
            
            tmp *=16;
            
        }
        
        if(find(num.begin(),num.end(), sum) == num.end())   num.push_back(sum);
    }
}
void rotate()
{
    int idx = N/4-1; // 2~8
    char tmp[4]={0,};
    
    for(int i=0;i<4;i++)    tmp[i] = map[i][idx];
    
    while(idx>0){
        
        for(int i=0;i<4;i++){
            map[i][idx] = map[i][idx-1];
        }
        idx--;
    }
    
    for(int i=0;i<3;i++)    map[i+1][0] = tmp[i];
    map[0][0] = tmp[3];
    
}

void init()
{
    for(int i=0;i<4;i++){
        for(int j=0;j<8;j++)    map[i][j] = {0,};
    }
    num.clear();
    
}

int main(void)
{
    
    int T;
    cin >> T;
    
    for(int k=0;k<T;k++){
        init();
        
        cin >> N >> K;
        for(int i=0;i<4;i++){
            for(int j=0;j<N/4;j++){
                cin >> map[i][j];
            }
        }
        
        for(int i=0;i<N/4;i++){
            rotate();
            calc();
        }
        
        sort(num.begin(), num.end(),comp);
        cout << "#" << k+1 << " " << num[K-1]<<"\n";
    }
    return 0;
}

 

조언, 질문 환영입니다!

댓글 남겨주세요~

 

벡터 시간 오래 걸릴까봐 안 쓰고 풀었는데

오히려 벡터 사용하니까 더 빠르다.

 


DFS로 접근 

 

- 벡터 대신 반복문 사용

시간  :  124ms

 

#include <iostream>
#define MAX 20

using namespace std;

int N;
int map [MAX][MAX]={0,};
int visited[20]={0,};
int MIN = 1e9;


void solve()
{
    int start=0;
    int link=0;
    
    for(int i=0;i<N;i++)
    {
        if(visited[i]==1){
            for(int j=0;j<N;j++)    if(visited[j]==1)   start+=map[i][j];
        }
        else{
            for(int j=0;j<N;j++)    if(visited[j]==0)   link+=map[i][j];
        }
    }
    
    int res = start > link ? start-link : link - start;
    if( MIN > res)  MIN = res;
    
}

void DFS(int cnt,int idx)
{
    if(cnt == N/2)
    {
        solve();
        return;
    }
    
    for(int i=idx;i<N;i++){
        if(visited[i]==0)
        {
            visited[i]=1;
            DFS(cnt+1,i+1);
            visited[i]=0;
        }
    }
}
int main(void)
{
    cin >> N;
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++)
            scanf("%d",&map[i][j]);
    }
    
    DFS(0,0);
    cout << MIN;
    return 0;
}

 

 

 

 

- 벡터 사용 

시간 : 100ms

 

#include <iostream>
#include <vector>

#define MAX 20

using namespace std;

int N;
int map [MAX][MAX]={0,};
int visited[20]={0,};
int MIN = 1e9;


void solve()
{
    int start=0;
    int link=0;
    
    vector <int> s;
    vector <int> l;

    for(int i=0;i<N;i++)
    {
        if(visited[i])  s.push_back(i);
        else    l.push_back(i);
    }
    
    for(int i=0;i<N/2;i++)
    {
        for(int j=0;j<N/2;j++){
            start += map[s[i]][s[j]];
            link += map[l[i]][l[j]];
        }
    }
    
    int res = start > link ? start-link : link - start;
    if( MIN > res)  MIN = res;
    
}

void DFS(int cnt,int idx)
{
    if(cnt == N/2)
    {
        solve();
        return;
    }
    
    for(int i=idx;i<N;i++){
        if(visited[i]==0)
        {
            visited[i]=1;
            DFS(cnt+1,i+1);
            visited[i]=0;
        }
    }
}
int main(void)
{
    cin >> N;
    for(int i=0;i<N;i++){
        for(int j=0;j<N;j++)
            scanf("%d",&map[i][j]);
    }
    
    DFS(0,0);
    cout << MIN;
    return 0;
}

 

다른분들 풀이 보니까 DFS 사용 안하고 0ms로도 풀던데 한번 참고해봐야겠다.

 

조언, 질문 환영입니다!

댓글 남겨주세요~

'알고리즘 > 백준' 카테고리의 다른 글

[백준]15683. 감시  (0) 2020.09.21
[백준] 14890. 경사로  (0) 2020.09.17
[백준] 14503.로봇 청소기  (0) 2020.07.30
14499-주사위 굴리기  (0) 2020.07.24
6118_숨바꼭질  (0) 2020.07.22

+ Recent posts