Multi-University Training Contest 4

（hdoj 4897-4906）

1001

   LCT和树链剖分都可以做，简单起见就说说树链剖分，LCT类似。 

   首先注意到一条路径上是logn条重链和logn条轻边。

   当我们给一个点的所有边上的邻居边打标记时，如果该点在重链上，会影响他的轻孩子们。（要特殊考虑链头和链尾之类的）。

   那么我们可以给重链上的点打标记，表示这个点的轻孩子们被翻转了没。

   那么一个轻边就可以直接询问出来。复杂度:O(nlog2n)。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
using namespace std;

const int MAX_N = int(1e5) + 10;
int n;

vector<int> E[MAX_N];
int que[MAX_N], qh, qt, fa[MAX_N], size[MAX_N];
int pathIdx[MAX_N], pathFirst[MAX_N], dep[MAX_N];

struct Tree {
    int l, r;
    bool rev;
    int sum;

    Tree*pl, *pr;

    void applyRev() {
        rev ^= 1;
        sum = r - l - sum;
    }

    void relax() {
        if (rev) {
            pl->applyRev(), pr->applyRev();
            rev = false;
        }
    }

    void update() {
        sum = pl->sum + pr->sum;
    }

    Tree(int l, int r) :
        l(l), r(r), rev(false) {
        sum = 0;
        if (l + 1 == r) {
            pl = pr = 0;
            return;
        }
        pl = new Tree(l, l + r >> 1), pr = new Tree(l + r >> 1, r);
    }

    int querySum(int L, int R) {
        if (L >= R)
            return 0;
        if (L <= l && R >= r)
            return sum;
        if (L >= r || l >= R)
            return 0;
        relax();
        return pl->querySum(L, R) + pr->querySum(L, R);
    }

    void reverse(int L, int R) {
        if (L >= R)
            return;
        if (L <= l && R >= r) {
            applyRev();
            return;
        }
        if (L >= r || l >= R)
            return;
        relax();
        pl->reverse(L, R), pr->reverse(L, R);
        update();
    }
};

Tree*sumTree[MAX_N], *markTree[MAX_N];

void build(int vs) { //build path-composition
    qh = qt = 0;
    que[qt++] = vs, fa[vs] = -1, dep[vs] = 0;
    while (qh < qt) {
        int u = que[qh++];
        vector<int>::iterator v;
        for(v=E[u].begin(); v!=E[u].end(); v++)
            if (*v != fa[u]) {
                fa[*v] = u, que[qt++] = *v, dep[*v] = dep[u] + 1;
            }
    }
    for (int i = n - 1; i >= 0; --i) {
        int u = que[i];
        size[u] = 1;
        vector<int>::iterator v;
        for(v=E[u].begin(); v!=E[u].end(); v++)
            if (fa[*v] == u)
                size[u] += size[*v];
    }

    memset(pathFirst, -1, sizeof pathFirst);
    for (int i = 0; i < n; ++i) {
        int u = que[i];
        if (pathFirst[u] != -1)
            continue;
        int top = u, cnt = 0;
        for (;;) {
            pathFirst[u] = top;
            pathIdx[u] = cnt++;

            int nxt = -1;
            vector<int>::iterator v;
            for(v=E[u].begin(); v!=E[u].end(); v++)
                if (fa[*v] == u)
                    if (nxt == -1 || size[*v] > size[nxt]) {
                        nxt = *v;
                    }
            if (nxt == -1)
                break;
            u = nxt;
        }
        sumTree[top] = new Tree(0, cnt);
        markTree[top] = new Tree(0, cnt);
    }
}

int col[MAX_N]; //for light edge u and u's father

int getLightEdge(int u) {
    //u and fa[u] is a light edge, get its weight
    int v = fa[u];
    return col[u] ^ markTree[pathFirst[v]]->querySum(pathIdx[v], pathIdx[v] + 1);
}

int query(int x, int y) {
    int ret = 0;
    for (;;) {
        if (pathFirst[x] == pathFirst[y]) {
            int l = pathIdx[x], r = pathIdx[y];
            if (l > r)
                swap(l, r);
            ret += sumTree[pathFirst[x]]->querySum(l + 1, r + 1);
            break;
        }
        if (dep[pathFirst[x]] < dep[pathFirst[y]])
            swap(x, y);
        //x goest first
        ret += sumTree[pathFirst[x]]->querySum(1, pathIdx[x] + 1);
        x = pathFirst[x];
        ret += getLightEdge(x);
        x = fa[x];
    }
    return ret;
}

void reversePath(int x, int y) {
    for (;;) {
        if (pathFirst[x] == pathFirst[y]) {
            int l = pathIdx[x], r = pathIdx[y];
            if (l > r)
                swap(l, r);
            sumTree[pathFirst[x]]->reverse(l + 1, r + 1);
            break;
        }
        if (dep[pathFirst[x]] < dep[pathFirst[y]])
            swap(x, y);
        //x goest first
        sumTree[pathFirst[x]]->reverse(1, pathIdx[x] + 1);
        x = pathFirst[x];
        col[x] ^= 1;
        x = fa[x];
    }
}

void reverseAdj(int x, int y) {
    for (;;) {
        if (pathFirst[x] == pathFirst[y]) {
            int l = pathIdx[x], r = pathIdx[y];
            if (l > r)
                swap(l, r), swap(x, y);
            markTree[pathFirst[x]]->reverse(l, r + 1);
            if (pathFirst[x] == x)
                col[x] ^= 1;
            else
                sumTree[pathFirst[x]]->reverse(l, l + 1);

            sumTree[pathFirst[y]]->reverse(r + 1, r + 2);
            break;
        }
        if (dep[pathFirst[x]] < dep[pathFirst[y]])
            swap(x, y);
        //x goest first
        markTree[pathFirst[x]]->reverse(0, pathIdx[x] + 1);
        sumTree[pathFirst[x]]->reverse(pathIdx[x] + 1, pathIdx[x] + 2);
        x = pathFirst[x];
        col[x] ^= 1;
        x = fa[x];
    }
}

int main() {
    int T;
    scanf("%d",&T);
    while (T--) {
        scanf("%d",&n);
        for (int i = 0; i < n; ++i) {
            E[i].clear();
        }
        memset(col, 0, sizeof col);
        for (int i = 0; i < n - 1; ++i) {
            int a, b;
            scanf("%d %d",&a,&b);
            --a, --b;
            E[a].push_back(b), E[b].push_back(a);
        }

        build(0);

        int Q;
        scanf("%d",&Q);
        while (Q--) {
            int t, a, b;
            scanf("%d%d%d", &t, &a, &b), --a, --b;
            if (t == 1) {
                reversePath(a, b);
            } else if (t == 2) {
                reverseAdj(a, b);
            } else {
                printf("%d
", query(a, b));
            }
        }
    }
}

1002

   首先二分答案，并且注意到一个点开始的子串越长字典序越大。

   那么现在问题变成了给你一个环，每个点i能往后延伸长度ri，问存不存在一个 从某点跳k次绕一圈跳回自己的路径。

   首先递归删掉ri = 0的点，因为这些点不能经过。那么现在所有点的r都>0，那么如果还有n个点，那么最多跳n次。注意到可行次数显然是一个区间，那么只要求出最小跳的次数就行了。

   最小跳的次数就是枚举一个开始点然后不停往后狂跳。

   ADD

   n ≤ 10w的话怎么做？

 

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
using namespace std;
const int MAX_N = 4000 + 10;
char S[MAX_N];
int n, k;
int lcp[MAX_N][MAX_N];

struct Sub {
    int l, r; //[l,r)

    Sub(int l, int r) :
        l(l), r(r) {
    }

    int size() {
        return r - l;
    }
    char charAt(int x) {
        if (x < size())
            return S[l + x];
        else
            return 0;
    }
};

int Lcp(Sub a, Sub b) {
    return min(lcp[a.l][b.l], min((int) a.size(), (int) b.size()));
}

bool operator<(Sub a, Sub b) {
    int L = Lcp(a, b);
    return a.charAt(L) < b.charAt(L);
}

int step[MAX_N];

bool check(Sub M) {
    vector<int> nxt(n);
    for (int i = 0; i < n; ++i) {
        int L = Lcp(Sub(i, i + n), M);
        if (S[(i + L) % n] < M.charAt(L))
            nxt[i] = n;
        else
            nxt[i] = L;
    }

//    for (int i = 0; i < n; ++i) {
//        cout << nxt[i] << " ";
//    }
//    cout << endl;
    //clean
    for (;;) {
        bool done = true;
        for (int i = 0; i < nxt.size(); ++i) {
            if (nxt[i] == 0) {
                for (int j = 0; j < nxt.size(); ++j)
                    if (j != i) {
                        if (j < i && j + nxt[j] >= i)
                            --nxt[j];
                        else if (j > i && j + nxt[j] >= i + nxt.size())
                            --nxt[j];
                    }
                nxt.erase(nxt.begin() + i);
                done = false;
                break;
            }
        }
        if (done)
            break;
    }

//    for (int i = 0; i < nxt.size(); ++i) {
//        cout << nxt[i] << " ";
//    }
//    cout << endl;

    if (k > nxt.size())
        return false;

    for (int i = 0; i < nxt.size() * 2; ++i) {
        step[i] = i + nxt[i % nxt.size()];
    }

    for (int i = 0; i < nxt.size(); ++i) {
        int need = 0, at = i;
        while (at < i + nxt.size()) {
            at = step[at];
            ++need;
        }
        if (need <= k)
            return true;
    }

    return false;
}

int main() {
    int T;
    scanf("%d",&T);
    while (T--) {
        scanf("%d %d",&n,&k);

        memset(S, 0, sizeof S);

        scanf("%s", S);

        for (int i = n; i < n + n; ++i) {
            S[i] = S[i - n];
        }

        for (int i = n + n - 1; i >= 0; --i) {
            for (int j = n + n - 1; j >= 0; --j) {
                if (S[i] == S[j])
                    lcp[i][j] = lcp[i + 1][j + 1] + 1;
                else
                    lcp[i][j] = 0;
            }
        }

        vector<Sub> subs;
        for (int i = 0; i < n; ++i) {
            for (int j = i; j < i + (i == 0 ? n : n - 1); ++j) {
                subs.push_back(Sub(i, j + 1));
            }
        }
        sort(subs.begin(), subs.end());

        int l = -1, r = subs.size() - 1;
        while (l + 1 < r) {
            int m = (l + r) >> 1;
            if (check(subs[m]))
                r = m;
            else
                l = m;
        }

        Sub ans = subs[r];
        for (int i = 0; i < ans.size(); ++i) {
            printf("%c", ans.charAt(i));
        }
        puts("");
//        check(ans);
    }
    return 0;
}

1003

   考虑dpi,j 表示S的前i个和T 的前j个的LCT。 注意到，如果我们枚举了一个长度为i的串，我们关心哪些信息？有意义的只有dpi,∗的值！对于i，我们暴力记录所有dpi,∗的值来。

   注意到dpi,j 和dpi,j−1最多差1，因此状态数量很少。

 

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
#include <map>
using namespace std;
const int MOD = int(1e9) + 7;
string S;
int m;
const string ACGT = "ACGT";

vector<int> getNext(vector<int> cur, char c) {
    for (int i = S.size(); i >= 1; --i) {
        if (S[i - 1] == c)
            cur[i] = max(cur[i - 1] + 1, cur[i]);
    }
    for (int i = 1; i <= S.size(); ++i) {
        cur[i] = max(cur[i], cur[i - 1]);
    }
    return cur;
}

map<vector<int>, int> idmp;
vector<vector<int> > states;

void dfs(vector<int> cur) {
    if (idmp.count(cur))
        return;

    int me = idmp.size();
    idmp[cur] = me;
    states.push_back(cur);

    for (int i = 0; i < ACGT.size(); ++i) {
        dfs(getNext(cur, ACGT[i]));
    }
}

vector<vector<int> > trans;

void addIt(int&x, int c) {
    x += c;
    if (x >= MOD)
        x -= MOD;
}

int calcStates(string S) {
    ::S = S;
    idmp.clear(), states.clear();
    vector<int> init(S.size() + 1, 0);
    dfs(init);
    return states.size();
}

int maxState;
string who;

void dfs(string cur, int rem, int nused) {
    if (rem == 0) {
        int tmp = calcStates(cur);
//        maxState = max(maxState, calcStates(cur));
        if (tmp > maxState) {
            maxState = tmp;
            who = cur;
        }
        return;
    }
    for (int i = 0; i < 4 && i <= nused; ++i) {
        dfs(cur + ACGT[i], rem - 1, max(nused, i + 1));
    }
}

int main() {
    int T;
    cin >> T;
    while (T--) {
        cin >> S;
        cin >> m;

        idmp.clear(), states.clear();

        vector<int> init(S.size() + 1, 0);
        dfs(init);
        trans.assign(idmp.size(), vector<int>(4, 0));

        for (int i = 0; i < states.size(); ++i) {
            for (int j = 0; j < 4; ++j) {
                trans[i][j] = idmp[getNext(states[i], ACGT[j])];
            }
        }

        vector<int> am(states.size(), 0);
        vector<int> nam = am;

        am[idmp[init]] = 1;

        for (int i = 0; i < m; ++i) {
            fill(nam.begin(), nam.end(), 0);
            for (int a = 0; a < states.size(); ++a) {
                for (int b = 0; b < 4; ++b) {
                    addIt(nam[trans[a][b]], am[a]);
                }
            }
            am = nam;
        }

        vector<int> ans(S.size() + 1, 0);
        for (int i = 0; i < states.size(); ++i) {
            addIt(ans[states[i].back()], am[i]);
        }

        for (int i = 0; i <= S.size(); ++i) {
            cout << ans[i] << endl;
        }
    }
}

1004

   不妨枚举a，b作为直径，然后计算该情况的概率。注意到如果不考虑字典序这其实等价于其它选的点满足Dc→a ≤ Da→b  并且 Dc→b ≤ Da→b。

   考虑字典序也类似。

 

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <vector>
using namespace std;

const int MAX_N = 1000 + 10;
int n, k;
int lab[MAX_N];
int dist[MAX_N][MAX_N], ans[MAX_N][MAX_N];

vector<int> E[MAX_N];

int cnt[MAX_N];

void dfs(int u, int p, int d, int w, int dst[], int am[]) {

    if (++cnt[lab[u]] == 1)
        ++w;

    dst[u] = d;
    am[u] = w;
    vector<int>::iterator x;
    for(x=E[u].begin(); x!=E[u].end(); x++)
        if (*x != p)
            dfs(*x, u, d + 1, w, dst, am);

    --cnt[lab[u]];
}

typedef int T;
struct Index: public vector<T> {
    void doit() {
        sort(begin(), end());
        erase(unique(begin(), end()), end());
    }
    int get(T x) {
        return lower_bound(begin(), end(), x) - begin();
    }
};

double comb[MAX_N][MAX_N];

int main() {
    for (int i = 0; i < MAX_N; ++i) {
        for (int j = 0; j <= i; ++j) {
            comb[i][j] =
                (i == 0 || j == 0) ?
                1 : (comb[i - 1][j] + comb[i - 1][j - 1]);
        }
    }

    int T;
    cin >> T;
    while (T--) {
        cin >> n >> k;
        for (int i = 0; i < n; ++i) {
            E[i].clear();
        }
        for (int i = 0; i < n - 1; ++i) {
            int a, b;
            cin >> a >> b, --a, --b;
            E[a].push_back(b);
            E[b].push_back(a);
        }

        Index idx;

        for (int i = 0; i < n; ++i) {
            cin >> lab[i];
            idx.push_back(lab[i]);
        }

        idx.doit();

        for (int i = 0; i < n; ++i) {
            lab[i] = idx.get(lab[i]);
        }

        memset(cnt, 0, sizeof cnt);

        for (int i = 0; i < n; ++i) {
            dfs(i, -1, 0, 0, dist[i], ans[i]);
        }

        if (k == 1) {
            printf("%0.10lf
", 0.);
            continue;
        }

        double ans = 0;

        for (int a = 0; a < n; ++a) {
            for (int b = a + 1; b < n; ++b) {
                int cnt = 0;
                for (int c = 0; c < n; ++c)
                    if (a != c && b != c) {
                        int L = dist[a][b];
                        if (dist[a][c] > L || (dist[a][c] == L && c < b))
                            continue;
                        if (dist[b][c] > L || (dist[b][c] == L && c < a))
                            continue;
                        ++cnt;
                    }
                double pb = comb[cnt][k - 2] / comb[n][k];
                ans += pb * ::ans[a][b];
            }
        }

        printf("%0.10lf
", ans);
    }
}

1005

   大家肯定会做吧。

 

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;

const int MAX_N = int(1e3) + 10;
const int MOD = int(1e9) + 7;
int dp1[MAX_N][1024], dp2[MAX_N][1024], n, a[MAX_N];

void addIt(int&x, int c) {
    x += c;
    if (x >= MOD)
        x -= MOD;
}

int main() {
    int T;
    cin >> T;
    for (int it = 0; it < T; ++it) {
        cin >> n;
        for (int i = 0; i < n; ++i) {
            cin >> a[i];
        }
        memset(dp1, 0, sizeof dp1);

        dp1[0][0] = 1;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < 1024; ++j) {
                if (dp1[i][j] > 0) {
                    addIt(dp1[i + 1][j], dp1[i][j]);
                    addIt(dp1[i + 1][j ^ a[i]], dp1[i][j]);
                }
            }
        }
        memset(dp2, 0, sizeof dp2);

        dp2[n][1023] = 1;
        for (int i = n - 1; i >= 0; --i) {
            for (int j = 0; j < 1024; ++j) {
                if (dp2[i + 1][j] > 0) {
                    addIt(dp2[i][j], dp2[i + 1][j]);
                    addIt(dp2[i][j & a[i]], dp2[i + 1][j]);
                }
            }
        }
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < 1024; ++j) {
                int w1 = dp1[i + 1][j];
                addIt(w1, MOD - dp1[i][j]);
                int w2 = dp2[i + 1][j];
                if (j == 1023) { //delete the case T is empty
                    addIt(w2, MOD - 1);
                }
                addIt(ans, 1LL * w1 * w2 % MOD);
            }
        }
        cout << ans << endl;
    }
}

1006

 

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <map>
using namespace std;

const int MAX_N = int(1e5) + 10;
int a[MAX_N], n;

struct Tree {
    Tree*pl, *pr;
    int l, r;

    pair<int, int> mx; //value,position

    bool same;
    int samev;

    void update() {
        mx = max(pl->mx, pr->mx);
    }

    void apply(int v) {
        same = true;
        samev = v;
        mx = make_pair(v, l);
    }

    void relax() {
        if (same) {
            pl->apply(samev);
            pr->apply(samev);
            same = false;
        }
    }

    Tree(int l, int r) :
        l(l), r(r) {
        same = false;
        if (l + 1 == r) {
            mx = make_pair(a[l], l);
            return;
        }
        pl = new Tree(l, l + r >> 1);
        pr = new Tree(l + r >> 1, r);
        update();
    }

    void change(int L, int R, int x) {
        if (L <= l && R >= r) {
            apply(x);
            return;
        }
        if (L >= r || l >= R)
            return;
        relax();
        pl->change(L, R, x);
        pr->change(L, R, x);
        update();
    }

    pair<int, int> query(int L, int R) {
        if (L <= l && R >= r) {
            return mx;
        }
        if (L >= r || l >= R)
            return make_pair(-1, 0);
        relax();
        return max(pl->query(L, R), pr->query(L, R));
    }

    void print(int a[]) {
        if (l + 1 == r) {
            a[l] = mx.first;
            return;
        }
        relax();
        pl->print(a), pr->print(a);
    }
}*rt;

struct Cover {
    map<int, int> mp;

    void init(int l, int r, int init) { //[l,r)
        mp[l] = mp[r] = init;
    }

    int get_value(int x) {
        map<int, int>::iterator it = --mp.upper_bound(x);
        int v = it->second;
        int l = it->first;
        int r = (++it)->first;
//        return make_tuple(v, l, r);
        return v;
    }

    pair<int, int> get_range(int x) {
        map<int, int>::iterator it = --mp.upper_bound(x);
        int v = it->second;
        int l = it->first;
        int r = (++it)->first;
//        return make_tuple(v, l, r);
//        return v;
        return make_pair(l, r);
    }

    void cover(int l, int r, int w) {
        //[l,r)
//        int old = ::get<0>(get(r));
        int old = get_value(r);
        mp.erase(mp.lower_bound(l), mp.upper_bound(r));
        mp[l] = w;
        mp[r] = old;
    }
};

int main() {
    int T;
    cin >> T;
    while (T--) {
        cin >> n;
        Cover cv;
        cv.init(0, n, 0);
        for (int i = 0; i < n; ++i) {
            cin >> a[i];
            cv.cover(i, i + 1, a[i]);
        }
        rt = new Tree(0, n);

        int Q;
        cin >> Q;
        while (Q--) {
            int t, l, r, x;
            cin >> t >> l >> r >> x;
            --l;
            if (t == 1) {
                rt->change(l, r, x);
                cv.cover(l, r, x);
            } else {
                for (;;) {
                    pair<int, int> mx = rt->query(l, r);
                    if (mx.first <= x)
                        break;
                    pair<int, int> t = cv.get_range(mx.second);
                    int L = t.first, R = t.second; //[l,r)
                    L = max(L, l);
                    R = min(R, r);
                    int v = __gcd(mx.first, x);
                    rt->change(L, R, v);
                    cv.cover(L, R, v);
                }
            }
        }
        rt->print(a);
        for (int i = 0; i < n; ++i) {
            cout << a[i] << " ";
        }
        cout << endl;
    }
}

1007

   首先我们不妨枚举所有点的距离标号，> k的就看成k + 1就可以了。 然后考虑一个距离标号为b的点。

   对于一个标号为a的点，如果a < b，那么a到b的边要≥ b − a，并且需要存在一个点使得那条边是b − a。

   这个可以用dp来计算方案数。 当然这样复杂度还是不够，注意到其实没必要枚举点的具体标号，只要分别枚举每种标号的点有几个就可以了。

   ADD

   有多项式算法吗?

 

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;

const int MAX_N = 10 + 10;
const int MOD = int(1e9) + 7;
int n, k, L;
int cnt[MAX_N];
int comb[MAX_N][MAX_N];
int pw[MAX_N * MAX_N];

int ans;

void addIt(int&x, int c) {
    x += c;
    if (x >= MOD)
        x -= MOD;
}

int calcDp(int i) {
    int dp[MAX_N][2] = { };
    int o = 0;
    dp[o][0] = 1;

    for (int j = 0; j < i; ++j) {
        for (int it = 0; it < cnt[j]; ++it) {
            int minL = i - j;
            if (minL > L)
                return 0;
            int upd[2] = { L - minL, 1 };
            for (int u = 0; u < 2; ++u) {
                for (int v = 0; v < 2; ++v) {
                    addIt(dp[o + 1][u | v], 1LL * dp[o][u] * upd[v] % MOD);
                }
            }
            ++o;
        }
    }

//        w *= dp[o][1];
    int one = dp[o][1];
    if (i == k + 1)
        addIt(one, dp[o][0]);

    return one;
}

int calc() {
    int w = 1; //calculate the way
    int rem = n - 2;
    for (int i = 1; i <= k + 1; ++i) {
        int need = cnt[i];
        if (i == k)
            --need;
        w = 1LL * w * comb[rem][need] % MOD;
        rem -= need;
    }

//    for (int i = 0; i <= k + 1; ++i) {
//        cout << cnt[i] << " ";
//    }
//    cout << endl;

    //calcualte the way to put it
    for (int i = 1; i <= k + 1; ++i)
        if (cnt[i] > 0) {
            int dp[MAX_N][2] = { };
            int o = 0;
            dp[o][0] = 1;

            for (int j = 0; j < i; ++j) {
                for (int it = 0; it < cnt[j]; ++it) {
                    int minL = i - j;
                    if (minL > L)
                        return 0;
                    int upd[2] = { L - minL, 1 };
                    for (int u = 0; u < 2; ++u) {
                        for (int v = 0; v < 2; ++v) {
                            addIt(dp[o + 1][u | v],
                                  1LL * dp[o][u] * upd[v] % MOD);
                        }
                    }
                    ++o;
                }
            }

//        w *= dp[o][1];
            int one = dp[o][1];
            if (i == k + 1)
                addIt(one, dp[o][0]);

            int t = cnt[i];

            for (int j = 0; j < t; ++j) {
                w = 1LL * w * one % MOD;
            }
            w = 1LL * w * pw[t * (t - 1) / 2] % MOD;
        }
//    ans +=
//    addIt(ans, w);
    return w;
}

void search(int at, int rem, int w) {
    if (at == k + 2) {
        if (rem == 0) {
            addIt(ans, w);
//            cout << w << " " << calc() << endl;
        }
        return;
    }
    int one = calcDp(at);
    if (at != k) {
        for (int now = 0; now <= rem; ++now) {
            cnt[at] = now;
            search(at + 1, rem - now, 1LL * w * comb[rem][now] % MOD);
            w = 1LL * w * one % MOD * pw[now] % MOD;
            if (w == 0)
                break;
        }
    } else {
        w = 1LL * w * one % MOD;

        for (int now = 0; now <= rem; ++now) {
            cnt[at] = now + 1;
            search(at + 1, rem - now, 1LL * w * comb[rem][now] % MOD);
            w = 1LL * w * one % MOD * pw[now + 1] % MOD;
            if (w == 0)
                break;
        }
    }
}

int main() {
    for (int i = 0; i < MAX_N; ++i) {
        for (int j = 0; j <= i; ++j) {
            comb[i][j] =
                (i == 0 || j == 0) ?
                1 : (comb[i - 1][j] + comb[i - 1][j - 1]) % MOD;
        }
    }

    int T;
    scanf("%d",&T);
    while (T--) {
        scanf("%d %d %d",&n,&k,&L);

        pw[0] = 1;
        for (int i = 1; i <= n * n; ++i) {
            pw[i] = 1LL * pw[i - 1] * L % MOD;
        }

        memset(cnt, 0, sizeof cnt);
        ans = 0;
        cnt[0] = 1;
        search(1, n - 2, 1);

        printf("%d
",ans);
    }
}

1008

   如果知道了该点离a，b中的a近一点，这实际上意味着确定了一个半平面，左侧是该点可能的区域。

   我们不妨枚举离该点第二近的是哪个，再枚举第一近的是哪个，然后平面切割出这种情况下的多边形。

   然后进行简单的积分就能计算出答案了。

   ADD

   第k远当然也是可做的。

 

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
#include <cmath>
#include <vector>
using namespace std;

const double EPS = 1e-8;
inline int sign(double a) {
    return a < -EPS ? -1 : a > EPS;
}

struct Point {
    double x, y;
    Point() {
    }
    Point(double _x, double _y) :
        x(_x), y(_y) {
    }
    Point operator+(const Point&p) const {
        return Point(x + p.x, y + p.y);
    }
    Point operator-(const Point&p) const {
        return Point(x - p.x, y - p.y);
    }
    Point operator*(double d) const {
        return Point(x * d, y * d);
    }
    Point operator/(double d) const {
        return Point(x / d, y / d);
    }
    bool operator<(const Point&p) const {
        int c = sign(x - p.x);
        if (c)
            return c == -1;
        return sign(y - p.y) == -1;
    }
    double dot(const Point&p) const {
        return x * p.x + y * p.y;
    }
    double det(const Point&p) const {
        return x * p.y - y * p.x;
    }
    double alpha() const {
        return atan2(y, x);
    }
    double distTo(const Point&p) const {
        double dx = x - p.x, dy = y - p.y;
        return hypot(dx, dy);
    }
    double alphaTo(const Point&p) const {
        double dx = x - p.x, dy = y - p.y;
        return atan2(dy, dx);
    }
    void read() {
        scanf("%lf%lf", &x, &y);
    }
    double abs() {
        return hypot(x, y);
    }
    double abs2() {
        return x * x + y * y;
    }
    void write() {
        cout << "(" << x << "," << y << ")" << endl;
    }
    Point rot90() {
        return Point(-y, x);
    }
};

#define cross(p1,p2,p3) ((p2.x-p1.x)*(p3.y-p1.y)-(p3.x-p1.x)*(p2.y-p1.y))

#define crossOp(p1,p2,p3) sign(cross(p1,p2,p3))

Point isSS(Point p1, Point p2, Point q1, Point q2) {
    double a1 = cross(q1,q2,p1), a2 = -cross(q1,q2,p2);
    return (p1 * a2 + p2 * a1) / (a1 + a2);
}

vector<Point> convexCut(const vector<Point>&ps, Point q1, Point q2) {
    vector<Point> qs;
    int n = ps.size();
    for (int i = 0; i < n; ++i) {
        Point p1 = ps[i], p2 = ps[(i + 1) % n];
        int d1 = crossOp(q1,q2,p1), d2 = crossOp(q1,q2,p2);
        if (d1 >= 0)
            qs.push_back(p1);
        if (d1 * d2 < 0)
            qs.push_back(isSS(p1, p2, q1, q2));
    }
    return qs;
}

double calcArea(const vector<Point>&ps) {
    int n = ps.size();
    double ret = 0;
    for (int i = 0; i < n; ++i) {
        ret += ps[i].det(ps[(i + 1) % n]);
    }
    return ret / 2;
}

vector<Point> convexHull(vector<Point> ps) {
    int n = ps.size();
    if (n <= 1)
        return ps;
    sort(ps.begin(), ps.end());
    vector<Point> qs;
    for (int i = 0; i < n; qs.push_back(ps[i++])) {
        while (qs.size() > 1 && crossOp(qs[qs.size()-2],qs.back(),ps[i]) <= 0)
            qs.pop_back();
    }
    for (int i = n - 2, t = qs.size(); i >= 0; qs.push_back(ps[i--])) {
        while (qs.size() > t && crossOp(qs[qs.size()-2],qs.back(),ps[i]) <= 0)
            qs.pop_back();
    }
    qs.pop_back();
    return qs;
}

typedef vector<Point> Poly;

Poly background(double X, double Y) { //[0,X] * [0,Y]
    Poly ret;
    ret.push_back(Point(0, 0));
    ret.push_back(Point(X, 0));
    ret.push_back(Point(X, Y));
    ret.push_back(Point(0, Y));
    return ret;
}

const int MAX_N = 100 + 1;

Poly BIG;
int n, X, Y;
Point ps[MAX_N];

Poly getNear(Poly ps, Point a, Point b) { //get the part near a
    Point p1 = (a + b) / 2, p2 = p1 + (b - a).rot90();
    return convexCut(ps, p1, p2);
}

double cut(Poly ps, double x) {
    double ly = 1e100, ry = -1e100;
    for (int i = 0; i < ps.size(); ++i) {
        Point p1 = ps[i], p2 = ps[(i + 1) % ps.size()];
        if (p1.x > p2.x)
            swap(p1, p2);
        if (sign(x - p1.x) >= 0 && sign(p2.x - x) >= 0) {
            double a = x - p1.x, b = p2.x - x;
            double y = (b * p1.y + a * p2.y) / (a + b);
            ly = min(ly, y);
            ry = max(ry, y);
        }
    }
    return ry - ly;
}

double sqr(double x) {
    return x * x;
}

double calc(Poly ps, double x) {
    vector<double> ix;
    for (int i = 0; i < ps.size(); ++i) {
        ix.push_back(ps[i].x);
    }
    sort(ix.begin(), ix.end());
    double ret = 0;
    for (int i = 0; i + 1 < ix.size(); ++i) {
        double l = ix[i], r = ix[i + 1];
        double m1 = (l * 2 + r) / 3, m2 = (l + r * 2) / 3;
        double v = sqr(l - x) * cut(ps, l) + sqr(m1 - x) * cut(ps, m1) * 3
                   + sqr(m2 - x) * cut(ps, m2) * 3 + sqr(r - x) * cut(ps, r);
        v /= 8;
        v *= r - l;
        ret += v;
    }
    return ret;
}

double integrate(Poly ps, Point p) {
    double ret = calc(ps, p.x);
    for (int i = 0; i < ps.size(); ++i) {
        swap(ps[i].x, ps[i].y);
    }
    ret += calc(ps, p.y);
    return ret;
}

int main() {
    int T;
    scanf("%d",&T);
    while (T--) {
        scanf("%d %d %d",&n,&X,&Y);
        BIG = background(X, Y);
        for (int i = 0; i < n; ++i) {
            ps[i].read();
        }

        double sum = 0;

        for (int second = 0; second < n; ++second) {
            for (int first = 0; first < n; ++first)
                if (first != second) {
                    Poly py = BIG;
                    py = getNear(py, ps[first], ps[second]);
                    for (int i = 0; i < n; ++i)
                        if (i != first && i != second) {
                            py = getNear(py, ps[second], ps[i]);
                            if (calcArea(py) <= 1e-8)
                                break;
                        }
                    sum += integrate(py, ps[second]);
                }
        }

        printf("%0.10lf
", sum / X / Y);
    }
}

1009

   四边形不等式优化存在一定问题，暂时没有解法

 

1010

   和C类似，直接存到目前为止，哪些数可以被拼出来。

   ADD

   有更好的做法吗？

 

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <string>
using namespace std;
int n, k, L;

const int MAX_K = 20, MOD = int(1e9) + 7;

void addIt(int&x, int c) {
    x += c;
    if (x >= MOD)
        x -= MOD;
}

int dp[1 << MAX_K];

int main() {
    int T;
    scanf("%d",&T);
    while (T--) {
        scanf("%d %d %d",&n,&k,&L);
        memset(dp, 0, sizeof dp);
        dp[0] = 1;
        int extra = 0;
        if (L > k) {
            extra = L - k;
            L = k;
        } else {
        }
        int mask = (1 << k) - 1;
        for (int i = 0; i < n; ++i) {
            for (int j = (1 << k) - 1; j >= 0; --j) {
                int c = dp[j];
                if (c == 0)
                    continue;
                for (int o = 1; o <= L; ++o) {
                    int nj = j | ((j << o) & mask) | (1 << (o - 1));
//                dp[nj] += c;
                    addIt(dp[nj], c);
                }
                addIt(dp[j], 1LL * c * extra % MOD);
            }
        }
        int ans = 0;
        for (int i = 0; i < (1 << k); ++i) {
            if (i >> (k - 1) & 1)
                addIt(ans, dp[i]);
        }
        cout << ans << endl;
    }
    return 0;
}