hdu区域赛在线热身赛 暨 第十二场组队赛

题目编号：hdu 4257~4266 (对应比赛题号1001~1010)

　　这是我们第十二场组队赛，在今天中午进行。

　　比赛刚开始，依然是由我的队友读题。还没看几题，就发现了好多题judge时长高达20秒，这真的有点给我们心理造成压力。不过，我们很快就缓解下来，然后进入读题切题的状态。因为水平不足，所以还是选择跟board做。开始没几分钟，大board就有人过了1003，于是我们就赶紧看1003了！题目相当简短，很快就看懂了是纸牌经过一系列操作以后得到另一个序列，问操作多少次会再次出现初始序列。刚开始还打算打表来看看规律，程序打出来了，发现跑起来，答案可以超过10^9，就是说暴力是不可能的。不过队友还是叫我提交上去试试，结果不言而喻，开门一个TLE了。然后我就打了一个n到9的表，让我的队友观察。十分庆幸的是，我的队友以前做过置换群的题目，所以很快就想到了可以用置换群来做。直接套入模板，然后最后加了个特判，提交上去，AC了~

代码如下（优化的不太好，时间大约要3s hdu 4259）：

#include <cstdio>

const int maxn = 801;
typedef __int64 ll;
int s[maxn][maxn], top[maxn];
int pp[maxn];

ll gcd(ll a, ll b){
    return b ? gcd(b, a % b) : a;
}

ll polya(int *perm, int n, int &num){ // 求置换群循环节的长度
    int i, j, p, v[maxn] = {0};
    ll cycle = 1;

    for (num = i = 0; i < n; i++){
        if (!v[i]){
            num++;
            p = i;
            for (j = 0; !v[perm[p]]; j++){
                p = perm[p];
                v[p] = 1;
            }
            cycle *= j / gcd(cycle, j);
        }
    }

    return cycle;
}

ll deal(int n, int m){ // 转换成置换群
    for (int i = 0; i < m; i++){
        top[i] = 0;
    }
    for (int i = 0; i < n; i++){
        int j = i % m;
        s[j][top[j]++] = i;
    }

    int k = 0;

    for (int i = 0; i < m; i++){
        while (top[i]){
            pp[k++] = s[i][top[i] - 1];
            top[i]--;
        }
    }
    return polya(pp, n, k);
}

int main(){
    int n, m;
    
    while (~scanf("%d%d", &n, &m) && (n || m)){
        if (m >= n){
            printf("1\n");
            continue;
        }
        if (m == 1){
            printf("2\n");
            continue;
        }
        printf("%I64d\n", deal(n, m));
    }
    
    return 0;
}

 

　　然后就是1004，一道与汉诺塔有关的题。刚开始的时候，打算用汉诺塔的原理来推出公式，但是看了好些时间都没看出是应该怎么判断的。于是我就将碟数为3的8种情况都写出来了，然后被我发现一个很有趣的规律，描述如下：

　　最后一个碟只可能是在A或B柱子上，如果在A柱子上，那么当前操作数就没有超过总数的一半。然后再观察倒数第二个碟子，如果跟最后一个碟子的状态一样的话，就是和最后一个碟子处于同一趋势。这里解释不太好，如果换成代码语言就是，从最后面开始判断，假设有n+1层碟子，就设第n+1个总是在A处。再说，整个过程就是移动前n层的碟子到B，所以第n+1层总是在A的位置。然后就是判断了，相邻两个碟子比较，初始状态是第n+1层是1，如果不同，就从1变成0，否则保持不变。然后，这样就可以得到一个长度为n的01串了。这个01串表示的值就是要输出的答案了！

代码很简单(hdu 4260)：

#include <cstdio>
#include <cstring>

typedef __int64 ll;
const int maxn = 70;

int main(){
    char s[maxn];
    ll ans, last;
    int len;

    while (~scanf("%s", s) && s[0] != 'X'){
        ans = 0;
        len = strlen(s);
        s[len] = 'A';
        last = 1;
        for (int i = len - 1; i >= 0; i--){
            if (s[i + 1] != s[i]) last = (last + 1) & 1;
            ans += last << i;
        }
        printf("%I64d\n", ans);
    }

    return 0;
}

 

　　然后就是1010了。题目是队友看的，然后他将题意告诉我，这是一个毫无掩饰的暴力三维凸包啊！可是刚开始的时候，队友因为从未写过凸包，所以就说不敢做。不过，凡是都应该有第一次的尝试，就是这次要用尝试来较真而已。我们好不容易才搞到一个三维凸包的模板，不过以前从未用过这样的模板，所以刚开始的时候拿着模板看了好长时间，先研究一下模板各个参数的含义。搞了个十来分钟，最后看懂的各个变量的意思了，然后就是打上去试用。打字还是慢啊，花了近半个钟才抄完代码。然后，我们将它当作黑箱，随便测了一下返回的结果。没有问题！然后就是将它放心的套入我们的暴力搜索的代码中去了！  在封榜前3分钟，提交上去，1y~  相当好的结果！

代码(hdu 4266)：

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

const int inf = 0x7fffffff;
#define max2(a, b) ((a) > (b) ? (a) : (b))
#define min2(a, b) ((a) < (b) ? (a) : (b))
const double eps = 1e-7;
const int maxn = 1005;
const double _4to5 = 5e-5;


struct pt{
    double x, y, z;
    pt(){}
    pt(double _x, double _y, double _z): x(_x), y(_y), z(_z) {}
    pt operator - (const pt p1) {return pt(x - p1.x, y - p1.y, z - p1.z);}
    pt operator * (pt p) {return pt(y * p.z - z * p.y, z * p.x - x * p.z, x * p.y - y * p.x);}
    double operator ^ (pt p) {return x * p.x + y * p.y + z * p.z;}
};

void swap(int &a, int &b){
    int t = a;
    a = b;
    b = t;
}

struct _3DCH{
    struct fac{
        int a, b, c;
        bool ok;
    };

    int n;
    pt P[maxn];

    int cnt;
    fac F[maxn * 8];

    int to[maxn][maxn];

    double vlen(pt a) {return sqrt(a.x * a.x + a.y * a.y + a.z * a.z);}
    double area(pt a, pt b, pt c) {return vlen((b - a) * (c - a));}
    double volume(pt a, pt b, pt c, pt d) {return (b - a) * (c - a) ^ (d - a);}

    double ptof(pt &p, fac &f){
        pt m = P[f.b] - P[f.a], n = P[f.c] - P[f.a], t = p - P[f.a];
        return (m * n) ^ t;
    }
    void deal(int p, int a, int b){
        int f = to[a][b];
        fac add;

        if (F[f].ok){
            if (ptof(P[p], F[f]) > eps)
                dfs(p, f);
            else{
                add.a = b, add.b = a, add.c = p, add.ok = true;
                to[p][b] = to[a][p] = to[b][a] = cnt;
                F[cnt++] = add;

            }
        }
    }

    void dfs(int p, int cur){
        F[cur].ok = false;
        deal(p, F[cur].b, F[cur].a);
        deal(p, F[cur].c, F[cur].b);
        deal(p, F[cur].a, F[cur].c);
    }

    bool same(int s, int t){
        pt &a = P[F[s].a], &b = P[F[s].b], &c = P[F[s].c];
        return fabs(volume(a, b, c, P[F[t].a])) < eps && fabs(volume(a, b, c, P[F[t].b])) < eps && fabs(volume(a, b, c, P[F[t].c])) < eps;
    }

    void construct(){
        cnt = 0;
        if (n < 4) return ;

        fac add;
        for (int i = 0; i < 4; i++){
            add.a = (i + 1) % 4, add.b = (i + 2) % 4, add.c = (i + 3) % 4, add.ok = 1;

            if (ptof(P[i], add) > 0)
                swap(add.b, add.c);
            to[add.a][add.b] = to[add.b][add.c] = to[add.c][add.a] = cnt;
            F[cnt++] = add;
        }

        for (int i = 4; i < n; i++){
            for (int j = 0; j < cnt; j++){
                if (F[j].ok && ptof(P[i], F[j]) > eps){
                    dfs(i, j);
                    break;
                }
            }
        }

        int tmp = cnt;
        cnt = 0;
        for (int i = 0;i < tmp; i++){
            if (F[i].ok){
                F[cnt++] = F[i];
            }
        }
    }

    int facetCnt_tri(){
        return cnt;
    }
};

_3DCH hull;

double vlen(pt p){
    return sqrt(p ^ p);
}

pt pvec(pt a, pt b, pt c){
    return (a - b) * (b - c);
}

double ptoplane(pt p, int a, int b, int c){
    return fabs((pvec(hull.P[a], hull.P[b], hull.P[c]) ^ (p - hull.P[a])) / vlen(pvec(hull.P[a], hull.P[b], hull.P[c])));
}

double final(pt a, int cnt){
    double mindis = 1e300;

    for (int i = 0; i < cnt; i++){
        double dis = ptoplane(a, hull.F[i].a, hull.F[i].b, hull.F[i].c); // 求点到面的距离

        if (mindis > dis) mindis = dis;
    }

    return mindis;
}

int main(){
    int cnt;

    while (scanf("%d", &hull.n) && hull.n){
        for (int i = 0; i < hull.n; i++){
            scanf("%lf%lf%lf", &hull.P[i].x, &hull.P[i].y, &hull.P[i].z);
        }
        hull.construct(); // 构建凸包
        cnt = hull.facetCnt_tri(); // 凸包的三角形面的个数
#ifndef ONLINE_JUDGE
        for (int i = 0; i < cnt; i++){
            printf("%3d %3d %3d\n", hull.F[i].a, hull.F[i].b, hull.F[i].c);
        }
        puts("");
#endif
        int m;
        pt tmp;

        scanf("%d", &m);
        while (m--){
            scanf("%lf%lf%lf", &tmp.x, &tmp.y, &tmp.z);
            printf("%.4f\n", final(tmp, cnt)); // 暴力搜索最小解
        }
    }

    return 0;
}

 

　　最后还有一个钟，我们就尝试着做1007。1007当时是比较多人过的，当时没想懂为什么求两次生成树得到一个范围，然后如果k在这个范围里就是存在这样的生成树，所以没敢将这个想法转换成代码！  现在想起来就觉得后悔了，因为当时还剩1个小时，这题如果是尝试的话是绝对可能过的！不过也算了吧，今天的成绩还算是挺好的了！下周依然要加把努力，争取最后能够有质的飞跃！

 

1007代码(hdu 4263)：

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>

using namespace std;

const int maxn = 1005;
const int inf = 0x7f7f7f7f;

int eh[maxn], tt, dis[maxn];
bool vis[maxn];
struct edge{
    int s;
    int t;
    int c;
    void add(int _s, int _t, int _c){
        s = _s;
        t = _t;
        c = _c;
    }
    bool operator < (const edge &x) const{
        return c < x.c;
    }
}E[maxn * maxn];
priority_queue<edge, vector<edge>, less<edge> > Q;

bool cmp(edge a, edge b){
    return a.s < b.s;
}

void pre_prim(int n, int m){
    sort(E, E + m, cmp);
    int p = 0, k;

    for (int i = 1; i <= n; i++){
        eh[i] = 0;
    }
    for (k = 0; k < m; k++){
        while (p <= E[k].s) eh[p++] = k;
    }
    while (p <= n + 1) {
        eh[p++] = m;
    }
#ifndef ONLINE_JUDGE
    for (int i = 0; i <= n + 1; i++){
        printf("%d : %d %d %d eh %d\n", i, E[i].s, E[i].t, E[i].c, eh[i]);
    }
    puts("");
#endif
}

int prim(int n, int m, int s){
    edge tmp;
    int ret = 0;

    pre_prim(n, m);
    tmp.add(s, 0, 0);
    for (int i = 1; i <= n; i++){
        vis[i] = false;
        dis[i] = -inf;
    }
    while (Q.size()) Q.pop();
    Q.push(tmp);
    dis[s] = 0;

    while (Q.size()){
        edge cur = Q.top();
        Q.pop();

        int u = cur.s, cost = cur.c;
        if (vis[u]) continue;
        ret += cost;
        vis[u] = true;
        for (int i = eh[u]; i < eh[u + 1]; i++){
            int v = E[i].t;

            if (!vis[v] && dis[v] < E[i].c){
                dis[v] =  E[i].c;
                cur.add(v, 0, dis[v]);
                Q.push(cur);
            }
        }
    }

    return ret;
}

void reverse(int m){
    for (int i = 0; i < m; i++){
        E[i].c++;
        E[i].c &= 1;
    }
}

bool deal(int n, int m, int k){
    int high, low;

    high = prim(n, m, 1);
    reverse(m);
    low = prim(n, m, 1);
    low = n - low - 1;
#ifndef ONLINE_JUDGE
    printf("%d %d\n", high, low);
#endif
    return low <= k && k <= high;
}

int main(){
    int n, m, k;
    int s, t, i1, i2;
    char cl[3];

#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
#endif
    while (~scanf("%d%d%d", &n, &m, &k) && (n || m || k)){
        for (int i = 0; i < m; i++){
            scanf("%s%d%d", cl, &s, &t);
            i1 = i << 1;
            i2 = i << 1 | 1;
            E[i1].add(s, t, cl[0] == 'B');
            E[i2].add(t, s, cl[0] == 'B');
        }
        printf("%d\n", deal(n, m << 1, k));
    }

    return 0;
}

 

 

——written by Lyon