문제링크 : https://www.acmicpc.net/problem/1946

 

문제 접근

  • 문제를 추상화 하면
    • A와 B 과목에서 하나라도 다른 사람에 비해 떨어지면 안됨
  • 모두 떨어지는 경우를 구하는게 쉬울듯
  • 접근 1 : 각 노드당 모든 노드를 순회하면서 모두 떨어지는 경우를 구할경우
    • O(N^2) > e10 시간초과
  • 접근 2 : 하나를 기준으로 나머지 값의 최소값을 갱신
    • A,B 과목이 있을때 A 과목을 기준으로 정렬
    • A과목의 순위가 가장 높은 지원자의 B과목 순위를 최소값의 초기 셋팅
    • A과목 순위가 낮은 것들을 순회
      • A 과목 순위가 낮기 때문에, B과목은 더 순위가 높아야함
      • B과목의 순위를 최소값으로 갱신하면서 순회

 

시간복잡도 계산

  • 테스트케이스 : T
  • A과목을 기준으로 정렬 : NlgN
  • 모든 지원자 순회 : N
  • 시간복잡도 : O(T * (NlgN + N)) = O(TNlgN) =20* 1e5 * 20 = 4e7

인트 계산

  • 면접 지원자숫자 최대 1e6 > 인트 가능

 

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <iostream>
#include <algorithm>
 
using namespace std;
 
pair<intint> people[100010];
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    
    int T;cin >> T;
    while(T--) {
        int N; cin >> N;
        for(int i=0; i<N; i++) {
            int a,b; cin >> a >> b;
            people[i] = make_pair(a,b);
        }
        
        sort(people, people+N);
        
        int minv= people[0].second;
        int cnt=0;
        for(int i=1; i<N; i++) {
            // A과목 순위가 높은 사람의 B과목 순위도 순위가 높다면 카운트
            if(minv < people[i].second) {
                cnt++;
            }
            // 최소 순위 갱신, 왜냐하면 다음 사람은 최대값과 비교
            minv = min(minv, people[i].second);
        }
        
        cout << N-cnt << '\n';
    }
    return 0;
}
 
cs

 

문제유형

  • 그리디 - 두과목 모두 낮은 경우
    • A 과목을 기준으로 정렬한 후
    • A가 가장 높은 사람의 B 점수를 기록
    • A 과목을 순회하면서 B점수를 보다 높은값으로 갱신하며
    • 두과목 모두 낮은 경우 조회

 

문제링크 : https://www.acmicpc.net/problem/1937


문제 접근

  • 각 노드에서 DFS로 모든 경우의 수 사용할 경우
    • 모든 노드 : O(N^2)
    • 각 노드에서 DFS할경우, O(V+E) : O(N^2 + 4 * N^2) : O(5*N^2)
    • O(N^2 * 5N^2) = O(5N^4) = 5*625 * e8 > 시간초과
      • DP를 사용, 각 노드 : 판다가 최대한 살수 있는 일수
    • 각 노드에서 값 구하기 위해 DFS 사용
    • 4방향에서 현재보다 값 작을경우, DP 값있으면 반환하고, 없으면 다시 DFS
    • O(V+E) : O(5*N^2)

시간복잡도 계산

  • DP 사용하면, 가장 높은 값을 갖는곳으로부터 DFS 한것과 같은 효과
    • O(V+E) = O(N^2 + 4N^2) = O(5*N^2)

인트 계산

  • 대나무 양 : 1e6보다 작음 > INT 가능
  • DP 값 : 25e4보다 작음 > DP 가능

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#include <iostream>
 
using namespace std;
 
int map[510][510];
int dp[510][510];
int dy[] = {0,1,0,-1};
int dx[] = {1,0,-1,0};
 
int get_dp(int y, int x) {
    if(dp[y][x] != 0return dp[y][x];
    
    int rs=0;
    for(int k=0; k<4; k++) {
        int ny = y + dy[k];
        int nx = x + dx[k];
        if(map[y][x] < map[ny][nx]) rs = max(rs, get_dp(ny, nx));
    }
    
    return dp[y][x] = rs+1;
}
int main() {
    int N; cin >> N;
    
    fill(&dp[0][0], &dp[509][510], 0);
    for(int j=0; j<N; j++) {
        for(int i=0; i<N; i++) {
            cin >> map[j][i];
        }
    }
    
    int rs=0;
    for(int j=0; j<N; j++) {
        for(int i=0; i<N; i++) {
            rs = max(rs, get_dp(j,i));
        }
    }
    
    cout << rs << '\n';
    return 0;
}
 
cs

문제유형

  • DP - DFS
    • DP에서 순차적으로 오는것이 아닌, 여러 경로가 있을떄 사용
    • 특히 2차원에서 상하좌우를 모두 고려해줘야할 때

비슷한 문제

문제링크 : https://www.acmicpc.net/problem/10999


문제 접근

  • 세그먼트 트리 응용 문제
    • 세그먼트 트리 기본 개념: https://dev-jango.tistory.com/30
    • 수정이 구간으로 이루어질경우 lazy 사용
    • lazy : 해당 노드에 대해서 업데이트 해줘야 할 값
    • 해당 노드를 조회하거나 업데이트처럼 직접 사용할때 한번에 처리
    • 그 전까지는 작업을 뒤로 미뤄둠

시간복잡도 계산

  • 처음 세그먼트 트리 생성 : N * lgN
  • M+K번 의 수정 및 출력 : (M+K)*lgN
  • O((N+M+K) * lgN) = 1e6 * 20 = 2e7

인트 계산

  • 세그먼트 트리 값 : 최대값인 2^63이 1e6개 있을경우 제일 상단값은 2^63 * 1e6 = e18 * e6 = e24 >> long long
  • 입력으로 들어오는값 모두 최대 2^63 > long long

코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
#include <iostream>
#include <vector>
#include <cmath>
 
using namespace std;
typedef long long ll;
 
vector<ll> tree;
vector<ll> lazy;
ll nums[1000010];
 
ll make(int node, int st, int en) {
    if(st==en) return tree[node] = nums[st];
    
    int mid = (st+en)/2;
    ll rsl = make(node*2, st, mid);
    ll rsr = make(node*2+1, mid+1, en);
    
    return tree[node] = rsl + rsr;
}
 
// 해당 노드에 있는 lazy를 적용하고 lazy를 비워줌
void lazy_update(int node, int st, int en) {
    if(lazy[node] != 0) {
        tree[node] += (en-st+1* lazy[node];
        
        if(st != en) {
            lazy[node*2+= lazy[node];
            lazy[node*2+1+= lazy[node];
        }
        
        lazy[node] = 0;
    }
}
 
void update(int node, int st, int en, int li, int ri, ll diff) {
    // lazy 업데이트 먼저 수행
    lazy_update(node, st, en);
    
    if(ri < st || en < li) return;
    if(li <= st && en <= ri) {
        // 구하려는 구간 안에 노드가 있으면 업데이트 반영
        tree[node] += (en-st+1* diff;
        if(st != en) {
            lazy[node*2+= diff;
            lazy[node*2+1+= diff;
        }
        return;
    }
    
    int mid = (st+en)/2;
    update(node*2, st, mid, li, ri, diff);
    update(node*2+1, mid+1, en, li, ri, diff);
    tree[node] = tree[node*2+ tree[node*2+1];
}
 
ll sumt(int node, int st, int en, int li, int ri) {
    lazy_update(node, st, en);
    if(ri < st || en < li) return 0;
    if(li <= st && en <= ri) return tree[node];
    
    int mid = (st+en)/2;
    ll rsl = sumt(node*2, st, mid, li, ri);
    ll rsr = sumt(node*2+1, mid+1, en, li, ri);
    return rsl + rsr;
}
 
int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    
    int N,M,K; cin >> N >> M >> K;
    
    
    for(int i=0; i<N; i++cin >> nums[i];
    
    // tree, lazy, 초기화
    int h = ceil(log2(N));
    tree.resize(1<<(h+1));
    lazy.resize(1<<(h+1));
    
    make(1,0,N-1);
    
    for(int i=0; i<M+K; i++) {
        int a,b,c; cin >> a >> b >> c;
        if(a==1) {
            ll d; cin >> d;
            update(1,0,N-1,b-1,c-1,d);
        } else {
            cout << sumt(1,0,N-1,b-1,c-1<< '\n';
        }
        
        
    }
    return 0;
}
 
cs

문제유형

  • 세그먼트 트리 - lazy

+ Recent posts