2013多校训练赛第三场 总结

HDU 4621~4631

　　今天的多校好变态，是IOI冠军出的题，把我们虐的半死了。

　　简单讲一下今天的情况，今天就只做了两道水题，算是签了个到，然后就卡1011（HDU 4631）一个下午了。其实感觉今天1009的几何是可以做的，因为我之前也做过类似的题，不过最后还是因为没信心做，所以放弃了。目测是可以用PSLG来做1009的，不过当时计算了一下最坏复杂度，觉得会超时，一直没做。

　　1011啱看上去是kd树，不过当时搞了好久都还是超时。开始的时候我直接上标准kd树，不带平衡功能的，各种超时。然后我就改成预处理整棵树，然后就用标记法来搞点的插入，理论上平均能达到O(log n)每次操作的，因为树的结点是固定下来的。不过最意想不到的是，这样做的kd树最后还是退化了，随便搞一组case就跑了个本地21s，虽然很多500k的数据还是能12s内出答案的。

　　然后我就加上更多的标记，原来12s的变成7s了，优化了不少。然后还是被我找到要20s+才能出答案的数据。。。_(:з」∠)_这题就一直卡到最后了。

今天0贡献，代码不用队友的，重写了一遍：

4631 ( Sad Love Story )

　　居然用set能过，真是大开眼界了。

#include <iostream>
#include <set>
#include <algorithm>
#include <cstring>
#include <cstdio>
#include <ctime>

using namespace std;

typedef long long LL;
typedef pair<int, int> PII;
template<class T> T sqr(T x) { return x * x;}
LL dist(PII a, PII b) { return sqr((LL) a.first - b.first) + sqr((LL) a.second - b.second);}
#define ITOR iterator
set<PII> pts;

int main() {
    int T, n;
    int ax, bx, cx, ay, by, cy;
    cin >> T;
    while (T--) {
        cin >> n >> ax >> bx >> cx >> ay >> by >> cy;
        //time_t t1 = clock();
        pts.clear();
        int x = 0, y = 0;
        LL sum = 0, mn = 1ll << 62, dis;
        set<PII>::ITOR si, c;
        PII cur;
        for (int i = 0; i < n; i++) {
            x = ((LL) ax * x + bx) % cx;
            y = ((LL) ay * y + by) % cy;
            cur = PII(x, y);
            if (mn == 0) break;
            if (pts.find(cur) != pts.end()) { mn = 0; break;}
            pts.insert(cur);
            c = si = pts.find(cur);
            c++;
            while (c != pts.end()) {
                dis = dist(cur, *c);
                mn = min(mn, dis);
                if (sqr((LL) (*c).first - cur.first) >= mn) break;
                c++;
            }
            c = si;
            while (true) {
                if (c == pts.begin()) break;
                c--;
                dis = dist(cur, *c);
                mn = min(mn, dis);
                if (sqr((LL) (*c).first - cur.first) >= mn) break;
            }
            if (i) sum += mn;
        }
        cout << sum << endl;
        //cout << "time " << (double) (clock() - t1) / CLOCKS_PER_SEC << endl;
    }
    return 0;
}

4628 ( Pieces )

　　直接状态压缩然后暴力dp枚举子集，for (int j = i; j; j = (j - 1) & i) ;

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>

using namespace std;

const int N = 1 << 16;
bool vis[N];
int dp[N], top;
char str[22], cur[22];

bool check() {
    int s = 0, t = top;
    while (s < t) if (cur[s++] != cur[t--]) return false;
    return true;
}

void dfs(int p, int len, int st) {
    if (p >= len) {
        if (check()) vis[st] = true;
        return ;
    }
    cur[++top] = str[p];
    dfs(p + 1, len, st | 1 << p);
    top--;
    dfs(p + 1, len, st);
}

int DP(int len) {
    memset(dp, 127, sizeof(dp));
    dp[0] = 0;
    for (int i = 1, e = 1 << len; i < e; i++) {
        for (int j = i; j; j = (j - 1) & i) {
            if (vis[j]) dp[i] = min(dp[i ^ j] + 1, dp[i]);
        }
    }
    return dp[(1 << len) - 1];
}


int main() {
    int T;
    cin >> T;
    while (T-- && cin >> str) {
        memset(vis, 0, sizeof(vis));
        top = -1;
        dfs(0, strlen(str), 0);
        //for (int i = 0; i < (1 << strlen(str)); i++) cout << i << ' ' << vis[i] << endl;
        cout << DP(strlen(str)) << endl;
    } 
    return 0;
}

4627 ( The Unsolvable Problem )

　　分3种情况，一种是奇数的时候，直接分解成n/2和n/2+1相乘即可，偶数有两种，其实就是枚举(n/2-1)和(n/2+1)、(n/2-2)和(n/2+2)两个的gcd。

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

typedef long long LL;
inline LL gcd(LL a, LL b) { return b ? gcd(b, a % b) : a;}
inline LL lcm(LL a, LL b) { return a / gcd(a, b) * b;}

int main() {
    int T;
    LL n;
    cin >> T;
    while (T-- && cin >> n) {
        if (n & 1) cout << (n >> 1) * ((n >> 1) + 1) << endl;
        else {
            LL m = n >> 1, ans = m;
            for (int i = 1; i <= 2; i++) {
                if (m - i <= 0) break;
                ans = max(ans, lcm(m + i, m - i));
            }
            cout << ans << endl;
        }
    }
    return 0;
}

　　总的来说，这次就是被惨虐。一个原因是最近在恶补基础，没有锻炼思维的灵活性，题目稍微变形就只会死板的解题是不行的。在补完基础以后再加强一下！

UPD：

4629（Burning）

　　PSLG简单模型。

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <ctime>
#include <vector>
#include <map>
#include <set>

using namespace std;

const int N = 11111;
const double EPS = 1e-8;
template<class T> T sqr(T x) { return x * x;}
inline int sgn(double x) { return (x > EPS) - (x < -EPS);}
struct Point {
    double x, y;
    int id;
    Point() {}
    Point(double x, double y) : x(x), y(y) {}
    Point operator + (Point a) { return Point(x + a.x, y + a.y);}
    Point operator - (Point a) { return Point(x - a.x, y - a.y);}
    Point operator * (double p) { return Point(x * p, y * p);}
    Point operator / (double p) { return Point(x / p, y / p);}
    bool operator < (Point a) const { return sgn(x - a.x) < 0 || sgn(x - a.x) == 0 && y < a.y;}
    bool operator == (Point a) const { return sgn(x - a.x) == 0 && sgn(y - a.y) == 0;} 
} ips[N];

inline double cross(Point a, Point b) { return a.x * b.y - a.y * b.x;}
inline double dot(Point a, Point b) { return a.x * b.x + a.y * b.y;}
inline double veclen(Point x) { return sqrt(dot(x, x));}
inline Point vecunit(Point x) { return x / veclen(x);}
inline Point normal(Point x) { return Point(-x.y, x.x) / veclen(x);}

struct Line {
    Point s, t;
    Line() {}
    Line(Point s, Point t) : s(s), t(t) {}
    Point vec() { return t - s;}
    Point point(double d) { return s + vec() * d;}
} ;

inline Point llint(Line a, Line b) { return a.point(cross(b.vec(), a.s - b.s) / cross(a.vec(), b.vec()));}
inline bool onseg(Point x, Point a, Point b) { return sgn(cross(a - x, b - x)) == 0 && sgn(dot(a - x, b - x)) <= 0;}

int ptinpoly(Point p, Point *pt, int n) {
    int wn = 0;
    pt[n] = pt[0];
    for (int i = 0; i < n; i++) {
        if (onseg(p, pt[i], pt[i + 1])) return -1;
        int k = sgn(cross(pt[i + 1] - pt[i], p - pt[i]));
        int d1 = sgn(pt[i].y - p.y);
        int d2 = sgn(pt[i + 1].y - p.y);
        if (k > 0 && d1 <= 0 && d2 > 0) wn++;
        if (k < 0 && d2 <= 0 && d1 > 0) wn--;
    }
    return wn != 0;
}

Point tri[55][4], pts[222];
typedef pair<double, int> PDI;
typedef pair<int, int> PII;
vector<PDI> rel[N];
map<int, int> nxp[N];
set<PII> vis;
double ans[55];

inline double angle(Point x) { return atan2(x.y, x.x);}
bool operator < (PDI a, PDI b) { return sgn(a.first - b.first) < 0 || sgn(a.first - b.first) == 0 && a.second < b.second;}
bool operator == (PDI a, PDI b) { return sgn(a.first - b.first) == 0 && a.second == b.second;}

int main() {
    //freopen("in", "r", stdin);
    int T, n, m;
    scanf("%d
", &T);
    while (T-- && ~scanf("%d", &n)) {
        m = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < 3; j++) {
                scanf("%lf%lf", &tri[i][j].x, &tri[i][j].y);
                ips[m++] = tri[i][j];
            }
            tri[i][3] = tri[i][0];
        }
        Line a, b;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < 3; j++) {
                a = Line(tri[i][j], tri[i][j + 1]);
                for (int x = i + 1; x < n; x++) {
                    if (i == x) continue;
                    for (int y = 0; y < 3; y++) {
                        b = Line(tri[x][y], tri[x][y + 1]);
                        if (sgn(cross(a.vec(), b.vec()))) {
                            ips[m] = llint(a, b);
                            if (onseg(ips[m], a.s, a.t) && onseg(ips[m], b.s, b.t)) m++;
                        }
                    }
                }
            }
        }
        sort(ips, ips + m);
        m = (int) (unique(ips, ips + m) - ips);
        for (int i = 0; i < m; i++) ips[i].id = i, rel[i].clear(), nxp[i].clear();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < 3; j++) {
                int t = 0;
                for (int k = 0; k < m; k++) {
                    if (onseg(ips[k], tri[i][j], tri[i][j + 1])) pts[t++] = ips[k];
                }
                sort(pts, pts + t);
                for (int i = 1; i < t; i++) {
                    rel[pts[i].id].push_back(PDI(angle(pts[i - 1] - pts[i]), pts[i - 1].id));
                    rel[pts[i - 1].id].push_back(PDI(angle(pts[i] - pts[i - 1]), pts[i].id));
                }
            }
        }
        for (int i = 0; i < m; i++) {
            sort(rel[i].begin(), rel[i].end());
            int t = (int) (unique(rel[i].begin(), rel[i].end()) - rel[i].begin());
            while (rel[i].size() > t) rel[i].pop_back();
            if (t) {
                rel[i].push_back(rel[i][0]);
                for (int j = 0; j < t; j++) nxp[rel[i][j + 1].second][i] = rel[i][j].second;
                rel[i].pop_back();
            }
        }
        vis.clear();
        memset(ans, 0, sizeof(ans));
        Point mid, nor;
        for (int i = 0, t; i < m; i++) {
            int sz = rel[i].size();
            for (int j = 0; j < sz; j++) {
                if (vis.find(PII(i, rel[i][j].second)) != vis.end()) continue;
                double tmp = 0;
                int c = i, nx = rel[i][j].second;
                while (vis.find(PII(c, nx)) == vis.end()) {
                    tmp += cross(ips[c], ips[nx]);
                    vis.insert(PII(c, nx));
                    t = c, c = nx, nx = nxp[t][c];
                }
                c = i, nx = rel[i][j].second;
                nor = normal(ips[nx] - ips[c]) * 1e-4;
                mid = (ips[c] + ips[nx]) / 2 + nor;
                int cnt = 0;
                for (int i = 0; i < n; i++) {
                    if (ptinpoly(mid, tri[i], 3)) cnt++;
                }
                ans[cnt] += tmp;
            }
        }
        for (int i = 1; i <= n; i++) printf("%.6f
", ans[i] / 2);
    }
    return 0;
}

——written by Lyon