thisisuser's study

BOJ 11011. Forged Answer

thisisuserr — Fri, 13 Sep 2024 11:58:10 +0900

11011번: Forged Answers (acmicpc.net)

solved.ac: Gold I (2024.09.13)

아이디어 하나가 필요한 그리디 문제입니다.

문제를 요약하면, 답지를 조작해서 세 사람의 점수 중 가장 낮은 값을 최대로 끌어올리는 문제입니다.

다음과 같이 각 문제를 분류할 수 있습니다.

세 사람 다 동일한 답안을 낸 경우
두 사람이 동일한 답안을 내고, 한 사람은 다른 답안을 낸 경우
세 사람 모두 다른 답안을 낸 경우

1번의 경우, 당연히 다 맞게 하는 게 최적입니다. 이는 너무나 자명합니다.

3번의 경우 원하는 사람의 점수를 1 올릴 수 있습니다.

2번의 경우가 조금 특이합니다. 여기서는 두 사람의 점수를 1 올리거나, 한 사람의 점수를 1 올릴 수 있습니다.

일단 솔직히 좀 난해합니다. 다음과 같이 그림을 그리겠습니다.

아직 3번 문제는 고려하지 않았습니다.

연보라색은 1번의 경우, 나머지는 2번의 경우이며 같은 색깔은 두 학생이 같은 제출을 내었음을 의미합니다.

일단 모두 두 명이 점수를 얻도록 구성하였습니다. 높이는 점수와 비례하며, 같은 색깔 블록의 높이는 동일해야 합니다.

여기서 항상 저런 꼴이 나올 수 있는 이유는, 2번 문제의 경우 학생을 고려하면 3가지 경우가 나옵니다. (1, 2), (1, 3), (2, 3)

각 문제의 개수를 a, b, c라 하면 학생을 바꿈으로써 a >= b >= c를 만들 수 있고, a + b >= a + c >= b + c이므로 항상 가능합니다.

(Without Loss Of Generality)

이제 약간의 케이스워크를 해 봅시다.

1. 3번 문제가 충분함

진한 보라색이 3번 문제입니다.

이 경우, 당연하게도 낮은 사람 먼저 채워주고, 나머지는 3등분하면 됩니다.

최댓값은 그냥 싹 더해서 3으로 나누어 주면 됩니다.

2. 약간 부족함

2번 문제에서 같은 색깔 블록 하나씩 뺀 다음에 나머지를 추가할 수는 있겠습니다만,

어떤 블록을 빼던 낮은 점수를 가진 학생의 점수가 1 감소합니다.

문제 하나를 빼서 할당할 수 있는 점수는 고작 1이기 때문에, 의미없는 행동입니다.

따라서 그냥 점수가 낮은 두 학생에 골고루 채워주면 됩니다.

이 경우 최댓값은 (1번 막대 + 2번 막대 + 3번 문제 수) / 2입니다.

3. 많이 부족함

이 경우, 빨간색 블록의 높이를 줄인 만큼 가장 왼쪽의 막대를 늘릴 수 있습니다.

항상 3번째 블록이 2번째 블록보단 높게 되므로, 잠시 무시하고 1번째와 2번째 막대만 관찰해 봅시다.

2번 막대가 1 내려가면, 1번 막대가 1 올라가게 됩니다.

어떻게 적당히 잘 맞췄다고 가정하면, 이후로는 2번의 케이스가 됩니다. 더 이상 진행하지 않아도 문제 없습니다.

따라서 이 경우 (1번 막대 + 2번 막대 + 3번 문제 수) / 2가 됩니다.

이제 구현 좀 해 주면 됩니다.

여담으로 2번 맞왜틀을 했는데, else if 까먹어서 틀린 거였습니다, 이런.

#include <iostream>
#include <string>
#include <algorithm>

using namespace std;

int solve()
{
  int n;
  string arr[3];

  cin >> n;
  for(int i = 0; i < 3; i++) cin >> arr[i];

  int a = 0, b[3] = {0, 0, 0}, c = 0;
  for(int i = 0; i < n; i++)
    {
      if(arr[0][i] == arr[1][i] && arr[1][i] == arr[2][i]) a++;
      else
      {
        if(arr[0][i] == arr[1][i]) b[0]++;
        else if(arr[1][i] == arr[2][i]) b[1]++;
        else if(arr[2][i] == arr[0][i]) b[2]++;
        else c++;
      }
    }

  int res[3] = {a, a, a};
  for(int i = 0; i < 3; i++)
    {
      res[i] += b[i];
      res[(i + 1) % 3] += b[i];
    }
  sort(res, res + 3);

  if(res[0] + res[1] + c >= res[2] * 2)
  {
    int rem = c - (res[2] - res[1]) - (res[2] - res[0]);
    return res[2] + rem / 3;
  }
  else return (res[0] + res[1] + c) / 2;
}

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0);

  int T;
  cin >> T;
  while(T--)
    {
      cout << solve() << "\n";
    }
}

BOJ 13576. Prefix와 Suffix

thisisuserr — Tue, 10 Sep 2024 13:43:54 +0900

13576번: Prefix와 Suffix (acmicpc.net)

solved.ac: Platinum II (2024.09.10)

꽤나 흥미롭게 풀었던 문제입니다.

배울 점이 많은 문제라고 생각합니다.

1. Prefix이자 Suffix인 substr 구하기

처음엔 전체 문자열 하나 잡고, 앞으로 계속 lcp랑 len이랑 다를 때까지 탐색하면 되지 않을 까 생각했습니다.

그러나 BBAABB같은 문자열을 생각해 보면, 씨알도 안 먹히는 소리임을 알 수 있습니다.

처음엔 쌩 SA + LCP만 가지고 풀어보려 했으나, 능지 이슈로 이건 아직도 모르겠습니다.

그래서 그냥 실패함수 가져다 썼습니다. 조건을 만족시키는 substr의 길이는 fail(len)을 반복적으로 수행하여 얻을 수 있습니다.

2. 그래서 문자열 나타는 거 어케 확인함?

어떤 문자열에 대해서, 문자열이 나타나는 지의 여부를 판단하는 방법을 생각해 봅시다.

문자열 S에 대해 S[i]를 i번째 글자부터 시작하는 접미사라 생각해 보면,

모든 접미사에 대해 해당 문자열이 접두사가 되는 지 확인하면 됩니다.

물론 나이브하게 구현하면 당연히 노답임을 알 수 있습니다. 우리가 접두사인지 판단해 보는 문자열도 접미사임을 상기합시다.

확인하고자 하는 접미사 T와 다른 접미사에 대해 공통 접두사의 길이가 len(T)라면, 그 접미사는 T를 접두사로 갖습니다.

이때 T를 접두사로 갖는 접미사 A와 다른 접미사 B에 대해, 공통 접두사의 길이가 len(T) 이상이라면,

B 역시 T를 접두사로 갖는 접미사임을 알 수 있게 됩니다.

여기까지 왔다면 뭘 써야 하는지는 지레짐작이 갑니다. 접미사 배열을 만들어야 합니다.

접미사 배열은 정렬되어 있으므로, 인접한 두 접미사끼리 LCP를 비교하면서 한 번이라도 길이가 len(T) 미만으로 간다?

그 이후의 문자열은 볼 필요도 없습니다. 딱 거기까지만 개수를 세면 됩니다.

map 등을 이용해서 길이를 통해 인덱스를 O(logN) 미만으로 구할 수 있게 구성하면,

N이 10만으로 상당히 애매하기 때문에 O(N²)이 어떻게 잘 통과됩니다. 2초라서 7억 번 정도는 잘 돌아가는 것 같습니다.

아래는 첫 풀이입니다. (1540ms)

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <cstring>
#include <map>

using namespace std;

/* returns pair of suffix array, lcp array. lcp range = [0, n - 1] */
pair<vector<int>, vector<int>> sa_lcp(string str)
{
  int n = str.length(), d = 1;
  vector<int> pos(n), sa(n), lcp(n - 1), tmp(n);

  auto cmp = [&n, &d, &pos](int i, int j)
  {
    if(pos[i] != pos[j]) return pos[i] < pos[j];
    i += d; j += d;
    return (i < n && j < n) ? (pos[i] < pos[j]) : (i > j);
  };

  //struct suffix array
  for(int i = 0; i < n; i++) sa[i] = i, pos[i] = str[i];
  for(d = 1; ; d <<= 1)
    {
      sort(sa.begin(), sa.end(), cmp);
      for(auto &i: tmp) i = 0;
      for(int i = 0; i < n - 1; i++)
        {
          tmp[i + 1] = tmp[i];
          if(cmp(sa[i], sa[i + 1]) == true) tmp[i + 1]++;
        }
      for(int i = 0; i < n; i++) pos[sa[i]] = tmp[i];

      //모든 접미사가 서로 다른 그룹에 존재
      if(tmp[n - 1] == n - 1) break;
    }

  //struct LCP array
  for(int i = 0, k = 0; i < n; i++, k = max(k - 1, 0))
    {
      //마지막 접미사, 비교할 접미사 존재하지 않음
      if(pos[i] == n - 1) continue;
      //다음 그룹의 접미사
      for(int j = sa[pos[i] + 1]; str[i + k] == str[j + k]; k++);
      lcp[pos[i]] = k;
    }

  return {sa, lcp};
}

vector<int> failureFunction(string substr)
{
  int sublen = substr.length();
  vector<int> pi(sublen);
  int prefix = 0;
  for(int suffix = 1; suffix < sublen; suffix++)
    {
      while(prefix > 0 && substr[prefix] != substr[suffix]) prefix = pi[prefix - 1];
      if(substr[prefix] == substr[suffix]) pi[suffix] = ++prefix;
    }
  return pi;
}

/* len -> i */
map<int, int> idx;

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0);

  string str;
  cin >> str;

  int n = str.length();
  auto arrays = sa_lcp(str);
  auto sa = arrays.first, lcp = arrays.second;
  lcp.push_back(0);

  auto fail = failureFunction(str);
  for(int i = 0; i < n; i++) idx[n - sa[i]] = i;
  
  vector<pair<int, int>> res;
  int len = n;
  while(len)
    {
      int i = idx[len];
      int cnt = 0;
      while(lcp[i + cnt] >= len) cnt++;
      res.push_back({len, cnt + 1});
      len = fail[len - 1];
    }
  
  sort(res.begin(), res.end());

  cout << res.size() << '\n';
  for(auto ans: res)
    {
      cout << ans.first << ' ' << ans.second << '\n';
    }
}

3. 개억지로 푼 거 아님?

일단 풀기는 했지만, 상당히 불-편합니다.

애초에 N 제한부터 O(N²) 풀이를 의도한 것은 아님을 알 수 있습니다.

물론 뭐 세그트리라던가 세그트리라던가 세그트리같은 걸 끼워팔아서 O(NlogN)으로 줄일 수는 있겠지만,

이 문제는 약간의 관점 전환으로 훨씬 간단히 해결할 수 있습니다.

문제에서 확인할 문자열은 접두사이사 접미사인 부분 문자열들입니다.

여기서 접두사라는 사실에 조금 주목을 해 보면, 길이 L의 부분 문자열에 대해서,

전체 문자열과 각각의 접미사에 대해 LCP가 L 이상이면 해당 접미사의 맨 처음 인덱스에서 매칭이 가능함을 알 수 있습니다.

미리 길이들을 다 구해놨다고 하면, 필요한 것은 '각각의 접미사에 대한 전체 문자열과의 LCP 길이'입니다.

이는 Z 알고리즘으로 선형 시간에 구할 수 있습니다.

Z array를 활용하면, 사실 실패함수로 길이를 구하지 않아도 됩니다.

문제의 조건에서 접두사이자 접미사인 문자열의 길이를 요구하고 있고, 각각의 접미사에 대해

접두사의 길이와 접미사의 길이가 같다면, 즉 i + z[i] == n이면 구하는 길이는 z[i]가 됩니다.

LCP의 길이가 L 이상인 접미사의 개수, 이건 그냥 누적합으로 간단히 구할 수 있습니다.

아래는 2차 코드입니다. 실행 시간은 16ms로 확 줄었습니다.

#include <iostream>
#include <vector>
#include <algorithm>
#include <string>

using namespace std;

/* Z array: 각각의 접미사에 대한 공통 접두사 길이 */
vector<int> zFunction(string &str)
{
  int n = str.length();
  vector<int> z(n);

  z[0] = n;
  int l = 0, r = 0;
  for(int i = 1; i < n; i++)
    {
      if(i < r) z[i] = min(z[i - l], r - i);
      while(i + z[i] < n && str[z[i]] == str[i + z[i]]) z[i]++;
      if(i + z[i] > r) l = i, r = i + z[i];
    }
  return z;
}

int cnt[100001];

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0);

  string str;
  cin >> str;

  int n = str.length();
  auto z = zFunction(str);

  for(int i = 0; i < n; i++) cnt[z[i]]++;
  for(int i = n - 1; i >= 0; i--) cnt[i] += cnt[i + 1];

  vector<pair<int, int>> res;
  for(int i = n - 1; i >= 0; i--)
    {
      if(i + z[i] == n) res.push_back({n - i, cnt[z[i]]});
    }

  cout << res.size() << '\n';
  for(auto pi: res) cout << pi.first << ' ' << pi.second << '\n';
}

BOJ 19651. 수열과 쿼리 39

thisisuserr — Wed, 4 Sep 2024 21:06:11 +0900

19651번: 수열과 쿼리 39 (acmicpc.net)

solved.ac: Diamond V (2024.09.06)

나이브하게 처리하는 것은 상당히 노답이므로, 문제를 변형시킬 필요가 있습니다.

등차수열에서 주로 사용되는 성질로 A[i-1] + A[i+1] = 2A[i]를 이용합시다.

새로운 배열을 생각해서 B[i] = A[i-1] + A[i+1] - 2A[i]이라 하면,

세 수 A[i-1], A[i], A[i+1]가 등차수열을 이룰 시 B[i] = 0이 됩니다.

따라서 쿼리의 답은 (연속해서 0인 B[i]의 개수) + 2가 됩니다. 이는 금광세그 트릭을 이용하면 구할 수 있습니다.

업데이트의 경우 세 수가 모두 포함되거나 포함되지 않을 경우 변화량은 없으므로,

쿼리 [s, e]에 대해 B[s - 1], B[s], B[e], B[e + 1]만 업데이트됩니다.

자세한 풀이는 코드를 참고해 주세요.

#include <iostream>
#include <vector>

using namespace std;
typedef long long int LL;

/*
B[i] = A[i-1] + A[i+1] - 2A[i]로 정의하면, (연속한 0의 개수 + 2)를 구하는 문제로 바뀐다.
구간 [s, e]에 (x + nd)를 더한다고 해 보자.

B[s - 1] = A[s - 2] + A[s] - 2A[s - 1]에서, 변화량은 x이다.
B[s] = A[s - 1] + A[s + 1] - 2A[s]에서, 변화량은 d - x이다.

B[e] = A[e - 1] + A[e + 1] - 2A[e]에서, 변화량은 (s - e - 1)d - x이다.
B[e + 1] = A[e] + A[e + 2] - 2A[e + 1]에서, 변화량은 (e - s)d + x이다.
*/

/* 연속한 0의 개수 관리: 금광 세그 */
struct seg
{
bool all;
int lmax, rmax, mx, sz;
};

LL arr[400001];
seg tree[400001];

seg merge(seg &l, seg &r)
{
  seg res;
  res.all = l.all && r.all;
  res.lmax = (l.all ? l.sz + r.lmax : l.lmax);
  res.rmax = (r.all ? l.rmax + r.sz : r.rmax);
  res.mx = max(max(l.mx, r.mx), l.rmax + r.lmax);
  res.sz = l.sz + r.sz;
  return res;
}

void update(int node, int s, int e, int idx, int val)
{
  if(idx < s || e < idx) return;
  if(s == e) // update
  {
    arr[node] += val;
    tree[node].sz = 1;
    
    if(arr[node] == 0)
    {
      tree[node].lmax = 1; tree[node].rmax = 1; 
      tree[node].mx = 1;   tree[node].all = true;
    }
    else
    {
      tree[node].lmax = 0; tree[node].rmax = 0;
      tree[node].mx = 0;   tree[node].all = false;
    }
    return;
  }

  int m = (s + e) / 2;
  update(node * 2, s, m, idx, val);
  update(node * 2 + 1, m + 1, e, idx, val);

  tree[node] = merge(tree[node * 2], tree[node * 2 + 1]);
}

seg query(int node, int s, int e, int l, int r)
{
  if(r < s || e < l) return {true, 0, 0, 0, 0};
  if(l <= s && e <= r) return tree[node];

  int m = (s + e) / 2;
  seg left = query(node * 2, s, m, l, r);
  seg right = query(node * 2 + 1, m + 1, e, l, r);
  return merge(left, right);
}

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0);

  int n;
  cin >> n;

  vector<int> init(n + 1);
  for(int i = 1; i <= n; i++) cin >> init[i];
  for(int i = 2; i < n; i++) update(1, 1, n, i, init[i - 1] + init[i + 1] - 2 * init[i]);

  int Q;
  cin >> Q;
  while(Q--)
    {
      int op;
      cin >> op;

      if(op == 1)
      {
        int s, e, x, d;
        cin >> s >> e >> x >> d;

        update(1, 1, n, s - 1, x);
        update(1, 1, n, s, d - x);
        update(1, 1, n, e, (s - e - 1) * d - x);
        update(1, 1, n, e + 1, (e - s) * d + x);
      }
      else
      {
        int l, r;
        cin >> l >> r;
        cout << query(1, 1, n, l + 1, r - 1).mx + 2 << '\n';
      }
    }
}

BOJ 12963. 달리기

thisisuserr — Tue, 3 Sep 2024 12:33:27 +0900

12963번: 달리기 (acmicpc.net)

solved.ac: Platinum 3 (2024.09.06)

플로우 안 쓰는 플로우 문제입니다.

일단 문제를 딱 보자마자 최대 유량 문제구나를 파악할 수 있는데 범위가 노답입니다.

최대 유량을 구하는 문제이므로 최소 컷을 구해야 함을 알 수 있습니다.

이때 용량이 특수하게 주어지므로, 다음을 이용합시다.

1. 최대 유량을 흘렸을 때, 유량이 존재하는 간선을 모두 제거하면 보낼 수 있는 유량은 0이다.
2. i번 간선에 유량이 흐른다면 이 유량으로 0번부터 i-1번 간선에 모두 유량을 보낼 수 있다.

0번 간선에서 N-1번 간선까지의 어떠한 경로가 존재한다면, 유량은 당연히 가장 작은 간선의 용량이 될 것입니다.

또한 2번에 의해, 여러 개의 경로가 존재할 때 일부 간선이 겹쳐도 전혀 문제될 게 없습니다.

만약 모든 간선을 연결해도 두 정점이 연결되지 않는다면, 당연히 유량은 0입니다.

이제 어떠한 간선이 있고, 해당 간선을 연결하면 0번과 N-1번 정점이 연결된다고 가정해 보겠습니다.

그래프 상에서 현재 최소 용량 간선은 연결되어 있지 않다고 가정해 보겠습니다.

그렇다면 0번 정점과 N-1번 정점을 잇는 또 다른 경로를 찾았다고 하면, 다음과 같이 일반화가 가능합니다.

만약 색칠된 간선의 용량이 가장 작고, a에 충분히 보내도 될 만큼의 유량이 흐른다면,

전체 유량은 이전에 미리 빼두었던 간선의 용량과 현재 칠해진 간선의 유량의 합이 됩니다.

충분히 보내도 될 만큼의 유량이 흐른다, 이는 위의 2번 정리를 이용하면 될 것 같습니다.

아래 그림에서 빨간색 간선의 용량이 파란색 간선의 용량보다 크다면, 빨간색 간선을 통해 흘린 유량은 두 파란 간선에 모두 흘리고도 남습니다.

다음으로 어떠한 간선으로 연결을 시도했을 때 두 정점이 연결이 된다. 이때 용량은 가장 작아야 한다.

잠깐만 생각해보면 그냥 간선 용량을 큰 것부터 연결해 보면 됨을 알 수 있습니다. 이렇게 구성하면 충분히 보내도 될 만큼의 유량이 흐르는 것도 자연스럽게 만들어지게 됩니다.

어떤 간선을 연결했을 때 0번 정점과 N-1번 정점이 연결되는가?

이는 분리 집합 자료구조를 이용하면 알 수 있습니다.

확인하려는 간선이 잇는 두 정점을 p, q라 하면,

(0과 p, q와 n-1이 연결되어 있다) or (0과 q, p와 n-1이 연결되어 있다) 를 만족시키면 연결되는 간선임을 알 수 있습니다.

구현은 꽤나 간단합니다.

#include <iostream>
#include <vector>

using namespace std;
typedef long long int LL;
const LL mod = 1e9+7;

/* Disjoint Set */
int parent[2001];

void init()
{
  for(int i = 0; i < 2001; i++) parent[i] = i;
}

int find(int x)
{
  if(parent[x] == x) return x;
  else return parent[x] = find(parent[x]);
}

void merge(int p, int q)
{
  p = find(p);
  q = find(q);
  if(p != q) parent[q] = p;
}

struct edge
{
LL cost;
int p, q;
};

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0);

  int n, m;
  cin >> n >> m;

  vector<edge> edges;
  init();

  LL cur = 1;
  for(int i = 0; i < m; i++)
    {
      int p, q;
      cin >> p >> q;
      edges.push_back({cur, p, q});
      cur = (cur * 3) % mod;
    }

  LL res = 0;
  for(int i = m - 1; i >= 0; i--)
    {
      LL cost = edges[i].cost;
      LL p = edges[i].p, q = edges[i].q;

      if((find(p) == find(0) && find(q) == find(n - 1)) || (find(p) == find(n - 1) && find(q) == find(0)))
      {
        res = (res + cost) % mod;
      }
      else merge(p, q);
    }
  cout << res;
}

BOJ 17501. 수식 트리

thisisuserr — Fri, 30 Aug 2024 08:50:39 +0900

솔직히 왜 골드2인지 모르겠는 문제. 간단한 트리 DP?를 통해 해결했다.

문제

solved.ac: Gold II (2024.09.06)

어차피 식을 모두 합치면, (a1 + a2 + ... ) - (b1 + b2 + ... ) 꼴이 될 것이다.

따라서 최대한 작은 수들을 빼면 된다. 이건 정렬 + 그리디로 된다.

어떤 서브트리와 두 서브트리에서 빼야 하는 노드의 개수를 각각 A, B개라 하자.

만약 현재 노드가 +라면, 이 서브트리에서 빼야 하는 노드의 개수는 자명히 A + B개가 된다.

반면 현재 노드가 -라면, 원래 빼야 했던 노드는 다 더해지고, 원래 더해야 했던 노드들이 빼지게 된다.

따라서 우측 서브트리의 트리 크기를 sz라 하면, 빼야 하는 노드의 개수는 A + (sz - B)개가 된다.

그러면 총 빼야 하는 노드의 수 s를 구할 수 있고, 오름차순 정렬 후 앞에서부터 s개는 빼고, 나머지는 더하면 된다.

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

int n;
int dp[200001], sz[200001];
string tree[200001];

int child[200001][2];

void DP(int cur)
{
  if(cur <= n)
  {
    sz[cur] = 1;
    dp[cur] = 0;
    return;
  }

  int l = child[cur][0], r = child[cur][1];
  DP(l); DP(r);

  sz[cur] = sz[l] + sz[r];
  if(tree[cur] == "+") dp[cur] = dp[l] + dp[r];
  else dp[cur] = dp[l] + (sz[r] - dp[r]);
}

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0);

  cin >> n;

  vector<int> arr(n);
  for(int i = 0; i < n; i++) cin >> arr[i];
  for(int i = n + 1; i < 2 * n; i++) cin >> tree[i] >> child[i][0] >> child[i][1];

  DP(2 * n - 1);
  sort(arr.begin(), arr.end());

  int res = 0, idx = dp[2 * n - 1];
  for(int i = 0; i < n; i++)
    {
      if(i < idx) res -= arr[i];
      else res += arr[i];
    }
  cout << res;
}

BOJ 11378. 열혈강호 4

thisisuserr — Tue, 27 Aug 2024 12:06:45 +0900

11378번: 열혈강호 4 (acmicpc.net)

solved.ac: Platinum III (2024.09.10)

문제에서 시키는 대로 모델링하고 맞을 수 있다.

모델링 방법이 조금씩 다른 것 같긴 하다. 본인은 다음과 같이 모델링했다.

#include <iostream>
#include <vector>
#include <queue>
#include <cstring>

using namespace std;
const int INF = 1e9;

vector<int> node[2005];
int capacity[2005][2005];
int flow[2005][2005];

int networkFlow(int source, int sink)
{
  int res = 0;
  int parent[2005];

  while(1)
    {
      memset(parent, -1, sizeof(parent));
      queue<int> q;
      parent[source] = source;
      q.push(source);

      while(!q.empty() && parent[sink] == -1)
        {
          int cur = q.front();
          q.pop();

          for(auto nxt: node[cur])
            {
              if(capacity[cur][nxt] > flow[cur][nxt] && parent[nxt] == -1)
              {
                parent[nxt] = cur;
                q.push(nxt);
              }
            }
        }
      if(parent[sink] == -1) break;

      int amount = INF;
      for(int cur = sink; cur != source; cur = parent[cur])
        {
          int prv = parent[cur];
          amount = min(amount, capacity[prv][cur] - flow[prv][cur]);
        }
      for(int cur = sink; cur != source; cur = parent[cur])
        {
          int prv = parent[cur];
          flow[prv][cur] += amount;
          flow[cur][prv] -= amount;
        }
      res += amount;
    }
  return res;
}

void addNode(int from, int to, int cap, bool is_inv = false)
{
  node[from].push_back(to);
  node[to].push_back(from);
  capacity[from][to] += cap;
  if(is_inv) capacity[to][from] += cap;
}

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0);

  int source = 2001, sink = 2002, punish = 2003;
  int n, m, k;
  cin >> n >> m >> k;

  addNode(source, punish, k);
  for(int i = 1; i <= n; i++)
    {
      addNode(source, i, 1);
      addNode(punish, i, k);
    }
  for(int i = 1; i <= m; i++) addNode(i + 1000, sink, 1);
  for(int i = 1; i <= n; i++)
    {
      int sz;
      cin >> sz;
      while(sz--)
        {
          int nxt;
          cin >> nxt;
          addNode(i, nxt + 1000, 1);
        }
    }
  cout << networkFlow(source, sink);
}

BOJ 1867. 돌멩이 제거

thisisuserr — Tue, 27 Aug 2024 10:17:30 +0900

1867번: 돌멩이 제거 (acmicpc.net)
solved.ac: Platinum III (2024.09.10)

a행 b열에 놓인 돌멩이를 제거하기 위해서는 a행을 쓸거나 b열을 쓸어야 한다.

그래프로 환원시키면, 1~n행과 1~m행 정점을 만들어 놓고,

간선을 돌로 정의해서, 해당 간선이 잇는 두 정점 중 하나가 색칠되면 된다라고 할 수 있다.

예제

여기서는 1행을 쓸고, 2열을 쓸면 된다. 그래프로 나타내면, 다음과 같다.

즉, 문제를 재정의하면 이분 그래프에서 최소한의 정점으로 모든 간선을 칠하는 방법을 찾는 문제가 된다.

이는 최소 정점 커버 문제 (Minimum Vertex Cover)로 알려져 있고, 이분 그래프의 경우 다항 시간 해법이 존재한다.

결론부터 말하면, 이분 그래프에서 최소 정점 커버의 해답은 이분 매칭의 최대 수와 동일하다.

이는 쾨닉의 정리(Konig's Theorem)로 잘 알려져 있다.

증명은 꽤나 어려워 보인다. 나중에 다시 공부해 봐야겠다.

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

/* 0 - based */

bool dfs(int cur, vector<vector<int>> &node, vector<int> &fromB, vector<bool> &vis)
{
  for(auto nxt: node[cur])
    {
      if(vis[nxt]) continue;
      vis[nxt] = true;

      if(fromB[nxt] == -1 || dfs(fromB[nxt], node, fromB, vis))
      {
        fromB[nxt] = cur;
        return true;
      }
    }
  return false;
}

vector<pair<int, int>> BipartiteMatch(vector<vector<int>> &node)
{
  int n = node.size();
  vector<int> fromB(n, -1);
  vector<bool> vis(n);

  for(int i = 0; i < n; i++)
    {
      vis.assign(n, false);
      dfs(i, node, fromB, vis);
    }

  vector<pair<int, int>> res;
  for(int i = 0; i < n; i++) if(fromB[i] != -1) res.push_back({fromB[i], i});
  sort(res.begin(), res.end());
  return res;
}

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0);

  int n, k;
  cin >> n >> k;

  vector<vector<int>> node(2 * n);
  for(int i = 0; i < k; i++)
    {
      int x, y;
      cin >> x >> y;
      x--; y--;

      node[x].push_back(y + n);
    }
  cout << BipartiteMatch(node).size();
}

BOJ 11012. Egg

thisisuserr — Mon, 26 Aug 2024 22:54:38 +0900

11012번: Egg (acmicpc.net)

solved.ac: Platinum II (2024.09.10)

각 직사각형별로 경계 또는 내부에 있는 점의 수를 세어 더하는 문제다.

예제 2번 테스트케이스.

일단 직사각형을 하나씩 구해 보는 건 당연히 불가능할 것임을 짐작할 수 있다.

조금 생각을 바꿔서, 각 점별로 세지는 횟수를 구해 보자.

점별로 구하기 위해서는, 해당 점에 몇 개의 직사각형이 겹쳐 있는 지 파악해야 한다.

왼쪽부터 훑으면서 직사각형을 관리하는 것은 스위핑 기법이 잘 알려져 있다.

다음과 같이 직사각형의 시작과 끝을 구분해 보자. 푸른 색이 새로운 직사각형 시작, 빨간 색이 직사각형 끝이다.

이제 왼쪽부터 스위핑을 하면서, 구간 업데이트를 통해 해당 위치에서의 직사각형 개수를 구하면 된다.

이는 lazyprop 세그트리를 이용하면 간단히 구할 수 있다.

마지막으로 두 번째 위치에서 쿼리 순서를 결정해야 하는 부분이 있다.

어떤 경계에서 직사각형이 끝난다 해도, 해당 위치에 점이 있다면 그 끝나는 직사각형에 걸치게 되므로

직사각형 종료 쿼리는 점 계산 쿼리보다 나중에 진행해야 한다.

즉, 동일한 x좌표의 쿼리에 우선순위를 매기면 다음과 같다.

새로운 직사각형 생성
점의 위치에 따른 직사각형 개수 계산
직사각형 종료

이제 구현만 하면 끝난다. 코드는 다음과 같다.

#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>

using namespace std;
typedef long long int LL;

LL tree[400001], lazy[400001];

void propagate(int node, int s, int e)
{
  if(!lazy[node]) return;

  tree[node] += (e - s + 1) * lazy[node];
  if(s != e)
  {
    lazy[node * 2] += lazy[node];
    lazy[node * 2 + 1] += lazy[node];
  }
  lazy[node] = 0;
}

LL update(int node, int s, int e, int l, int r, int val)
{
  propagate(node, s, e);

  if(r < s || e < l) return tree[node];
  if(l <= s && e <= r)
  {
    tree[node] += val * (e - s + 1);
    if(s != e)
    {
      lazy[node * 2] += val;
      lazy[node * 2 + 1] += val;
    }
    return tree[node];
  }

  int m = (s + e) / 2;
  LL left = update(node * 2, s, m, l, r, val);
  LL right = update(node * 2 + 1, m + 1, e, l, r, val);
  return tree[node] = left + right;
}

LL query(int node, int s, int e, int idx)
{
  propagate(node, s, e);
  if(idx < s || e < idx) return 0;
  if(s == e) return tree[node];

  int m = (s + e) / 2;
  LL left = query(node * 2, s, m, idx);
  LL right = query(node * 2 + 1, m + 1, e, idx);
  return left + right;
}

void init()
{
  memset(tree, 0, sizeof(tree));
  memset(lazy, 0, sizeof(lazy));
}

struct Query
{
int op;
int x, y1, y2;

bool operator< (const Query &l)
{
  if(x != l.x) return x < l.x;
  return op > l.op;
}
};

void solve()
{
  init();
  int n, m;
  cin >> n >> m;

  vector<Query> arr;
  while(n--)
    {
      int x, y;
      cin >> x >> y;
      arr.push_back({0, x, y, y});
    }
  while(m--)
    {
      int x1, x2, y1, y2;
      cin >> x1 >> x2 >> y1 >> y2;

      arr.push_back({1, x1, y1, y2});
      arr.push_back({-1, x2, y1, y2});
    }
  sort(arr.begin(), arr.end());

  LL res = 0;
  for(auto i: arr)
    {
      int op = i.op;
      int y1 = i.y1, y2 = i.y2;

      if(op == 0) res += query(1, 0, 100000, y1);
      else update(1, 0, 100000, y1, y2, op);
    }
  cout << res << '\n';
}

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0);

  int T;
  cin >> T;
  while(T--) solve();
}

여담

그래서 이거 왜돼요

BOJ 7626. 직사각형

thisisuserr — Mon, 26 Aug 2024 21:23:08 +0900

https://www.acmicpc.net/problem/7626

solved.ac: Platinum I (2024.09.10)

직사각형이 여러 개가 주어질 때 합집합의 넓이를 구하라는 문제다.

참 별 게 다 웰노운이다 싶다.

일단 x축 기준으로 쭉 정렬한 다음, 세로 선분들을 관리해주고 대충 스위핑질해주는 풀이이다.

세그먼트 트리 사용이 조금 특이하긴 하다.

두 가지 변수를 관리해주는데, 구간별 누적 길이랑 전체를 덮은 횟수를 기록해 준다.

전체를 덮은 횟수가 1 이상이라면 해당 구간의 값은 전체 길이와 동일하다.

그렇지 않다면 두 자식 노드로 쪼개고 그 합을 구하여 해결한다.

범위가 크니 좌표 압축을 해 주어야 한다.

딱히 쓸 게 없네요

#include <iostream>
#include <vector>
#include <algorithm>
#include <map>

using namespace std;
typedef long long int LL;

struct line
{
LL x;
LL y1, y2;
int val;

bool operator< (const line& l){return x < l.x;}
};

vector<line> lines;
vector<LL> comp;

LL tree[2000001], cnt[2000001];

void update(int node, int s, int e, int l, int r, int val)
{
  if(r < s || e < l) return;
  if(l <= s && e <= r) cnt[node] += val;
  else
  {
    int m = (s + e) / 2;
    update(node * 2, s, m, l, r, val);
    update(node * 2 + 1, m + 1, e, l, r, val);
  }

  if(cnt[node]) tree[node] = comp[e] - comp[s - 1];
  else
  {
    if(s == e) tree[node] = 0;
    else tree[node] = tree[node * 2] + tree[node * 2 + 1];
  }
}

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0);

  int n;
  cin >> n;
  for(int i = 0; i < n; i++)
    {
      LL x1, x2, y1, y2;
      cin >> x1 >> x2 >> y1 >> y2;

      lines.push_back({x1, y1, y2, 1});
      lines.push_back({x2, y1, y2, -1});
      comp.push_back(y1);
      comp.push_back(y2);
    }

  sort(comp.begin(), comp.end());
  comp.erase(unique(comp.begin(), comp.end()), comp.end());

  sort(lines.begin(), lines.end());

  LL res = 0;
  line prv = lines[0];

  for(int i = 0; i < 2 * n; i++)
    {
      line cur = lines[i];
      LL dx = cur.x - prv.x;
      res += tree[1] * dx;

      LL s = lower_bound(comp.begin(), comp.end(), cur.y1) - comp.begin();
      LL e = lower_bound(comp.begin(), comp.end(), cur.y2) - comp.begin();
      update(1, 1, comp.size() + 1, s + 1, e, cur.val);
      prv = cur;
    }
  cout << res;
}

Aho-Corasick 알고리즘

thisisuserr — Mon, 26 Aug 2024 10:08:55 +0900

간단히 말해 트라이 위에서 KMP를 수행하는 알고리즘이다.

짤막하게 트라이와 KMP를 짚어보고 넘어가겠다.

1. 트라이(Trie)

N개의 길이 M 문자열 리스트가 있을 때, 어떤 문자열이 해당 리스트에 포함되어 있는 지 판단하는 알고리즘을 짠다고 하자.

Naive하게 짜면 $O(NM)$일 것이고, 여기서 더 줄일 수 있는 방법은 딱히 없어 보인다.

(정렬을 하면 $O(MlogN)$으로 줄어들긴 하겠지만, 그 과정이 애초에 비효율적이다.)

트라이는 트리 자료구조에서 착안하여, 무려 $O(M)$에 찾을 수 있도록 구성해준 것이다.

기본적으로 다음과 같이, 트리를 따라 리프 노드까지 쭉 따라가면서 순서대로 합친 것을 문자열로 생각한다.

보통 포인터를 활용하여 구성한다. 아래는 트라이 코드의 일부이다.

struct node
{
node* c[26]; //자식노드
int cnt; //자식노드 개수
bool fin; //단어의 끝 성분인가

node()
{
  for(int i=0;i<26;i++) c[i]=NULL;
  cnt=0; fin=false;
}
~node()
{
  for(int i=0;i<26;i++) if(c[i]!=NULL) delete c[i];
}

void insert(string &s, int idx)
{
  if(idx==s.length()) //더 이상 넣을 문자가 없다(현재 노드가 단어의 끝)
  {
    fin=true;
    return;
  }
  if(c[s[idx]-'a']==NULL)
  {
    c[s[idx]-'a']=new node();
    cnt++;
  }
  c[s[idx]-'a']->insert(s,idx+1);
}
};

2. KMP 알고리즘

어떤 문자열이 다른 문자열의 부분 문자열인 지를 $O(N+M)$에 탐색할 수 있도록 하는 알고리즘이다.

실패 함수라는 개념이 필요한데, 각각의 접두사 문자열에 대해 접두사와 접미사가 같아지는 최대 길이(전체 빼고)를 기록한다.

이걸 구해 놓으면 매칭을 쭉 돌리다 실패했을 때 많은 작업을 건너뛸 수 있게 해준다.

대충 이러한 탐색 과정을 가지고 있다고 해보자.

이때 무식하게 한 칸만 옮기는 게 아니라, 미리 구해놓은 실패함수를 이용해 이렇게 확 건너뛸 수 있다.

아래는 본인이 사용하는 KMP 템플릿이다. 아무래도 메인 주제는 아닌 만큼 대충 넘어가겠다.

#include <iostream>
#include <string>
#include <vector>

using namespace std;

/* KMP Template, returns matching prefix index vector */
vector<int> KMP(string str, string substr)
{
  const int len = str.length();
  const int sublen = substr.length();
  vector<int> res;

  /* Construct Failure Function */
  vector<int> pi(sublen);
  int prefix = 0;
  for(int suffix = 1; suffix < sublen; suffix++)
    {
      while(prefix > 0 && substr[prefix] != substr[suffix]) prefix = pi[prefix - 1];
      if(substr[prefix] == substr[suffix]) pi[suffix] = ++prefix;
    }

  /* Find */
  int sub_idx = 0;
  for(int str_idx = 0; str_idx < len; str_idx++)
    {
      while(sub_idx > 0 && str[str_idx] != substr[sub_idx]) sub_idx = pi[sub_idx - 1];
      if(str[str_idx] == substr[sub_idx])
      {
        sub_idx++;
        if(sub_idx == sublen)
        {
          res.push_back(str_idx - (sublen - 1));
          sub_idx = pi[sub_idx - 1];
        }
      }
    }
  return res;
}

여기까지가, 배경지식이다. BFS도 필요하긴 한데 솔직히 이거 할 정도면 당연히 알 거라 생각한다.

3. 아호-코라식 (Aho-Corasick)

요약하면 이 두개를 짬뽕시킨 것이다.

실제로 트라이 위에서 하는 실패함수 구축 과정이 KMP와 거의 동일하다.

여기서는 KMP를 알고 있다는 전제 하에 글을 작성한다. 설명하기 어렵기도 하고.

먼저, 실패함수를 구축하려면 현재 탐색 중인 노드의 모든 조상들에 대해 이미 실패함수가 구축되어 있어야 한다.

이는 트라이 탐색을 너비 우선 탐색으로 함으로써 간단히 해결된다.

어떤 한 노드에 대해서, 계속 부모 노드를 타고 올라가 얻은 문자열에 대해 KMP를 수행한다고 하자.

아래 트리를 예시로 들어 보자.

먼저 부모 노드가 루트라면, 그 노드의 실패함수는 루트 노드이다. 실패함수의 정의에 의해, 1글자일 경우 실패함수는 항상 0이다.

A의 자식노드 B에 대하여 현재까지의 문자열은 AB이다. 마찬가지로 실패함수는 루트 노드로 간다.

마찬가지로 ABC의 경우 C의 실패함수는 루트 노드이다. 중요한 점은 ABA이다.

ABA의 경우 접두사와 접미사가 일치하는 구간이 존재한다.(A)

이 경우, KMP 짜듯이 실패함수를 다음과 같이 구축해 준다.

ABAB의 경우 처음 B로 이동하게 될 것이다.

이제 ABABC의 경우가 중요하다. 바로 앞인 ABAB의 실패함수를 따라가면, AB에 도달하게 될 것이다.

이때 위의 AB에도 C가 있고, ABAB에도 C가 있으므로 공통적으로 ABC를 매칭시켜줄 수 있다.

따라서 실패함수는 다음과 같이 구축된다.

따라가 보면 알 수 있듯, KMP와 사실상 동일한 방법으로 실패함수를 구성한다.

사실 매칭도 KMP와 동일한 방법이라, 설명은 코드로 대체한다.

void AhoCorasick()
{
  queue<Trie*> q;
  root -> fail = root;
  q.push(root);

  while(!q.empty())
    {
      Trie* cur = q.front();
      q.pop();

      for(int i = 0; i < 26; i++)
        {
          Trie* nxt = cur -> go[i];
          if(!nxt) continue;

          if(cur == root) nxt -> fail = root; //fail(root) = root
          else
          {
            Trie* dest = cur -> fail;
            while(dest != root && !(dest -> go[i])) dest = dest -> fail;

            if(dest -> go[i] != nullptr) dest = dest -> go[i];
            nxt -> fail = dest;
          }
          if(nxt -> fail -> output) nxt -> output = true;
          q.push(nxt);
        }
    }
}

bool TrieMatch(string str)
{
  Trie* cur = root;
  bool res = false;

  for(int i = 0; i < str.length(); i++)
    {
      int nxt = str[i] - 'a';
      while(cur != root && !(cur -> go[nxt])) cur = cur -> fail;
      if(cur -> go[nxt]) cur = cur -> go[nxt];

      if(cur -> output)
      {
        res = true;
        break;
      }
    }
  return res;
}

중요하게 보아야 할 것은 output 변수의 관리이다.

여기서는 해당 노드를 끝으로 하는 문자열이 존재하는지를 판별해 주는 변수이다.

위의 예시에서는 다음과 같이 색칠된 노드에 output 변수가 true로 되어 있을 것이다.

여기서 만약 AB라는 변수가 추가되었다고 해 보자.

그러면 일단 이렇게 색칠이 되어 있을 것이다.

만약, 여기 초록색으로 색칠된 부분을 탐색 중이라고 해 보자.

여기서부터 내려간다면, 돌아가지 않는 이상 "AB"라는 문자열은 존재하는 지 판별할 수 없다. 적어도 이렇게 색칠되어 있다면.

그런데 우리는 이렇게 AB가 존재하는 것을 알고 있다. 이 점을 해결해 주어야 한다.

아호-코라식의 경우 문자열 끝만 마킹하지 않고, 일단 해당 지점을 끝으로 하는 문자열이 포함될 수 있다면 모두 마킹한다.

잠시 실패함수의 정의를 생각해보면, 해당 노드를 마지막으로 하는 문자열에 대해서,

가장 길고 겹치는 접두사와 접미사에 대해 접두사의 맨 끝으로 이동한다.

근데 접두사가 마킹이 되어 있다면? 접미사도 겹치므로 해당 노드를 끝으로 하는 부분 문자열도 반드시 존재한다는 것이다.

그래서 BFS 탐색이 끝나고, 다음과 같은 과정이 추가로 들어가는 것이다.

if(nxt -> fail -> output) nxt -> output = true;

아래는 아호코라식 기초 구현의 예제들이다.