출항사

[Kubernetes] Ingress

뱃싸공 — Tue, 15 Aug 2023 15:35:58 +0900

What is Ingress?

Kubernetes Ingress는 kubernetes cluster 내부에 존재하는 여러 service들을 cluster 외부의 client에게 HTTP, HTTPS로 노출하도록 도와준다.

Ingress는 cluster 내부의 여러 service들을 하나의 virtual IP address에 매핑하고, service에 접근하고자 하는 client들은 이 virtual IP address를 통해 service에 access할 수 있게 된다. Kubernetes Ingress를 통해 service에 접근하는 flow를 그림으로 나타내면 아래와 같다.

Ingress는 또한 Load Balancing, SSL 인증서 관리, Cache, 방화벽 설정 등의 기능을 제공하여 Client가 Service에 Access할 때, 성능과 보안을 향상시킨다. 이러한 기능들은 Kubernetes cluster 내부의 서비스를 외부에 노출할 때 발생할 수 있는 문제를 최소화하고, 서비스의 안정성과 확장성을 향상시키는데 도움을 준다.

Ingress와 다른 Service의 차이점

특정 service를 외부에 노출하는 방법으로 ingress만 있는 것은 아니다. 간략하게 이들의 특징을 비교해보면 아래와 같다.

1. NodePort

NodePort Service는 각 cluster node 자체의 port를 열고 해당 port로 트래픽을 전달한다.
NodePort Service는 Internal Cluster IP와 Port로 액세스할 수 있을 뿐만 아니라, 모든 노드의 전용 port로도 액세스를 할 수 있다.

2. LoadBalancer

LoadBalancer 기법은 kubernetes가 실행중인 cloud에서 제공하는 전용 LoadBalancer로 Service에 액세스하는 방법이다.
트래픽을 모든 node의 nodeport로 전달한다.
비용이 많이 든다.

3. Ingress

L7 (application Layer)에서 동작하기 때문에, 더 많은 기능을 쉽게 제공할 수 있다.
Ingress는 외부에서 Service에 액세스할 수 있게 해주는 GateWay 역할을 한다.
LoadBalancer와 비슷한 방식으로 동작하지만 더 유연하고 확장성이 높다.

Ingress 사용해보기

Ingress를 사용해보기 앞서, 아래와 같은 Service를 만들었다.

apiVersion: apps/v1
kind: ReplicaSet
metadata:
  name: ds4ouj
spec:
  replicas: 3
  selector:
    matchLabels:
      app: demo
  template:
    metadata:
      labels:
        app: demo
    spec:
      containers:
      - name: k8sdemo
        image: ds4ouj/k8s_demo
        ports:
        - containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
  name: demo-service
spec:
  type: NodePort
  selector:
    app: demo-app
  ports:
    - port: 8080
      targetPort: 8080

3개의 pod를 유지하는 replicaset과 이 replicaset의 pod들을 하나의 service로 묶어주는 설정이다.

이제 만들어진 서비스를 한번 확인해보면,

kubectl get svc

정상적으로 서비스가 생성된 것을 볼 수 있다. 이때, Cluster 내부에서 접근할 수 있는 Cluster-ip는 정상적으로 생성이 되었지만, External-ip는 none인 것을 볼 수 있다. 우리는 지금 서비스를 만들었지만, 이 서비스를 외부에 노출하지 않았기 때문에 당연한 결과이고, 그림으로 나타내보면 아래와 같은 상황이다.

이제 이 service를 외부로 expose하기 위한 Ingress를 생성해볼 것이다.

kubernetes에서 Ingress를 사용하기 위해서는 2가지 요소가 필요하다.

1. Ingress Object

Ingress를 정의한 YAML 파일이다.
외부에서 액세스할 수 있는 URL, 사용할 Port 번호, 트래픽을 전달할 Service, SSL 인증서 등을 설정한다.

2. Ingress Controller

Ingress Object를 해석하고, 필요한 설정을 적용하여 실제 외부에서 Service에 액세스할 수 있도록 하는 역할을 수행한다.
Nginx, Traefik, Istio 등으로 구현할 수 있다.

이제 Ingress를 구성해볼 것인데, 여기부터는 자신이 어떻게 kubernetes cluster를 구축했느냐에 따라 다르다.

sudo kubectl get po --all-namespaces

위의 명령어를 입력해보면, 아래와 같이 모든 namespace에 존재하는 pod를 볼 수 있다.

나는 k3s로 cluster를 구축했기 때문에 kube-system namespace를 보면 traefik이라는 pod가 띄워진 것을 볼 수 있다.
traefik은 k3s에서 제공하는 default ingress controller이기 때문에 띄워진 것이고, kubespray나 kubeadm을 사용했다면 nginx를 많이 사용하곤 한다.

이제 traefik을 ingress controller로 사용하도록 ingress object를 만들어보면 아래와 같다.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: demo-service-ingress
spec:
  ingressClassName: traefik
  rules:
    - host: "demo-service.local"
      http:
        paths:
          - path: /hello
            pathType: Prefix
            backend:
              service:
                name: demo-service
                port:
                  number: 8080

이 ingress object는 traefik이라는 ingress controller를 사용하고, demo-service.local이라는 hostname으로 들어오는 요청을 demo-service라는 service로 연결하도록 한 것이다.

sudo kubectl apply -f k8s-ingress-traefik.yaml

이제 위의 명령어를 사용해 ingress를 생성해보고, 아래의 명령어를 사용해 상세 정보를 확인해보자.

kubectl describe ingress [ingress name]

상세 정보를 확인해보면, demo-service.local가 host이고, /hello path에 대한 요청이 들어온다면 demo-service에게 요청을 전달한다는 설정대로 ingress와 service가 잘 연결된 것을 확인할 수 있다. 그림으로 보면 아래와 같다.

curl http://demo-service.local/hello

그러면 위의 명령어를 통해 진짜 요청을 한번 보내보자.

하지만, 아직 ingress가 요청을 받지 못하고 있다.
왜냐면 현재 curl 명령을 수행하는 host가 demo-service.local이라는 donmain name을 어떤 ip주소로 보내야할지 모르기 때문이다. 그래서 demo-service.local을 traefik의 IP로 routing하도록 또 DNS 설정을 해줘야 한다.

나의 경우 현재 192.168.49.132 ip 주소가 master node이기에 이 정보를 /etc/hosts 파일에 이 정보를 추가하였다.

이제 client는 demo-service.local이라는 domain으로 요청을 보내기 전, 이 hosts 파일을 먼저 확인한 후 host의 ip주소를 얻을 수 있어서 요청을 정상적으로 보낼 수 있게 되었다. 지금까지의 상황을 그림으로 나타내면 아래와 같다.

이제 다시 한번 해당 도메인으로 curl 요청을 보내보면,

위와 같이 정상적으로 OK를 응답받는 것을 볼 수 있다. 이제 원하는대로, ingress가 요청을 받아 내부의 service에게 routing하는 구조가 된 것이다.

Ref:

Ingress

Make your HTTP (or HTTPS) network service available using a protocol-aware configuration mechanism, that understands web concepts like URIs, hostnames, paths, and more. The Ingress concept lets you map traffic to different backends based on rules you defin

kubernetes.io

Traefik Ingress on arm64 K3s Kubernetes cluster.

Guide how to use Traefik in arm64 K3s Kubernetes cluster. Running DietPi 64bit on Raspberry Pi 4.

rpi4cluster.com

[Atcoder] ABC308 :: F - Vouchers

뱃싸공 — Tue, 4 Jul 2023 13:09:59 +0900

그리디로 풀 수 있는 문제이다.

N개의 아이템(P)이 주어지고, M개의 쿠폰 (L, D)가 주어진다. 이때 D <= L을 항상 만족하며, N개의 아이템에 M개의 쿠폰을 사용해서, 비용을 최소화해야 한다. 쿠폰을 사용하기 위해서는 L <= P을 만족해야 한다.

일단 가장 비싼 아이템 먼저 생각을 해보자. 그러면 떠올릴 수 있는 아이디어는 2가지인데,

1. D가 가장 큰 쿠폰을 사용한다. 2. L이 가장 큰 쿠폰을 사용한다. 이다. 하지만 이 두가지 접근법은 모두 정답을 보장할 수 없다는걸 어렵지 않게 파악할 수 있다.

그러면 가장 싼 아이템을 먼저 생각해볼 수 있고, 이때 P <= L인 모든 쿠폰 중 가장 D가 큰 쿠폰을 사용하면 최소의 비용을 보장할 수 있게 된다. 왜냐면 D <= L이라는 조건이 있기 때문이다. 만약 여기서 가장 할인율이 높은 쿠폰을 선택하지 않더라도, 이 쿠폰은 다음 아이템에 사용할 수 있게 되고 그러면 결국 할인되는 총 가격은 같은 값으로 수렴하게 된다. 따라서 매 순간마다 사용할 수 있는 쿠폰 중 D가 가장 큰 쿠폰을 선택하는 방법이 최선의 방법임을 보장하게 된다.

그래서 가장 싼 아이템부터 확인하면서 (L, D)를 PQ에 담고, 그때마다 가장 D가 큰 쿠폰을 사용하는 방식으로 구현하면 해결할 수 있다.

#include<iostream>
#include <queue>
#include <vector>
#include <algorithm>
#define X first
#define Y second
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
int N, M;
vector<ll> v, l, d;
priority_queue<pll> pq;
priority_queue<ll> p;


int main()
{
    cin >> N >> M;
    for (int i=0; i<N; i++) {
        ll x;
        cin >> x;
        v.push_back(x);
    }
    sort(v.begin(), v.end());
    for (int i=0; i<M; i++) {
        ll x;
        cin >> x;
        l.push_back(x);
    }
    for (int i=0; i<M; i++) {
        ll x;
        cin >> x;
        d.push_back(x);
    }
    
    for (int i=0; i<M; i++) {
        ll x = l[i], y = d[i];
        pq.push({-x, y});
    }
    
    ll answer = 0;
    for (int i=0; i<N; i++) {
        ll num = v[i];
        while (!pq.empty()) {
            ll x = -pq.top().X, y = pq.top().Y;
            if (x > num) break;
            pq.pop();
            p.push(y);
        }
        
        if (p.empty()) {
            answer += num;
        } else {
            auto t = p.top();
            p.pop();
            answer += (num - t);
        }
    }
    cout << answer << '\n';
}

[AtCoder] ABC308

뱃싸공 — Tue, 4 Jul 2023 12:34:54 +0900

E가 꽤나 어렵게 느껴졌고, 그냥 넘어가서 F를 잡을걸 그랬다. C에서 3WA를 받았는데, double로 연산하면 터져버리는 케이스가 있었던 것 같다.

A - 2:17

단순 구현 문제이다. 8개의 숫자가 들어오고, 모든 숫자가 25의 배수인지 그리고 각 숫자가 100 ~ 675 이내의 차이를 가지고 있는지 확인하면 된다. 하나라도 만족하지 않을 경우 No를 출력하자.

#include <iostream>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <stack>
#include <cstring>
#define X first
#define Y second
#define NUM 21
using namespace std;
vector<int> v;
bool flag = true;

int main() {
    for (int i=0; i<8; i++) {
        int x;
        cin >> x;
        v.push_back(x);
    }

    for (int i=0; i<8; i++) {
        if (i != 0) {
            if (v[i] < v[i-1]) flag = false;
        }
        if (v[i] < 100 || v[i] > 675) flag = false;
        if (v[i] % 25 != 0) flag = false;
    }

    if (flag) {
        cout << "Yes" << '\n';
    } else {
        cout << "No" << '\n';
    }

}

B - 9:17

내가 궁금한 string이 들어오고, string별 price가 주어진다. 만약 이 price가 주어지지 않은 문자열이 있다면 P0의 값을 더하면 된다. map을 이용하면 아주 간단하게 해결할 수 있는 문제이다. 해석을 대충하고 넘어갔다가 문제를 괜히 2번 읽었다.

#include <iostream>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <stack>
#include <cstring>
#define X first
#define Y second
#define NUM 21
using namespace std;
int N, M;
vector<string> v, vv;
map<string,int> mp;

int main() {
    cin >> N >> M;
    for (int i=0; i<N; i++) {
        string s;
        cin >> s;
        v.push_back(s);
    }

    for (int i=0; i<M; i++) {
        string ss;
        cin >> ss;
        vv.push_back(ss);
    }

    int cost;
    cin >> cost;

    for (int i=0; i<M; i++) {
        int c;
        cin >> c;
        mp[vv[i]] = c;
    }
    int answer = 0;

    for (int i=0; i<N; i++) {
        string s = v[i];
        if (mp[s] != 0) {
            answer += mp[s];
        } else {
            answer += cost;
        }
    }
    cout << answer << '\n';
}

C - 20:27

아주 간단한 정렬 문제이다. Ai, Bi가 N개 주어질때, Ai / (Ai + Bi)를 기준으로 내림차순 정렬을 수행하고 만약 이 값이 같다면 입력받은 순서로 오름차순으로 정렬하면 된다.

double로 풀었는데 자꾸 틀려서 long double을 넣어봤는데 풀렸다.

#include <iostream>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <stack>
#include <cstring>
#define X first
#define Y second
#define NUM 21
using namespace std;
typedef pair<int, long double> pid;
int N, M;

vector<pid> v;

bool compare(pid a, pid b) {
    if (a.Y == b.Y) {
        return a.X < b.X;
    }
    return a.Y > b.Y;
}

int main() {
    cin >> N;
    for (int i=1; i<=N; i++) {
        long double a, b;
        cin >> a >> b;
        v.push_back({i, a / (a + b)});
    }    

    sort(v.begin(), v.end(), compare);
    for (auto vv : v) {
        cout << vv.X << ' ';
    }
}

D - 33:37

(1, 1)부터 (H, W)로 이동하려고 한다. 이때 각 칸마다 알파벳이 들어있는데, 무조건 s -> n -> u -> k -> e 을 밟으면서 이동을 해야한다. 주어진 알파벳이 5개뿐이므로, 방문 배열을 3차원으로 잡아 BFS를 돌려볼 수 있다. visited[i][j][k]를 i알파벳을 밟고 j, k에 도달할 수 있는지?로 기준을 잡아서 풀었다.

그런데 지금 다시보니 그럴 필요가 없어보인다. 이미 각 칸에 대해 알파벳이 정해져있고 그냥 순서대로 갈 수 있는지만 보면 될 것 같다.

#include <iostream>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <stack>
#include <cstring>
#define X first
#define Y second
#define NUM 21
using namespace std;
typedef pair<int, long double> pid;
typedef pair<int, int> pii;
typedef pair<pii, int> piii;
bool visited[5][510][510] = {false};
vector<char> ch = {'s', 'n', 'u', 'k', 'e'};
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int h, w;
vector<string> graph;
bool flag = false;
queue<piii> q;

void bfs() {
    q.push({{0, 0}, 0});
    visited[0][0][0] = true;
    while (!q.empty()) {
        auto curr = q.front();
        int x = curr.X.X, y = curr.X.Y, d = curr.Y;
        q.pop();
        for (int i=0; i<4; i++) {
            int nx = x + dx[i];
            int ny = y + dy[i];
            int nd = (d + 1) % 5;
            if (nx < 0 || nx >= h || ny < 0 || ny >= w || visited[nd][nx][ny] || graph[nx][ny] != ch[nd]) continue;
            visited[nd][nx][ny] = true;
            q.push({{nx, ny}, nd});
        }
    }
}

int main() {
    cin >> h >> w;
    for (int i=0; i<h; i++) {
        string s;
        cin >> s;
        graph.push_back(s);
    }

    if (graph[0][0] == 's') {
        bfs();
    }
    for (int i=0; i<5; i++) {
        if (visited[i][h-1][w-1]) flag = true;
    }
    if (flag) {
        cout << "Yes" << '\n';
    } else {
        cout << "No" << '\n';
    }
}

[AtCoder] ABC307

뱃싸공 — Sat, 24 Jun 2023 22:49:47 +0900

C가 왤캐 복잡한 빡구현이 나온지 모르겠지만, 망했다 ㅠ 너무 풀기 싫게 생겼다.

근데 저번 305때는 4솔이였는데 그때보다 등수가 더 높다. C가 좀 어렵긴 했나보다. E도 하필 조합론이 나왔고, 좀 나랑 안맞았던 셋 같다.
그래도 업솔빙 하면서 조합론을 연습해봐야 할것 같다. 문제가 너무 코드포스 같았다

A - 3:40

7개씩 숫자를 묶어서 더한 후 출력하면 된다.

#include <iostream>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <cstring>
#define X first
#define Y second
#define NUM 200010
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
int ans[11];

int main()
{
    memset(ans, 0, sizeof(ans));
    int n;
    cin >> n;
    for (int i=0; i<n*7; i++) {
        int x;
        cin >> x;
        ans[i/7] += x;
    }
    for (int i=0; i<n; i++) {
        cout << ans[i] << " ";
    }
    
}

B - 7:35

(i, j) 문자열을 더했을때 펠린드롬인지 확인하는 문제이다.

#include <iostream>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <cstring>
#define X first
#define Y second
#define NUM 200010
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
int n;
vector<string> v;

int main() {
    cin >> n;
    for (int i=0; i<n; i++) {
        string s;
        cin >> s;
        v.push_back(s);
    }
    bool flag = false;
    for (int i=0; i<n; i++) {
        for (int j=0; j<n; j++) {
            if (i != j) {
                string s1 = v[i] + v[j];
                reverse(s1.begin(), s1.end());
                string s2 = v[i] + v[j];

                if (s1 == s2) {
                    flag = true;
                }
            }
        }
    }
    
    if (flag) {
        cout << "Yes" << '\n';
    }
    else {
        cout << "No" << '\n';
    }
}

C - 업솔빙

D - 27:27

흔한 스택문제이다. 열고 닫는거만 신경쓰면 된다.

#include <iostream>
#include <queue>
#include <vector>
#include <set>
#include <map>
#include <algorithm>
#include <string>
#include <stack>
#include <cstring>
#define X first
#define Y second
#define NUM 31
using namespace std;
stack<char> s;
string answer = "";
int main() {
    int n;
    cin >> n;
    for (int i=0; i<n; i++) {
        char c;
        cin >> c;
        if (c == '(') {
            s.push(c);
        }
        else if (c == ')') {
            if (s.empty()) {
                answer += ')';
            } else {
                while (!s.empty()) {
                    char cc = s.top();
                    if (cc == '(') {
                        s.pop();
                        break;
                    }
                    s.pop();
                }
            }
        }
        else {
            if (s.empty()) {
                answer += c;
            } else {
                s.push(c);
            }
        }
    }
    string res = "";
    while (!s.empty()) {
        res += s.top();
        s.pop();
    }
    reverse(res.begin(), res.end());
    cout << answer + res << '\n';
}

E - 업솔빙

[Atcoder] ABC306 :: D - Poisonous Full-Course

뱃싸공 — Mon, 19 Jun 2023 13:00:37 +0900

DP로 해결할 수 있는 문제이다.
각 음식은 0과 1로 주어지는데, 연속해서 1을 먹을 수가 없다고 한다. 그리고 음식을 먹지 않고 skip을 할 수도 있다.
1을 먹은 상태에서 0을 먹으면 상태가 0으로 변한다. 그래서 직관적으로 0인 음식은 무조건 먹으면 되겠네.. 싶지만 음수가 주어질 수도 있다.

따라서 최근 먹은 음식이 0인지 1인지의 경우의 수로 나누고 점화식을 세워볼 수 있다.

DP[i][j] = i 상태이고 j번째 음식까지 먹었을때의 최댓값으로 설정하자.
그다음 각 음식의 상태에 따라 점화식을 2개 만들 수 있는데, 현재 음식이 0인 경우와 1인 경우로 나눠보자.
현재 i번째 음식이 0이라면, DP[0][i-1], DP[1][i-1] 중 최댓값과 현재 음식의 만족도를 더한 값을 DP[0][i]에 갱신해주면 된다. 이때 i 음식의 만족도가 음수일 수도 있으므로 DP[0][i-1]도 DP[0][i]의 후보가 될 수 있다.

현재 i번째 음식이 1이라면, DP[0][i-1] 음식만 정답의 후보가 될 수 있다. 왜냐면 1을 연속해서 먹을 수 없기 때문이다. 그리고 i번째 음식이 음수일 수도 있으므로, skip한 경우도 정답의 후보로 추가할 수 있다.

이 점화식을 구현하면 된다.

#include<iostream>
#include <cstring>
#include <map>
#include <vector>
#include <algorithm>
#define X first
#define Y second
using namespace std;
typedef long long ll;
int N;
ll DP[2][300010], foods[300010];
bool isOk[300010];


int main() {
    memset(isOk, false, sizeof(isOk));
    memset(DP, 0, sizeof(DP));
    cin >> N;
    for (int i=1; i<=N; i++) {
        int x, y;
        cin >> x >> y;
        if (x == 0) isOk[i] = true;
        foods[i] = y;
    }
    
    for (int i=1; i<=N; i++) {
        if (isOk[i]) {
            DP[0][i] = max({DP[0][i-1] + foods[i], DP[1][i-1] + foods[i], DP[0][i-1]});
            DP[1][i] = DP[1][i-1];
        } else {
            DP[1][i] = max({DP[0][i-1] + foods[i], DP[1][i-1]});
            DP[0][i] = max({DP[0][i-1]});
        }
    }
    cout << max(DP[0][N], DP[1][N]) << '\n';
}

[Atcoder] ABC306 :: C - Centers

뱃싸공 — Mon, 19 Jun 2023 12:40:05 +0900

간단한 정렬 문제이다.
N이 주어지고 3 * N개의 입력으로 숫자들이 입력된다. 이때 i (1 <= i <= N)에 속하는 숫자들은 반드시 3번 입력이 된다.

이때, 각 i가 2번째로 입력되는 인덱스를 기준으로, 정렬을 해서 출력을 하라고 한다.
N이 1e5이하이므로, O(N) 짜리 배열을 하나 만들고, 각 숫자가 몇번 입력되었는지 count하자. 2번째로 입력된 순간 vector에 넣고 인덱스를 기준으로 정렬을 하면 된다.

#include<iostream>
#include <cstring>
#include <map>
#include <vector>
#include <algorithm>
#define X first
#define Y second
using namespace std;
int N, cnt[100010];
typedef pair<int, int> pii;
vector<pii> v;

bool compare(pii a, pii b) {
    return a.Y < b.Y;
}

int main() {
    cin >> N;
    for (int i=0; i<3*N; i++) {
        int x;
        cin >> x;
        cnt[x]++;
        if (cnt[x] == 2) {
            v.push_back({x, i});
        }
    }
    sort(v.begin(), v.end(), compare);
    for (auto curr : v) {
        cout << curr.X << ' ';
    }
}

[Atcoder] ABC302 :: E - Isolation

뱃싸공 — Thu, 15 Jun 2023 12:44:54 +0900

set 자료구조를 잘 써야 하는 문제이다.

N개의 노드가 존재하고, 초기 상태는 어떠한 간선도 존재하지 않는다. 그리고 이제부터 Q개의 쿼리를 입력받게 된다.
쿼리의 개수는 2개인데, 1번 쿼리의 경우 간선을 연결하고 2번 쿼리의 경우 특정 노드와 연결된 모든 간선을 끊는 연산을 수행해야 한다. 각 쿼리를 수행할때 마다 어떠한 노드와도 연결되지 않은 노드의 개수를 출력해야 한다.

N, Q <= 300000이므로, 제한이 꽤나 크다. 처음에는 오프라인 쿼리 + 유니온 파인드로 접근했으나, 이 방법으로는 해결할 수 없다. 뒤에서 부터 본다고 해서 연산 횟수가 줄어들지 않기 때문이다.

각 노드를 기준으로 연결된 노드들을 set으로 관리한다고 생각해보자. 그리고 초기에는 모든 노드가 연결되어 있지 않으므로 answer = n으로 선언하고, answer를 출력하기로 하자.

answer가 변하는 순간은 명확하다. 간선을 연결할때 처음으로 간선이 생기는 노드가 있다면? 과 노드와 연결된 모든 간선을 끊는 경우이다.
이 두가지 케이스를 set으로 쉽게 관리할 수 있고, 이 경계선에 조건문을 걸어 answer를 업데이트하면 된다.

시간복잡도는 쿼리별로 set을 조회하기 때문에 O(QlogN)로 잡을 수 있다.

#include<iostream>
#include <algorithm>
#include <map>
#include <set>
#include <vector>
using namespace std;
int n, m;
set<int> v[300010];

int main()
{
    cin >> n >> m;
    int answer = n;
    for (int i=0; i<m; i++) {
        int x, y, z;
        cin >> x;
        if (x == 1) {
            cin >> y >> z;
            if (v[y].size() == 0) {
                answer--;
            }
            if (v[z].size() == 0 ) {
                answer--;
            }
            v[y].insert(z);
            v[z].insert(y);
            
        } 
        else {
            cin >> y;        
            for (auto next : v[y]) {
                v[next].erase(y);
                if (v[next].size() == 0) answer++;
            }
            if (v[y].size() > 0 ) answer++;
            v[y].clear();
        }
        cout << answer << '\n';
    }
    return 0;
}

[Atcoder] ABC302 :: D - Impartial Gift

뱃싸공 — Tue, 13 Jun 2023 12:50:52 +0900

A배열에 N개의 선물이 들어오고, B 배열에 M개의 선물이 들어온다고 한다.
우리가 구하고 싶은 값은 A배열과 B배열에서 임의로 선물을 하나씩 선택했을때, abs(A - B) <= D인 선물을 찾고, 이중 가장 큰 합을 구하면 된다. 만약 없다면 -1을 출력하면 된다.

배열의 크기는 둘다 2e5이기 때문에 2중 for문은 힘들고 효율적으로 해결을 해야하는데, A를 기준으로 생각해보자.
A라는 배열에 들어있는 어떤 a라는 값이 있을때, a가 정답의 후보가 되기 위해서는 B 배열에서 a-D보다 크고 a + D보다 작은 값들을 보면 된다. 그리고 우리는 이 경계에 있는 값만 확인하면 된다. abs(a - b)의 최댓값을 찾으면 되기 때문이다.

따라서 lower_bound와 upper_bound를 적절히 사용해서 경계에 있는 값을 찾은 후 이중 최댓값을 찾으면 된다. 그리고 이는 시간복잡도 O(NlogM)에 해결할 수 있다.

#include<iostream>
#include <cstring>
#include <vector>
#include <algorithm>
#include <map>
#define NUM 200010
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
int n, m;
ll d;
vector<ll> A, B;

ll answer = -1;

int main() {
    cin >> n >> m >> d;
    for (int i=0; i<n; i++) {
        ll x;
        cin >> x;
        A.push_back(x);
    }
    for (int i=0; i<m; i++) {
        ll x;
        cin >> x;
        B.push_back(x);
    }
    
    sort(A.begin(), A.end());
    sort(B.begin(), B.end());
    for (int i=0; i<A.size(); i++) {
        ll a = A[i];
        int idx = lower_bound(B.begin(), B.end(), a - d) - B.begin();
        if (abs(a - B[idx]) <= d) {
            answer = max(answer, a + B[idx]);
        }
        idx = upper_bound(B.begin(), B.end(), a + d) - B.begin();
        
        if (abs(a - B[idx-1]) <= d) {
            answer = max(answer, a + B[idx-1]);
        }
        
    }
    cout << answer << '\n';
}

[Atcoder] ABC305 :: E - Art Gallery on Graph

뱃싸공 — Mon, 12 Jun 2023 12:49:44 +0900

약간의 테크닉이 필요한 그래프 탐색 문제였다.

그래프가 주어지고, K개의 특별한 노드가 주어진다. 이 특별한 노드는 가드가 존재하는데, 이 가드는 자신과의 거리가 h 미만인 노드들을 지킬 수 있다는 상황이 주어진다. 이때 가드에 의해 보호받을 수 있는 노드의 총 개수와 번호를 출력해야 하는 문제이다.

그래서 나는 다익스트라로 문제를 접근했다.
가드가 지키고 있는 노드들을 전부 우선순위 큐에 때려박고, 순차적으로 탐색을 할 것이다. 이때 우선순위 큐에서 꺼내는 정렬 기준은 '남은 h의 크기'로 잡았다.

왜냐하면 초기 K에 속하지 않는 어떤 P라는 노드가 있다고 가정해보자. 이 P라는 노드에 도달할 수 있는 방법은 여러가지가 존재할 수도 있는데, 우리는 이 P라는 노드에 도달할 수 있으면서 h가 가장 크게 남아있는 경우만 찾으면 된다. 그 이외의 값들은 가장 큰 h에 의해 무시해도 되기 때문이다.

이러한 로직으로 접근을 해봤을때 각 노드는 딱 한번만 접근하고 모든 간선을 한번씩 타지만, 방문을 표시하는 부분 때문에 간선의 개수는 M개를 넘어서게 되고, O((N+M) log(N+M))에 해결할 수 있다.

주의할 점은 방문을 언제 표시할 것인가? 이다.
나는 방문을 표시할 순간을 잘못 나타내서 풀지 못했는데, 이 부분만 조금 유의해서 생각해보면 크게 어렵지 않은 문제였다.

#include<iostream>
#include <vector>
#include <algorithm>
#include <queue>
#define X first
#define Y second
#define NUM 200010
using namespace std;
typedef pair<int, int> pii;
int N, M, K;
bool visited[NUM];
vector<int> adj[NUM];
priority_queue<pii> pq;

int main() {
    memset(visited, false, sizeof(visited));
    cin >> N >> M >> K;
    
    for (int i=0; i<M; i++) {
        int x, y;
        cin >> x >> y;
        adj[x].push_back(y);
        adj[y].push_back(x);
    }
    
    for (int i=0; i<K; i++) {
        int p, h;
        cin >> p >> h;
        pq.push({h, p});
    }
    
    while (!pq.empty()) {
        auto curr = pq.top();
        pq.pop();
        if (curr.X < 0 || visited[curr.Y]) continue;
        visited[curr.Y] = true;
        for (int next: adj[curr.Y]) {
            if(visited[next]) continue;
            pq.push({curr.X - 1, next});
        }
    }
    int cnt = 0;
    for (int i=1; i<=N; i++) {
        if (visited[i]) cnt++;
    }
    cout << cnt << '\n';
    for (int i=1; i<=N; i++) {
        if (visited[i]) {
            cout << i << ' ';
        }
    }
}

[AtCoder] ABC305

뱃싸공 — Sat, 10 Jun 2023 23:08:06 +0900

음.. C에서 조금 말려가지고 아쉽다. D도 조금 해매고.. E는 조금 신박했는데 왜 안뚫리는지 모르겠다.
그래도 문제는 전반적으로 재밌었던 것 같다.

A - 4:32

N이 주어질때, 가장 가까운 5의 배수 숫자를 찾으면 된다.

#include <iostream>
#include <cmath>
#include <vector>
#include <set>
#include <queue>
#include <algorithm>
#define MINF 0x7f7f7f7f
#define INF 300000000000001
#define MOD 10007
#define NUM 200010
#define X first
#define Y second
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<int, ll> pil;
typedef pair<pii, int> piii;
typedef pair<piii, int> piiii;
typedef pair<ll, ll> pll;
typedef pair<pll, ll> plll;
typedef pair<pll, string> plls;

int psum[4000000];
vector<int>  a, b;
vector<pii> v;


void init(){
    int x;
    cin >> x;
    int answer = 1e9;
    int dist = 1e9;
    for (int i=0; i<=100; i++) {
        if (i == 0 || i % 5 == 0) {
            // cout << i << " " << dist << " " << abs(i-x) << " " << answer << '\n';
            if (abs(i - x) < dist) {
                answer = i;
                dist = abs(i-x);
            }
        }
        
    }
    cout << answer << '\n';
}

int main() {
	ios_base :: sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	init();
}

B - 10:55

A - B, B - C, C - D ... 의 간격간 더해야 하는 숫자가 주어져있다.

우리는 P, Q를 입력받아 이들 사이에 있는 간격을 전부 더하면 된다. 어케 간단하게 구현할까..를 고민하다가 그냥 알파벳을 숫자로 치환해서 범위를 계산하는 코드를 직접 짜서 해결했다. 그냥 무지성 구현을 했으면 더 빨랐을 것 같다.

#include <iostream>
#include <cmath>
#include <vector>
#include <set>
#include <queue>
#include <algorithm>
#include <map>
#define MINF 0x7f7f7f7f
#define INF 300000000000001
#define MOD 10007
#define NUM 200010
#define X first
#define Y second
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<int, ll> pil;
typedef pair<pii, int> piii;
typedef pair<piii, int> piiii;
typedef pair<ll, ll> pll;
typedef pair<pll, ll> plll;
typedef pair<pll, string> plls;

map<char, int> mp;

void init(){
    mp['A'] = 0;
    mp['B'] = 1;
    mp['C'] = 2;
    mp['D'] = 3;
    mp['E'] = 4;
    mp['F'] = 5;
    mp['G'] = 6;
    
    char a, b;
    cin >> a >> b;

    int x = min(mp[a], mp[b]), y = max(mp[a], mp[b]);

    int answer = 0;
    if (x <= 0 && y >= 1) {
        answer += 3;
    }
    if (x <= 1 && y >= 2) {
        answer += 1;
    }
    if (x <= 2 && y >= 3) {
        answer += 4;
    }
    if (x <= 3 && y >= 4) {
        answer += 1;
    }
    if (x <= 4 && y >= 5) {
        answer += 5;
    }
    if (x <= 5 && y >= 6) {
        answer += 9;
    }
    cout << answer << '\n';
}

int main() {
	ios_base :: sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	init();
}

C - 28:48

H, W로 주어진 격자판에 연속으로 색칠 된 어떤 직사각형이 존재한다.

우리가 구해야 하는 것은 이 직사각형 중 어떤 한 칸이 비어있을때, 이 칸의 좌표를 구하는 것이다.
이게 생각보다 좀 귀찮은데.. 나는 '#'을 기준으로 4방향에 전부 +1을 더해줬다. 그리고 2중 for문을 돌면서 2이상의 값인 칸이 있다면 해당 칸은 무조건 직사각형에 속하면서 공백인 칸이 보장이 되므로, 이 칸의 좌표를 출력해주면 된다.

#include <iostream>
#include <cmath>
#include <vector>
#include <set>
#include <queue>
#include <algorithm>
#include <map>
#define MINF 0x7f7f7f7f
#define INF 300000000000001
#define MOD 10007
#define NUM 200010
#define X first
#define Y second
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<int, ll> pil;
typedef pair<pii, int> piii;
typedef pair<piii, int> piiii;
typedef pair<ll, ll> pll;
typedef pair<pll, ll> plll;
typedef pair<pll, string> plls;
int n, m;
vector<string> v;
int psum[510][510];
int dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};
int ax, ay;

void init(){
    memset(psum, 0, sizeof(psum));

    cin >> n >> m;
    for (int i=0; i<n; i++) {
        string s;
        cin >> s;
        v.push_back(s);
    }

    for (int i=0; i<n; i++) {
        for (int j=0; j<m; j++) {
            if (v[i][j] == '.') continue;
            int x = i+1, y = j+1;
            for (int k=0; k<4; k++) {
                int nx = x + dx[k], ny = y + dy[k];
                if (nx < 0 || ny < 0 || nx > n || ny > m) continue;
                if (v[nx-1][ny-1] == '#') continue;
                psum[nx][ny]++;
            }
        }
    }

    for (int i=0; i<=n; i++) {
        for (int j=0; j<=m; j++) {
            if (psum[i][j] > 1) ax = i, ay = j;
        }
    }

    cout << ax << " " << ay << '\n';
}   

int main() {
	ios_base :: sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	init();
}

D - 55:38

홀수번째 주어지는 칸은 잠을 자기 시작한 시간이고, 짝수번째 주어지는 시간은 잠에서 깬 시간이라고 한다.
이때 Q개의 쿼리가 [left, right] 형태로 주어지는데 left ~ right 사이에 잠을 잔 시간을 구하는 문제이다.

제한이 매우 크기 때문에 단순 배열로는 못풀고, 일단 누적합을 이용해야 한다.
그래서 입력을 받을때, 짝수번째 숫자에서 누적합을 위한 배열을 채워나가자. 이때 숫자의 범위가 너무 크므로 좌표 압축을 수행하게 된다.

그리고 이분 탐색을 통해 left와 right가 홀수번째 숫자인지를 알아야 한다. 이에 따라 구해야 하는 기준이 달라지기 때문이다.

그위의 그림에서 left가 약 250인 경우와 230인 경우 두가지를 생각해보자. 만약 240보다 작다면 upper_bound를 사용해서 240의 좌표를 이용한 누적합을 구해야 한다.
반대로 250인 경우에는 240을 기준으로 잡으면서 250 - 240의 만큼을 해당 누적합에서 빼야한다. 이 규칙을 찾았다면 쉽게 해결이 된다.

#include <iostream>
#include <cmath>
#include <vector>
#include <set>
#include <queue>
#include <algorithm>
#include <map>
#define MINF 0x7f7f7f7f
#define INF 300000000000001
#define MOD 10007
#define NUM 200010
#define X first
#define Y second
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<int, ll> pil;
typedef pair<pii, int> piii;
typedef pair<piii, int> piiii;
typedef pair<ll, ll> pll;
typedef pair<pll, ll> plll;
typedef pair<pll, string> plls;
int n;
vector<ll> v;
int q;
ll psum[200010];

void init(){
    memset(psum, 0, sizeof(psum));
    cin >> n;
    for (int i=0; i<n; i++) {
        ll x;
        cin >> x;
        v.push_back(x);
        if (i % 2 == 0) {
            if (i != 0) {
                psum[i] = x - v[i - 1];
            }
        }
    }

    for (int i=0; i<=n; i++) psum[i] += psum[i-1];
    cin >> q;
    for (int i=0; i<q; i++) {
        ll answer = 0;
        
        ll x, y;
        cin >> x >> y;
        
        int left, right;
        int l = upper_bound(v.begin(), v.end(), x) - v.begin();
        int r = lower_bound(v.begin(), v.end(), y) - v.begin();


        if (l % 2 == 0) {
            answer += v[l] - x;
            left = l;

        } else {
            left = l;
        }

        if (r % 2 == 0) {
            answer += y - v[r-1];
            right = r-1;
        } else {
            right = r;
        }


        answer += psum[right] - psum[left];
        cout << answer << '\n';
    }
}   


int main() {
	ios_base :: sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	init();
}

E - 업솔빙

[Atcoder] ABC305 :: E - Art Gallery on Graph

약간의 테크닉이 필요한 그래프 탐색 문제였다. 그래프가 주어지고, K개의 특별한 노드가 주어진다. 이 특별한 노드는 가드가 존재하는데, 이 가드는 자신과의 거리가 h 미만인 노드들을 지킬 수

jojaeng2.tistory.com