M’s 코딩 블로그

leetcode 987 - Vertical Order Traversal of a Binary Tree

2020-11-13T00:00:00+00:00

문제

leetcode 987 - Vertical Order Traversal of a Binary Tree 풀러가기

문제 분석

tree를 bfs나 dfs로 탐색하면서

왼쪽 자식의 경우에는 현재 노드의 column-1, row-1을 해주고

오른쪽 자식의 경우에는 현재 노드의 column+1, row-1을 해준다.

문제 코드(C++)

전체 코드

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
class Solution {
public:
    vector<vector<int>> verticalTraversal(TreeNode* root) {
        map<int, pair<int, int>> m;
        
        vector<vector<int>> ans;
        
        queue<TreeNode*> q;
        
        q.push(root);
        m[root->val] = make_pair(0,0);
        while(!q.empty()){
            TreeNode* curr = q.front();
            q.pop();
            if(curr->left){
                q.push(curr->left);
                m[curr->left->val] = make_pair(m[curr->val].first-1, m[curr->val].second-1);
            }
            if(curr->right){
                q.push(curr->right);
                m[curr->right->val] = make_pair(m[curr->val].first+1, m[curr->val].second-1);
            }
        }
        vector<pair<int, pair<int,int>>> tmp(m.begin(), m.end());
        
        sort(tmp.begin(), tmp.end(), [](pair<int, pair<int,int>> x, pair<int, pair<int,int>> y){
            if(x.second.first != y.second.first){
                return x.second.first < y.second.first;
            }else if(x.second.second != y.second.second){
                return x.second.second>y.second.second;
            }else{
                return x.first<y.first;
            }
        });
        
        for(int i=0;i<tmp.size();i++){
            int curr = tmp[i].second.first;
            vector<int> t;
            t.push_back(tmp[i].first);
            for(int j=i+1; j<tmp.size();j++){
                if(tmp[j].second.first==curr){
                    t.push_back(tmp[j].first);
                    i=j;
                }else{
                    break;
                }
            }
            ans.push_back(t);
        }
        
        return ans;
    }
};
Colored by Color Scripter
cs

12~23번째 줄 : tree를 bfs로 탐색하면서 row, column 값으로 구성된 map을 채운다. map을 사용한 이유는 key가 없는 경우에 자동으로 그 key를 생성하기 때문이다.
24~34번째 줄 : sort를 하기 위해 각 노드의 위치 정보가 담긴 map을 vector로 옮긴다.
- 옮긴 후에는 sorting을 하는데, 이때 1) column이 작은 순 2) column이 같다면 row가 큰 순 3) column,row가 같다면 노드의 값이 작은 순 으로 정렬을 해야 한다.
36~49번째 줄 : 정렬 된 결과를 이용하여, column이 같은 값끼리 같은 vector에 넣고 그 vector를 전체 정답 vector에 넣어준다.

Runtime: 4 ms, faster than 90.10% of C++ online submissions for Vertical Order Traversal of a Binary Tree.

Memory Usage: 12.3 MB, less than 84.03% of C++ online submissions for Vertical Order Traversal of a Binary Tree.

아직 배움의 과정에 있는 학생이니 내용에 부족한 점이 보이면 지적은 하되, 비난은 하지 말아주세요!!

프로그래머스 - 다리를 지나는 트럭

2020-11-13T00:00:00+00:00

문제

프로그래머스 - 다리를 지나는 트럭 풀러가기

문제 분석

이 문제는 큐를 이용해서 특정 무게의 트럭을 추가 할 수 있는지 없는지 파악한 뒤 할 수 있다면 큐에 트럭의 무게를 넣어주고 없다면 그냥 0의 값을 넣어주면 됩니다.

다리의 길이가 10000이하이기 때문에, 시간을 1씩 증가시키면서 진행해도 괜찮습니다.

문제 코드(C++)

전체 코드

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
#include <string>
#include <vector>
#include <algorithm>
#include <queue>
 
using namespace std;
 
int solution(int bridge_length, int weight, vector<int> truck_weights) {
    int answer = 0;
    
    queue<int> q;
    int idx=0;
    int sum=0;
    
    while(1){
        if(idx == truck_weights.size()){
            answer+=bridge_length;
            break;
        }
        
        answer++;
        
        int tmp = truck_weights[idx];
        
        if(q.size()==bridge_length){
            sum-=q.front();
            q.pop();
        }
        
        if(sum+tmp<=weight){
            sum += tmp;
            q.push(tmp);
            idx++;
        }else{
            q.push(0);
        }
    }
    
    return answer;
}
Colored by Color Scripter
cs

16~19번째 줄 : 모든 truck이 다리에 올라갔다면, 마지막 트럭의 이동이 끝나기만 하면 됩니다. 따라서 현재 시간에 다리 길이 만큼의 시간을 더해주고 반복문을 끝냅니다.
21~23번째 줄 : 시간을 1올려주고 truck의 무게를 구합니다.
25~27번째 줄 : 큐의 크기가 다리의 크기와 같다면, 이동이 끝난 것이므로 큐에서 해당 트럭과 sum에서 해당 무게를 빼줍니다. 이때, 다리의 끝에 다다른 것이 트럭이 아니라면 무게를 0으로 해서 큐에 삽입 했으므로 sum에는 변화가 없습니다.
30~36번째 줄 : 다리에 트럭을 올릴 수 잇으면 트럭의 무게를 큐에 넣고, 무게 총합에 해당 무게를 더해줍니다. 올릴 수 없다면 큐에 0을 추가합니다.

아직 배움의 과정에 있는 학생이니 내용에 부족한 점이 보이면 지적은 하되, 비난은 하지 말아주세요!!

프로그래머스 - 더 맵게

2020-11-13T00:00:00+00:00

문제

프로그래머스 - 더 맵게 풀러가기

문제 분석

모든 음식의 스코빌 지수가 k이상이 되도록 만들어야 한다.

그렇다면 모든 음식의 스코빌 지수 중 최소값이 k 이상이 되도록 만들면 된다.

즉, 정렬을 이용하면 된다.

힙은 데이터를 삽입하고, 제거하는데 각각 logn의 시간 복잡도를 가진다.

최소 힙은 부모 노드의 값이 자식 노드의 값 보다 작다. 따라서, 루트 노드의 값이 최솟값을 가진다.

c++의 경우 priority queue를 이용하면 힙을 쉽게 구현 할 수 있다.

이를 이용하여 문제를 풀어본다.

문제 코드(C++)

전체 코드

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
#include <string>
#include <vector>
#include <queue>
 
using namespace std;
 
int solution(vector<int> scoville, int K) {
    int answer = 0;
 
    priority_queue<int, vector<int>, greater<int>> pq;
    
    for(int i = 0;i<scoville.size();i++){
        pq.push(scoville[i]);
    }
    
    while(!pq.empty()){
        if(pq.top()>=K){
            break;
        }
        if(pq.size() == 1){
            if(pq.top()<K){
                answer = -1;
                break;
            }
        }
        int n1 = pq.top();
        pq.pop();
        int n2 = pq.top();
        pq.pop();
    
        int n = n1+n2*2;
        pq.push(n);
        answer++;
    }
    
    return answer;
}
Colored by Color Scripter
cs

10번째 줄 : priority queue를 오름차순으로 만든다. 이렇게 하면 min heap을 만들 수 있다.
16~34번째 줄 : priority queue가 빌 때까지 반복문을 진행한다.
- 17~19번째 줄 : priority queue의 top, 즉 루트 노드의 값이 k와 같거나 크다면 모든 음식의 스코빌 지수는 k이상이라고 할 수 있다. 따라서 반복문을 중단한다.
- 20~25번째 줄 : 작은 두 값끼리 연산을 반복 한 뒤 priority queue에 하나만 남았는데, 그 하나가 k보다 작다면 모든 음식의 스코빌 지수를 k이상으로 만들 수 없는 경우다. 따라서 answer를 -1로 만들고 반복문을 중단한다.
- 26~33번째 줄 : 제일 작은 두 값을 꺼내서 새로운 스코빌 지수를 생성한 뒤 그 값을 priority queue에 넣어주고 횟수(answer)를 증가시킨다.

아직 배움의 과정에 있는 학생이니 내용에 부족한 점이 보이면 지적은 하되, 비난은 하지 말아주세요!!

프로그래머스 - 네트워크

2020-11-13T00:00:00+00:00

문제

프로그래머스 - 네트워크 풀러가기

문제 분석

이 문제는 연결 요소를 찾는 문제입니다.

연결 요소 보러가기

이 개념만 안다면 쉽게 푸실 수 있는 문제에요!

문제 코드(C++)

전체 코드

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
#include <string>
#include <vector>
#include <queue>
 
using namespace std;
 
int solution(int n, vector<vector<int>> computers) {
    int answer = 0;
 
    vector<bool> visit(n, false);
 
    for(int i=0;i<n;i++){
        if(!visit[i]){
            visit[i] = true;
            queue<int> q;
            q.push(i);   
            while(!q.empty()){
                int cur = q.front();
                q.pop();
                for(int k=0;k<n;k++){
                    if(!visit[k] && computers[cur][k] == 1){
                        q.push(k);
                        visit[k] = true;
                    }
                }
            }
            answer++;
        }
    }
 
    return answer;
}
Colored by Color Scripter
cs

13번째 줄 : 아직 탐색이 안 되었다 = 새로운 연결 요소의 시작
- 이를 지점을 시작으로 해서 새로운 탐색을 시작하면 됩니다.
- 15~26번째 줄 : bfs 구현 부분

아직 배움의 과정에 있는 학생이니 내용에 부족한 점이 보이면 지적은 하되, 비난은 하지 말아주세요!!

백준 12767 - Ceiling Function

2020-11-11T00:00:00+00:00

문제

백준 12767 - Ceiling Function 풀러가기

문제 풀이

주어진 입력들로 만들 수 있는 서로 다른 binary search tree의 형태 수를 찾는 문제다.

주어진 문제로 binary search tree를 만든다.
순회 한 결과가 몇개가 있는지 확인하면 된다. 여기선 pre-order로 구현했다.

문제 코드(C++)

전체 코드

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
#include <cstdio>
#include <set>
#include <vector>
#include <string>
 
using namespace std;
 
struct Node {
    int val;
    Node* left;
    Node* right;
    Node() {
        val = 0;
        left = NULL;
        right = NULL;    
    }
};
 
string preorder(Node *root) {
    string ans = "";
    ans += "V";
    if (root->left) {
        ans += "L";
        ans += preorder(root->left);
        ans +="l";
    }
    if(root->right) {
        ans += "R";
        ans += preorder(root->right);
        ans += "r";
    }
    ans += "v";
    return ans;
}
 
void remove(Node *root) {
    if (root->left) {
        remove(root->left);
    }
    if (root->right) {
        remove(root->right);
    }
    delete root;
}
 
int main() {
    int n, k;
 
    scanf("%d %d", &n, &k);
 
    set<string> s;
 
    while (n--) {
        vector<int> a(k);
        for (int i = 0; i < k; i++) {
            scanf("%d", &a[i]);
        }
 
        Node* root = new Node;
        root->val = a[0];
        for (int i = 1; i < k; i++) {
            Node* curr = root;
            while (1) {
                if (curr->val > a[i]) {
                    if (curr->left == NULL) {
                        curr->left = new Node();
                        curr->left->val = a[i];
                        break;
                    }
                    else {
                        curr = curr->left;
                    }
                }
                else if (curr->val < a[i]) {
                    if (curr->right == NULL) {
                        curr->right = new Node();
                        curr->right->val = a[i];
                        break;
                    }
                    else {
                        curr = curr->right;
                    }
 
                }else{
                    break;
                }
            }
        }
        s.insert(preorder(root));
        remove(root);
    }
    printf("%d", s.size());
    return 0;
}
Colored by Color Scripter
cs

54 ~ 88번째 줄 : 주어진 input 배열로 bst를 만든다. 현재 노드보다 값이 작다면 왼쪽에, 오른쪽에 값을 넣는다. 왼쪽이나 오른쪽에 이미 값이 있다면 그 노드로 이동하여, 해당 노드의 자식이 있는지를 파악한다. * 19~34번째 줄 : preorder로 순서를 찾는다. 방문했을 때 V, L, R 방문을 끝내고 나갈 때를 v,l,r로 표시했다.
89번째 줄 : preorder 함수에서 구한 값을 set에 넣어준다. set은 중복이 없는 값으로 구성된다.

아직 배움의 과정에 있는 학생이니 내용에 부족한 점이 보이면 지적은 하되, 비난은 하지 말아주세요!!

백준 1939 - 중량제한

2020-11-11T00:00:00+00:00

문제

백준 1939 - 중량제한 풀러가기

문제 풀이

이 문제의 해결 포인트는 2가지가 있다.

출발 공장에서 도착 공장으로 갈 수 있는가? - 그래프 문제다.
옮길 수 있는 중량의 최대값은 얼마인가? - 탐색 문제다.

1의 경우에는 bfs, dfs를 이용하여 갈 수 있냐/없냐를 판단하면 된다.

그렇다면 2의 경우는?

가능한 중량이 10억까지 있으므로, 하나하나 탐색을 하면 분명 시간 초과가 걸릴 것이다.

그래서 이분 탐색을 통해 문제를 해결하고자 한다.

w라는 무게가 통과할 수 있다면, w보다 작은 무게는 무조건 통과할 수 있으므로 w의 무게를 올린다.

w라는 무게가 통과할 수 없다면, w보다 큰 무게는 무조건 통과할 수 없으므로 w의 무게를 낮춘다.

문제 코드(C++)

전체 코드

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
#include <cstdio>
#include <vector>
#include <cstring>
 
using namespace std;
 
vector<vector<pair<int, int>>> a(10001);
bool visit[10001];
int st, dt;
 
bool go(int limit, int curr) {
 
    if (visit[curr]) {
        return false;
    }
    visit[curr] = true;
    if (curr == dt) {
        return true;
    }
    for (int i = 0; i < a[curr].size(); i++) {
        int next = a[curr][i].first;
        int weight = a[curr][i].second;
        if (weight >= limit) {
            if (go(limit, next)) {
                return true;
            }
        }
    }
 
    return false;
}
 
int main() {
    int n, m;
 
    scanf("%d %d", &n, &m);
 
    for (int i = 0; i < m; i++) {
        int s, d, w;
        scanf("%d %d %d", &s, &d, &w);
        a[s].push_back(make_pair(d, w));
        a[d].push_back(make_pair(s, w));
    }
 
    scanf("%d %d", &st, &dt);
 
    int left = 1;
    int right = 1000000000;
    int mid;
    int ans = 0;
    while (left <= right) {
        mid = (left + right) / 2;
        memset(visit, false, sizeof(visit));
        if (go(mid, st)) {
            ans = mid;
            left = mid + 1;
        }
        else {
            right = mid - 1;
        }
    }
 
    printf("%d", ans);
 
    return 0;
}
Colored by Color Scripter
cs

11~31번째 줄 : 일반적인 재귀를 이용한 dfs 코드에 중량을 체크하는 경우를 포함시킨다. 무조건 연결되어있다고 다음으로 갈 수 있는 것이 아니라, 중량 제한을 넘지 않아야 갈 수 있다.
54번째 줄 : 현재 무게를 통해 도착 공장까지 갈 수 있는 경우다. 이 경우에 정답을 현재 무게로 바꿔주고, 현재 무게보다 더 큰 무게가 가능한지 확인을 위해 left의 값을 증가시킨다.
59번째 줄 : 현재 무게를 통해 도착 공장까지 갈 수 없는 경우다. 이 경우에는 현재 무게를 낮춰야 하므로 right의 값을 감소시킨다.

아직 배움의 과정에 있는 학생이니 내용에 부족한 점이 보이면 지적은 하되, 비난은 하지 말아주세요!!

백준 2606 - 바이러스

2020-11-11T00:00:00+00:00

문제

백준 2606 - 바이러스 풀러가기

문제 풀이

이 문제를 보고 처음 떠오른 풀이는 연결 요소 를 구하듯이 푸는 것이다. (연결 요소에 대한 설명이 필요하다면)

그래서 bfs를 이용하여 손쉽게 풀 수 있었다.

두번째로 풀 수 있는 방법은 Union Find를 이용하는 것이다.

root가 같은지 확인하면 되기 때문이다.

문제 코드(C++)

전체 코드(bfs이용)

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
#include <cstdio>
#include <vector>
#include <queue>
 
using namespace std;
 
int main() {
    int n, p;
 
    scanf("%d", &n);
    scanf("%d", &p);
 
    vector<vector<int>> a(n+1);
    vector<bool> visit(n+1);
 
    for (int i = 0; i < p; i++) {
        int x, y;
        scanf("%d %d", &x, &y);
 
        a[x].push_back(y);
        a[y].push_back(x);
    }
 
    queue<int> q;
    q.push(1);
    visit[1] = true;
    int cnt = 0;
 
    while (!q.empty()) {
        int cur = q.front();
        q.pop();
        for (int i = 0; i < a[cur].size(); i++) {
            int next = a[cur][i];
            if (visit[next] == false) {
                cnt++;
                visit[next] = true;
                q.push(next);
            }
        }
    }
 
    printf("%d", cnt);
 
    return 0;
}
Colored by Color Scripter
cs

16~22번째 줄 : 인접 리스트를 통해 그래프를 표현했다. (인접리스트에 대한 설명이 필요하다면)
24~40번째 줄 : 정점 1부터 시작하여, 1에 연결된 정점들을 방문하고, 방문 시에 count를 증가시켜준다.

전체 코드(유니온 파인드 이용)

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
#include <cstdio>
#include <vector>
 
using namespace std;
 
vector<int> parent;
 
int Find(int x) {
    if (x == parent[x]) {
        return x;
    }
    else {
        parent[x] = Find(parent[x]);
        return parent[x];
    }
}
 
void Union(int x, int y) {
    x = Find(x);
    y = Find(y);
 
    if (x != y) {
        parent[y] = x;
    }
}
 
int main() {
    int n, p;
 
    scanf("%d", &n);
    scanf("%d", &p);
 
    parent.resize(n + 1);
 
    for (int i= 1; i <= n; i++) {
        parent[i] = i;
    }
 
    for (int i = 0; i < p; i++) {
        int x, y;
        scanf("%d %d", &x, &y);
        Union(x, y);
    }
    int ans = 0;
    int root = Find(1);
    for (int i = 2; i <= n; i++) {
        if (root == Find(i)) {
            ans++;
        }
    }
    printf("%d", ans);
 
    return 0;
}
cs

35~37번째 줄 : 처음에는 현재 요소를 parent로 초기화한다.
39~40번째 줄 : 연결 정보를 입력 받고, union을 통해 x와 y가 포함되어 있는 집합을 합친다.
45번째 줄 : 1의 root를 찾는다.
46~50번째 줄 : 위에서 찾은 root와 같은 root를 가지는 집합의 원소가 있다면 count를 증가시킨다.

아직 배움의 과정에 있는 학생이니 내용에 부족한 점이 보이면 지적은 하되, 비난은 하지 말아주세요!!

leetcode 517 - Super Washing Machines

2020-11-11T00:00:00+00:00

문제

leetcode 517 - Super Washing Machines 풀러가기

문제 코드(C++)

전체 코드

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
class Solution {
public:
    int findMinMoves(vector<int>& machines) {
        
        int s = machines.size();
        
        if(s==1){
            return 0;
        }
        
        int sum = accumulate(machines.begin(), machines.end(), 0);
        
        if(sum%s != 0){
            return -1;
        }
        
        int avg = sum/s;
        int tmp = 0;
        int ans = 0;
        
        for(int i=0;i<s;i++){
            tmp += machines[i]-avg;
            ans = max(max(abs(tmp), machines[i]-avg), ans);
        }
        
        return ans;
    }
};
Colored by Color Scripter
cs

11~15번째 줄 : 총 세탁물의 양을 구한 뒤, 모든 세탁기에 나눠떨어지지 않으면 -1을 return 한다.
21~24번째 줄 : 모든 세탁기를 순회하면서, 현재 세탁기의 세탁물의 양에서 평균 세탁 양을 빼고, 그 값을 tmp에 더한다.
- 이때, 현재 세탁물의 양이 평균 세탁물의 양 보다 작으면 -가 되므로 tmp값이 줄어든다.
- tmp의 절대값과 현재 세탁물의 양에서 평균을 뺀 값과, 지금까지의 정답을 비교하여 그 중 최대 값을 구한다.

Runtime: 16 ms, faster than 88.02% of C++ online submissions for Super Washing Machines.

Memory Usage: 13.4 MB, less than 20.31% of C++ online submissions for Super Washing Machines.

아직 배움의 과정에 있는 학생이니 내용에 부족한 점이 보이면 지적은 하되, 비난은 하지 말아주세요!!

leetcode 84 - Largest Rectangle in Histogram

2020-11-11T00:00:00+00:00

문제

leetcode 84 - Largest Rectangle in Histogram 풀러가기

문제 설명

이 문제는 워낙 유명한 문제다. 백준에도 똑같은 문제가 있다. (백준 6549 - 히스토그램에서 가장 큰 직사각형)

이 문제는 stack을 이용하여 풀 수 있다.

현재 막대의 높이를 s라고 하면, s를 높이로 하는 가장 큰 직사각형을 찾는다.

다음 막대가 현재 막대보다 크다면, 그곳에서도 s를 높이로 할 수 있다.
다음 막대가 현재 막대보다 작다면, 그곳에서는 s를 높이로 할 수 없다.

따라서, 현재 막대의 높이(위치 3)보다 높은 막대가 있으면 stack에 push하고, 작은 막대가 나오면(위치 6) 그 이전까지의 위치인 5를 이용하여 현재 막대의 높이인 3과 현재 stack의 top의 값인 5를 이용하여 가로 길이를 구한다. 그리고 그 가로 길이와 현재 막대의 높이를 곱해줘서 넓이를 구한다.

이런 식으로 반복을 해서 배열의 끝에 다다르면, stack에 남아있는 index들을 이용하여 넓이를 계산한다.

이번에는 stack의 현재 top의 index의 높이를 가지는 최대 넓이를 구하는데, 가로 길이는 현재 top의 바로 아래에 있는 index를 통해 구할 수 있다.

문제 코드(C++)

전체 코드

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
class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        
        if(heights.empty()){
            return 0;
        }
        
        stack<int> s;
        int max = 0;
        for(int i=0;i<heights.size();i++){
            while(!s.empty() && heights[i]<heights[s.top()]){
                int height = heights[s.top()];
                int width = i;
                s.pop();
                if(!s.empty()){
                    width = i-s.top()-1;
                }
                if(max < height*width){
                    max = height * width;
                }
            }
            s.push(i);
        }
        
        while(!s.empty()){
            int height = heights[s.top()];
            int width = heights.size();
            s.pop();
            if(!s.empty()){
               width = heights.size()-s.top()-1;
            }
            if(max < height*width){
                    max = height * width;
            }
        }
        
        return max;
    }
};
Colored by Color Scripter
cs

11~24번째 줄 : 배열의 모든 높이를 순회하면서, 현재 높이보다 작은 높이가 나올 때까지는 stack에 push하고 작은 높이가 나오면 넓이를 계산한다.(왼쪽에서 오른쪽으로 넓이 계산)
25~36번째 줄 : stack에 남은 인덱스들을 이용하여 이번에는 오른쪽에서 왼쪽으로 넓이를 계산한다.

Runtime: 20 ms, faster than 92.20% of C++ online submissions for Largest Rectangle in Histogram.

Memory Usage: 14.6 MB, less than 9.77% of C++ online submissions for Largest Rectangle in Histogram.

아직 배움의 과정에 있는 학생이니 내용에 부족한 점이 보이면 지적은 하되, 비난은 하지 말아주세요!!

leetcode 300 - Longest Increasing Subsequence

2020-11-10T00:00:00+00:00

문제

leetcode 51 - N-Queens 풀러가기

문제 분석

문제 분석

백준 11053 - 가장 긴 증가하는 부분 수열(LIS) 과 동일한 문제다.

문제 풀이(C++)

전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        
        if(nums.empty()){
            return 0;
        }
        
        vector<int> d(nums.size());
        
        for(int i = 0; i<nums.size();i++){
            d[i] = 1;
            for(int j =0;j<i;j++){
                if(nums[j]<nums[i] && d[i] < d[j]+1){
                    d[i] = d[j]+1;
                }
            }
        }
        
        return *max_element(d.begin(), d.end());
    }
};
Colored by Color Scripter
cs

Runtime: 80 ms, faster than 43.23% of C++ online submissions for Longest Increasing Subsequence.

Memory Usage: 8.1 MB, less than 7.80% of C++ online submissions for Longest Increasing Subsequence.

아직 배움의 과정에 있는 학생이니 내용에 부족한 점이 보이면 지적은 하되, 비난은 하지 말아주세요!!