【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 = ;
 const int maxm = ;
 int c[maxn], s[maxn];
 int a[maxn], R[maxm];
 bool visit[maxm][maxm];
 int n, m, bound;
 bool flag;

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

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

 bool check(int x, int y, int n) {
     if (x & ) {
         // straight triangle
         int yy = y;
         rep(i, , n+) {
             int xx = x, l = i*-;
             rep(j, , l) {
                 if (judge(xx, yy) || visit[yy][xx])    return false;
                 ++xx;
             }
             ++yy;
         }
     } else {
         // reverse triangle
         int yy = y;
         int c = ;
         per(i, , n+) {
             int xx = x + c * , l = i*-;
             rep(j, , 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 & ) {
         // straight triangle
         int yy = y;
         rep(i, , n+) {
             int xx = x, l = i*-;
             rep(j, , l) {
                 visit[yy][xx] = delta;
                 ++xx;
             }
             ++yy;
         }
     } else {
         // reverse triangle
         int yy = y;
         int c = ;
         per(i, , n+) {
             int xx = x + c * , l = i*-;
             rep(j, , l) {
                 visit[yy][xx] = delta;
                 ++xx;
             }
             ++c;
             ++yy;
         }
     }
 }

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

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

     if (visit[dep][r])    {
         dfs(rr, depp);
     } else {
         rep(i, , 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, , n+)
         R[i] = *i-;
     dfs(, );
     return flag;
 }

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

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

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

     {    // filter unnecessary
         int j = ;

         rep(i, , m) {
             if (a[i] > n)
                 break;
             bool flag = true;
             rep(k, , j) {
                 if (a[i]%a[k] == ) {
                     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();
     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, , m)
             scanf("%d", a+i);
         solve();
     }

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

     return ;
 }