6 October

P1514 引水入城

題目描述

在一個遙遠的國度，一側是風景秀美的湖泊，另外一側則是漫無邊際的沙漠。該國的行政區劃十分特殊，恰好構成一個 \(N\) 行 \(\times M\) 列的矩形，如上圖所示，其中每一個格子都表明一座城市，每座城市都有一個海拔高度。

爲了使居民們都儘量飲用到清澈的湖水，如今要在某些城市建造水利設施。水利設施有兩種，分別爲蓄水廠和輸水站。蓄水廠的功能是利用水泵將湖泊中的水抽取到所在城市的蓄水池中。

所以，只有與湖泊毗鄰的第 1 行的城市能夠建造蓄水廠。而輸水站的功能則是經過輸水管線利用高度落差，將湖水從高處向低處輸送。故一座城市能建造輸水站的前提，是存在比它海拔更高且擁有公共邊的相鄰城市，已經建有水利設施。因爲第 \(N\) 行的城市靠近沙漠，是該國的乾旱區，因此要求其中的每座城市都建有水利設施。那麼，這個要求可否知足呢？若是能，請計算最少建造幾個蓄水廠；若是不能，求乾旱區中不可能建有水利設施的城市數目。

BFS 記憶化搜索（優先隊列優化）+ 區間徹底覆蓋問題（貪心）。

定理：蓄水廠所在城市海拔必然不低於左右城市。即對於可能建造蓄水廠的城市 \(G(1,i)\)，知足 \(G(1,i-1) \leq G(1,i) \geq G(1,i+1)\)。

#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;

int n, m, G[503][503], v[503][503], cc[503], rat, tot;

struct node {
    int a, b;
    bool operator < (const node& aa) const {return a<aa.a; }
} ra[503];
priority_queue<node> q;

int main() {
    scanf("%d%d", &n, &m);
    for (int i=1; i<=n; ++i) for (int j=1; j<=m; ++j) 
        scanf("%d", &G[i][j]);
    for (int i=1; i<=m; ++i) ra[i].a=1000003;
    for (int i=1; i<=m; ++i) if (G[1][i-1]<=G[1][i] && G[1][i]>=G[1][i+1]) {
        q.push((node) {1, i}); ++rat;
        memset(v, 0, sizeof v);
        while (!q.empty()) {
            node p=q.top(); q.pop(); int &x=p.a, &y=p.b;
            if (v[x][y]) continue; v[x][y]=i;
            if (x==n) {
                if (!cc[y]) ++tot; cc[y]=1;
                ra[rat].a = min(ra[rat].a, y),
                ra[rat].b = max(ra[rat].b, y);
            }
            else if (!v[x+1][y]) if (G[x+1][y]<G[x][y]) q.push((node) {x+1, y});
            if (x>1) if (!v[x-1][y]) if (G[x-1][y]<G[x][y]) q.push((node) {x-1, y});
            if (y<m) if (!v[x][y+1]) if (G[x][y+1]<G[x][y]) q.push((node) {x, y+1});
            if (y>1) if (!v[x][y-1]) if (G[x][y-1]<G[x][y]) q.push((node) {x, y-1});
        }
    }
    if (tot<m) printf("0\n%d\n", m-tot);
    else {
        printf("1\n");
        sort(ra+1, ra+rat+1);
        int ans=0, bat=0, bat2=0, i=1;
        while (bat<m) {
            for (; i<=rat && ra[i].a-1<=bat; ++i)
                bat2=max(bat2, ra[i].b);
            bat=bat2, ++ans;
        }
        printf("%d\n", ans);
    }
    return 0;
}

抽象出來的 區間徹底覆蓋問題：

求給定區間集合的一個子集，使得覆蓋所有區間，且該子集的元素個數最小。

貪心：左端點排序，按照可否覆蓋前一區間貪心統計。

int maxLen, n;

struct node {
    int l, r;
    bool operator < (const node& aa) const {return l<aa.l; }
} D[503];

int main() {
    scanf("%d", &n);
    for (int i=1; i<=n; ++i)
        scanf("%d%d", &D[i].l, &D[i].r), maxLen=max(maxLen, D[i].r);
    sort(D+1, D+n+1);
    int ans=0, end=0, end2=0, i=1;
    while (end<maxLen) {
        for (; i<=n&& D[i].l-1<=end; ++i)
            end2=max(end2, D[i].r);
        end=end2, ++ans;
    }
    printf("%d\n", ans);
    return 0;
}

[SCOI2009] Windy數

參考 數位 DP - OI Wiki.

\(f(x, pre, op) = \displaystyle \sum_{|pre-i|\geq 2} f(x-1, i, op \operatorname{and} i=M)\).

數位 DP 的 記憶化搜索實現:

#include <cstdio>
#include <cmath>
#include <cstring>

int G[13], gt; long long A, B, f[13][13];

long long search(int x, int pre, int op) {
    if (!x) return 1;
    if (!op && ~f[x][pre]) return f[x][pre];
    int M = op ? G[x] : 9; long long res=0;
    for (int i=0; i<=M; ++i) if (abs(pre-i)>=2) {
        if (pre==11 && !i) res+=search(x-1, 11, op && i==M);
        else res+=search(x-1, i, op && i==M);
    }
    if (!op) f[x][pre]=res;
    return res;
}

long long sum(long long x) {
    gt=0;
    while (x) G[++gt]=x%10, x/=10;
    G[gt+1]=-1;
    return search(gt, 11, 1);
}

int main() {
    scanf("%lld%lld", &A, &B);
    memset(f, -1, sizeof f);
    printf("%lld\n", sum(B)-sum(A-1));
    return 0;
}

簡便寫法 Get:

• ~a \(\Leftrightarrow\) a!=-1
• !a \(\Leftrightarrow\) a==0.