Zaehyeon's BLOG

#include <stdio.h>
#define mod 1000000007

int dp[101][10][5]; // 0 == 3 dec, 1 == 2 dec, 2(mid) == 1 dec || inc, 3 == 2 inc, 4 == 3 inc

int main(){
    int N;
    int sum = 0;
    int mid = 2;
    scanf("%d", &N);
    for (int i = 0; i < 10; i++){ // 길이가 1이고 증감 X의 변형 계단 수의 개수는 1개
        dp[1][i][mid] = 1;
    }
    for(int i = 1; i < 9; i++){ // 길이가 2일 경우에는 연속 1번 증/감 밖에 없음
        dp[2][i][mid+1] = dp[1][i-1][mid];
        dp[2][i][mid-1] = dp[1][i+1][mid];
    }
    dp[2][0][mid-1] = dp[1][1][mid]; // 0 예외처리
    dp[2][9][mid+1] = dp[1][8][mid]; // 9 예외처리
    for (int i = 3; i <= N; i++){
        for (int j = 0; j < 10; j++){
            if (j == 0){ // 0 예외처리 0일 경우는 1 -> 10으로 가는 감소 밖에 없다.
                dp[i][0][mid-1] = dp[i-1][1][mid+1] % mod;
                dp[i][0][mid-2] = dp[i-1][1][mid-1] % mod;
            }
            else if (j == 9) { // 9 예외처리 9일 경우는 8 -> 89로 가는 증가 밖에 없다.
                dp[i][9][mid+1] = dp[i-1][8][mid-1] % mod;
                dp[i][9][mid+2] = dp[i-1][8][mid+1] % mod;
            }
            else { // 점화식
                dp[i][j][mid+1] = (dp[i-1][j-1][mid-1] + dp[i-1][j-1][mid-2]) % mod;
                dp[i][j][mid+2] = dp[i-1][j-1][mid+1] % mod;
                dp[i][j][mid-1] = (dp[i-1][j+1][mid+1] + dp[i-1][j+1][mid+2]) % mod;
                dp[i][j][mid-2] = dp[i-1][j+1][mid-1] % mod;
            }
        }
    }
    for (int i = 0; i < 10; i++){ // 정답 N의 모든 배열을 더해준다.
        for (int j = 0; j < 5; j++){
            sum += dp[N][i][j];
            sum %= mod;
        }
    }
    printf("%d\n", sum % mod);
    
}

C++

#include <bits/stdc++.h>

using namespace std;

vector <vector<int> > node(101); // 노드의 개수

int chk[101];

void bfs(int n){ // BFS 따로 BFS에 대해선 설명하지 않겠습니다.
    int fn;
    queue <int> q;
    chk[n] = 0;
    q.push(n);
    while(!q.empty()){
        fn = q.front();
        q.pop();
        for(int i = 0; i < node[fn].size(); i++){
            if(chk[node[fn][i]] == -1){
                q.push(node[fn][i]);
                chk[node[fn][i]] = chk[fn] + 1;
            }
        }
    }
}

int main(){
    int N, K; cin >> N >> K;
    for(int i = 0; i < K; i++){ // 친구관계 형성
        int a, b; scanf("%d%d", &a, &b);
        node[a].push_back(b);
        node[b].push_back(a);
    }
    for(int i = 1; i <= N; i++){
        memset(chk, -1, sizeof(chk)); // 노드를 탐색할 때 마다 노드 초기화
        bfs(i); // BFS
        for(int j = 1; j <= N; j++){
            if(chk[j] == -1 || chk[j] > 6){ // 노드가 이어져있지 않거나, 6보다 많은 단계로 연결되어 있으면
                printf("Big World!\n");
                return 0;
            }
        }
    }
    printf("Small World!\n");
}

Python3 (두 번째 방법)

input = input()

ans = min(abs(ord('A') + 26 - ord(input[0])), ord(input[0]) - ord('A')) # 처음 화살표는 'A'를 가리킨다.
for i in range(len(input)-1) :
	# abs 처리
    left = ord(input[i]) - ord(input[i+1])
    right = ord(input[i+1]) - ord(input[i])
    if left < 0:
        left += 26
    if right < 0:
        right += 26
    ans += min(abs(left), abs(right))
print(ans)

C++ (첫 번째 방법)

#include <bits/stdc++.h>

using namespace std;

int main(){
	string inp;
	cin >> inp;
    int ans = 0;
    inp = 'A' + inp; // 처음 화살표는 'A'를 가리킨다.
    for(int i = 0; i < inp.size()-1; i++){
    	ans += min(abs((inp[i+1] - 'A') - (inp[i] - 'A')), 26 - abs((inp[i+1] - 'A') - (inp[i] - 'A')));
        // 왼쪽, 오른쪽중 최솟값을 더함
    }
    cout << ans << '\n';
    return 0;
}