けんちょんの競プロ精進記録

競プロの精進記録や小ネタを書いていきます

パ研合宿2020 第1日「SpeedRun」 N - 背の順

面白かった!セグ木を使ったけど、区間を複数個にする必要がないことから、しゃくとり法で線形でできるね!

問題概要

 1, 2, \dots, N の順列  A_{1}, A_{2}, \dots, A_{N} が与えられる。以下の操作を繰り返すことで、単調増加となるようにしたい。

  • 区間  \lbrack l, r \rbrack の要素をすべて削除する (コストは  A_{l} + A_{r}

目的を達成するための最小コストを求めよ。

制約

  •  1 \le N \le 2 \times 10^{5}

解法 (1):僕のやった解法

まず、操作する区間入れ子になったり交差したりする意味はないので、操作は「残す要素を固定すると、その間隔の区間を削除していく」というものになる。

これを踏まえて次の DP をする。

  • dp[v] ← 順列を左から見ていって、値  v が来たときに、値  v を最後の要素としたときの、最小コスト (ただし値 v の右隣の値も合算しておく)

この DP 配列をセグ木 (RMQ) に載せることで、LIS を求める DP と同じ要領で高速に更新していける。ただし DP 更新において、値  v の左隣の要素も選ぶ場合については、別途遷移する。

計算量は  O(N \log N)

#include <bits/stdc++.h>
using namespace std;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }

template<class Monoid> struct RMQ {
    Monoid INF;
    int SIZE_R;
    vector<pair<Monoid,int> > dat;
    
    RMQ() {}
    RMQ(int n, const Monoid &inf): INF(inf) { 
        init(n, inf);
    }
    void init(int n, const Monoid &inf) {
        INF = inf;
        SIZE_R = 1;
        while (SIZE_R < n) SIZE_R *= 2;
        dat.assign(SIZE_R * 2, pair<Monoid,int>(INF, -1));
    }
    
    /* set, a is 0-indexed */
    void set(int a, const Monoid &v) { dat[a + SIZE_R] = make_pair(v, a); }
    void build() {
        for (int k = SIZE_R - 1; k > 0; --k) {
            dat[k] = min(dat[k*2], dat[k*2+1]);
        }
    }
    
    /* update, a is 0-indexed */
    void update(int a, const Monoid &v) {
        int k = a + SIZE_R;
        dat[k] = make_pair(v, a);
        while (k >>= 1) dat[k] = min(dat[k*2], dat[k*2+1]);
    }
    
    /* get {min-value, min-index}, a and b are 0-indexed */
    pair<Monoid,int> get(int a, int b) {
        pair<Monoid,int> vleft = make_pair(INF, -1), vright = make_pair(INF, -1);
        for (int left = a + SIZE_R, right = b + SIZE_R; left < right; left >>= 1, right >>= 1) {
            if (left & 1) vleft = min(vleft, dat[left++]);
            if (right & 1) vright = min(dat[--right], vright);
        }
        return min(vleft, vright);
    }
    inline Monoid operator [] (int a) { return dat[a + SIZE_R].first; }
    
    /* debug */
    void print() {
        for (int i = 0; i < SIZE_R; ++i) {
            Monoid val = (*this)[i];
            if (val < INF) cout << val;
            else cout << "INF";
            if (i != SIZE_R-1) cout << ",";
        }
        cout << endl;
    }
};


const long long INF = 1LL<<60;
int main() {
    int N;
    cin >> N;
    deque<long long> A(N);
    for (int i = 0; i < N; ++i) cin >> A[i];
    A.push_front(0), A.push_back(N+1), A.push_back(0);
    RMQ<long long> dp(N+10, INF);
    dp.update(0, A[1]);
    for (int i = 1; i <= N+1; ++i) {
        long long val = dp.get(0, A[i]).first + A[i-1] + A[i+1];
        if (i-1 >= 0 && A[i-1] < A[i]) {
            chmin(val, dp.get(A[i-1], A[i-1]+1).first - A[i] + A[i+1]);
        }
        dp.update(A[i], val);
    }
    cout << dp.get(N+1, N+2).first << endl;
}

解法 (2)

よくよく考えると、操作する区間は 1 個だけでよい。なぜなら、いくつかの区間について操作するくらいなら、

を選んでまとめて削除してしまった方がよいからだ。そしてそのような条件を満たす区間は単調性 (区間 A が条件を満たすならば、A を包含する区間 B も条件を満たす) を満たすので、しゃくとり法で解ける。この場合計算量は  O(N) となる。

JOI 春合宿 2007 day3-2 Route (難易度 7)

DIjkstra をするときに、直前の頂点ももつ系

問題概要

頂点数  N、辺数  M の重み付き無向グラフが与えられる。頂点  i の座標は  (X_{i}, Y_{i}) となっている。

頂点 1 から頂点 2 へと至る経路のうち、鋭角に曲がる箇所がないようなものを考える (頂点  v の前の頂点を  u v の次の頂点を  w としたとき、線分  uv と線分  uw のなす角が 90 度未満)。

そのような経路の最短路長を求めよ。

制約

  •  2 \le N \le 100

考えたこと

基本的には Dijkstra 法を使うことで最短路が求められる。ただし、頂点  v から次の頂点  nv へと行けるかどうかを判定するために、頂点  v の前の頂点がどうだったかの情報が必要になる。よって、

  • dp[pv][v] ← 始点 (頂点 1) から頂点  v へと至る経路のうち、頂点  v の直前の頂点が  pv であるようなものの長さの最小値

として、Dijkstra 法で扱っていく。これは頂点集合を拡張したグラフ上の Dijkstra 法とみなすことができる。あとは、以下の判定関数が作れれば OK。

// 頂点 pv から頂点 v へ行き、そこから頂点 nv へ行けるか
auto isvalid = [&](int pv, int v, int nv) -> bool {
    ang = (線分 v-pv と線分 v-nv のなす角)
    if (dif < π/2 - EPS) return false;
    else return true;
};

コード

ここでは幾何ライブラリで殴ることにした。計算量を解析すると

  • 拡張したグラフの頂点数: O(M)
  • 拡張したグラフの辺数: O(NM)

となるので、priority_queue を使って Dijkstra をすると  O(NM \log N) となる。

#include <bits/stdc++.h>
using namespace std;
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }

// 幾何
using DD = double;
const DD EPS = 1e-10;        // to be set appropriately
const DD PI = acosl(-1.0);
DD torad(int deg) {return (DD)(deg) * PI / 180;}
DD todeg(DD ang) {return ang * 180 / PI;}

struct Point {
    DD x, y;
    Point(DD x = 0.0, DD y = 0.0) : x(x), y(y) {}
    friend ostream& operator << (ostream &s, const Point &p) {return s << '(' << p.x << ", " << p.y << ')';}
};
inline Point operator + (const Point &p, const Point &q) {return Point(p.x + q.x, p.y + q.y);}
inline Point operator - (const Point &p, const Point &q) {return Point(p.x - q.x, p.y - q.y);}
inline Point operator * (const Point &p, DD a) {return Point(p.x * a, p.y * a);}
inline Point operator * (DD a, const Point &p) {return Point(a * p.x, a * p.y);}
inline Point operator * (const Point &p, const Point &q) {return Point(p.x * q.x - p.y * q.y, p.x * q.y + p.y * q.x);}
inline Point operator / (const Point &p, DD a) {return Point(p.x / a, p.y / a);}
inline Point conj(const Point &p) {return Point(p.x, -p.y);}
inline Point rot(const Point &p, DD ang) {return Point(cos(ang) * p.x - sin(ang) * p.y, sin(ang) * p.x + cos(ang) * p.y);}
inline Point rot90(const Point &p) {return Point(-p.y, p.x);}
inline DD cross(const Point &p, const Point &q) {return p.x * q.y - p.y * q.x;}
inline DD dot(const Point &p, const Point &q) {return p.x * q.x + p.y * q.y;}
inline DD norm(const Point &p) {return dot(p, p);}
inline DD abs(const Point &p) {return sqrt(dot(p, p));}
inline DD amp(const Point &p) {DD res = atan2(p.y, p.x); if (res < 0) res += PI*2; return res;}

const long long INF = 1LL<<60;
int main() {
    int N, M;
    cin >> N >> M;
    vector<Point> vp(N);
    for (int i = 0; i < N; ++i) cin >> vp[i].x >> vp[i].y;

    auto isvalid = [&](int pv, int v, int nv) -> bool {
        DD pang = amp(vp[pv] - vp[v]), nang = amp(vp[nv] - vp[v]);
        DD dif = abs(pang - nang);
        if (dif < PI/2 - EPS) return false;
        else return true;
    };

    using pint = pair<int, int>; // prev node, current node
    using Edge = pair<int, long long>;
    using Graph = vector<vector<Edge>>;
    Graph G(N);
    for (int i = 0; i < M; ++i) {
        int u, v, w;
        cin >> u >> v >> w;
        --u, --v;
        G[u].emplace_back(v, w), G[v].emplace_back(u, w);
    } 
    int s = 0;
    vector<vector<long long>> dp(N, vector<long long>(N, INF));
    priority_queue<pair<long long, pint>,
                   vector<pair<long long, pint>>,
                   greater<pair<long long, pint>>> que;
    for (auto e: G[s]) {
        dp[s][e.first] = e.second;
        que.push(make_pair(dp[s][e.first], pint(s, e.first)));
    }
    while (!que.empty()) {
        auto tmp = que.top();
        que.pop();
        long long dis = tmp.first;
        int pv = tmp.second.first, v = tmp.second.second;
        if (dis > dp[pv][v]) continue;
        for (auto e: G[v]) {
            int nv = e.first;
            if (!isvalid(pv, v, nv)) continue;
            if (chmin(dp[v][nv], dp[pv][v] + e.second)) {
                que.push(make_pair(dp[v][nv], pint(v, nv)));
            }
        }
    }
    long long res = INF;
    for (int v = 0; v < N; ++v) chmin(res, dp[v][1]);
    cout << (res < INF ? res : -1) << endl;
}

JOI 本選 2007 E - 最軽量のモビール (AOJ 0520, 難易度 7)

読解が大変だけど、本質的には木 DP な問題

問題概要

 N 本の棒を用いて、下図のようなモビールを作りたい。

f:id:drken1215:20210104024203p:plain

入力としては、各棒  i についての

  • 左端から支点までの長さ  P_{i}
  • 右端から支点までの長さ  Q_{i}
  • 左端からつながっている棒の index  L_{i} (重りの場合は 0)
  • 右端からつながっている棒の index  R_{i} (重りの場合は 0)

が与えられる。重りの重さはすべて整数値でなければならない。考えられるモビールをすべて考えたときの、重りの重さの総和の最小値を求めよ。

制約

考えたこと

モビールは実際には木に過ぎない。木 DP と同じ発想が使える。

  • dp[i]モビール  i 以下のみを考えたときの、重りの重さの総和として考えられる最小値

とする。さて、dp[i] を求めるとき

  • 左側のモビールについての重さの総和を  L (= dp[L[i]])
  • 右側のモビールについての重さの総和を  R (= dp[R[i]])

としよう。このとき、左側の重さの総和は  L の倍数となり、右側の重さの総和は  R の倍数となる。よって、てこの原理を考慮して

 LP_{i}x = RQ_{i}y

を満たす正の整数  x, y の最小値を求めればよいということになる。具体的には、

  •  G = {\rm GCD}(LP_{i}, RQ_{i})

としたとき、

とすればよいことがわかる。よって、

  • dp[i] =  \frac{LR}{G}(P_{i} + Q_{i})

と求められた。このような DP を再帰的に実施すれば OK。なお、最初に根の位置を特定する必要がある。

コード

#include <bits/stdc++.h>
using namespace std;

int main() {
    int N;
    cin >> N;
    vector<long long> P(N), Q(N), left(N), right(N);
    vector<int> par(N, -1);
    for (int i = 0; i < N; ++i) {
        cin >> P[i] >> Q[i] >> left[i] >> right[i];
        --left[i], --right[i];
        if (left[i] != -1) par[left[i]] = i;
        if (right[i] != -1) par[right[i]] = i;
    }

    // 根を特定
    int root = -1;
    for (int v = 0; v < N; ++v) if (par[v] == -1) root = v;

    // DP
    auto rec = [&](auto self, int v) -> long long {
        // 葉の場合
        if (v == -1) return 1;

        long long L = self(self, left[v]);
        long long R = self(self, right[v]);
        long long G = gcd(L*P[v], R*Q[v]);
        return L * R * (P[v] + Q[v]) / G;
    };
    cout << rec(rec, root) << endl;
}

Codeforces Round #557 (Div. 1) C. Thanos Nim (R2000)

面白かった!

問題概要

 N 個の石の山がある ( N は偶数)。 i 番目の山には  A_{i} 個の石がある。先手と後手が交互に以下の操作を行う。操作できなくなった方が負けである

  1. 石の山のうち、まだ石が 1 個以上残っている山をちょうど  \frac{N}{2} 子選ぶ
  2. そのそれぞれの山から、石を任意個数除去する (選んだ山ごとに異なる個数の石を除去してもよい)

つまり、「石の個数が 0」であるような山が過半数となった状態で手番を渡されたら負けである。双方最善を尽くしたとき、どちらが勝つか?

制約

  •  N, A_{i} \le 50

考えたこと

たとえば、 A = (8, 8) とかは対象戦略から後手必勝となる。 (8, 10) とかは先手が  (8, 8) とすることで、先手必勝となる。

 N = 2 の場合はすぐにわかった。 N = 4 の場合を考えよう。少しずつ以下のことがわかってきた。

  • (1, 1, 1, 1) は後手必勝
  • (1, 1, 1, 2以上) は後手必勝
  • (1, 1, 2以上, 2以上) は先手必勝
  • (1, 2以上, 2以上, 2以上) は先手必勝
  • (2, 2, 2, 2) は後手必勝
  • (2, 2, 2, 3以上) は後手必勝
  • (2, 2, 3以上, 3以上) は先手必勝
  • (2, 3以上, 3以上, 3以上) は先手必勝
  • ...

このようにしていくうちに、以下の予想が立った。

「最小の値が過半数の場面は後手必勝 (勝ちパターン)」

予想さえ立てられたら示すのは比較的容易だ。

  • 最小の値が過半数の状態からは、いかなる操作を行っても、そうでない状態へと遷移する
  • 最小の値が過半数でない状態からは、「最小の値が過半数である」という状態へと遷移することができる

というわけで、「最小の値が過半数」という状態を作れたら勝ち (後手必勝) であることがわかった。

コード

#include <bits/stdc++.h>
using namespace std;

int main() {
    int N;
    cin >> N;
    vector<int> A(N);
    for (int i = 0; i < N; ++i) cin >> A[i];

    auto solve = [&]() -> bool {
        int mi = 100;
        map<int,int> ma;
        for (int i = 0; i < N; ++i) ma[A[i]]++, chmin(mi, A[i]);
        if (ma[mi] > N/2) return false;
        else return true;
    };
    cout << (solve() ? "Alice" : "Bob") << endl;
}

Codeforces Round #557 (Div. 1) B. Chladni Figure (R1900)

KMP 法で殴ったけど、愚直にやっても調和級数的計算量で間に合うね。

問題概要

円周上に等間隔に  N 個の点が打たれている。これらの点を端点とした  M 個の線分がある (下図のような感じ)。

f:id:drken1215:20210104005723p:plain

これが回転対象性をもつかどうかを判定せよ (1 周未満の回転で模様が一致するかを判定せよ)。

制約

  •  2 \le N \le 10^{5}
  •  1 \le M \le 2 \times 10^{5}

考えたこと

なんとなく文字列のように扱えそうな気がした。具体的には

  • vec[v] ← 点  v から見て隣接している頂点への差分の集合

とする (vector<vector<int>> 型などで管理)。これを、各文字が vector<int> 型であるような文字列とみなすと、KMP 法が使える。KMP 法を用いると、文字列の最小周期  d が求められる。 d \lt N かつ  d | N であれば "Yes"、そうでなければ "No"。これで計算量は  O(N + M) となる。

なお、KMP 法を使わなくても、周期  d = 1, 2, \dots, N-1 を愚直に試しても OK。これで計算量は  O(M \log N) となる。

コード

#include <bits/stdc++.h>
using namespace std;

// T = string or vector<long long>
template<class T> struct KMP {
    T pat;
    vector<int> fail;

    // construct
    KMP(const T &p) { init(p); }
    void init(const T &p) {
        pat = p;
        int m = (int)pat.size();
        fail.assign(m+1, -1);
        for (int i = 0, j = -1; i < m; ++i) {
            while (j >= 0 && pat[i] != pat[j]) j = fail[j];
            fail[i+1] = ++j;
        }
    }

    // the period of S[0:i]
    int period(int i) { return i - fail[i]; }
    
    // the index i such that S[i:] has the exact prefix p
    vector<int> match(const T &S) {
        int n = (int)S.size(), m = (int)pat.size();
        vector<int> res;
        for (int i = 0, k = 0; i < n; ++i) {
            while (k >= 0 && S[i] != pat[k]) k = fail[k];
            ++k;
            if (k >= m) res.push_back(i - m + 1), k = fail[k];
        }
        return res;
    }
};

int main() {
    int N, M;
    cin >> N >> M;
    vector<int> X(M), Y(M);
    for (int i = 0; i < M; ++i) {
        cin >> X[i] >> Y[i];
        --X[i], --Y[i];
    }
    vector<vector<int>> str(N);
    for (int i = 0; i < M; ++i) {
        str[X[i]].push_back( (Y[i]-X[i]+N) % N );
        str[Y[i]].push_back( (X[i]-Y[i]+N) % N );
    }
    for (int i = 0; i < N; ++i) sort(str[i].begin(), str[i].end());
  
    KMP<vector<vector<int>>> kmp(str);
    int syu = kmp.period(N);
    if (syu < N && N % syu == 0) cout << "Yes" << endl;
    else cout << "No" << endl;
}