P2831 愤怒的小鸟

本来想先做天天爱跑步的, 被恶心到了, 所以来做这个题.

Solution

代码基础为XKY的爆搜代码
然后优化优化再优化.

主要做了以下优化:

• 预处理出每种状态最后一个缺失的猪.
• 预处理出打到每种猪的状态, 且状态之间不存在包含关系.
• 将打到每种猪的所有状态按打到猪的个数排序.
• 如果当前状态的答案大于等于这个状态的最优答案, 搜索无效.

然后其实最后一个优化才是最关键的, 它会减少大量的搜索.
前几种大概会让复杂度上界变小很多, 不知道该怎么描述这个东西.

#include <algorithm>
#include <iostream>
#include <cstdio>
#include <stdlib.h>
#include <cstring>
#include <cmath>
#include <vector>
using namespace std;
#pragma GCC target ("popcnt")
const double eps = 1e-7;
const int N = 55;

struct edge {
    double x, y;
} e[N];
vector<int> P[N];
int First[1 << 19];
bool vis[N][N];

inline void calc(double &a, double &b, double x1, double y1, double x2, double y2) {
    a = (x2 * y1 - x1 * y2) / (x1 * x2 * (x1 - x2));
    b = (x1 * x1 * y2 - x2 * x2 * y1) / (x1 * x2 * (x1 - x2));
}
int lim[1 << 18];
void dfs(int Status, const int& goal, int sum, int& ans) {
    if (sum >= lim[Status]) return;
    lim[Status] = min(sum, lim[Status]);
    if (Status == goal) { ans = min(ans, sum); return; }
    int p = First[Status];
    for (auto status : P[p])
        dfs(Status | status, goal, sum + 1, ans);
}

inline bool equal_double(double a, double b) {
    return a - b < eps and b - a < eps;
}
inline bool cmp(int a, int b) {
    return __builtin_popcount(a) > __builtin_popcount(b);
}

int main() {
    int T, n, k;
    scanf("%d", &T);
    while (T--) {
        scanf("%d%d", &n, &k);
        int Mx = 1 << n;
        for (int i = 0; i < Mx; i += 1) {
            for (int j = 0; j < n; j += 1)
                if (not (i & (1 << j))) {
                    First[i] = j; break;
                }
        }
        memset(lim, 0x3f, sizeof lim);
        int ans = 0x7fffffff;
        memset(vis, false, sizeof vis);
        for (int i = 0; i < n; i += 1) P[i].clear();
        for (int i = 0; i < n; i += 1)
            scanf("%lf%lf", &e[i].x, &e[i].y);
        double a, b;
        int flag = false, Status = 0;
        for (int i = 0; i < n; i += 1) {
            for (int j = i + 1; j < n; j += 1) {
                if (vis[i][j]) continue;
                flag = Status = false;
                calc(a, b, e[i].x, e[i].y, e[j].x, e[j].y);
                if (a >= 0) continue;
                flag = true;
                vis[i][j] = vis[j][i] = 1;
                Status |= (1 << i) + (1 << j);
                for (int k = 0; k < n; k += 1) {
                    if (k == i or k == j) continue;
                    if (vis[k][i] or vis[k][j]) continue;
                    if (equal_double((e[k].x * e[k].x) * a + b * e[k].x, e[k].y)) {
                        Status |= (1 << k), vis[i][k] = vis[k][i] = vis[k][j] = vis[j][k] = 1;
                    }
                }
                for (int k = 0; k < n; k += 1)
                    if (Status & (1 << k))
                    P[k].push_back(Status);
            }
            if (not flag) P[i].push_back(1 << i);
        }
        for (int i = 0; i < n; i += 1)
            std:: sort(P[i].begin(), P[i].end(), cmp);
        dfs(0, Mx - 1, 0, ans);
        printf("%d\n", ans);
    }
    return 0;
}

转载于:https://www.cnblogs.com/qdscwyy/p/9875776.html