1번.

수열이 정렬되어 있지 않으니까 이분 탐색은 못쓴다.

#include <stdio.h>

int a[100051];

int main() {
    int n, q;
    scanf("%d %d", &n, &q);
    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);

    for(int j=1; j<=q; j++) {
        int k;
        scanf("%d", &k);
        int ans = -1;
        for (int i = 1; i <= n; i++) {   
            if (a[i] == k) {
                ans = i;                 
                break;                  
            }
        }
        printf("%d\n", ans);
    }
}

2번. 

이게 조금 어려울수있는데 알고보면 쉽다.

시각을 전부 0시 0분부터 몇 분째인지로 바꾸면 0~1439 사이의 정수가 된다.
이걸 정렬해 두면 s 이상 e 이하인 기록 개수는 upper_bound(e) − lower_bound(s)로 
바로 구할 수 있다.

s가 e보다 늦으면 자정을 넘는 구간이니까 [s, 23:59]와 [00:00, e] 

두 구간으로 나눠서 각각 세고 더하면 된다.

#include <stdio.h>

int n, q;
int data[100071];  
int cnt[1440];      

int lower_bound(int start, int end, int key) {
    int result = end + 1;
    while (start <= end) {
        int mid = (start + end) / 2;
        if (data[mid] >= key) {     
            result = mid;
            end = mid - 1;
        }
        else start = mid + 1;
    }
    return result;
}

int upper_bound(int start, int end, int key) {
    int result = end + 1;
    while (start <= end) {
        int mid = (start + end) / 2;
        if (data[mid] > key) {    
            result = mid;
            end = mid - 1;
        }
        else start = mid + 1;
    }
    return result;
}

// s 이상 e 이하인 기록의 개수 (s <= e)
int count(int s, int e) {
    return upper_bound(1, n, e) - lower_bound(1, n, s);
}

int main() {
    int h, m, h2, m2;

    scanf("%d %d", &n, &q);
    for (int i = 1; i <= n; i++) {
        scanf("%d:%d", &h, &m);     // "hh:mm" 을 시, 분으로 읽기, 문자열써도 된다.
        cnt[h * 60 + m]++; ///이렇게 안하고 배열에 넣고 정렬해도 된다. 
    }
		
    int idx = 1;
    for (int t = 0; t < 1440; t++)
        for (int c = 0; c < cnt[t]; c++)
            data[idx++] = t;

    while (q--) {
        scanf("%d:%d %d:%d", &h, &m, &h2, &m2);
        int s = h * 60 + m, e = h2 * 60 + m2;
        if (s <= e) printf("%d\n", count(s, e));
        else printf("%d\n", count(s, 1439) + count(0, e));   // 자정을 넘는 구간
    }
}

3번

시험에 나온것처럼 bfs 돌린후에 마지막에 처리하면 끝.
거리 배열을 만들어놓으면 다양한 문제를 해결가능하다.

#include <stdio.h>
#include <queue>
using namespace std;

int n, m, s, k;
int adj[1001][1001];   
int dist[1001];        

int main() {
    scanf("%d %d %d %d", &n, &m, &s, &k);
    for (int i = 0; i < m; i++) {
        int u, v;
        scanf("%d %d", &u, &v);
        adj[u][v] = adj[v][u] = 1;    
    }

    for (int i = 1; i <= n; i++) dist[i] = -1;

    // BFS
    queue<int> q;
    dist[s] = 0;
    q.push(s);
    while (!q.empty()) {
        int x = q.front();
        q.pop();
        for (int y = 1; y <= n; y++) {
            if (adj[x][y] && dist[y] == -1) {
                dist[y] = dist[x] + 1;
                q.push(y);
            }
        }
    }

    // 번호가 작은 순서대로 거리가 k인 정점 출력
    int found = 0;
    for (int i = 1; i <= n; i++) {
        if (dist[i] == k) {
            printf("%d\n", i);
            found = 1;
        }
    }
    if (!found) printf("-1\n");
}

4번

인접리스트 -> 입력순
인접행렬 -> 사전순(번호가 작은순서, 큰순서)

#include <stdio.h>
#include <vector>
using namespace std;

vector<int> adj[1001];   
int order[1001];         // 방문 순서 (0이면 미방문)
int cnt = 0;

void dfs(int x) {
    order[x] = ++cnt;
   
    for (int i = 0; i < adj[x].size(); i++) {
        int y = adj[x][i];
        if (order[y] == 0) dfs(y);
    }
}

int main() {
    int n, m, r;
    scanf("%d %d %d", &n, &m, &r);
    for (int i = 0; i < m; i++) {
        int u, v;
        scanf("%d %d", &u, &v);
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    dfs(r);
    for (int i = 1; i <= n; i++) printf("%d\n", order[i]);
}

5번

두더지는 8방향나올수도있고 문자열입력나올수도있으니까 응용문제목록중에 
세균 안풀었으면 풀어보자. 이건 워낙 풀이가 다양 

#include <stdio.h>
#include <algorithm>
using namespace std;

int n, A[51][51], cnt, area[1300];
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
int best, bestCnt;

void input() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            scanf("%d", &A[i][j]);
}

void output() {
    printf("%d %d\n", best, bestCnt);
}

bool safe(int a, int b) {
    return (0 <= a && a < n) && (0 <= b && b < n);
}

bool cmp(int a, int b) {
    return a > b;
}

void dfs(int a, int b, int c) {
    A[a][b] = c;                                 
    for (int i = 0; i < 4; i++)
        if (safe(a + dx[i], b + dy[i]) && A[a + dx[i]][b + dy[i]] == 1)
            dfs(a + dx[i], b + dy[i], c);
}

void solve() {
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (A[i][j] == 1) {
                cnt++;
                dfs(i, j, cnt + 1);               
            }

    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            if (A[i][j]) area[A[i][j] - 2]++;     

    sort(area, area + cnt, cmp);                   

    best = area[0];                            
    for (int i = 0; i < cnt; i++)
        if (area[i] == best) bestCnt++;            
}

int main() {
    input();
    solve();
    output();
}

6번
0은빼 문제에서 좀더많이 뺴는문제다.
스택이 비어있을때 pop하면 오류가 발생하니까 
비어있는지 검사를 꼭 해준다.

#include <stdio.h>
#include <stack>
using namespace std;

int main() {
    int n;
    stack<int> st;

    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        int x;
        scanf("%d", &x);
        if (x > 0) {
            st.push(x);                       
        } else {
            int k = -x;                        
            while (!st.empty() && k > 0 ) {     
                st.pop();
                k--;
            }
        }
    }

    int sum = 0;
    while (!st.empty()) {                      
        sum += st.top();
        st.pop();
    }
    printf("%d\n", sum);
}