【HDOJ】1362 The Bermuda Triangle

1. 题目描述
给定几个三角形拼成一个百慕大三角形。

2. 基本思路
基本思路肯定是搜索，关键点是剪枝。
(1) 若存在长度为$l$的边，则一定可以拼成长度为$k \cdot l$的三角形，则可拼成长度为$k \cdot l$的百慕大三角形；
(2) 长度超过百慕大三角形的边长的三角形没有任何价值；
(3) 百慕大三角形中每个正三角形可以作为正多边形的顶点，倒三角形可以作为倒正三角形的顶点。
因此，可以将每个三角形映射到二维坐标，高度为$y$，倒三角形的$x$坐标为偶数，正三角形的$x$坐标为奇数。
对于每个有效的坐标，枚举可以使用的三角形。暴力深搜可解。
然后，观察可发现每个百慕大是由6个正三角形或3个平行四边形组成。因此，假设可以拼成三角形或平行四边形，那么一定可以拼成百慕大。
对于不同的形状，不需要重写dfs函数，只需要限定好边界即可。

3. 代码

/* 1362 */
#include <iostream>
#include <sstream>
#include <string>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
#include <deque>
#include <bitset>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <ctime>
#include <cstring>
#include <climits>
#include <cctype>
#include <cassert>
#include <functional>
#include <iterator>
#include <iomanip>
using namespace std;
//#pragma comment(linker,"/STACK:102400000,1024000")

#define sti                set<int>
#define stpii            set<pair<int, int> >
#define mpii            map<int,int>
#define vi                vector<int>
#define pii                pair<int,int>
#define vpii            vector<pair<int,int> >
#define rep(i, a, n)     for (int i=a;i<n;++i)
#define per(i, a, n)     for (int i=n-1;i>=a;--i)
#define clr                clear
#define pb                 push_back
#define mp                 make_pair
#define fir                first
#define sec                second
#define all(x)             (x).begin(),(x).end()
#define SZ(x)             ((int)(x).size())
#define lson            l, mid, rt<<1
#define rson            mid+1, r, rt<<1|1

const int maxn = 30;
const int maxm = 60;
int c[maxn], s[maxn];
int a[maxn], R[maxm];
bool visit[maxm][maxm];
int n, m, bound;
bool flag;

void init() {
    rep(i, 1, maxn)
        c[i] = c[i-1] + i*2-1;
    rep(i, 1, maxn)
        s[i] = 6 * c[i];
}

inline bool judge(int x, int y) {
    return y<=0 || y>bound || x<=0 || x>R[y];
}

bool check(int x, int y, int n) {
    if (x & 1) {
        // straight triangle
        int yy = y;
        rep(i, 1, n+1) {
            int xx = x, l = i*2-1;
            rep(j, 0, l) {
                if (judge(xx, yy) || visit[yy][xx])    return false;
                ++xx;
            }
            ++yy;
        }
    } else {
        // reverse triangle
        int yy = y;
        int c = 0;
        per(i, 1, n+1) {
            int xx = x + c * 2, l = i*2-1;
            rep(j, 0, l) {
                if (judge(xx, yy) || visit[yy][xx])    return false;
                ++xx;
            }
            ++c;
            ++yy;
        }
    }
    return true;
}

void update(int x, int y, int n, bool delta) {
    if (x & 1) {
        // straight triangle
        int yy = y;
        rep(i, 1, n+1) {
            int xx = x, l = i*2-1;
            rep(j, 0, l) {
                visit[yy][xx] = delta;
                ++xx;
            }
            ++yy;
        }
    } else {
        // reverse triangle
        int yy = y;
        int c = 0;
        per(i, 1, n+1) {
            int xx = x + c * 2, l = i*2-1;
            rep(j, 0, l) {
                visit[yy][xx] = delta;
                ++xx;
            }
            ++c;
            ++yy;
        }
    }
}

void dfs(int r, int dep) {
    if (dep > bound)    {
        flag = true;
        return ;
    }

    int rr = r + 1, depp = dep;
    if (r == R[dep]) {
        rr = 1;
        ++depp;
    }

    if (visit[dep][r])    {
        dfs(rr, depp);
    } else {
        rep(i, 0, m) {
            int l = a[i];
            if (check(r, dep, l)) {
                update(r, dep, l, true);
                dfs(rr, depp);
                update(r, dep, l, false);
                if (flag)    return;
            } else {
                break;
            }
        }
    }
}

bool judge1() {
    flag = false;
    bound = n;
    memset(visit, false, sizeof(visit));
    rep(i, 1, n+1)
        R[i] = 2*i-1;
    dfs(1, 1);
    return flag;
}

bool judge2() {
    flag = false;
    bound = n;
    memset(visit, false, sizeof(visit));
    rep(i, 1, n+1)
        R[i] = 2*i-1;
    dfs(1, 1);
    return flag;
}

bool judge3() {
    flag = false;
    bound = n*2;
    memset(visit, false, sizeof(visit));
    rep(i, 1, n+1) {
        R[i] = n*2 + 2*i-1;
    }
    rep(i, n+1, n*2+1) {
        rep(j, 1, 2*(i-n))
            visit[i][j] = true;
        R[i] = (n + n)*2;
    }
    dfs(1, 1);
    return flag;
}

void solve() {
    sort(a, a+m);
    rep(i, 0, m) {
        if (n%a[i] == 0) {
            puts("YES");
            return ;
        }
    }
    if (a[0] > n) {
        puts("NO");
        return ;
    }

    {    // filter unnecessary
        int j = 1;

        rep(i, 1, m) {
            if (a[i] > n)
                break;
            bool flag = true;
            rep(k, 0, j) {
                if (a[i]%a[k] == 0) {
                    flag = false;
                }
            }
            if (flag)
                a[j++] = a[i];
        }
        m = j;
    }

    if (judge1()) {
        puts("YES");
        return ;
    }

    if (judge2()) {
        puts("YES");
        return ;
    }

    if (judge3()) {
        puts("YES");
        return ;
    }

    puts("NO");
}

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);
    #ifndef ONLINE_JUDGE
        freopen("data.in", "r", stdin);
        freopen("data.out", "w", stdout);
    #endif

    int t;

    scanf("%d", &t);
    while (t--) {
        scanf("%d%d", &n,&m);
        rep(i, 0, m)
            scanf("%d", a+i);
        solve();
    }

    #ifndef ONLINE_JUDGE
        printf("time = %ldms.\n", clock());
    #endif

    return 0;
}