LA 3667 Ruler

https://icpcarchive.ecs.baylor.edu/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=1668

　　这题想了两天，两天里经历了发烧感冒，各种疲惫难堪。

　　因为这题在网上没有题解，只好强迫着自己去想应该怎么去搜索来解决。其实很容易就留意到答案的长度最多是7，实际上最多只需要找6个数，这个相当的关键。然后留意的一个要点是，距离是怎么测的呢？显然，一个长度是通过两个标记的距离差测出来的，所以对某个序列其中一个标记加或减这个长度，就会得到另一个标记，从而可以通过搜索6!*2种排列方式找到答案。而不是google能搜到的唯一的，而且还是没过的题解中解释的那样，标记不一定都是长度的其中几个。例如，5,15,25,35这组数据。

　　我的搜索是用bfs的，可是写的有点复杂。最可惜的是，我写完以后，发现LA的这题无论怎么交都是PE。。。囧。表示最近比较倒霉！希望到时OJ弄好这个问题以后可以通过这个代码。现在先发上来：

/***************** Written By Lyon, From SCAU, Beta 1.4.0 **************/
/**************** headers && constants && definitions ****************/
#pragma comment(linker, "/STACK:102400000,102400000")

#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <numeric>
#include <vector>
#include <string>
#include <bitset>
#include <queue>
#include <ctime>
#include <stack>
#include <set>
#include <map>

using namespace std;

#define PB push_back
#define FI first
#define SE second
#define MPR make_pair
#define REP(i, n) for (int i = 0; i < (n); i++)
#define REP_1(i, n) for (int i = 1; i <= (n); i++)
#define INC(i, a, b) for (int i = (a); i <= (b); i++)
#define DEC(i, a, b) for (int i = (a); i >= (b); i--)
#define _clr(x) memset(x, 0, sizeof(x))
#define _rst(x) memset(x, -1, sizeof(x))
#define SZ(x) ((int) x.size())
#define PRIQ priority_queue
#define MSET multiset
#define ITOR iterator
#define RITOR reverse_iterator
#define ALL(x) (x).begin(), (x).end()

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PII;
typedef pair<double, double> PDBDB;
typedef pair<double, int> PDBI;
typedef pair<int, double> PIDB;
typedef vector<PIDB> VPIDB;
typedef vector<PDBDB> VPDBDB;
typedef vector<PDBI> VPDBI;
typedef pair<PII, int> PIII;
typedef pair<PII, string> PIIS;
typedef vector<int> VI;
typedef vector<LL> VL;
typedef vector<PII> VPII;
typedef vector<PIII> VPIII;
typedef vector<double> VDBL;
typedef vector<string> VSTR;
typedef vector<VSTR> VVSTR;
typedef vector<VI> VVI;
typedef vector<char> VCH;
typedef vector<VCH> VVCH;
typedef vector<bool> VBL;
typedef long double LDB;

const int N = 1e6 + 500;
const int M = 1 << 5;
const int LEN = 105;
const int hashMod = 1e6 + 5;
const int inf = 0x55555555;
const double eps = 1e-8;
const LDB leps = 1e-10;
const LL linf = 0x5555555555555555ll;
const double finf = 1e50;
const double pi = acos(-1.0);
const int mod = 1e9 + 7;

template <class T> inline T sqr(T x) {
    return x * x;
}
/*********************************************************************/

typedef pair<char, VI> PCHVI;
queue<PCHVI> Q;
PCHVI best;
int rec[55], n, id[N];
bool vis[55];

void getBest(PCHVI &tmp) {
    if (~best.FI) {
        if (SZ(best.SE) == SZ(tmp.SE)) {
            sort(ALL(tmp.SE));
            if (*best.SE.rbegin() > *tmp.SE.rbegin()) best = tmp;
        } else {
            if (SZ(best.SE) > SZ(tmp.SE)) best = tmp;
        }
    } else best = tmp;
}

bool check(VI &tmp) {
    int t;
    REP(i, n) vis[i] = false;
    REP(i, SZ(tmp)) {
        REP(j, i) {
            if (abs(tmp[i] - tmp[j]) >= N) continue;
            t = id[abs(tmp[i] - tmp[j])];
            if (t) vis[t - 1] = true;
        }
    }
    REP(i, n) if (!vis[i]) return false;
    return true;
}

bool test(VI &tmp, int x) {
    REP(i, SZ(tmp)) if (x == tmp[i]) return false;
    return true;
}

void bfs(int n) {
    VI tmp;
    PCHVI cur;
    n = min(n, 6);
    tmp.clear();
    best = MPR((char) -1, tmp);
    while (!Q.empty()) Q.pop();
    tmp.PB(0);
    Q.push(MPR(0, tmp));
    while (true) {
        if (Q.empty()) break;
        int qn = SZ(Q);
//        cout << SZ(Q.front().SE) << endl;
        bool found = false;
        REP(i, qn) {
            cur = Q.front();
            Q.pop();
            REP(j, n) {
                if (cur.FI & (1 << j)) continue;
                cur.FI ^= 1 << j;
                REP(k, SZ(cur.SE)) {
                    int t = cur.SE[k] - rec[j];
                    if (t > 0 && test(cur.SE, t)) {
                        cur.SE.PB(t);
                        if (check(cur.SE)) {
                            getBest(cur);
                            found = true;
                        }
                        Q.push(cur);
                        cur.SE.pop_back();
                    }
                    t = cur.SE[k] + rec[j];
                    if (test(cur.SE, t)) {
                        cur.SE.PB(t);
                        if (check(cur.SE)) {
                            getBest(cur);
                            found = true;
                        }
                        Q.push(cur);
                        cur.SE.pop_back();
                    }
                }
                cur.FI ^= 1 << j;
            }
        }
        if (found) break;
    }
}

void work() {
    _clr(id);
    sort(rec, rec + n);
    n = unique(rec, rec + n) - rec;
    REP(i, n) {
        id[rec[i]] = i + 1;
    }
    bfs(n);
    sort(ALL(best.SE));
    printf("%d\n", SZ(best.SE));
    REP(i, SZ(best.SE)) {
        if (i) putchar(' ');
        printf("%d", best.SE[i]);
    }
    puts("");
}

int main() {
    int cas = 1;
    while (~scanf("%d", &n) && n) {
        REP(i, n) scanf("%d", &rec[i]);
        printf("Case %d:\n", cas++);
        work();
    }
    return 0;
}

　　欢迎有优化方法的大神留言，小牛表示虚心接受！

UPD：

　　Yeah！修复以后表示178ms过了！值得一做的好题！

——written by Lyon