《算法竞赛进阶指南》2.2深度优先搜索

165. 小猫爬山

翰翰和达达饲养了N只小猫，这天，小猫们要去爬山。
经历了千辛万苦，小猫们终于爬上了山顶，但是疲倦的它们再也不想徒步走下山了（呜咕>_<）。
翰翰和达达只好花钱让它们坐索道下山。
索道上的缆车最大承重量为W，而N只小猫的重量分别是C1、C2……CN。
当然，每辆缆车上的小猫的重量之和不能超过W。
每租用一辆缆车，翰翰和达达就要付1美元，所以他们想知道，最少需要付多少美元才能把这N只小猫都运送下山？

输入格式
第1行：包含两个用空格隔开的整数，N和W。
第2…N+1行：每行一个整数，其中第i+1行的整数表示第i只小猫的重量Ci。

输出格式
输出一个整数，表示最少需要多少美元，也就是最少需要多少辆缆车。

数据范围
1≤N≤18,
1≤Ci≤W≤108

输入样例：
5 1996
1
2
1994
12
29

输出样例：
2

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 20;

int n, m;
int cat[N], sum[N]; //cat表示猫的重量 sum 当前车的重量
int ans = N; //最优解是多少

void dfs(int u, int k) //u当前第几只猫 k 当前车的数量
{
    if(k >= ans) return;
    
    if(u == n)
    {
        ans = k;
        return;
    }
     
    for(int i = 0; i < k; i++)
        if(cat[u] + sum[i] <= m)
        {
            sum[i] += cat[u];
            dfs(u + 1, k);
            sum[i] -= cat[u]; //恢复现场
        }
    sum[k] = cat[u]; //新加一辆车
    dfs(u + 1, k + 1);
    sum[k] = 0;
}

int main()
{
    cin >> n >> m;
    for(int i = 0; i < n; i ++) cin >> cat[i];
    
    sort(cat, cat + n); //从小到大排序
    reverse(cat, cat + n); //翻转，从大到小排序
    
    dfs(0, 0); //从第0 只猫开始考虑 第0辆车 开始
    
    cout << ans << endl;
    return 0;
}

166. 数独

数独是一种传统益智游戏，你需要把一个9 × 9的数独补充完整，使得图中每行、每列、每个3 × 3的九宫格内数字1~9均恰好出现一次。

请编写一个程序填写数独。

输入格式
输入包含多组测试用例。
每个测试用例占一行，包含81个字符，代表数独的81个格内数据（顺序总体由上到下，同行由左到右）。
每个字符都是一个数字（1-9）或一个”.”（表示尚未填充）。
您可以假设输入中的每个谜题都只有一个解决方案。
文件结尾处为包含单词“end”的单行，表示输入结束。

输出格式
每个测试用例，输出一行数据，代表填充完全后的数独。

输入样例：
.2738…1…1…6735…293.5692.8…6.1745.364…9518…7…8…6534.
…52…8.4…3…9…5.1…6…2…7…3…6…1…7.4…3.
end

输出样例：
527389416819426735436751829375692184194538267268174593643217958951843672782965341
416837529982465371735129468571298643293746185864351297647913852359682714128574936

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 9;

int ones[1 << N], map[1 << N]; //ones储存1的数组  map返回lowbit运算后第几位是1
int row[N], col[N], cell[3][3];
char str[100];

inline int lowbit(int x) //非递归函数加 inline可以节省调用函数的开销 加速
{
    return x & -x;
}

void init()
{
    for(int i = 0; i < N; i++) row[i] = col[i] = (1 << N) - 1;//一开始初始化为所有数都可以选 都为1 2^9 - 1
    for(int i = 0; i < 3; i++)
        for(int j = 0; j < 3; j++)
            cell[i][j] = (1 << N) - 1;
}

inline int get(int x, int y)
{
    return row[x] & col[y] & cell[x / 3][y / 3];//求可选方案的交集
}

bool dfs(int cnt)//返回true 找到答案
{
    if(!cnt) return true;//cnt = 0填满
    
    //找出可选方案数最少的空格
    int minv = 10;
    int x, y;
    for(int i = 0; i < N; i++)
        for(int j = 0; j < N; j++)
            if(str[i * 9 + j] == '.')
            {
                int t = ones[get(i, j)];
                if(t < minv)
                {
                    minv = t;
                    x = i, y = j;
                }
            }
           
    for(int i = get(x, y); i; i-= lowbit(i))
    {
        int t = map[lowbit(i)]; //第几位是1
        
        //修改状态
        row[x] -= 1 << t; 
        col[y] -= 1 << t; //***这里是col[y]
        cell[x / 3][y / 3] -= 1 << t;
        str[x * 9 + y] = '1' + t;
        
        if (dfs(cnt - 1)) return true;
        
        //恢复现场，回溯
        row[x] += 1 << t;
        col[y] += 1 << t;//***这里是col[y]
        cell[x / 3][y / 3] += 1 << t;
        str[x * 9 + y] = '.';
    }
    return false;
}

int main()
{
    for(int i = 0; i < N; i ++) map[1 << i] = i;
    for(int i = 0; i < 1 << N; i ++)
    {
        int s = 0;
        for(int j = i; j; j -= lowbit(j)) s++; //j从i开始
        ones[i] = s; //i的二进制表示里面有s个1
    }
    
    while(cin >> str, str[0] != 'e')
    {
        init();//初始化
        //把已有的数字去掉
        int cnt = 0;
        for(int i = 0, k = 0; i < N; i++)
            for(int j = 0; j < N; j++, k++) //k枚举字符串里的
                if(str[k] != '.') //不为空 已填数字 去掉
                {
                    int t = str[k] - '1'; //映射成0-8
                    row[i] -= 1 << t;//减去 1
                    col[j] -= 1 << t;//***这里是col[y]
                    cell[i / 3][j / 3] -= 1 << t;
                }
                else cnt ++;//可选的数目
        dfs(cnt);        
        // cout << dfs(cnt) << endl;
        cout << str <<endl;
    }
    return 0;
}