[Offer收割]编程练习赛32

气泡图

两两判断关系，dfs。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
double x[], y[], r[];
int f[][];
const double eps = 1e-;
#include<vector>
using namespace std;
vector<int> G[];
int p[], father[];
void dfs(int x, int fa) {
    father[x] = fa;
    for (int i = ; i < G[x].size(); i++) {
        p[G[x][i]]--;
    }
    for (int i = ; i < G[x].size(); i++) {
        int v = G[x][i];
        if (p[v] ==  && father[v]==) {
            dfs(v, x);
        }
    }
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    int n;
    scanf("%d", &n);
    for (int i = ; i <= n; i++) {
        scanf("%lf%lf%lf", &x[i], &y[i], &r[i]);
    }
    memset(f, , sizeof(f));
    memset(p, , sizeof(p));
    memset(father, , sizeof(father));
    for (int i = ; i <= n; i++) {
        for (int j = i + ; j <= n; j++) {
            if (i != j) {
                double d = sqrt((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]));
                if (r[i] - r[j] >= d) {
                    f[i][j] = ;
                    G[i].push_back(j);
                    f[j][i] = -;
                    p[j]++;
                }
                if (r[j] - r[i] >= d) {
                    f[i][j] = -;
                    f[j][i] = ;
                    G[j].push_back(i);
                    p[i]++;
                }
            }
        }
    }
    for (int i = ; i <= n; i++) {
        if (p[i] == ) {
            dfs(i, );
            break;
        }
    }
    for (int i = ; i <= n; i++) {
        printf("%d\n", father[i]);
    }
    return ;
}

候选人追踪

维护S集合中的最小值和其余候选人中的最大值

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
template <class T> class SegmentTree {
public:
    T dat, lazy;
    int leftBorder, rightBorder, mid;
    SegmentTree * leftSon, * rightSon;
    T(* lazyfunc)(T, T);
    T(* mergefunc)(T, T);
    SegmentTree() {
        leftBorder = rightBorder = -;
        leftSon = rightSon = NULL;
    }
    void pushdown();
    void pushup();
    void Build(T *, int, int, T(*)(T, T), T(*)(T, T));
    void Modify(int, int, T);
    T Query(int, int);
    void Free();
};
template<class T> void SegmentTree<T>::pushdown() {
    if (lazy && leftBorder != rightBorder) {
        leftSon->dat = lazyfunc(leftSon->dat, lazy);
        rightSon->dat = lazyfunc(rightSon->dat, lazy);
        leftSon->lazy = lazyfunc(leftSon->lazy, lazy);
        rightSon->lazy = lazyfunc(rightSon->lazy, lazy);
    }
    lazy = (T);
}
template<class T> void SegmentTree<T>::pushup() {
    dat = mergefunc(leftSon->dat, rightSon->dat);
}
template<class T> void SegmentTree<T>::Build(T * S, int l, int r, T(* lfunc)(T, T), T(* mfunc)(T, T)) {
    if (l > r) {
        return;
    }
    lazy = (T);
    leftBorder = l;
    rightBorder = r;
    mid = (leftBorder + rightBorder) >> ;
    lazyfunc = lfunc;
    mergefunc = mfunc;
    if (l == r) {
        dat = S[l];
        return;
    }
    leftSon = new SegmentTree;
    leftSon->Build(S, l, mid, lfunc, mfunc);
    rightSon = new SegmentTree;
    rightSon->Build(S, mid + , r, lfunc, mfunc);
    pushup();
}
template<class T> void SegmentTree<T>::Modify(int l, int r, T NewDat) {
    if (l > r || l < leftBorder || rightBorder < r) {
        return;
    }
    if (leftBorder == l && rightBorder == r) {
        dat = lazyfunc(dat, NewDat);
        lazy = lazyfunc(lazy, NewDat);
        return;
    }
    pushdown();
    if (r <= mid) {
        leftSon->Modify(l, r, NewDat);
    } else if (mid < l) {
        rightSon->Modify(l, r, NewDat);
    } else {
        leftSon->Modify(l, mid, NewDat);
        rightSon->Modify(mid + , r, NewDat);
    }
    pushup();
}
template<class T> T SegmentTree<T>::Query(int l, int r) {
    if (l > r || l < leftBorder || rightBorder < r) {
        return dat;
    }
    pushdown();
    if (l == leftBorder && r == rightBorder) {
        return dat;
    }
    if (r <= mid) {
        return leftSon->Query(l, r);
    } else if (mid < l) {
        return rightSon->Query(l, r);
    } else {
        return mergefunc(leftSon->Query(l, mid), rightSon->Query(mid + , r));
    }
}
template<class T> void SegmentTree<T>::Free() {
    if (leftSon != NULL) {
        leftSon->Free();
    }
    if (rightSon != NULL) {
        rightSon->Free();
    }
    delete leftSon;
    delete rightSon;
}
int lazyfunc(int a, int b) {
    return a + b;
}
int mergefunc(int a, int b) {
    return a > b ? b : a;
}
int n, k;
bool f[];
class tick {
public:
    int t, c;
};
int cmp(const void *x, const void *y) {
    tick * tx = (tick *)x;
    tick * ty = (tick *)y;
    return tx->t > ty->t ?  : -;
}
tick p[];
int index_____[], a[];
SegmentTree<int> st;
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    memset(a, , sizeof(a));
    scanf("%d%d", &n, &k);
    for (int i = ; i < n; i++) {
        scanf("%d%d", &p[i].t, &p[i].c);
    }
    memset(f, false, sizeof(f));
    for (int i = ; i < k; i++) {
        int s;
        scanf("%d", &s);
        f[s] = true;
    }
    int cnt = ;
    for (int i = ; i < ; i++) {
        if (f[i]) {
            index_____[i] = cnt++;
        }
    }
    qsort(p, n, sizeof(tick), cmp);
    int ptr = , ans = , max = , time = p[].t, s = -;
    st.Build(a, , k - , lazyfunc, mergefunc);
    while (ptr < n) {
        do {
            if (f[p[ptr].c]) {
                st.Modify(index_____[p[ptr].c], index_____[p[ptr].c], );
            } else {
                a[p[ptr].c]++;
                if (a[p[ptr].c] > max) {
                    max = a[p[ptr].c];
                }
            }
            ptr++;
        } while (p[ptr].t == p[ptr - ].t && ptr < n);
        int q = st.Query(, k - );
        if (s == ) {
            ans += p[ptr - ].t - time;
        }
        time = p[ptr - ].t;
        if (q > max) {
            s = ;
        } else {
            s = -;
        }
    }
    printf("%d\n", ans);
    return ;
}

墨水滴

bfs，优先扩展队列中颜色最深的点。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
class ink {
public:
    int x, y;
};
int n, k;
int a[][];
bool f[][];
const int dx[] = {-, , , }, dy[] = {, , , -};
ink heap[];
int len;
void adjust_down(int p) {
    if (p *  <= len && a[heap[p].x][heap[p].y] < a[heap[p * ].x][heap[p * ].y]) {
        ink tmp = heap[p];
        heap[p] = heap[p * ];
        heap[p * ] = tmp;
        adjust_down(p * );
    }
    if (p *  +  <= len && a[heap[p].x][heap[p].y] < a[heap[p *  + ].x][heap[p *  + ].y]) {
        ink tmp = heap[p];
        heap[p] = heap[p *  + ];
        heap[p *  + ] = tmp;
        adjust_down(p *  + );
    }
}
void adjust_up(int p) {
    if (p <= ) {
        return;
    }
    if (a[heap[p].x][heap[p].y] > a[heap[p / ].x][heap[p / ].y]) {
        ink tmp = heap[p];
        heap[p] = heap[p / ];
        heap[p / ] = tmp;
        adjust_up(p / );
    }
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    scanf("%d%d", &n, &k);
    memset(f, false, sizeof(f));
    memset(a, , sizeof(a));
    len = ;
    for (int i = ; i < k; i++) {
        ink t;
        int g;
        scanf("%d%d%d", &t.x, &t.y, &g);
        if (g > a[t.x][t.y]) {
            a[t.x][t.y] = g;
            if (!f[t.x][t.y]) {
                heap[++len] = t;
                adjust_up(len);
                f[t.x][t.y] = true;
            }
        }
    }
    while (len > ) {
        ink head = heap[];
        heap[] = heap[len];
        len--;
        adjust_down();
        f[head.x][head.y] = false;
        for (int i = ; i < ; i++) {
            int x = head.x + dx[i], y = head.y + dy[i];
            if (x <  || x >= n || y <  || y >= n) {
                continue;
            }
            if (a[x][y] < a[head.x][head.y] - ) {
                a[x][y] = a[head.x][head.y] - ;
                if (!f[x][y]) {
                    f[x][y] = true;
                    ink p;
                    p.x = x, p.y = y;
                    heap[++len] = p;
                    adjust_up(len);
                }
            }
        }
    }
    for (int i = ; i < n; i++) {
        for (int j = ; j < n; j++) {
            printf("%d ", a[i][j]);
        }
        printf("\n");
    }
    return ;
}

鱼形子图计数

先枚举A点，再从A点能到的点中枚举D点，计算AD都能到的点的数量tmp，则鱼身部分p1=tmp*(tmp-1)种构造；D点度数减3为鱼尾的可选集合，共p2=(d(D)-3)*(d(D)-4)/2种构造；则以A点为鱼头的子图个数为p1*p2。

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<vector>
#include<algorithm>
using namespace std;
const long long M = ;
vector<int> G[];
int n, m;
long long common(int u, int v) {
    int iu = , iv = ;
    long long ret = ;
    while (iu < G[u].size() && iv < G[v].size()) {
        if (G[u][iu] == G[v][iv]) {
            iu++, iv++, ret++;
        } else if (G[u][iu] < G[v][iv]) {
            iu++;
        } else {
            iv++;
        }
    }
    return ret;
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
#endif
    long long ans;
    while (scanf("%d%d", &n, &m) != EOF) {
        ans = ;
        for (int i = ; i <= n; i++) {
            G[i].clear();
        }
        for (int i = ; i < m; i++) {
            int u, v;
            scanf("%d%d", &u, &v);
            G[u].push_back(v);
            G[v].push_back(u);
        }
        for (int i = ; i <= n; i++) {
            sort(G[i].begin(), G[i].end());
        }
        int A, B, C, D, E, F;
        for (A = ; A <= n; A++) {
            if (G[A].size() < ) {
                continue;
            }
            for (int i = ; i < G[A].size(); i++) {
                long long p1 = , p2 = , tmp;
                D = G[A][i];
                if (G[D].size() < ) {
                    continue;
                }
                tmp = common(A, D);
                if (tmp >= ) {
                    p1 = tmp * (tmp - ) /  % M;
                }
                tmp = G[D].size() - ;
                if (tmp >= ) {
                    p2 = tmp * (tmp - ) /  % M;
                }
                ans = (ans + p1 * p2) % M;
            }
        }
        printf("%lld\n", ans);
    }
    return ;
}