$ACM$ 课第三次作业-搜索
\(ACM\) 课第三次作业-搜索
\(A.\ Sum\ It\ Up\)
题意
给定 \(t\) 和 \(n\) 个整数 \(x_{i}\)，从 \(n\) 个整数中挑任意个数，使得它们的和为 \(t\)
输入格式
多组数据，\(n\leq 12,\ t\leq 1000,\ x_{i}\leq 100\)
输出格式
数字之间添 \(+\) 号，不考虑顺序（\(2 + 2 + 1\) 与 \(2 + 1 + 2\) 看作同一个），按照字典序列从大到小输出所有组合
题解
由于 \(n\) 很小，故考虑二进制枚举，然后 \(check\)
由于不考虑顺序，所以对于每一个枚举的情况都要用 \(map\) 记忆化一下，即 map<multiset<int>, int>
输出结果用字符串拼接，放到容器里面排序即可
\(code\)
#include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int, int>
#define arrayDebug(a, l, r) for(int i = l; i <= r; ++i) printf("%d%c", a[i], " \n"[i == r])
typedef long long LL;
typedef unsigned long long ULL;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int inf = 0x3f3f3f3f;
const int DX[] = {0, -1, 0, 1, 0, -1, -1, 1, 1};
const int DY[] = {0, 0, 1, 0, -1, -1, 1, 1, -1};
const int MOD = 1e9 + 7;
const int N = 4e2 + 7;
const double PI = acos(-1);
const double EPS = 1e-6;
using namespace std;
inline int read()
{
char c = getchar();
int ans = 0, f = 1;
while(!isdigit(c)) {if(c == '-') f = -1; c = getchar();}
while(isdigit(c)) {ans = ans * 10 + c - '0'; c = getchar();}
return ans * f;
}
int t, n, cnt, a[20];
set<string, greater<string> > st;
map<multiset<int>, int> mp;
bool check(int x)
{
int res = 0;
for(int i = 0; i < n; ++i) {
if(x & (1 << i)) res += a[i];
}
return res == t;
}
int main()
{
while(scanf("%d %d", &t, &n) && t && n) {
mp.clear(), st.clear();
for(int i = 0; i < n; ++i) scanf("%d", &a[i]);
printf("Sums of %d:\n", t);
for(int i = 0; i < (1 << n); ++i) {
if(check(i)) {
string temp = "";
multiset<int> mlst;
for(int j = 0; j < n; ++j)
if(i & (1 << j)) temp += a[j] + '0', mlst.insert(a[j]);
if(!mp[mlst]) {
mp[mlst] = 1;
st.insert(temp);
}
}
}
int cnt = st.size();
if(!cnt) puts("NONE");
else {
for(auto i: st) {
int len = i.length();
for(int j = 0; j < len; ++j)
printf("%d%c", i[j] - '0', "+\n"[j == len - 1]);
}
}
}
return 0;
}
/*
4 6 4 3 2 2 1 1
5 3 2 1 1
400 12 50 50 50 50 50 50 25 25 25 25 25 25
0 0
*/
时间复杂度
\(O(2^{n}\cdot n)\)，极限也就 \(2^{12}\cdot 12\)
\(B.\ Fling\)
题意
给定一个 \(7\times 8\) 的地图，上面分布着至多 \(12\) 个小球，每个小球可以向上下左右四个方向移动（'U', 'L', 'R', 'D'）
对于每一个小球，只有两种情况它无法移动
-
其当前移动方向上没有小球
-
其当前移动方向上紧挨着一个小球
小球会传递动能
- 对于每一个小球 \(i\)，若它在移动过程中撞到另一个小球 \(j\)，那么 \(i\) 会立刻停在 \(j\) 的前一个位置，而 \(j\) 继续按当前方向移动
- 若 \(j\) 与 另一个小球 \(k\) 紧邻，那么 \(j\) 不动，\(k\) 按当前方向移动，直到它掉落，以此类推
输入格式
多组数据
输出格式
输出 \(i,\ j,\ k\) ，分别代表小球的横坐标、纵坐标和移动方向
若有多个答案，按照字典序最小的输出
题解
这是一个游戏，玩一玩就能理解题意
对于计算机而言，最好的策略就是一步一步尝试
任取一个球，向四个方向搜索，若搜索成功，则更新图，继续搜索；若搜索失败，则回溯，把图复原，换方向继续搜索
\(dfs\) 实际上就是一个穷尽所有可能，搜索、回溯的过程
- 往下搜索更新状态
- 往上回溯复原状态
考虑可行性剪枝
用一个字符串维护答案，若当前得到的答案字符串已经比我们之前的答案大，那么没必要继续搜索，返回即可
注意开一个临时数组 \(temp\_g\) 存储地图，便于回溯的时候复原地图，但是 \(temp\_g\) 得设置成局部变量
\(code\)
#include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int, int>
#define arrayDebug(a, l, r) for(int i = l; i <= r; ++i) printf("%d%c", a[i], " \n"[i == r])
typedef long long LL;
typedef unsigned long long ULL;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int inf = 0x3f3f3f3f;
const int DX[] = {0, -1, 0, 1, 0, -1, -1, 1, 1};
const int DY[] = {0, 0, 1, 0, -1, -1, 1, 1, -1};
const int MOD = 1e9 + 7;
const int N = 4e2 + 7;
const double PI = acos(-1);
const double EPS = 1e-6;
using namespace std;
inline int read()
{
char c = getchar();
int ans = 0, f = 1;
while(!isdigit(c)) {if(c == '-') f = -1; c = getchar();}
while(isdigit(c)) {ans = ans * 10 + c - '0'; c = getchar();}
return ans * f;
}
const int n = 7, m = 8;
const int D1[] = {-1, 0, 0, 1};
const int D2[] = {0, -1, 1, 0};
const char D[] = {'U', 'L', 'R', 'D'};
int vis[20][20], caseNum;
char g[20][20];
string ans;
struct node
{
int x, y;
char d;
node() {}
node(int _x, int _y, char _d) {x = _x, y = _y, d = _d;}
};
bool check(int s, int t) {return s >= 0 && s < n && t >= 0 && t < m;}
void dfs(int num, string &str)
{
if(num == 1) {
if(ans != "" && ans > str || ans == "") ans = str;
return;
}
for(int i = 0; i < n; ++i) {
for(int j = 0; j < m; ++j) {
if(g[i][j] == 'O') {
for(int k = 0; k < 4; ++k) {
if(check(i + D1[k], j + D2[k]) && g[i + D1[k]][j + D2[k]] == 'O') continue;
int f = 0;
for(int s = i + D1[k], t = j + D2[k]; check(s, t); s += D1[k], t += D2[k]) {
if(g[s][t] == 'O') {
f = 1;
break;
}
}
if(!f) continue;
else {//进入这个分支，就保证了从 i, j 往 k 方向移动球，一定可以移动
char temp_g[20][20] = {0}; //这个 temp 不能设为全局变量，否则会出错
memcpy(temp_g, g, sizeof(g));
g[i][j] = 'X';
for(int s = i + D1[k], t = j + D2[k]; check(s, t); s += D1[k], t += D2[k]) {
if(g[s][t] == 'O') {
g[s - D1[k]][t - D2[k]] = 'O';
g[s][t] = 'X';
}
}
str += i + '0', str += j + '0', str += D[k];
//cout<<str<<endl;
if(ans != "" && str > ans) { // 可行性剪枝，字典序小的答案不继续搜索
for(int it = 0; it < 3; ++it) str.erase(--str.end());
return;
}
dfs(num - 1, str);
for(int it = 0; it < 3; ++it) str.erase(--str.end()); //删除迭代器比赋值更快一点
memcpy(g, temp_g, sizeof(temp_g));
}
}
}
}
}
return;
}
int main()
{
while(~scanf("%s", g[0])) {
for(int i = 1; i < n; ++i)
scanf("%s", g[i]);
int cnt = 0;
for(int i = 0; i < n; ++i)
for(int j = 0; j < m; ++j)
if(g[i][j] == 'O') ++cnt;
string res = "";
dfs(cnt, res);
if(caseNum) puts(""); //诡异的输出格式
printf("CASE #%d:\n", ++caseNum);
if(ans != "") {
int len = ans.length();
for(int i = 0; i < len; i += 3) {
putchar(ans[i]), putchar(' ');
putchar(ans[i + 1]), putchar(' ');
putchar(ans[i + 2]), puts("");
}
}
memset(g, 0, sizeof(g));
ans = "";
}
return 0;
}
后记
我一开始打算穷尽所有可能，把可行的答案字符串全部存起来，最后排序输出最小的
不幸得，代码 \(T\) 了
迫不得已考虑可行性剪枝，结果时间不仅减下来了，代码长度也缩减了很多
\(C.\ N\) 皇后
题意
在 \(N\times N\) 的棋盘上放置 \(N\) 个皇后，任意两个皇后需要满足
- 不在同一行
- 不在同一列
- 不处在与棋盘呈 \(45^{\circ}\) 角的直线上
输入格式
多组数据，\(N\leq 10\)
输出格式
输出方案数
题解
经典题，考虑 \(dfs\)
枚举行，用 \(col[i],\ d1[i],\ d2[i]\) 维护列，两个对角线
对于处在斜率为 \(-1\) 的同一条直线上的两个皇后 \(i_{1},\ j_{1},\ i_{2},\ j_{2}\)，满足 \(i_{1} - j_{1} = i_{2} - j_{2}\)
对于处在斜率为 \(1\) 的同一条直线上的两个皇后 \(i_{1},\ j_{1},\ i_{2},\ j_{2}\)，满足 \(i_{1} + j_{1} = i_{2} + j_{2}\)
用上述条件进行可行性剪枝即可
对于此题，先预处理出答案，然后回答查询
\(code\)
#include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int, int>
#define arrayDebug(a, l, r) for(int i = l; i <= r; ++i) printf("%d%c", a[i], " \n"[i == r])
typedef long long LL;
typedef unsigned long long ULL;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int inf = 0x3f3f3f3f;
const int DX[] = {0, -1, 0, 1, 0, -1, -1, 1, 1};
const int DY[] = {0, 0, 1, 0, -1, -1, 1, 1, -1};
const int MOD = 1e9 + 7;
const int N = 4e2 + 7;
const double PI = acos(-1);
const double EPS = 1e-6;
using namespace std;
inline int read()
{
char c = getchar();
int ans = 0, f = 1;
while(!isdigit(c)) {if(c == '-') f = -1; c = getchar();}
while(isdigit(c)) {ans = ans * 10 + c - '0'; c = getchar();}
return ans * f;
}
int n, col[20];
map<int, int> mp1, mp2;
void dfs(int x, int n, int &ans)
{
if(x == n + 1) {
ans++;
return;
}
for(int i = 1; i <= n; ++i) {
if(!col[i] && !mp1[i - x] && !mp2[i + x]) {
mp1[i - x] = mp2[i + x] = 1;
col[i] = 1;
dfs(x + 1, n, ans);
mp1[i - x] = mp2[i + x] = 0;
col[i] = 0;
}
}
}
int main()
{
int ans[20] = {0};
for(int i = 1; i <= 10; ++i) {
memset(col, 0, sizeof(col));
mp1.clear(), mp2.clear();
dfs(1, i, ans[i]);
}
while(scanf("%d", &n) && n) {
printf("%d\n", ans[n]);
}
return 0;
}
/*
1
8
5
0
*/
后记
这题一开始没有预处理，狂 \(T\)
\(D.\ Find\ a\ way\)
题意
给定一个 \(n\times m\) 的地图，上面分布了多个 \(KFC\)，# 表示不可走，其他均表示可走，走一个单位耗时 \(11\) 分钟
两个小憨批 \(Y,\ M\) 约着在某个 \(KFC\) 相遇，假设他们同时出发，求他们的最短相遇时间
输入格式
多组数据，\(2\leq n,\ m\leq 200\)
输出格式
输出最短相遇时间
题解
以 \(Y,\ M\) 为起点分别作 \(1\) 次 \(bfs\)，对每个 \(KFC\) 维护一个俩人相遇所耗费的时间，最后取最小值即可
\(code\)
#include <bits/stdc++.h>
#define fi first
#define se second
#define pii pair<int, int>
#define arrayDebug(a, l, r) for(int i = l; i <= r; ++i) printf("%f%c", a[i], " \n"[i == r])
typedef long long LL;
typedef unsigned long long ULL;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int inf = 0x3f3f3f3f;
const int DX[] = {0, -1, 0, 1, 0, -1, -1, 1, 1};
const int DY[] = {0, 0, 1, 0, -1, -1, 1, 1, -1};
const int MOD = 1e9 + 7;
const int N = 4e2 + 7;
const double PI = acos(-1);
const double EPS = 1e-6;
using namespace std;
inline int read()
{
char c = getchar();
int ans = 0, f = 1;
while(!isdigit(c)) {if(c == '-') f = -1; c = getchar();}
while(isdigit(c)) {ans = ans * 10 + c - '0'; c = getchar();}
return ans * f;
}
int n, m, dis[207][207], vis[207][207];
char g[207][207];
struct node
{
int x, y, step;
node() {}
node(int _x, int _y, int _step) {x = _x, y = _y, step = _step;}
};
void bfs(int s, int t)
{
queue<node> q;
q.push(node(s, t, 0));
vis[s][t] = 1;
while(!q.empty()) {
node temp = q.front(); q.pop();
if(g[temp.x][temp.y] == '@') dis[temp.x][temp.y] += temp.step;
for(int i = 1; i <= 4; ++i) {
int sx = temp.x + DX[i], sy = temp.y + DY[i];
if(sx >= 1 && sx <= n && sx >= 1 && sy <= m && g[sx][sy] != '#' && !vis[sx][sy]) {
q.push(node(sx, sy, temp.step + 1));
vis[sx][sy] = 1;
}
}
}
}
int main()
{
while(~scanf("%d %d", &n, &m)) {
memset(dis, 0, sizeof(dis));
for(int i = 1; i <= n; ++i)
scanf("%s", g[i] + 1);
for(int i = 1; i <= n; ++i) {
for(int j = 1; j <= m; ++j) {
if(g[i][j] == 'Y' || g[i][j] == 'M') memset(vis, 0, sizeof(vis)), bfs(i, j);
}
}
int ans = inf;
for(int i = 1; i <= n; ++i)
for(int j = 1; j <= m; ++j)
if(g[i][j] == '@') ans = min(ans, dis[i][j]);
printf("%d\n", ans * 11);
}
return 0;
}
浙公网安备 33010602011771号