【Luogu】【关卡2-9】带有技巧的搜索（2017年10月）

任务说明：这里的搜索不仅包含了dfs和bfs，还包括剪枝、记录等技巧以加快速度。

[USACO06FEB]数字三角形Backward Digit Su…
滑雪
吃奶酪
靶形数独

P1118 [USACO06FEB]数字三角形Backward Digit Su…

有这么一个游戏：写出一个1～N的排列a[i]，然后每次将相邻两个数相加，构成新的序列，再对新序列进行这样的操作，显然每次构成的序列都比上一次的序列长度少1，直到只剩下一个数字位置。

最后得到16这样一个数字。

现在想要倒着玩这样一个游戏，如果知道N，知道最后得到的数字的大小sum，请你求出最初序列a[i]，为1～N的一个排列。若答案有多种可能，则输出排序最小的那一个。

解答：第一次我想直接next_permutation，然后在嵌套循环计算顶层数字，结果TLE了好几个点。

后来看了题解，大家都说的杨辉三角，我还是没懂。专门搜索了题解才看懂。

最后的结果其实是一个杨辉三角。（拿样例来说，第4层的杨辉三角是1 3 3 1; 1∗3+3∗1+3∗2+1∗4=16）

然后知道杨辉三角怎么用了之后，直接dfs求全排列，如果超过了sum值就回溯。 

#include <bits/stdc++.h>
#include <string>
using namespace std;

int n, sum;
int yanghuisanjiao[20][20] = {0};
int used[20] = {0};

void print(vector<int>& vec, std::string& strDes) {
    printf("%s: ", strDes.c_str());
    for (int i = 0; i < vec.size(); ++i) {
        printf("%d ", vec[i]);
    }
    printf("
");
}

void print(vector<int>& vec) {
    for (int i = 0; i < vec.size(); ++i) {
        printf("%d ", vec[i]);
    }
    printf("
");
}

bool dfs(int level, vector<int>& permutation, int cal_sum, int idx) {
    if (level == n + 1) {
        if (cal_sum == sum) {
            print(permutation);
            return true;
        }
        return false;
    }
    for (int i = 0; i < n; ++i) {
        if (!used[i+1]) {
            permutation[idx] = i + 1;
            used[i+1] = 1;
            //如果求和大于sum，就剪枝
            if (cal_sum + yanghuisanjiao[n-1][idx] * permutation[idx]  > sum) {
                used[i+1] = false;
                return false;
            }
            bool ans = dfs(level + 1, permutation, cal_sum + yanghuisanjiao[n-1][idx] * permutation[idx], idx + 1);
            if (ans == true) {
                return true;
            }
            used[i+1] = 0;
        }
    }
    //找到最后也没找到, 就return false
    return false;
}


int main() {
    cin >> n >> sum;

    //[1]计算杨辉三角
    for (int i = 0; i < n ; ++i) {
        for (int j = 0; j <= i; ++j) {
            if (j == 0 || j == i ) {
                yanghuisanjiao[i][j] = 1;
            }
            else {
                yanghuisanjiao[i][j] = yanghuisanjiao[i-1][j-1] + yanghuisanjiao[i-1][j];
            }
        }
    }

    //[2]深搜求全排列
    vector<int> permutation(n, 0);
    dfs(1, permutation, 0, 0);
    return 0;
}

P1433 吃奶酪

房间里放着n块奶酪。一只小老鼠要把它们都吃掉，问至少要跑多少距离？老鼠一开始在(0,0)点处。

输入：第一行一个数n (n<=15)，接下来每行2个实数，表示第i块奶酪的坐标。两点之间的距离公式=sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2))

输出：一个数，表示要跑的最少距离，保留2位小数。

题解：显然贪心不行。那么只能搜索每个点的顺序，求最小值的距离。

//这个题目最后也是90分，第五个点TLE，没想明白为啥
#include<bits/stdc++.h>
#include<unistd.h>
#include <sys/time.h>
using namespace std;

typedef pair<double, double> P;
int n;

double ans = DBL_MAX;
int addx[4] = {0, -1, 0, 1};
int addy[4] = {-1, 0, 1, 0};

void print(vector<vector<double>> vec) {
    printf("===============debug============
");
    for (int i = 0; i < vec.size(); ++i) {
        for(int j = 0; j < vec.size(); ++j) {
            printf("%.2f ", vec[i][j]);
        }
        printf("
");
    }
    printf("===============end==============
");
}

void dfs(const vector<P>& coor, const double dis[16][16], vector<int>& used, int level, double tmpans, int pre) {
    if (tmpans >= ans) {
        return;
    }
    if (level == coor.size()) {
        if (ans > tmpans) { ans = tmpans;}
        return;
    }
    for(int i = 1; i < coor.size(); ++i) {
        double temp = dis[pre][i] + tmpans;
        if (!used[i] && temp < ans) {
            used[i] = 1;
            dfs(coor, dis, used, level+1, temp, i);
            used[i] = 0;
        }
    }
}

int main() {
        struct timeval tv;
        gettimeofday(&tv, NULL);
        printf("%ld
", tv.tv_sec);
    scanf("%d", &n);
    vector<P> coor(n + 1);
    coor[0] = make_pair(0.0, 0.0);
    for(int i = 1; i <= n; ++i){
        double x, y;
        scanf("%lf %lf", &x, &y);
        coor[i] = make_pair(x, y);
    }

    double dis[16][16] = {0.0};
    for(int i = 0; i <= n; ++i) {
        for(int j = i; j <= n; ++j) {
            dis[i][j] = dis[j][i]
            = sqrt((coor[i].first - coor[j].first)*(coor[i].first - coor[j].first)
                + (coor[i].second - coor[j].second)*(coor[i].second - coor[j].second));
        }
    }

    vector<int> use(n+1);
    use[0] = 1;
    dfs(coor, dis, use, 1, 0.0, 0);
    printf("%.2f
", ans);
        gettimeofday(&tv, NULL);
        printf("%ld
", tv.tv_sec);
    return 0;
}