반응형
더보기

문제

상근이는 요즘 설탕공장에서 설탕을 배달하고 있다. 상근이는 지금 사탕가게에 설탕을 정확하게 N킬로그램을 배달해야 한다. 설탕공장에서 만드는 설탕은 봉지에 담겨져 있다. 봉지는 3킬로그램 봉지와 5킬로그램 봉지가 있다.

상근이는 귀찮기 때문에, 최대한 적은 봉지를 들고 가려고 한다. 예를 들어, 18킬로그램 설탕을 배달해야 할 때, 3킬로그램 봉지 6개를 가져가도 되지만, 5킬로그램 3개와 3킬로그램 1개를 배달하면, 더 적은 개수의 봉지를 배달할 수 있다.

상근이가 설탕을 정확하게 N킬로그램 배달해야 할 때, 봉지 몇 개를 가져가면 되는지 그 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N이 주어진다. (3 ≤ N ≤ 5000)

출력

상근이가 배달하는 봉지의 최소 개수를 출력한다. 만약, 정확하게 N킬로그램을 만들 수 없다면 -1을 출력한다.

예제 입력 1 
18
예제 출력 1 
4
예제 입력 2 
4
예제 출력 2 
-1
예제 입력 3 
6
예제 출력 3 
2
예제 입력 4 
9
예제 출력 4 
3
예제 입력 5 
11
예제 출력 5 
3

 

이 문제는 동적 계획법 문제로 풀어야 한다. 

 

/*baekjoon 2839 설탕 배달*/
#include <iostream>
using namespace std;
int N; // 설탕 무게 

void InputData(){
    cin >> N;
}
void Solve()
{
    int total = 0;
    int tmp = 0;

    if( N%5 == 0 ){
        cout <<  N/5 << endl;
    }else{
        tmp = N/5;
        do{
            if((N - tmp*5)%3 == 0){
                cout << tmp + (N -5*tmp)/3 << endl;
                break; 
            }
            tmp--;
            }while(tmp >=0 );
    }
    if( tmp == -1 )
    cout << "-1" << endl;
}
int main()
{
    InputData();
    Solve();
    return 0;
}
/*baekjoon 2839 설탕 배달*/
반응형

'Algorithm > 동적계획법(dynamic programming)' 카테고리의 다른 글

[c++][baekjoon]1912 연속합  (0) 2022.05.09
[c++][baekjoon]1912 연속합  (0) 2022.05.08
반응형

문제

체스판 위에 한 나이트가 놓여져 있다. 나이트가 한 번에 이동할 수 있는 칸은 아래 그림에 나와있다. 나이트가 이동하려고 하는 칸이 주어진다. 나이트는 몇 번 움직이면 이 칸으로 이동할 수 있을까?

입력

입력의 첫째 줄에는 테스트 케이스의 개수가 주어진다.

각 테스트 케이스는 세 줄로 이루어져 있다. 첫째 줄에는 체스판의 한 변의 길이 l(4 ≤ l ≤ 300)이 주어진다. 체스판의 크기는 l × l이다. 체스판의 각 칸은 두 수의 쌍 {0, ..., l-1} × {0, ..., l-1}로 나타낼 수 있다. 둘째 줄과 셋째 줄에는 나이트가 현재 있는 칸, 나이트가 이동하려고 하는 칸이 주어진다.

출력

각 테스트 케이스마다 나이트가 최소 몇 번만에 이동할 수 있는지 출력한다.

 

예제 입력 1 
3
8
0 0
7 0
100
0 0
30 50
10
1 1
1 1

예제 출력 1 
5
28
0

 

풀이

1)입력은

T: 테스트 케이스 

N : 체스판의 한변의 길이

sy,sx : 나이트 시작 좌표

ey,ex : 나이트 목적지 좌표 

2)풀이 핵심은 

dy,dx를 그림과 같이 이동하는 경우를 모두 표시해 두는 게 가장 중요하다. 

그리고 나머지는 기존 bfs를 이용한 방법과 동일 하다 

/*[baekjoon]7562 나이트의 이동*/
#include <bits/stdc++.h>
using namespace std;
#define MAXN ((int) 3e2)
int Map[MAXN+10][MAXN+10];
bool visited[MAXN+10][MAXN+10];
int T;//test case
int N;//Map size
int sy,sx,ey,ex;
int dy[]={2,1,2,1,-2,-1,-2,-1};
int dx[]={1,2,-1,-2,-1,-2,1,2};
bool inRange(int x, int y){
    return ( (x>=0) && (x<N) && (y>=0) && (y<N));
}

void BFS(int y, int x){
    int ny,nx;
    queue <pair<int,int>> q;
    q.push(make_pair(y,x));
    visited[y][x]=true;

    while(!q.empty()){
        y=q.front().first;
        x=q.front().second;
        q.pop();
        if((y==ey) && (x==ex)) break;
        for(int i=0; i<8; i++){
            ny=y+dy[i];
            nx=x+dx[i];
            if(inRange(ny,nx) && !visited[ny][nx]){
                visited[ny][nx]=true;
                Map[ny][nx]=Map[y][x]+1;
                q.push(make_pair(ny,nx));
            }
        }

    }

}
void InputData(){
    cin >> T;
}
void Solve(){
    for(int i=0; i<T; i++){
        cin >> N;
        cin >> sy >> sx >> ey >> ex ;
        BFS(sy,sx);
        cout << Map[ey][ex] << endl;
        memset(Map, false, sizeof(Map));
        memset(visited, false, sizeof(visited));
    }
}
int main(){
   InputData();
   Solve();
   return 0;
}
/*[baekjoon]7562 나이트의 이동*/
반응형
반응형

문제

철수의 토마토 농장에서는 토마토를 보관하는 큰 창고를 가지고 있다. 토마토는 아래의 그림과 같이 격자모양 상자의 칸에 하나씩 넣은 다음, 상자들을 수직으로 쌓아 올려서 창고에 보관한다.

창고에 보관되는 토마토들 중에는 잘 익은 것도 있지만, 아직 익지 않은 토마토들도 있을 수 있다. 보관 후 하루가 지나면, 익은 토마토들의 인접한 곳에 있는 익지 않은 토마토들은 익은 토마토의 영향을 받아 익게 된다. 하나의 토마토에 인접한 곳은 위, 아래, 왼쪽, 오른쪽, 앞, 뒤 여섯 방향에 있는 토마토를 의미한다. 대각선 방향에 있는 토마토들에게는 영향을 주지 못하며, 토마토가 혼자 저절로 익는 경우는 없다고 가정한다. 철수는 창고에 보관된 토마토들이 며칠이 지나면 다 익게 되는지 그 최소 일수를 알고 싶어 한다.

토마토를 창고에 보관하는 격자모양의 상자들의 크기와 익은 토마토들과 익지 않은 토마토들의 정보가 주어졌을 때, 며칠이 지나면 토마토들이 모두 익는지, 그 최소 일수를 구하는 프로그램을 작성하라. 단, 상자의 일부 칸에는 토마토가 들어있지 않을 수도 있다.

입력

첫 줄에는 상자의 크기를 나타내는 두 정수 M,N과 쌓아올려지는 상자의 수를 나타내는 H가 주어진다. M은 상자의 가로 칸의 수, N은 상자의 세로 칸의 수를 나타낸다. 단, 2 ≤ M ≤ 100, 2 ≤ N ≤ 100, 1 ≤ H ≤ 100 이다. 둘째 줄부터는 가장 밑의 상자부터 가장 위의 상자까지에 저장된 토마토들의 정보가 주어진다. 즉, 둘째 줄부터 N개의 줄에는 하나의 상자에 담긴 토마토의 정보가 주어진다. 각 줄에는 상자 가로줄에 들어있는 토마토들의 상태가 M개의 정수로 주어진다. 정수 1은 익은 토마토, 정수 0 은 익지 않은 토마토, 정수 -1은 토마토가 들어있지 않은 칸을 나타낸다. 이러한 N개의 줄이 H번 반복하여 주어진다.

토마토가 하나 이상 있는 경우만 입력으로 주어진다.

출력

여러분은 토마토가 모두 익을 때까지 최소 며칠이 걸리는지를 계산해서 출력해야 한다. 만약, 저장될 때부터 모든 토마토가 익어있는 상태이면 0을 출력해야 하고, 토마토가 모두 익지는 못하는 상황이면 -1을 출력해야 한다.

 

예제 입력 1 
5 3 1
0 -1 0 0 0
-1 -1 0 1 1
0 0 0 1 1
예제 출력 1 
-1

예제 입력 2 
5 3 2
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 1 0 0
0 0 0 0 0
예제 출력 2 
4

예제 입력 3 
4 3 2
1 1 1 1
1 1 1 1
1 1 1 1
1 1 1 1
-1 -1 -1 -1
1 1 1 -1
예제 출력 3 
0

풀이 

1. 입력 : 1인 모든 좌표를 queue에 push

2. queue에서 하나씩 꺼내서 상하좌우,위,아래 6개 방향을 확인해서 1이 있는 지 확인한다.

3. 

/*baekjoon 7569 토마토 BFS*/
#include <iostream>
#include <queue>
using namespace std;
#define max ((int)1e2+5)

int M,N,H ;//가로, 세로,상자수 
int map[max][max][max];
bool mapCheck[max][max][max];
int path[max][max][max];
int cnt;
int dz[6] = {0,0,0,0,-1,1};
int dy[6] = {-1,1,0,0,0,0};
int dx[6] = {0,0,1,-1,0,0};
struct Q{
	int z,y,x;
};
Q cur;
queue<Q>q;

bool isInside(int z, int y,int x){
    return ((z>=0 && z<H) && (y>=0 && y<N) && (x>=0 && x<M));
}

void Solve(){
    int nx,ny,nz;
    while(!q.empty()) {
        cur=q.front();
        q.pop();

        for (int i = 0; i < 6; i++) {
            nz = cur.z + dz[i];
            ny = cur.y + dy[i];
            nx = cur.x + dx[i];

            if(isInside(nz,ny,nx) && map[nz][ny][nx]==0 && mapCheck[nz][ny][nx]==0 ){
                mapCheck[nz][ny][nx] = 1;
                q.push({nz,ny,nx});
                path[nz][ny][nx] = path[cur.z][cur.y][cur.x] + 1;
            }
        }
    }
}
void InputData(){
    cin >> M >> N >> H;
    for( int z=0; z < H; z++){
        for( int y=0; y < N; y++){
            for( int x=0; x < M; x++){
                cin >> map[z][y][x];
                if( map[z][y][x] == 1 ){
                    q.push({z,y,x}); 
                 }
             }
        }
    }
}
int main(){
    InputData();
    Solve();

    for( int z=0; z <H; z++){
        for( int y=0; y < N; y++){
            for( int x=0; x < M; x++){
                if( map[z][y][x] == 0 && path[z][y][x] == 0 ){
                    cout << -1 << endl;	
                    return 0;
                }
            }
        }
    }

    int ans = -1;
    for( int z=0; z < H; z++){
        for( int y=0; y < N; y++){
            for( int x=0; x < M; x++){
                if( path[z][y][x] > ans ){
                    ans = path[z][y][x];	
                }
            }
        }
    }
    cout << ans << endl;

    return 0;
}
/*baekjoon 7569 토마토 BFS*/
반응형
반응형

문제

방향 없는 그래프가 주어졌을 때, 연결 요소 (Connected Component)의 개수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 정점의 개수 N과 간선의 개수 M이 주어진다. (1 ≤ N ≤ 1,000, 0 ≤ M ≤ N×(N-1)/2) 둘째 줄부터 M개의 줄에 간선의 양 끝점 u와 v가 주어진다. (1 ≤ u, v ≤ N, u ≠ v) 같은 간선은 한 번만 주어진다.

출력

첫째 줄에 연결 요소의 개수를 출력한다.

 

예제 입력 1 
6 5
1 2
2 5
5 1
3 4
4 6
예제 출력 1 
2
예제 입력 2 
6 8
1 2
2 5
5 1
3 4
4 6
5 4
2 4
2 3
예제 출력 2 
1

 

/*[11724] baekjoon 연결 요소의 개수*/
#include <bits/stdc++.h>
using namespace std;
#define MAXN ((int) 1e3) 

int N,M,cnt=0;
int s[MAXN*MAXN], e[MAXN*MAXN];
int mat[MAXN+10][MAXN+10];
int visited[MAXN+10];

void InputData(){
	int u, v;
	cin >> N >> M;
	for (int i=0; i<M; i++){
		cin >> u >> v;
		mat[u][v] = 1;
		mat[v][u] = 1;
	}
}
void DFS(int x){
	visited[x] = 1;
	for(int i =1; i<=N; i++){
		if(mat[x][i] ==1 && visited[i] ==0){
			DFS(i);
		}
	}
}
void BFS(int x){
	int t;
	queue <int> q;
	q.push(x);
	visited[x] = 1;
	while( !q.empty()){
		t = q.front();
		q.pop();
		for(int i=1; i<=N; i++){
			if(mat[t][i] == 1 && visited[i] ==0){ 
				q.push(i);
				visited[i] =1;
			}
		}
	}
}
void Solve(){
	for(int i=1; i<=N; i++){
		if(visited[i] ==0){
			BFS(i);
			cnt++;
		}
	}
	cout << cnt << endl;
}
int main(){
	InputData();
	Solve();
	return 0;
}
/*[11724] baekjoon 연결 요소의 개수*/
반응형
반응형

문제

재난방재청에서는 많은 비가 내리는 장마철에 대비해서 다음과 같은 일을 계획하고 있다. 먼저 어떤 지역의 높이 정보를 파악한다. 그 다음에 그 지역에 많은 비가 내렸을 때 물에 잠기지 않는 안전한 영역이 최대로 몇 개가 만들어 지는 지를 조사하려고 한다. 이때, 문제를 간단하게 하기 위하여, 장마철에 내리는 비의 양에 따라 일정한 높이 이하의 모든 지점은 물에 잠긴다고 가정한다.

어떤 지역의 높이 정보는 행과 열의 크기가 각각 N인 2차원 배열 형태로 주어지며 배열의 각 원소는 해당 지점의 높이를 표시하는 자연수이다. 예를 들어, 다음은 N=5인 지역의 높이 정보이다.

 

이제 위와 같은 지역에 많은 비가 내려서 높이가 4 이하인 모든 지점이 물에 잠겼다고 하자. 이 경우에 물에 잠기는 지점을 회색으로 표시하면 다음과 같다. 

 

물에 잠기지 않는 안전한 영역이라 함은 물에 잠기지 않는 지점들이 위, 아래, 오른쪽 혹은 왼쪽으로 인접해 있으며 그 크기가 최대인 영역을 말한다. 위의 경우에서 물에 잠기지 않는 안전한 영역은 5개가 된다(꼭짓점으로만 붙어 있는 두 지점은 인접하지 않는다고 취급한다). 

또한 위와 같은 지역에서 높이가 6이하인 지점을 모두 잠기게 만드는 많은 비가 내리면 물에 잠기지 않는 안전한 영역은 아래 그림에서와 같이 네 개가 됨을 확인할 수 있다. 

이와 같이 장마철에 내리는 비의 양에 따라서 물에 잠기지 않는 안전한 영역의 개수는 다르게 된다. 위의 예와 같은 지역에서 내리는 비의 양에 따른 모든 경우를 다 조사해 보면 물에 잠기지 않는 안전한 영역의 개수 중에서 최대인 경우는 5임을 알 수 있다. 

어떤 지역의 높이 정보가 주어졌을 때, 장마철에 물에 잠기지 않는 안전한 영역의 최대 개수를 계산하는 프로그램을 작성하시오.

 

입력

첫째 줄에는 어떤 지역을 나타내는 2차원 배열의 행과 열의 개수를 나타내는 수 N이 입력된다. N은 2 이상 100 이하의 정수이다. 둘째 줄부터 N개의 각 줄에는 2차원 배열의 첫 번째 행부터 N번째 행까지 순서대로 한 행씩 높이 정보가 입력된다. 각 줄에는 각 행의 첫 번째 열부터 N번째 열까지 N개의 높이 정보를 나타내는 자연수가 빈 칸을 사이에 두고 입력된다. 높이는 1이상 100 이하의 정수이다.

 

출력

첫째 줄에 장마철에 물에 잠기지 않는 안전한 영역의 최대 개수를 출력한다.

 

예제 입력 1 
5
6 8 2 6 2
3 2 3 4 6
6 7 3 3 2
7 2 5 3 6
8 9 5 2 7

예제 출력 1 
5

예제 입력 2 
7
9 9 9 9 9 9 9
9 2 1 2 1 2 9
9 1 8 7 8 1 9
9 2 7 9 7 2 9
9 1 8 7 8 1 9
9 2 1 2 1 2 9
9 9 9 9 9 9 9

예제 출력 2 
6

예제 입력 3
5
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1

예제 출력 3 
1

예제 입력 4
5
3 3 3 3 3
3 3 3 3 3
3 3 3 3 3
3 3 3 3 3
3 3 3 3 3

예제 출력 4
1

 

문제 풀이

 

 

/*baekjoon 2468 안전 영역*/
#include <bits/stdc++.h>
using namespace std;
#define MAXN ((int) 1e2) 

int N,cnt=0,maxval=0,minval=MAXN;
int Map[MAXN+10][MAXN+10];
int reMap[MAXN+10][MAXN+10];
int visited[MAXN+10][MAXN+10];

int dy[]={-1, 1, 0, 0};
int dx[]={0, 0, 1, -1};
int nx,ny;
bool inRange(int y, int x){
    return( (y>=1) && (y<=N) && (x >=1) && (x<=N));}

void DFS(int y, int x,int n){
    visited[y][x] = 1;

    for(int i=0; i<4; i++){
        ny=y+dy[i];
        nx=x+dx[i];
        if(Map[ny][nx] > n && visited[ny][nx] == 0){
            DFS(ny, nx, n);
        }
    }
}
void BFS(int y, int x){
    int ny, nx; 
    queue <pair<int, int>> q;
    q.push(pair<int,int>(y,x));

    while(!q.empty()){
        y = q.front().first;
        x = q.front().second;

        q.pop();
        for(int i=0; i<4; i++){
            ny = y + dy[i];
            nx = x + dx[i];
            if(inRange(ny, nx) && reMap[ny][nx]){
                q.push(pair<int,int>(ny,nx));
                reMap[ny][nx] =0; 
            }
        }
    }   
}
void remap(int num){
    for(int i=1; i<=N; i++){
        for(int j=1; j<=N; j++){
        if(Map[i][j] <= num){
            reMap[i][j] = 0;
        }else{
            reMap[i][j] = 1;
        }
        }
    }
}
void Solve(){
    int maxcnt=0;
    for(int k=0; k<100; k++){
    memset(visited, false, sizeof(visited));
    cnt=0;
    for(int i=1; i<=N; i++) {
        for(int j=1; j<=N; j++) {
            if(Map[i][j] > k && visited[i][j]==0 ){
                cnt++;
                DFS(i,j,k);
                //BFS(i,j);
            }
        }
    }
        if( cnt > maxcnt) maxcnt = cnt;
    }
    cout << maxcnt << endl;
}
void InputData(){
    cin >> N;
    for( int i=1; i<=N; i++){
        for( int j=1; j<=N; j++){
            cin >> Map[i][j];
            if(minval > Map[i][j] ) minval= Map[i][j];
            if(maxval < Map[i][j] ) maxval= Map[i][j];
        }
    }
}
int main(){
    InputData();
    Solve();
    return 0;
}
/*baekjoon 2468 안전 영역*/

 

반응형
반응형

문제

정사각형으로 이루어져 있는 섬과 바다 지도가 주어진다. 섬의 개수를 세는 프로그램을 작성하시오.

한 정사각형과 가로, 세로 또는 대각선으로 연결되어 있는 사각형은 걸어갈 수 있는 사각형이다. 

두 정사각형이 같은 섬에 있으려면, 한 정사각형에서 다른 정사각형으로 걸어서 갈 수 있는 경로가 있어야 한다. 지도는 바다로 둘러싸여 있으며, 지도 밖으로 나갈 수 없다.

입력

입력은 여러 개의 테스트 케이스로 이루어져 있다. 각 테스트 케이스의 첫째 줄에는 지도의 너비 w와 높이 h가 주어진다. w와 h는 50보다 작거나 같은 양의 정수이다.

둘째 줄부터 h개 줄에는 지도가 주어진다. 1은 땅, 0은 바다이다.

입력의 마지막 줄에는 0이 두 개 주어진다.

출력

각 테스트 케이스에 대해서, 섬의 개수를 출력한다.

 

예제 입력 1 
1 1
0
2 2
0 1
1 0
3 2
1 1 1
1 1 1
5 4
1 0 1 0 0
1 0 0 0 0
1 0 1 0 1
1 0 0 1 0
5 4
1 1 1 0 1
1 0 1 0 1
1 0 1 0 1
1 0 1 1 1
5 5
1 0 1 0 1
0 0 0 0 0
1 0 1 0 1
0 0 0 0 0
1 0 1 0 1
0 0

예제 출력 1 
0
1
1
3
1
9

 

 

/*baekjoon 4963 섬의개수*/
#include <bits/stdc++.h>
using namespace std;
#define MAXN 50
int w,h,cnt;
int Map[MAXN+10][MAXN+10];
int dy[] = {-1,1,0,0,-1,-1,1,1};
int dx[] = {0,0,-1,1,-1,1,-1,1};

void DFS(int y, int x){
    if(Map[y][x] != 1) return;
        Map[y][x] = 0;
    for(int i=0; i<8; i++){
        DFS(y+dy[i], x+dx[i]);
    }

}
void Solve(){
    cnt=0;
    for(int i=1; i<=h; i++){
        for(int j=1; j<=w; j++){
            if( Map[i][j]==1){
                DFS(i,j);
                cnt++;
            }
        }
     }
    cout << cnt << endl;
}
void InputData(){
    while(1){
        cin >> w >> h;
        if(w==0 && h==0) break;
        for(int i=1; i<=h; i++){
            for(int j=1; j<=w; j++){
                cin >> Map[i][j];
            }
         }
     Solve();
    }
}
int main(){
    InputData();

    return 0;
}
/*baekjoon 4963 섬의개수*/
반응형
반응형

 

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

 

10872번: 팩토리얼

0보다 크거나 같은 정수 N이 주어진다. 이때, N!을 출력하는 프로그램을 작성하시오.

www.acmicpc.net

문제

0보다 크거나 같은 정수 N이 주어진다. 이때, N!을 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 정수 N(0 ≤ N ≤ 12)가 주어진다.

출력

첫째 줄에 N!을 출력한다.

 

예제 입력 1 
10

예제 출력 1 
3628800

예제 입력 2 
0

예제 출력 2 
1

풀이 

N!은 N=3일 경우 3*2*1로 표시된다. 

 

예를 들어서 N=3일 경우 어떻게 진행되는지 확인 해 보자.

factorial 함수에 n=3이 전달 되면 아래와 같이 값들이 입력이 될 것이다. 

3*factorial(3-1)

n-1이므로 n=2가 전달되어서 아래와 같이 되고 

3*2*factorial(2-1)

마지막으로 n=1이 전달되면 더이상 factorial함수가 재귀로 호출되지 않고 return 1이 호출되어서 아래 값이 계산되어서 return됨.

3*2*1

최종 출력값은 6이다. 

 

[소스 코드]

/*baekjoon 10872 팩토리얼*/
#include <bits/stdc++.h>
using namespace std;
int N;
int factorial(int n)
{
    if(n > 1)
        return n*factorial(n-1);
    else
        return 1;
}
void InputData(){
    cin >> N;
}
int main()
{
    InputData();
    cout <<  factorial(N) ;
    return 0;
}
/*baekjoon 10872 팩토리얼*/

 

 

반응형
반응형

문제

숫자 카드는 정수 하나가 적혀져 있는 카드이다. 상근이는 숫자 카드 N개를 가지고 있다. 정수 M개가 주어졌을 때, 이 수가 적혀있는 숫자 카드를 상근이가 몇 개 가지고 있는지 구하는 프로그램을 작성하시오.

입력

첫째 줄에 상근이가 가지고 있는 숫자 카드의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 둘째 줄에는 숫자 카드에 적혀있는 정수가 주어진다. 숫자 카드에 적혀있는 수는 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.

셋째 줄에는 M(1 ≤ M ≤ 500,000)이 주어진다. 넷째 줄에는 상근이가 몇 개 가지고 있는 숫자 카드인지 구해야 할 M개의 정수가 주어지며, 이 수는 공백으로 구분되어져 있다. 이 수도 -10,000,000보다 크거나 같고, 10,000,000보다 작거나 같다.

출력

첫째 줄에 입력으로 주어진 M개의 수에 대해서, 각 수가 적힌 숫자 카드를 상근이가 몇 개 가지고 있는지를 공백으로 구분해 출력한다.

 

풀이

-오름차순 정렬

-이진 탐색

-Lowerbound

-Upperbound 

/*10816 숫자카드2*/
#include <iostream>
#include <algorithm>
using namespace std;
#define MAXN ((int)5e5+10) 
int N; 
int A[MAXN]; 
int M; 
int B[MAXN]; 
int Temp[MAXN];

void InputData() { 
    cin >> N;
    for(int i=0; i<N; i++) { 
        cin >> A[i]; 
    } 
    cin >> M;
    for(int i=0; i<M; i++) { 
        cin >> B[i]; 
    } 
} 
int BinarySearchLower(int s, int e, int d){
   int m, sol = -1;
    while( s <= e) {
        m = (s+e)/2;
        if( A[m] == d){
            sol = m;
            e = m -1;
        }
        else if (A[m] > d) e = m -1;
        else s = m+1;
    }
    return sol;
}

int BinarySearchUpper(int s, int e, int d){
    int m, sol = -1;
    while( s <= e) {
        m = (s+e) /2;
        if( A[m] == d){
            sol = m;
            s = m +1;
        }
        else if (A[m] > d) e = m -1;
        else s = m + 1;
    }
    return sol;
}

void Solve(){
    sort(A,A+N);
    for(int i=0; i<M; i++) { 
        int lower = BinarySearchLower(0, N-1, B[i] );
        if( lower != -1 ){
            int upper = BinarySearchUpper(0, N-1, B[i] );
            cout <<  upper - lower + 1 << ' '; 
        }else{
            cout <<  0 << ' '; 
        }
    } 
}
int main() { 
    InputData(); 
    Solve();
    return 0; 
} 
/*10816 숫자카드2*/
반응형
반응형

문제

N개의 정수 A[1], A[2], …, A[N]이 주어져 있을 때, 이 안에 X라는 정수가 존재하는지 알아내는 프로그램을 작성하시오.

입력

첫째 줄에 자연수 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 줄에는 N개의 정수 A[1], A[2], …, A[N]이 주어진다. 다음 줄에는 M(1 ≤ M ≤ 100,000)이 주어진다. 다음 줄에는 M개의 수들이 주어지는데, 이 수들이 A안에 존재하는지 알아내면 된다. 모든 정수의 범위는 -231 보다 크거나 같고 231보다 작다.

출력

M개의 줄에 답을 출력한다. 존재하면 1을, 존재하지 않으면 0을 출력한다.

 

예제 입력 1 
5
4 1 5 2 3
5
1 3 7 9 5

예제 출력 1 
1
1
0
0
1

풀이

-오름차순 정렬

1 2 3 4 5

-숫자 1개씩 이진 탐색으로 검색 

중간 값을 구하기 위한 s,e값은 A[] array의 순서이다. 

if s = 0, e = N-1, d=1 부터 시작하면 

m = (s + e)/2; 

m = (0 + 4)/2=2;

A[2] =3이므로 

if(A[m] >d) 이므로 e=m-1로 값을 변경후 다시 찾는다.

s=0, e=1로 값 설정

 

m=(0+1)/2=0;

if(A[0]==d)에 부합하므로 값을 찾아서 return 1을 전달해 준다. 

/*[1920]수찾기*/
#include <bits/stdc++.h>
using namespace std;
#define MAXN ((int)1e6)
int N;
int A[MAXN +10];
int M;
int X[MAXN+10];

void InputData(){
    cin >> N;
    for(int i =0; i<N; i++){
        cin >> A[i];
    }
    cin >> M;
    for(int i=0; i<M; i++){
        cin >> X[i];
    }
}
bool BinarySearch(int s, int e, int d){
    int m;
    while(s<=e){
        m=(s+e)/2;
        if(A[m]==d) return 1;
        else if(A[m]>d) e=m-1;
        else s = m+1;
    }
    return 0;
}
void Solve(){
    sort(A,A+N);
    for(int i=0; i<M; i++){
        printf("%d\n", BinarySearch(0, N-1, X[i]));
    }
}
int main(){
    InputData();
    Solve();
    return 0;
}
/*[1920]수찾기*/

 

libray를 이용해서 풀이하면 아래와 같이 간단히 할 수 있다.

 

http://www.cplusplus.com/reference/algorithm/binary_search/

#include <iostream>
#include <algorithm>
using namespace std;
#define MAXN ((int)1e6+10)
int N,M;
int A[MAXN],X[MAXN];
void Solve(){
    sort(A,A+N);
    for(int i=0; i<M; i++)
        cout<<binary_search(A, A+N, X[i])<<"\n";
}
void InputData(){
    cin >> N;
    for(int i =0; i<N; i++)
        cin >> A[i];
    cin >> M;
    for(int i=0; i<M; i++)
        cin >> X[i];
}
int main(){
    InputData();
    Solve();
    return 0;
}
반응형
반응형

문제

수를 처리하는 것은 통계학에서 상당히 중요한 일이다. 통계학에서 N개의 수를 대표하는 기본 통계값에는 다음과 같은 것들이 있다. 단, N은 홀수라고 가정하자.

  1. 산술평균 : N개의 수들의 합을 N으로 나눈 값
  2. 중앙값 : N개의 수들을 증가하는 순서로 나열했을 경우 그 중앙에 위치하는 값
  3. 최빈값 : N개의 수들 중 가장 많이 나타나는 값
  4. 범위 : N개의 수들 중 최댓값과 최솟값의 차이

N개의 수가 주어졌을 때, 네 가지 기본 통계값을 구하는 프로그램을 작성하시오.

 

입력

첫째 줄에 수의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 단, N은 홀수이다. 그 다음 N개의 줄에는 정수들이 주어진다. 입력되는 정수의 절댓값은 4,000을 넘지 않는다.

출력

첫째 줄에는 산술평균을 출력한다. 소수점 이하 첫째 자리에서 반올림한 값을 출력한다.

둘째 줄에는 중앙값을 출력한다.

셋째 줄에는 최빈값을 출력한다. 여러 개 있을 때에는 최빈값 중 두 번째로 작은 값을 출력한다.

넷째 줄에는 범위를 출력한다.

 

풀이

- data 입력 받기 : N 숫자 개수 

- 먼저 입력된 값을 정렬 한다.그래야 중앙값, 범위를 간단히 계산 해 낼 수 있다. 

- 산술평균, 중앙값,범위는 정렬후 간단히 계산이 가능한데, 중앙값은 좀 더 작업이 필요하다. 

-

/*baekjoon 2108 통계학*/
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;

#define MAXN  ((int)5e5)

int	N;
int Data[MAXN+10]; 
struct MaxData{
	int cnt,val;
};
int A[MAXN+10];
MaxData C[8000+10];
void OutputData(){
	cout << "Frequency : " << endl;
    for(int i = 0; i < 8010; i++){
		if( C[i].cnt >0){
    		cout << C[i].cnt << " " << C[i].val << endl;
		}
    }
}
void InputData(){
    cin >> N;
    for(int i = 0; i < N; i++){
    	cin >> Data[i];
    }
}
bool comp(struct MaxData a, struct MaxData b)
{ 
	if( a.cnt == b.cnt ){
		return a.val < b.val;
	}else{
		return a.cnt > b.cnt;
	}
}
int SortSecond(){
	int maxvalue=0, j=0;
	for(int i=0; i< 8010; i++){
		if(A[i] >0 ){
			if(i<=4000){
				C[j].val=i;
			}
			else{
				C[j].val=4000-i;
			}
			C[j].cnt=A[i];
			j++;
		}
	}
	sort(C, C+8010,comp);
	if(C[0].cnt == C[1].cnt){
		maxvalue= C[1].val;
	}else{
		maxvalue=C[0].val;
	}

	return maxvalue ;
}
void Solve()
{
	double sum=0;
	sort(Data, Data+N);
    for( int i=0; i<N; i++){
		sum += Data[i];
		if( Data[i] >=0){
			A[Data[i]]++;
		} else{
			A[4000-Data[i]]++;
		}
    }
	cout << round(sum/N) << endl;
	cout << Data[N/2] << endl;
	cout << SortSecond() << endl;
	cout << abs(Data[0] - Data[N-1]) << endl;
}
int main()
{
	InputData();
	Solve();
	return 0;
}
/*baekjoon 2108 통계학*/
반응형
반응형

문제

2차원 평면 위의 점 N개가 주어진다. 좌표를 y좌표가 증가하는 순으로, y좌표가 같으면 x좌표가 증가하는 순서로 정렬한 다음 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 점의 개수 N (1 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 N개의 줄에는 i번점의 위치 xi와 yi가 주어진다. (-100,000 ≤ xi, yi ≤ 100,000) 좌표는 항상 정수이고, 위치가 같은 두 점은 없다.

출력

첫째 줄부터 N개의 줄에 점을 정렬한 결과를 출력한다.

 

풀이

 

 

/*baekjoon 11651 좌표 정렬하기*/
#include <iostream>
#include <algorithm>
using namespace std;

#define MAX 100001

struct ST{
	int x, y;
};

int	N;
struct ST XYdata[MAX];

void InputData(){
	//input data size
    scanf("%d", &N);
	//input data
    for( int i=0; i<N; i++ ){
    scanf("%d %d", &XYdata[i].x, &XYdata[i].y );
    }
}

void OutputData(){
	for( int i=0; i<N; i++){
		printf("%d %d", XYdata[i].x, XYdata[i].y);
	printf("\n");
	}
}

bool comp(struct ST i, struct ST j){ 
	if (i.y < j.y) 
		return true;
	else if (i.y == j.y)
		return (i.x < j.x); 
	else 
		return false;
}

int main()
{
	InputData();
	sort( XYdata, XYdata+N, comp );
	OutputData();

	return 0;
}
/*baekjoon 11651 좌표 정렬하기*/
반응형
반응형

문제

2차원 평면 위의 점 N개가 주어진다. 좌표를 y좌표가 증가하는 순으로, y좌표가 같으면 x좌표가 증가하는 순서로 정렬한 다음 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 점의 개수 N (1 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 N개의 줄에는 i번점의 위치 xi와 yi가 주어진다. (-100,000 ≤ xi, yi ≤ 100,000) 좌표는 항상 정수이고, 위치가 같은 두 점은 없다.

출력

첫째 줄부터 N개의 줄에 점을 정렬한 결과를 출력한다.

 

풀이

 

 

 

반응형
반응형

문제

2차원 평면 위의 점 N개가 주어진다. 좌표를 x좌표가 증가하는 순으로, x좌표가 같으면 y좌표가 증가하는 순서로 정렬한 다음 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 점의 개수 N (1 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 N개의 줄에는 i번점의 위치 xi와 yi가 주어진다. (-100,000 ≤ xi, yi ≤ 100,000) 좌표는 항상 정수이고, 위치가 같은 두 점은 없다.

출력

첫째 줄부터 N개의 줄에 점을 정렬한 결과를 출력한다.

 

 

풀이

-sort함수를 이용한 정렬 문제

-sort의 비교함수의 조건만 추가 하면 풀이됨.

  x 좌표 증가할경우와 y조표가 같을 경우에 대한 조건만 추가하면 됨.

 

/*baekjoon 11650 좌표 정렬하기*/
#include <iostream>
#include <algorithm>
using namespace std;

#define MAXN 100000
int	N;
struct ST{
	int x, y;
};
struct ST XYdata[MAXN+10];

void InputData(){
	//input data size
    scanf("%d", &N);
	//input data
    for( int i=0; i<N; i++ ){
    scanf("%d %d", &XYdata[i].x, &XYdata[i].y );
    }
}
void OutputData(){
	for( int i=0; i<N; i++){
		printf("%d %d", XYdata[i].x, XYdata[i].y);
	printf("\n");
	}
}
bool comp(struct ST i, struct ST j){ 
	if (i.x < j.x) 
		return true;
	else if (i.x == j.x)
		return (i.y < j.y); 
	else 
		return false;
}
int main()
{
	InputData();
	sort( XYdata, XYdata+N, comp );
	OutputData();
	return 0;
}
/*baekjoon 11650 좌표 정렬하기*/
반응형
반응형

문제

배열을 정렬하는 것은 쉽다. 수가 주어지면, 그 수의 각 자리수를 내림차순으로 정렬해보자.

입력

첫째 줄에 정렬하고자하는 수 N이 주어진다. N은 1,000,000,000보다 작거나 같은 자연수이다.

출력

첫째 줄에 자리수를 내림차순으로 정렬한 수를 출력한다.

 

 

풀이 

- sort를 이용한 단순 정렬 문제 

 

  1 /*baekjoon 1427 소트인사이드*/
  2 #include <iostream>
  3 #include <algorithm>
  4 #include <string>
  5 using namespace std;
  6 
  7 string N;
  8 void InputData(){
  9     cin >> N;
 10 }
 11 bool comp(string a, string b){ return a < b;}
 12 void Solve(){
 13     sort(N.rbegin(),N.rend());
 14     cout << N << endl;
 15 }
 16 int main(){
 17     InputData();
 18     Solve();
 19     return 0;
 20 }
 21 /*baekjoon 1427 소트인사이드*/   
반응형
반응형

문제

알파벳 소문자로 이루어진 N개의 단어가 들어오면 아래와 같은 조건에 따라 정렬하는 프로그램을 작성하시오.

  1. 길이가 짧은 것부터
  2. 길이가 같으면 사전 순으로

 

입력

첫째 줄에 단어의 개수 N이 주어진다. (1 ≤ N ≤ 20,000) 둘째 줄부터 N개의 줄에 걸쳐 알파벳 소문자로 이루어진 단어가 한 줄에 하나씩 주어진다. 주어지는 문자열의 길이는 50을 넘지 않는다.

출력

조건에 따라 정렬하여 단어들을 출력한다. 단, 같은 단어가 여러 번 입력된 경우에는 한 번씩만 출력한다.

 

 

풀이

 

-sort를 이용한 단순 정렬 문제

-strcmp대신 c++에서 사용하는 str[i].compare(str[i+1])를 사용함 

 

/*baekjoon 1181 단어 정렬*/
#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;

#define MAX 20000
int	N;
string Data[MAX+10];

void InputData(){
	cin >> N;
	for(int i = 0; i < N; i++){
		cin >> Data[i];
	}
}
void OutputData(){
	for( int i=0; i<N; i++){
		cout << Data[i]<< endl;
	}
}
bool comp(string i, string j){ 
    if (i.size() == j.size()){
        return (i < j);
    }
    else{
        return i.size() < j.size();
    }
}
void Solve(){
	cout << Data[0] << endl;	
	for(int i=0; i<N-1; i++){
		if(Data[i].compare(Data[i+1]) ){
			cout << Data[i+1] << endl;	
		}
	}
}
int main()
{
	InputData();
	sort( Data, Data+N, comp);
	Solve();
	return 0;
}
/*baekjoon 1181 단어 정렬*/
반응형
반응형

문제

시골에 있는 태양이의 삼촌 댁에는 커다란 참외밭이 있다. 문득 태양이는 이 밭에서 자라는 참외가 도대체 몇 개나 되는지 궁금해졌다. 어떻게 알아낼 수 있는지 골똘히 생각하다가 드디어 좋은 아이디어가 떠올랐다. 유레카! 1m^2의 넓이에 자라는 참외 개수를 헤아린 다음, 참외밭의 넓이를 구하면 비례식을 이용하여 참외의 총개수를 구할 수 있다.

1m^2의 넓이에 자라는 참외의 개수는 헤아렸고, 이제 참외밭의 넓이만 구하면 된다. 참외밭은 ㄱ-자 모양이거나 ㄱ-자를 90도, 180도, 270도 회전한 모양(┏, ┗, ┛ 모양)의 육각형이다. 다행히도 밭의 경계(육각형의 변)는 모두 동서 방향이거나 남북 방향이었다. 밭의 한 모퉁이에서 출발하여 밭의 둘레를 돌면서 밭경계 길이를 모두 측정하였다.

예를 들어 참외밭이 위 그림과 같은 모양이라고 하자. 그림에서 오른쪽은 동쪽, 왼쪽은 서쪽, 아래쪽은 남쪽, 위쪽은 북쪽이다. 이 그림의 왼쪽위 꼭짓점에서 출발하여, 반시계방향으로 남쪽으로 30m, 동쪽으로 60m, 남쪽으로 20m, 동쪽으로 100m, 북쪽으로 50m, 서쪽으로 160m 이동하면 다시 출발점으로 되돌아가게 된다.

위 그림의 참외밭  면적은 6800m^2이다. 만약 1m^2의 넓이에 자라는 참외의 개수가 7이라면, 이 밭에서 자라는 참외의 개수는 47600으로 계산된다.

1m^2의 넓이에 자라는 참외의 개수와, 참외밭을 이루는 육각형의 임의의 한 꼭짓점에서 출발하여 반시계방향으로 둘레를 돌면서 지나는 변의 방향과 길이가 순서대로 주어진다. 이 참외밭에서 자라는 참외의 수를 구하는 프로그램을 작성하시오.

입력

첫 번째 줄에 1m^2의 넓이에 자라는 참외의 개수를 나타내는 양의 정수 K (1≤K≤20)가 주어진다. 참외밭을 나타내는 육각형의 임의의 한 꼭짓점에서 출발하여 반시계방향으로 둘레를 돌면서 지나는 변의 방향과 길이 (1 이상 500 이하의 정수) 가 둘째 줄부터 일곱 번째 줄까지 한 줄에 하나씩 순서대로 주어진다. 변의 방향에서 동쪽은 1, 서쪽은 2, 남쪽은 3, 북쪽은 4로 나타낸다.

출력

첫째 줄에 입력으로 주어진 밭에서 자라는 참외의 수를 출력한다.

풀이 

-면적을 구하는 방법 생각 (백준 2166과 동일한 방식으로 풀면 되나 입력이 달라서 좌표로 변환하는 부분이 추가되어야 합니다.)

-SW에서는 아래 신발끈 공식을 이용해서 면적을 구해야 함.

https://ko.wikipedia.org/wiki/%EC%8B%A0%EB%B0%9C%EB%81%88_%EA%B3%B5%EC%8B%9D

 

신발끈 공식 - 위키백과, 우리 모두의 백과사전

위키백과, 우리 모두의 백과사전. 신발끈 공식(―公式)은 좌표평면 상에서 꼭짓점의 좌표를 알 때 다각형의 면적을 구할 수 있는 방법이다. 다각형의 각 꼭짓점의 좌푯값을 교차하여 곱하는 모

ko.wikipedia.org

/*baekjoon 2477 참외밭*/
#include <iostream>
#include <algorithm>
using namespace std;

#define MAX 10010

struct Coordinate{
	int d;
	int length;
};

struct ST{
	int x;
	int y;
};

int	N;
struct Coordinate C[MAX];
struct ST CD[MAX];

void InputData(){
	//input data size
	cin >> N;
	//input data
	for(int i = 0; i < 6; i++){
		cin >> C[i].d >> C[i].length;
	}
}

void OutputData(){
	for( int i=0; i<N; i++){
	printf("\n");
	}
}

void ChangeCoord(){
	CD[0].x = 0;
	CD[0].y = 0;

	for(int i=0; i<6; i++){

		if( C[i].d == 1){
			CD[i+1].x = CD[i].x - C[i].length;
			CD[i+1].y += CD[i].y;
		}else if( C[i].d ==2 ){
			CD[i+1].x = CD[i].x + C[i].length;
			CD[i+1].y += CD[i].y;
		}else if( C[i].d == 3){
			CD[i+1].x += CD[i].x;
			CD[i+1].y = CD[i].y - C[i].length;
		}else if( C[i].d == 4){
			CD[i+1].x += CD[i].x;
			CD[i+1].y = CD[i].y + C[i].length;
		}

	}

}

int Solve(){
	int Sum=0;
	ChangeCoord();	
	for(int i=0; i<6; i++){
		int idx;
		idx = (i+1) % 6;
		Sum += (CD[i].x * CD[idx].y - CD[idx].x * CD[i].y );
	}
	return abs(Sum)/2.0;
}

int main()
{
	int ans=0;
	cout.precision(1);
	cout << fixed;
	InputData();
	ans = Solve();	
	cout << ans*N << endl;
	return 0;
}
/*baekjoon 2477 참외밭*/

 

반응형

'Algorithm > 구현-기하학' 카테고리의 다른 글

[c++][알고리즘]별찍기1~6  (0) 2021.10.11
[c++]baekjoon 2166 다각형의 면적  (0) 2021.06.05
반응형

문제

2차원 평면상에 N(3 ≤ N ≤ 10,000)개의 점으로 이루어진 다각형이 있다. 이 다각형의 면적을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N이 주어진다. 다음 N개의 줄에는 다각형을 이루는 순서대로 N개의 점의 x, y좌표가 주어진다. 좌표값은 절댓값이 100,000을 넘지 않는 정수이다.

출력

첫째 줄에 면적을 출력한다. 면적을 출력할 때에는 소수점 아래 둘째 자리에서 반올림하여 첫째 자리까지 출력한다.

풀이 

-면적을 구하는 방법 생각 

-SW에서는 아래 신발끈 공식을 이용해서 면적을 구해야 함.

https://ko.wikipedia.org/wiki/%EC%8B%A0%EB%B0%9C%EB%81%88_%EA%B3%B5%EC%8B%9D

 

신발끈 공식 - 위키백과, 우리 모두의 백과사전

위키백과, 우리 모두의 백과사전. 신발끈 공식(―公式)은 좌표평면 상에서 꼭짓점의 좌표를 알 때 다각형의 면적을 구할 수 있는 방법이다. 다각형의 각 꼭짓점의 좌푯값을 교차하여 곱하는 모

ko.wikipedia.org

/*baekjoon 2166 다각형 면적 */
#include <iostream>
#include <algorithm>
using namespace std;

#define MAX 10010

struct ST{
	double x;
	double y;
};

int	N;
struct ST CD[MAX];

void InputData(){
	//input data size
	cin >> N;
	//input data
	for(int i = 0; i < N; i++){
		cin >> CD[i].x >> CD[i].y;
	}
}

void OutputData(){
	for( int i=0; i<N; i++){
	printf("\n");
	}
}

double Solve(){
	double Sum=0;
	
	for(int i=0; i<N; i++){
		int idx;
		idx = (i+1) % N;
		Sum += (CD[i].x * CD[idx].y - CD[idx].x * CD[i].y );
	}
	return abs(Sum)/2.0;
}

int main()
{
	double ans=0;
	cout.precision(1);
	cout << fixed;
	InputData();
	ans = Solve();	
	cout << ans << endl;
	return 0;
}
/*baekjoon 2166 다각형 면적 */

 

반응형

'Algorithm > 구현-기하학' 카테고리의 다른 글

[c++][알고리즘]별찍기1~6  (0) 2021.10.11
[c++]baekjoon 2477 참외밭  (0) 2021.06.05
반응형

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

 

10989번: 수 정렬하기 3

첫째 줄에 수의 개수 N(1 ≤ N ≤ 10,000,000)이 주어진다. 둘째 줄부터 N개의 줄에는 숫자가 주어진다. 이 수는 10,000보다 작거나 같은 자연수이다.

www.acmicpc.net

문제

N개의 수가 주어졌을 때, 이를 오름차순으로 정렬하는 프로그램을 작성하시오.

입력

첫째 줄에 수의 개수 N(1 ≤ N ≤ 10,000,000)이 주어진다. 둘째 줄부터 N개의 줄에는 숫자가 주어진다. 이 수는 10,000보다 작거나 같은 자연수이다.

출력

첫째 줄부터 N개의 줄에 오름차순으로 정렬한 결과를 한 줄에 하나씩 출력한다.

 

 

/*baekjoon 10989  수 정렬하기 3*/
#include <iostream>
#include <algorithm>
using namespace std;

#define MAX 10001

int	N;
int NumData[MAX] = {0}; 

void InputData(){
	int tmp=0;
	//input data size
	cin >> N;
	//input data
	for(int i = 0; i < N; i++){
        scanf("%d", &tmp);
		NumData[tmp]++;
	}
}

void OutputData(){
	for( int i=0; i<MAX; i++){
		if(NumData[i]){
			for(int count=0; count<NumData[i]; count++)
				printf("%d\n", i);
		}
	}
}

int main()
{
	InputData();
	OutputData();

	return 0;
}
/*baekjoon 10989  수 정렬하기 3*/
반응형
반응형

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

 

10814번: 나이순 정렬

온라인 저지에 가입한 사람들의 나이와 이름이 가입한 순서대로 주어진다. 이때, 회원들을 나이가 증가하는 순으로, 나이가 같으면 먼저 가입한 사람이 앞에 오는 순서로 정렬하는 프로그램을

www.acmicpc.net

문제

온라인 저지에 가입한 사람들의 나이와 이름이 가입한 순서대로 주어진다. 이때, 회원들을 나이가 증가하는 순으로, 나이가 같으면 먼저 가입한 사람이 앞에 오는 순서로 정렬하는 프로그램을 작성하시오.

입력

첫째 줄에 온라인 저지 회원의 수 N이 주어진다. (1 ≤ N ≤ 100,000)

둘째 줄부터 N개의 줄에는 각 회원의 나이와 이름이 공백으로 구분되어 주어진다. 나이는 1보다 크거나 같으며, 200보다 작거나 같은 정수이고, 이름은 알파벳 대소문자로 이루어져 있고, 길이가 100보다 작거나 같은 문자열이다. 입력은 가입한 순서로 주어진다.

출력

첫째 줄부터 총 N개의 줄에 걸쳐 온라인 저지 회원을 나이 순, 나이가 같으면 가입한 순으로 한 줄에 한 명씩 나이와 이름을 공백으로 구분해 출력한다.

 

 

/*baekjoon 10814 나이순 정렬*/
#include <iostream>
#include <algorithm>
using namespace std;

#define MAX 100001

struct ST{
	int age;
	char name[110];
};

int	N;
struct ST PersonData[MAX];

void InputData(){
	//input data size
	cin >> N;
	//input data
	for(int i = 0; i < N; i++){
		cin >> PersonData[i].age >> PersonData[i].name;
	}
}

void OutputData(){
	for( int i=0; i<N; i++){
		printf("%d %s", PersonData[i].age, PersonData[i].name);
	printf("\n");
	}
}

bool Comp_age(struct ST i, struct ST j){ return (i.age < j.age);}
bool Comp_name(struct ST i, struct ST j){ return (i.name < j.name);}

int main()
{
	InputData();
	stable_sort( PersonData, PersonData+N, Comp_age);
	OutputData();

	return 0;
}
/*baekjoon 10814 나이순 정렬*/
반응형
반응형

www.acmicpc.net/problem/2839

 

2839번: 설탕 배달

상근이는 요즘 설탕공장에서 설탕을 배달하고 있다. 상근이는 지금 사탕가게에 설탕을 정확하게 N킬로그램을 배달해야 한다. 설탕공장에서 만드는 설탕은 봉지에 담겨져 있다. 봉지는 3킬로그

www.acmicpc.net

 

문제

상근이는 요즘 설탕공장에서 설탕을 배달하고 있다. 상근이는 지금 사탕가게에 설탕을 정확하게 N킬로그램을 배달해야 한다. 설탕공장에서 만드는 설탕은 봉지에 담겨져 있다. 봉지는 3킬로그램 봉지와 5킬로그램 봉지가 있다.

상근이는 귀찮기 때문에, 최대한 적은 봉지를 들고 가려고 한다. 예를 들어, 18킬로그램 설탕을 배달해야 할 때, 3킬로그램 봉지 6개를 가져가도 되지만, 5킬로그램 3개와 3킬로그램 1개를 배달하면, 더 적은 개수의 봉지를 배달할 수 있다.

상근이가 설탕을 정확하게 N킬로그램 배달해야 할 때, 봉지 몇 개를 가져가면 되는지 그 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 N이 주어진다. (3 ≤ N ≤ 5000)

출력

상근이가 배달하는 봉지의 최소 개수를 출력한다. 만약, 정확하게 N킬로그램을 만들 수 없다면 -1을 출력한다.

 

 

 

/*baekjoon 2839 설탕 배달*/
#include <iostream>

using namespace std;

int N; // 설탕 무게 

void InputData(){
	cin >> N;
}

void Solve()
{
	int total = 0;
	int tmp = 0;

	if( N%5 == 0 ){
		cout <<  N/5 << endl;
	}else {
		tmp = N/5;	
		do{
			if( (N - tmp*5)%3 == 0){
				cout << tmp + (N -5*tmp)/3 << endl;
				break; 
			}
			tmp--;
		}while(tmp >=0 );
	}	

	if( tmp == -1 )
		cout << "-1" << endl;
}

int main()
{
	InputData();
	Solve();

	return 0;
}
/*baekjoon 2839 설탕 배달*/
반응형

+ Recent posts