【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[][] = {};
 int used[] = {};

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

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

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

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

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

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

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[] = {, -, , };
 int addy[] = {-, , , };

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

 void dfs(const vector<P>& coor, const double dis[][], 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 = ; i < coor.size(); ++i) {
         double temp = dis[pre][i] + tmpans;
         if (!used[i] && temp < ans) {
             used[i] = ;
             dfs(coor, dis, used, level+, temp, i);
             used[i] = ;
         }
     }
 }

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

     double dis[][] = {0.0};
     for(int i = ; 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+);
     use[] = ;
     dfs(coor, dis, use, , 0.0, );
     printf("%.2f\n", ans);
         gettimeofday(&tv, NULL);
         printf("%ld\n", tv.tv_sec);
     return ;
 }