【Luogu】【关卡2-7】深度优先搜索（2017年10月）【AK】【题解没写完】

任务说明：搜索可以穷举各种情况。很多题目都可以用搜索完成。就算不能，搜索也是骗分神器。

P1219 八皇后

直接dfs。对角线怎么判断：同一条对角线的横纵坐标的和或者差相同。

 #include <iostream>
 #include <vector>
 #include <cstdio>
 #include <cstdlib>
 #include <cmath>

 using namespace std;

 static int total = ;
 vector<vector<int>> ans;

 void print(int t, vector<vector<bool>>& chess) {
     printf("the %dth answer\n", t);
     for(int i = ; i < chess.size(); ++i) {
         for(int j = ; j < chess[i].size(); ++j) {
             //printf("%d", chess[i][j]);
             cout << chess[i][j];
         }
         printf("\n");
     }
 }

 void print(int t, vector<int>& current_ans) {
     //printf("the %dth answer\n", t);
     printf("%d", current_ans[]);
     for(int i = ; i < current_ans.size(); ++i) {
             printf(" %d", current_ans[i]);
     }
     printf("\n");
 }

 void queuens(vector<vector<bool>>& chess, int i, const int N,
              vector<int>& cols, vector<int>& diagnals, vector<int>& anti_diagnals,
              vector<int>& current_answer) {
     if (i == N) {
         total++;
         if (total <= ) {
             print(total, current_answer);
         }
         return;
     }
     for(int col = ; col < N; ++col) {
         if(cols[col] ==  && anti_diagnals[i-col+N] ==  && diagnals[i+col] == ) {
             cols[col] = ; anti_diagnals[i-col+N] =  ; diagnals[i+col] = ;
             current_answer[i] = col+;
             queuens(chess, i+, N, cols, diagnals, anti_diagnals, current_answer);
             cols[col] = ; anti_diagnals[i-col+N] =  ; diagnals[i+col] = ;
             current_answer[i] = ;
         }
     }
 }

 int main() {
     int N;
     cin >> N;
     vector<vector<bool>> chess(N, vector<bool>(N, false));
     vector<int> diagnals(*N-, );
     vector<int> anti_diagnals(*N-, );
     vector<int> cols(N, );
     vector<int> current_answer(N, );
     queuens(chess, , N, cols, diagnals, anti_diagnals, current_answer);
     printf("%d\n", total);
     return ;
 }

P1019 单词接龙

做的时候没写题解，结果现在忘记了。。。orz

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <utility>
 #include <string>
 #include <cstring>
 #include <vector>
 using namespace std;

 typedef pair<string, int> P;
 static int maxans = ;

 void print (vector<string>& vecStr) {
     printf("vector dragon\n");
     for(auto ele : vecStr) {
         printf("%s ", ele.c_str());
     }
     printf("\n");
 }

 void dfs(int level, vector<P>& vecWord, int& ans, vector<string>& dragon)
 {
     string lastWord = dragon[level-];
     //printf("info for debug: level[%d] \n", level);
     //printf("lastWord[%s]", lastWord.c_str());
     //print(dragon);

     for (int i = ; i < vecWord.size(); ++i) {
         if(vecWord[i].second < ) {
             string curWord = vecWord[i].first;
             int startIdx;
             if (level == ) { startIdx = ; }
             else {startIdx = ;}
             for (int j = lastWord.size() - ; j >= startIdx; --j) {
                 string lssubstr = lastWord.substr(j);
                 if (curWord.find(lssubstr) !=  || curWord == lssubstr) { continue; }
                 vecWord[i].second++;
                 dragon[level] = curWord;
                 ans += curWord.size() - lssubstr.size();
                 if (ans > maxans) {maxans = ans;}
                 dfs(level+, vecWord, ans, dragon);
                 dragon[level] = "";
                 vecWord[i].second--;
                 ans -= curWord.size() - lssubstr.size();
             }
         }
     }
 }

 int main() {
     int n;
     cin >> n;
     vector<P> vecWord(n);
     for(int i = ; i < n; ++i) {
         string str;
         cin >> str;
         P p;
         p.first = str;
         p.second = ;
         vecWord[i] = p;
     }
     vector<string> vecDragon(*n+);
     string strDragon;
     cin >> strDragon;

     vecDragon[] = strDragon;
     int ans = ;
     dfs(, vecWord, ans, vecDragon);
     cout << maxans << endl;
     return ;
 }

P1101 单词方阵

就是在一个字母方阵中画出 “yizhong” 这个单词，八种方向都ok，但是一旦选定了方向，就不能换了。

如图：

解法：我的解法就是用一个相同的布尔方阵去决定这个字母是否显示，dfs决定use方阵的01。

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <utility>
 #include <string>
 #include <cstring>
 #include <vector>
 using namespace std;

 string pattern = "yizhong";

 void print (vector<vector<char>>& chess, vector<vector<bool>>& use) {
     for(int i = ; i < chess.size(); ++i) {
         for (int j = ; j < chess.size(); ++j) {
             if (use[i][j]) { printf("%c", chess[i][j]);}
             else { printf("*"); }
         }
         printf("\n");
     }
 }

 bool dfs(vector<vector<char>>& chess, vector<vector<bool>>& use, int level, const int addx, const int addy, int x, int y) {
     if (level == ) {
         return true;
     }
     if (x+addx >=  && x+addx < chess.size() && y+addy >=  && y+addy < chess.size()) {
         if (pattern[level] == chess[x+addx][y+addy]) {
             bool ans = dfs(chess, use, level+, addx, addy, x+addx, y+addy);
             if (ans) {
                 use[x+addx][y+addy] = ans;
             }
             return ans;
         }
         else {
             return false;
         }
     } else {
         return false;
     }
 }

 void findword(vector<vector<char>>& chess, vector<vector<bool>>& use, int x, int y) {
     for(int addx = -; addx <= ; ++addx) {
         for(int addy = -; addy <= ; ++addy) {
             if (addx ==  && addy == ) { continue; }
             if (x+addx >=  && x+addx < chess.size() && y+addy >=  && y+addy < chess.size()) {
                 bool ans = dfs(chess, use, , addx, addy, x, y);
                 if (ans) {
                     use[x][y] = ans;
                 }
             }
         }
     }

 }

 int main() {
     int n;
     cin >> n;
     vector<vector<char>> chess(n, vector<char>(n));

     int x = -, y = -;
     for(int i = ; i < n; ++i) {
         for (int j = ; j < n; ++j) {
             cin >> chess[i][j];
             if (chess[i][j] == 'y' && x == - && y == -) {
                 x = i, y = j;
             }
         }
     }
     vector<vector<bool>> use(n, vector<bool>(n, false));
     if (x == - && y == -) {
         print(chess, use);
         return ;
     }

     for(int i = ; i < chess.size(); ++i) {
         for(int j = ; j < chess[].size(); ++j) {
             if (chess[i][j] == 'y') {
                 findword(chess, use, i, j);
             }
         }
     }
     print(chess, use);

     return ;
 }

P1605 迷宫

给定一个N*M方格的迷宫，迷宫里有T处障碍，障碍处不可通过。给定起点坐标和终点坐标，问: 每个方格最多经过1次，有多少种从起点坐标到终点坐标的方案。在迷宫中移动有上下左右四种方式，每次只能移动一个方格。数据保证起点上没有障碍。

解答： 我是直接dfs， 爆搜出来的...题面只给了坐标，需要用坐标复现出棋盘的样子，然后爆搜就好

第一次提交70分， 原因在于 迷宫的起点也不能重复通过。

//initialize chess,
//state = 0 can go
//state = -1 obstacle
//state = 1 visited

 //1605
 //第一次提交70分， 问题在于迷宫起点也不能重复通过

 #include <iostream>
 #include <vector>
 #include <cstdio>
 #include <cstdlib>
 #include <cmath>

 using namespace std;

 static int ans = ;
 int n, m, t;
 int sx, sy, dx, dy;

 int addx[] = {, -, , };
 int addy[] = {-, , , };

 void print(const vector<vector<int>>& chess) {
     printf("======begin debug=======\n");
     for(int i = ; i < chess.size(); ++i) {
         for(int j = ; j < chess[].size(); ++j) {
             printf("%d ", chess[i][j]);
         }
         printf("\n");
     }
     printf("=======end==============\n");
 }

 void dfs(vector<vector<int>>& chess, int x, int y) {
     if (x == dx && y == dy) {
         ++ans;
         return;
     }
     for(int i = ; i < ; ++i) {
         int newx = x + addx[i], newy = y + addy[i];
         if(newx >  && newx <= n && newy >  && newy <= m && chess[newx][newy] != - && chess[newx][newy] != ) {
             chess[newx][newy] = ;
             dfs(chess, newx, newy);
             chess[newx][newy] = ;
         }
     }
 }

 int main() {

     cin >> n >> m >> t;
     cin >> sx >> sy >> dx >> dy;
     //initialize chess,
     //state = 0 can go
     //state = -1 obstacle
     //state = 1 visited

     vector<vector<int>> chess(n+, vector<int>(m+, ));
     for(int i = ; i < m+; ++i) {
         chess[][i] = -;
     }
     for (int i = ; i < n+; ++i) {
         chess[i][] = -;
     }
     while(t--) {
         int x, y;
         cin >> x >> y;
         chess[x][y] = -;
     }
     //print(chess);
     chess[sx][sy] = ; //start point can not repeat pass
     dfs(chess, sx, sy);

     cout << ans << endl;
     return ;
 }