#include <iostream>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <string>
#include <string.h>
#include <math.h>
#include <vector>
#include <algorithm>
using namespace std;
 
int N;
int Map[25][25];
int visited[25][25];
int Min = 999999999;
 
int dx[4= {001-1};
int dy[4= {1-100};
 
int safe(int x, int y, int d1, int d2)
{
    if(1 <= x && x+d1+d2 <= N && 1 <= y-d1 && y+d2 <= N)
    {
        return 1;
    }
    
    return 0;
}
 
void color1234(int x, int y, int d1, int d2)
{
    for(int i = 1; i < x+d1; i++)
    {
        for(int j = 1; j <= y; j++)
        {
            if(visited[i][j] == 5)
            {
                break;
            }
            
            visited[i][j] = 1;
        }
    }
    
    for(int i = 1; i <= x+d2; i++)
    {
        for(int j = N; j > y; j--)
        {
            if(visited[i][j] == 5)
            {
                break;
            }
            
            visited[i][j] = 2;
        }
    }    
    
    for(int i = x+d1; i <= N; i++)
    {
        for(int j = 1; j < y-d1+d2; j++)
        {
            if(visited[i][j] == 5)
            {
                break;
            }
            
            visited[i][j] = 3;
        }
    }
 
    for(int i = x+d2+1; i <= N; i++)
    {
        for(int j = N; j >= y-d1+d2; j--)
        {
            if(visited[i][j] == 5)
            {
                break;
            }
            
            visited[i][j] = 4;
        }
    }
}
 
void color5(int x, int y, int d1, int d2)
{
    for(int i = 0; i <= d1; i++)
    {
        int nx = x + i;
        int ny = y - i;
        visited[nx][ny] = 5;
        
        nx = x + d2 + i;
        ny = y + d2 - i;
        visited[nx][ny] = 5;
    }
    
    for(int i = 0; i <= d2; i++)
    {
        int nx = x + i;
        int ny = y + i;
        visited[nx][ny] = 5;
        
        nx = x + d1 + i;
        ny = y - d1 + i;
        visited[nx][ny] = 5;
    }
}
 
void print()
{
    for(int i = 1; i <= N; i++)
    {
        for(int j = 1; j <= N; j++)
        {
            cout << visited[i][j] << " ";
        }
        cout << "\n";
    }
    cout << "\n";    
}
 
int cal()
{
    int sum[6= {0};
    
    for(int i = 1; i <= N; i++)
    {
        for(int j = 1; j <= N; j++)
        {
            if(visited[i][j] == 0 || visited[i][j] == 5)
            {
                sum[5+= Map[i][j];    
            }
            else
            {
                sum[visited[i][j]] += Map[i][j];
            }
        }
    }
    
    int Max = max({sum[1], sum[2], sum[3], sum[4], sum[5]});
    int Min = min({sum[1], sum[2], sum[3], sum[4], sum[5]});
    
    return Max - Min;
}
 
void solve()
{
    for(int x = 1; x <= N; x++)
    {
        for(int y = 1; y <= N; y++)
        {
            for(int d1 = 1; d1 <= N; d1++)
            {
                for(int d2 = 1; d2 <= N; d2++)
                {
                    if(safe(x, y, d1, d2) == 1)
                    {
                        memset(visited, 0sizeof(visited));
                        
                        color5(x, y, d1, d2);
                        color1234(x, y, d1, d2);
                        
                        Min = min(Min, cal());
                    }
                }
            }
        }
    }
    
    cout << Min;
}
 
int main(void)
{
//    freopen("B17779_input.txt", "r", stdin);
    
    cin >> N;
    
    for(int i = 1; i <= N; i++)
    {
        for(int j = 1; j <= N; j++)
        {
            cin >> Map[i][j];
        }
    }
    
    solve();
    
    return 0;
}
cs
#include <iostream>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <string>
#include <string.h>
#include <math.h>
#include <vector>
#include <algorithm>
using namespace std;
 
int N;
int num[15];
vector<int> area[15];
vector<int> red;
int Min = 999999999;
 
int blue_check(vector<int> blue, int visited[15])
{
    queue<int> q;
    q.push(blue[0]);
    visited[blue[0]] = 1;
    int cnt = 1;
    
    while(!q.empty())
    {
        int now = q.front();
        q.pop();
        
        for(int i = 0; i < area[now].size(); i++)
        {
            int next = area[now][i];
            
            if(visited[next] == 0)
            {
                q.push(next);
                visited[next] = 1;
                cnt++;
            }
        }
    }
    
    if(cnt == blue.size())
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
 
int red_check(int visited[15])
{
    queue<int> q;
    q.push(red[0]);
    visited[red[0]] = 1;
    int cnt = 1;
    
    while(!q.empty())
    {
        int now = q.front();
        q.pop();
        
        for(int i = 0; i < area[now].size(); i++)
        {
            int next = area[now][i];
            
            if(visited[next] == 0)
            {
                q.push(next);
                visited[next] = 1;
                cnt++;
            }
        }    
    }
    
    if(cnt == red.size())
    {
        return 1;
    }
    else
    {
        return 0;
    }
}
 
void combination(int idx, int cnt, int finish)
{
    if(cnt == finish)
    {
        vector<int> blue;
        int red_visited[15= {0};
        int blue_visited[15= {0};
        int sum1 = 0;
        int sum2 = 0;
 
        for(int i = 0; i < red.size(); i++)
        {
            blue_visited[red[i]] = 1;
            sum1 += num[red[i]];
        }
        
        for(int i = 1; i <= N; i++)
        {
            if(blue_visited[i] == 0)
            {
                red_visited[i] = 1;
                blue.push_back(i);
                sum2 += num[i];
            }
        }
        
        if(red_check(red_visited) == 1)
        {
            if(blue_check(blue, blue_visited) == 1)
            {
                Min = min(Min, abs(sum1-sum2));
            }    
        }
        
        return;    
    }
    
    for(int i = idx; i <= N; i++)
    {
        red.push_back(i);
        combination(i+1, cnt+1, finish);
        red.pop_back();
    }
}
 
int main(void)
{
//    freopen("B17471_input.txt", "r", stdin);
    
    cin >> N;
    
    for(int i = 1; i <= N; i++)
    {
        cin >> num[i];
    }
    
    for(int from = 1; from <= N; from++)
    {
        int M; 
        cin >> M;
        
        for(int i = 1; i <= M; i++)
        {
            int to;
            cin >> to;
            
            area[from].push_back(to);
            area[to].push_back(from);
        }
    }
    
    for(int i = 1; i <= N/2; i++)
    {
        combination(10, i);
    }
    
    if(Min == 999999999)
    {
        cout << "-1";
    }
    else
    {
        cout << Min;    
    }
    
    return 0;
}
cs

C++에는 cout.precision(); 이라는, 출력 자릿수를 조절해주는 함수가 있습니다.

 

코드로 바로 볼게요 

 

#include <iostream>

using namespace std;

 

int main(void)

{

    int a = 10;

    int b = 3;

    

    cout << a/(double)b;

    // 3.33333

}

 

이 코드는 3.33333. 그러니까 소수점 아래 다섯번째 자리까지만 출력합니다.

그러나 출력 전에 cout.precision();이라는 함수에, 파라미터로 10을 넣어 사용하면

 

 

#include <iostream>

using namespace std;

 

int main(void)

{

    int a = 10;

    int b = 3;

    

    cout.precision(10);

    cout << a/(double)b;

    // 3.333333333

}

 

소수점 아래 아홉번째 자리까지 출력이 됩니다.

10을 넣었는데 소수점 아래 아홉번째 자리까지 출력되는 걸 보고 눈치 채신 분들도 계시겠지만

cout.precision()은 사실 소수점 아래 부분의 출력 범위만 설정하는 게 아니고 

실수의 정수부와 소수부를 합친, 전체의 출력 범위를 설정하는 함수입니다. 

 

만약, 이걸 소수점 아래 숫자의 출력 범위만 설정하게 쓰려면  

함수 위에 cout << fixed; 라는 라인을 추가하면 되고요

이걸 설정한 후 다시 해제해서 실수 전체의 출력 범위를 설정하고 싶다면

cout.unsetf(ios::fixed); 이라는 라인을 추가해주면 됩니다 

 

아래 코드처럼요

 

#include <iostream>

using namespace std;

 

int main(void)

{

    int a = 10;

    int b = 3;

    

    cout << fixed;

    cout.precision(9);

    cout << a/(double)b << endl;

    // 3.333333333

    

    cout.unsetf(ios::fixed);

    cout << a/(double)b;

    // 3.33333333

}

 

- 추가!

   printf()를 활용할 땐 아래와 같이 서식지정자를 활용하면 됩니다.

 

#include <stdio.h>

 

int main(void)

{

    int a = 10;

    int b = 3;

    

    printf("%f \n",a/(double)b);

    // 3.333333

    printf("%.9f",a/(double)b);

    // 3.333333333 

}

 

'C++' 카테고리의 다른 글

cin, cout 입출력 속도 빠르게 하는 방법  (3) 2019.09.25

http://blog.kichul.co.kr/2017/03/10/2017-03-10-git-auth-save/

Node.js & Express.js

Express : Node.js를 쉽게 이용하게 해주는 Framework

 

0. node -v를 통해 Node.js 다운로드 여부 확인

1. Node.js 다운로드

2. npm init을 통해 패키지 생성 -> package.json

3. index.js 생성 -> 백엔드부분의 시작점

4. Express 다운로드 -> npm install express --save

5. index.js에 기본적인 expree.js 만들기 -> http://expressjs.com/en/starter/hello-world.html

 

package.json의 scripts에 start 명령어 만들기 

-> "start" : node index.js

-> npm run start

 

Node.js와 MongoDB 연결

0. 화이트리스트에 ip추가

1. 몽고DB 유저 만들기

2. Connect Your Application 클릭 후 URL 사용

 

Mongoose : MongoDB를 편하게 사용할 수 있게 해주는 툴

-> npm install mongoose --save

 

MongoDB

Model : Schema를 감싸주는 역할

Schema : 데이터의 정보 지정 (이름, 닉네임, 이메일, 직업 등) 

 

0. models 폴더 생성

1. models 폴더 안에 Schema 저장

 

Git

git status : 깃의 상태 확인

 

Working Directory

--(git add)-->

Staging Area

--(git commit)-->

Git Repository(Local)

--(git push)-->

Git Repositroy(Remote), GitHub

 

#include <iostream>
#include <algorithm>
#include <math.h>
#include <algorithm>
using namespace std;
 
int N, M, K;
int arr[310][310];
long long dp[310][310];
int startX, startY;
int endX, endY;
 
int main(void)
{
//    freopen("B2167_input.txt", "r", stdin);
    
    cin >> N >> M;
    
    for(int i = 1; i <= N; i++)
    {
        for(int j = 1; j <= M; j++)
        {
            cin >> arr[i][j];
        }
    }
    
    // 미리 구해놓기
    for(int i = 1; i <= N; i++)
    {
        for(int j = 1; j <= M; j++)
        {
            dp[i][j] = dp[i-1][j] + dp[i][j-1+ arr[i][j] - dp[i-1][j-1];        
        }
    } 
    
    cin >> K;
    
    for(int i = 1; i <= K; i++)
    {
        cin >> startX >> startY >> endX >> endY;
        
        // 좌표가 사각형 기준 오른쪽위, 왼쪽 아래인 경우 -> 왼쪽 위, 오른쪽 아래로 좌표 수정 
        int sx = min(startX, endX);
        int sy = min(startY, endY);
        int ex = max(startX, endX);
        int ey = max(startY, endY);
        
        cout << dp[ex][ey] - dp[sx-1][ey] - dp[ex][sy-1+ dp[sx-1][sy-1<< endl;
    }
    
    return 0;
}
cs
#include <stdio.h>
#include <iostream>
#include <queue>
#include <algorithm>
#include <vector>
#include <string.h>
using namespace std;
 
int N;
pair<intint> Map[510][1020]; // 타일숫자, 타일번호 
int visited[510][1020];
int path[510*1020];
int tileNum;
int last; 
vector<int> trace;
 
int dx[4= {-1100}; // 상하좌우 
int dy[4= {00-11}; // 상하좌우 
 
void BFS()
{
    queue<pair<intint>> q;
    q.push({11});
    q.push({12});
    visited[1][1= 1;
    visited[1][2= 1;
    
    path[1= 0// 0번(초기화용 타일번호) -> 1번(시작 타일번호) 
    
    while(!q.empty())
    {
        int x = q.front().first;
        int y = q.front().second;
        q.pop();
        
 
        if(Map[x][y].second == tileNum)
        {
//            cout << visited[x][y] << endl;
            last = Map[x][y].second;
            return;
        }
        else
        {
            last = max(last, Map[x][y].second);
        }
        
        for(int i = 0; i < 4; i++)
        {
            int xpos = x+dx[i];
            int ypos = y+dy[i];
            
            if(visited[xpos][ypos] != 0 || Map[xpos][ypos].first == 0 || Map[xpos][ypos].second == 0)
            {
                continue;
            }
            
            // (타일 번호가 다르고) 타일의 숫자가 같은 경우
            if(Map[x][y].second != Map[xpos][ypos].second && Map[x][y].first == Map[xpos][ypos].first)
            {
                q.push({xpos, ypos});
                visited[xpos][ypos] = visited[x][y]+1;
                path[Map[xpos][ypos].second] = Map[x][y].second;
                
                // 타일 번호가 같은 타일 숫자 왼쪽, 오른쪽 확인 후 큐에 삽입 
                if(Map[xpos][ypos-1].second == Map[xpos][ypos].second)
                {
                    q.push({xpos, ypos-1});    
                    visited[xpos][ypos-1= visited[xpos][ypos];
                }
                else if(Map[xpos][ypos].second == Map[xpos][ypos+1].second)
                {
                    q.push({xpos, ypos+1});    
                    visited[xpos][ypos+1= visited[xpos][ypos];
                }
            }
        }
    }
}
 
int main(void)
{
//    freopen("B5213_input.txt", "r", stdin);
    
    cin >> N;
    
    int row = N;
    
    for(int k = 1; k <= row; k++)
    {
        // 홀수번째 row 
        if(k % 2 == 1)
        {
            for(int i = 1; i <= 2*N; i++)
            {
                if(i % 2 == 1)
                {
                    tileNum++;
                }
                
                int a;
                cin >> a;
                
                Map[k][i].first = a;
                Map[k][i].second = tileNum;
            }        
        }
        // 짝수번째 row
        else
        {
            for(int i = 2; i <= 2*N-1; i++)
            {
                if(i % 2 == 0)
                {
                    tileNum++;
                }
                
                int a;
                cin >> a;
                
                Map[k][i].first = a;
                Map[k][i].second = tileNum;
            }
        }
    }
 
    BFS();
    
    // 경로 구하는 과정 
    int idx = last;
    while(path[idx] != 0)
    {
        trace.push_back(idx);
        idx = path[idx];
    }
    trace.push_back(1);
    
    cout << trace.size() << endl;
    for(int i = trace.size()-1; i >= 0; i--)
    {
        cout << trace[i] << " ";
    }
        
    return 0;
}
cs
#include <stdio.h>
#include <iostream>
#include <queue>
#include <algorithm>
#include <vector>
#include <string.h>
using namespace std;
 
int N, M;
vector<pair<intlong long>> v[10010];
int start, arrive;
long long Max;
long long MaxCost;
 
bool BFS(int limit)
{
    queue<int> q;
    int visited[10010= {0};
    
    q.push(start);
    visited[start] = 1;
    
    while(!q.empty())
    {
        int x = q.front();
        q.pop();
        
        if(x == arrive)
        {
            return true;
        }
        
        for(int i = 0; i < v[x].size(); i++)
        {
            if(visited[v[x][i].first] == 0 && v[x][i].second >= limit)
            {
                visited[v[x][i].first] = 1;
                q.push(v[x][i].first);
            }
        }
    }
    
    return false;
}
 
int main(void)
{
//    freopen("B1939_input.txt", "r", stdin);
    
    cin >> N >> M;
    
    for(int i = 1; i <= M; i++)
    {
        int from, to;
        long long cost;
        cin >> from >> to >> cost;
        
        v[from].push_back({to, cost});
        v[to].push_back({from, cost});
        
        MaxCost = max(MaxCost, cost);
    }
    
    cin >> start >> arrive;
    
    long long left = 1;
    long long right = MaxCost;
    
    while(left <= right)
    {
        long long mid = (left + right) / 2;
        
        if(BFS(mid))
        {
            left = mid+1;    
            Max = mid;
        }
        else
        {
            right = mid-1;
        }
    }
    
    cout << Max << endl;
        
    return 0;
}
cs

+ Recent posts