ACdream dfs 专题
A - Hand in hand
题意:n个人围成一圈，相邻的人是好朋友必须拉着的手上的数互质 也就是说 这个人的右手的数 和下一个人 左手的数互质
求多少种可能？ 同一个环不重复计数
思路:
1 2 3 4假如围成一圈 那么 2 3 4 1也互质 1的右手由第一个圈可知已经和2的左手互质了
同理可以推出 3 4 1 2、4 1 2 3也是这样
所以我们如果我们任意爆搜开始的第一个人话 可搜出重复的 那么我们可不可以固定第一个人呢
显然是可以的 我们上面已经得证了
trick: 1个人的时候 是没有朋友的 即n = 1, ans = 0;
参考code:
//
// Created by TaoSama on 2015-05-29
// Copyright (c) 2015 TaoSama. All rights reserved.
//
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
int n, ans, l[15], r[15];
bool vis[15];
void dfs(int dep, int last, int first) {
if(dep == n + 1) {
if(__gcd(l[first], r[last]) == 1) {
/*for(int i = 0; i < n; ++i) {
char c = cur[0]; cur.erase(0, 1); cur += c;
if(s.count(cur)) return;
}*/
//s.insert(cur);
++ans;
}
return;
}
for(int i = 2; i <= n; ++i) {
if(!vis[i]) {
if(__gcd(l[i], r[last]) == 1) {
vis[i] = true;
dfs(dep + 1, i, first);
vis[i] = false;
}
}
}
}
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
// freopen("out.txt","w",stdout);
#endif
ios_base::sync_with_stdio(0);
while(scanf("%d", &n) == 1) {
//s.clear();
memset(vis, false, sizeof vis);
for(int i = 1; i <= n; ++i)
scanf("%d%d", l + i, r + i);
ans = 0;
if(n != 1) dfs(2, 1, 1);
else ans = 0;
printf("%d\n", ans);
/*for(auto i : s) {
cout << i << endl;
}*/
}
return 0;
}
B - Circle vs Triangle
题意:Alice和Bob A和B玩游戏 A先手 B必须走A旁边的四个格子 谁不能走了 谁就输了
思路:
根据博弈论的思想: 如果A必赢 那么接下来所有的情况中 B都必须输
如果A必输 那么接下来所有的情况中 必定包含一种B赢的情况
那么搜一下就好了
参考code:
//
// Created by TaoSama on 2015-05-30
// Copyright (c) 2015 TaoSama. All rights reserved.
//
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
int n, m, d[][2] = { -1, 0, 0, -1, 1, 0, 0, 1};
char a[8][8];
bool dfs(int x, int y) {
for(int i = 0; i < 4; ++i) {
int nx = x + d[i][0], ny = y + d[i][1];
if(nx < 1 || nx > n || ny < 1 || ny > m || a[nx][ny] == '*') continue;
a[x][y] = '*';
bool sub = dfs(nx, ny);
a[x][y] = '.';
if(sub) return false; //子局面有赢的就输了
}
return true; //子局面都输说明赢了
}
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
// freopen("out.txt","w",stdout);
#endif
ios_base::sync_with_stdio(0);
while(scanf("%d%d", &n, &m) == 2) {
for(int i = 1; i <= n; ++i) scanf("%s", a[i] + 1);
bool win = false;
for(int i = 1; i <= n; ++i) {
for(int j = 1; j <= m; ++j) {
if(a[i][j] == '.' && dfs(i, j)) {
win = true;
break;
}
}
if(win) break;
}
puts(win ? "Alice" : "Bob");
}
return 0;
}
C - 哗啦啦族的24点游戏
题意:
通过+ - x / 讲四个数凑成24点 考虑小数
思路:
考虑搜索一下4个数字的全排列
一个有两种情况 (a@b)@(c@d) a@(b@(c@d))
先考虑有交换律的运算 +和* a+b和b+a、a*b和b*a都一样啦
有没有括号都无所谓啦 因为我们搜全排列的时候 (a + b) * c 先计算a + b就等于添加了括号改变了+*的优先级
那么考虑没有交换律的运算 - / 举个例子关于/除法 b/(a-c) 如果我根据全排列的话 只能搜到 (a-c)/b 但是如果我们将运算数颠倒一下位置是不是就可以搜到了呢？
答案是可以 那我们在举个例子关于-减法 c - b/a 我们可以搜到b/a - c 但是怎么都搜不到要求的 如果我们颠倒下 b/a、c 是不是就可以了呢
所以就很明显啦~
trick: 有除法 别忘记了 除数不能为0
参考code:
//
// Created by TaoSama on 2015-05-29
// Copyright (c) 2015 TaoSama. All rights reserved.
//
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
const double EPS = 1e-10;
int a[5];
void dfs(int dep, double ans, double cur) {
if(dep == 5) {
if(abs(ans + cur - 24) < EPS || abs(ans - cur - 24) < EPS
|| abs(ans * cur - 24) < EPS) throw true;
if(abs(cur) > EPS && abs(ans / cur - 24) < EPS) throw true;
return;
}
dfs(dep + 1, ans + cur, a[dep + 1]);
dfs(dep + 1, ans - cur, a[dep + 1]);
dfs(dep + 1, ans * cur, a[dep + 1]);
if(abs(cur) > EPS) dfs(dep + 1, ans / cur, a[dep + 1]);
dfs(dep + 1, ans, cur + a[dep + 1]);
dfs(dep + 1, ans, cur - a[dep + 1]);
dfs(dep + 1, ans, cur * a[dep + 1]);
if(abs(a[dep + 1]) > EPS) dfs(dep + 1, ans, cur / a[dep + 1]);
}
int main() {
#ifdef LOCAL
// freopen("in.txt", "r", stdin);
// freopen("out.txt","w",stdout);
#endif
ios_base::sync_with_stdio(0);
int t; scanf("%d", &t);
while(t--) {
for(int i = 1; i <= 4; ++i) scanf("%d", a + i);
sort(a + 1, a + 5);
try {
do {
dfs(2, a[1], a[2]);
} while(next_permutation(a + 1, a + 5));
puts("no");
} catch(bool) {
puts("yes");
}
}
return 0;
}
D - 哗啦啦族的加法计算
题意:
找到合理的加法运算式子的个数 前n-1行是加数 第n行是结果 相同的字母数字相同 不用的字母数字不同
思路:
那么找到所有的字母 然后一一枚举可能的值 注意这里要特判首位不能为0
这里这两个枚举都map大法好啦~
一个剪枝:
由于所有的行的字符串都大于等于1 那么我们可以把最后一位字母先存下来
然后搜索完毕之后 check一下最后一位的运算是否合法 (大概优化了300+ms)
tirck:
相同的字母数字相同 不同的不同 数字有10个 字母有26个 如果字母数大于了10个
那么无论怎么样搜索 都没有合法解 这时候直接判0就好了
参考code:
//
// Created by TaoSama on 2015-06-03
// Copyright (c) 2015 TaoSama. All rights reserved.
//
//#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
long long n, m, last, ans;
bool vis[10];
vector<char> have;
map<char, int> mp, zero;
string a[15];
void dfs(int k) {
if(k == last) { //to check the last digits is legal or not
long long sum = 0;
for(int i = 1; i <= n; ++i) {
char &c = a[i][a[i].size() - 1];
if(i != n) sum += mp[c];
else {
if(sum % 10 != mp[c]) return;
}
}
}
if(k == m) { //to check the whole equation is legal or not
long long sum = 0;
for(int i = 1; i <= n; ++i) {
long long t = 0;
for(int j = 0; j < a[i].size(); ++j) {
char &c = a[i][j];
t = t * 10 + mp[c];
}
if(i != n) sum += t;
else {
if(sum == t) ++ans;
}
}
return;
}
for(int i = 0; i < 10; ++i) {
if(vis[i] || i == 0 && zero[have[k]]) continue;
vis[i] = true;
mp[have[k]] = i;
dfs(k + 1);
vis[i] = false;
}
}
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
// freopen("out.txt","w",stdout);
#endif
ios_base::sync_with_stdio(0);
while(cin >> n) {
memset(vis, false, sizeof vis);
have.clear(); mp.clear(); zero.clear();
//save the last digits first
for(int i = 1; i <= n; ++i) cin >> a[i];
for(int i = 1; i <= n; ++i) {
char &c = a[i][a[i].size() - 1];
if(!mp.count(c)) {
mp[c] = have.size();
have.push_back(c);
}
}
last = have.size();
//save the other digits then
for(int i = 1; i <= n; ++i) {
for(int j = 0; j < a[i].size() - 1; ++j) {
char &c = a[i][j];
if(j == 0) zero[c] = 1; //save the nonzero character
if(!mp.count(c)) {
mp[c] = have.size();
have.push_back(c);
}
}
}
m = have.size();
ans = 0;
if(m <= 10) dfs(0);
cout << ans << '\n';
}
return 0;
}
E - 哗啦啦族的01背包问题
题意:
很明显的01背包问题
思路:
由于背包w很大 那么我们明显不能dp 但是n很小只有40 我们可以以此为突破口
想到01背包就是装和不装的情况 如果搜索的话那么有 2^40种可能
但是我们可以折半搜索
先将2^20种可能存起来 然后搜索后20种可能的时候去匹配前面的情况
利用二分搜索找能装下背包w的最大价值
一个优化:
我们可以将前2^20种可能通过sort字典序 然后删掉一定不能的部分
就是 w[i] <= w[j] && v[i] >= v[j] 的j 通俗来说就是占大位置却没创造更多的价值的部分
当然这个题没必要啦~ 因为价值和背包体积是同等的
参考code:
这里是利用二进制枚举来写的 要比搜索写起来舒服的多
//
// Created by TaoSama on 2015-05-29
// Copyright (c) 2015 TaoSama. All rights reserved.
//
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int N = 1e5 + 10;
typedef long long LL;
int n;
LL W, w[45];
pair<LL, LL> ps[1 << 20];
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
// freopen("out.txt","w",stdout);
#endif
ios_base::sync_with_stdio(0);
while(scanf("%d%lld", &n, &W) == 2) {
for(int i = 0 ; i < n; ++i) scanf("%lld", w + i);
int n2 = n >> 1;
for(int i = 0; i < 1 << n2; ++i) {
LL sw = 0, sv = 0;
for(int j = 0; j < n2; ++j) {
if(i >> j & 1) {
sw += w[j];
sv += w[j];
}
}
ps[i] = make_pair(sw, sv);
}
sort(ps, ps + (1 << n2));
int m = 1;
for(int i = 1; i < 1 << n2; ++i) {
if(ps[m - 1].second < ps[i].second) {
ps[m++] = ps[i];
}
}
LL ans = 0;
for(int i = 0; i < 1 << (n - n2); ++i) {
LL sw = 0, sv = 0;
for(int j = 0; j < n - n2; ++j) {
if(i >> j & 1) {
sw += w[n2 + j];
sv += w[n2 + j];
}
}
if(sw <= W) {
LL tv = (lower_bound(ps, ps + m,
make_pair(W - sw, (LL)INF)) - 1)->second;
ans = max(ans, sv + tv);
}
}
printf("%lld\n", ans);
}
return 0;
}
F - 哗啦啦族的手环
题意:
给一个k 找最大的长度的M的01串 使得这个串的M个 k大小子串(到串尾时可以循环到串头) 都不相同
思路:
由于k大小的串的01串一个有2^k个 由于可以循环到串头 那么我们可以猜想 最长的长度会不会就是2^k呢
先尝试写一个暴力搜索来试试
发现直到15都找到了 16 17爆栈了 这里贴出前8个
说明我们的猜想完全可行 那么我们来也许证明下 我胡扯的
(
- - 根据鸽笼原理 超过2^k长度 本来串的可能就只有2^k个 超过了说明必然会形成循环
那么就出现了相同的子串 与题目要求违背 那么最大长度就是2^k ■
)
证明:
我们把每连着的k个数字当成一个点，每个点的出边有两条，因为下一个数字可能是0可能是1
入边同理也是两条，因为上一个数字可能是0可能是1
然后我们发现每个点的出度=入度，而这恰好是欧拉图的判定条件
所以原图是欧拉图，必然存在一条欧拉回路
那么第一问必然可以取到最大的2^k （官方题解写的 - -）
这么暴力的搜索必然会爆栈 - - 2^(2^k) = 这个数大的可怕了
所以我们来找找规律 观察上面的图发现
对于每个要求的k的求出的合理的2^k大小的串 它的开头是0000... 结尾是1111...
我们来数一下 咦？ 好像大小是k耶~
那么我们大胆猜想 所求串的开头一定是k个0 结尾一定是k个1
所以 - - 重新写出一个搜索这回就不会爆栈啦~ 然后我们得到了AC
参考code:
//
// Created by TaoSama on 2015-05-29
// Copyright (c) 2015 TaoSama. All rights reserved.
//
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int N = 1 << 17;
int n, m, l;
bool vis[N + 5], a[N + 5];
bool dfs(int k, int v) {
if(k == l) return true;
v = (v % m) << 1;
if(!vis[v] && k <= l - n) {
vis[v] = true;
a[k] = 0;
bool F = dfs(k + 1, v);
vis[v] = false;
if(F) return true;
}
int w = v + 1;
if(!vis[w]) {
vis[w] = true;
a[k] = 1;
bool F = dfs(k + 1, w);
vis[w] = false;
if(F) return true;
}
return false;
}
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
// freopen("out.txt","w",stdout);
#endif
ios_base::sync_with_stdio(0);
while(scanf("%d", &n) == 1) {
l = 1 << n; m = l >> 1;
memset(vis, false, sizeof vis);
for(int i = 1; i <= n; ++i) {
a[i] = 0;
a[l - i + 1] = 1;
}
vis[0] = vis[(1 << n) - 1] = true;
dfs(n + 1, 0);
printf("%d\n", l);
for(int i = 1; i <= l; ++i)
printf("%d", a[i]);
puts("");
}
return 0;
}
/*
暴力找规律代码(事实连linux都爆栈 数真大):
//
// Created by TaoSama on 2015-05-29
// Copyright (c) 2015 TaoSama. All rights reserved.
//
#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <set>
#include <vector>
using namespace std;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int N = 1 << 17;
int n, m, l;
bool vis[N + 5], a[N + 5];
bool dfs(int k, int v) {
if(k == l + 1) {
int w = (v % m) << 1, t = w;
for(int i = 1; i < n; ++i) {
w += a[i];
if(vis[w]) {
for(int j = 1; j <= i; ++j) {
t += a[j];
vis[t] = false;
t = (t % m) << 1;
}
return false;
}
w = (w % m) << 1;
}
return true;
}
v = (v % m) << 1;
for(int i = 0; i <= 1; ++i) {
int w = v + i;
if(k >= n && vis[w]) continue;
a[k] = i;
if(k >= n) vis[w] = true;
bool F = dfs(k + 1, w);
if(k >= n) vis[w] = false;
if(F) return true;
}
return false;
}
int main() {
#ifdef LOCAL
freopen("in.txt", "r", stdin);
// freopen("out.txt","w",stdout);
#endif
ios_base::sync_with_stdio(0);
while(scanf("%d", &n) == 1) {
l = 1 << n; m = l >> 1;
memset(vis, false, sizeof vis);
dfs(1, 0);
printf("%d\n", l);
for(int i = 1; i <= l; ++i)
printf("%d", a[i]);
puts("");
}
return 0;
}
*/