回溯法习题

5-1：

问题描述：

现有n种不同形状的宝石，每种n颗，共n*n颗。同一形状的n颗宝石分别具有n种不同的颜色c1,c2,…,cn中的一种颜色。欲将这n*n颗宝石排列成n行n列的一个方阵，使方阵中每一行和每一列的宝石都有n种不同的形状和n种不同颜色。是设计一个算法，计算出对于给定的n，有多少种不同的宝石排列方案。

设计思路：

该问题即将n*n个形状且颜色不同的宝石在n*n个位置上排序。并且需要满足‘‘每一行和每一列的宝石都有n种不同的形状和n种不同颜色“这个约束条件。求出可行解的数量

关键代码：

#include<iostream>
using namespace std;
int n;
int cnt = 0;				//记录最终方案数
bool rowcolor[100][100];	//记录某一行是否有了某个颜色
bool colcolor[100][100];	//记录某一列是否有了某个颜色
bool rowshape[100][100];	//记录某一行是否有了某个形状
bool colshape[100][100];	//记录某一列是否有了某个形状
bool celect[100][100];		//记录对应位置的宝石是否已经被选择,行代表颜色，列代表形状
void traceback(int t)
{
	int y = t % n;			//编号除以n取余即是列数
	int x = t / n;			//编号除以n取整即是行数
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)//遍历所有宝石的选择状态
		{
			if (celect[i][j] == 0)//如果该宝石还未被选择
			{
				if (rowcolor[x][i] == 0 && colcolor[y][i] == 0 && rowshape[x][j] == 0 && colshape[y][j] == 0)//如果与已选的宝石不冲突
				{
					celect[i][j] = 1;//将该宝石置为已选
					rowcolor[x][i] = 1, colcolor[y][i] = 1, rowshape[x][j] = 1, colshape[y][j] = 1;
					if (t == n * n - 1)		cnt++;			//已经选到了最后一个						
					else					traceback(t + 1);					
					celect[i][j] = 0;//回溯，恢复状态
					rowcolor[x][i] = colcolor[y][i] = rowshape[x][j] = colshape[y][j] = 0;
				}
			}
		}
	}
}
int main()
{
	cin >> n;
	traceback(0);		//	编号为0—n-1，从0开始
	cout << cnt << endl;
	return 0;
}

5-2：

问题描述：

罗密欧与朱丽叶身处一个m×n的迷宫中。每一个方格表示迷宫中的一个房间。这 m × n 个房间中有一些房间是封闭的，不允许任何人进入。在迷宫中任何位置均可沿 8 个方向进入未封闭的房间。罗密欧位于迷宫的(p，q)方格中，他必须找出一条通向朱丽叶所在的(r，s)方格的路。在抵达朱丽叶之前，他必须走遍所有未封闭的房间各一次，而且要使到达朱丽叶的转弯次数为最少。每改变一次前进方向算作转弯一次。请设计一个算法帮助罗密欧找出这样一条道路。

设计思路：

判断结束的条件为：如果所有方格走遍，且到达朱丽叶位置，且转弯次数<=最优转弯次数
当前路线的转弯次数小于最优的转弯次数的话需要更新记录值，否则只需要将路线数+1即可
然后需要遍历八个可走的方向进行回溯，在每个方向上均需要计算出下一步的坐标，然后判断下一步是否满足约束函数
如果满足就进入下一步继续回溯
如果不满足则跳过判断下一个方向是否可走

关键代码：

int n, m, k;
int road[1000][1000], best[1000][1000];
bool flag = false;
int min_rotation = 1000, cur_rotation = 0;
int min_count = 0;
typedef struct point        //定义point结构体表示每一个房间
{
    int x, y;
}point;
point Start, End;
int dx[8] = { 1,0,-1,0,1,1,-1,-1 };     //dx，dy组合起来对应8个方向
int dy[8] = { 0,1,0,-1,1,-1,1,-1 };
bool check(point pos)        //判断是否在迷宫内且未封闭
{
    if (pos.x > 0 && pos.x <= n && pos.y > 0 && pos.y <= m && road[pos.x][pos.y] == 0)
        return true;
    return false;
}
void upgrade()      //当前路径转弯次数更少时更新最优路径，依次把road赋值给best
{
    for (int i = 1; i <= n; i++)
    {
        for (int j = 1; j <= m; j++)
        {
            best[i][j] = road[i][j];
        }
    }
    flag = true;
}
void dfs(int depth, point pos, int d)            //遍历整个迷宫
{
    if (depth == m * n - k && pos.x == End.x && pos.y == End.y && cur_rotation <= min_rotation)
    {
        if (cur_rotation < min_rotation)
        {
            min_rotation = cur_rotation;
            min_count = 1;
            upgrade();
        }
        else
        {
            min_count++;
        }
        return;
    }
    else
    {
        point next_pos;
        next_pos.x = pos.x + dx[i];
        next_pos.y = pos.y + dy[i];
        if (check(next_pos))
        {
            road[next_pos.x][next_pos.y] = depth + 1;
            if (depth > 1 && d != i) cur_rotation++;
            if (cur_rotation <= min_rotation)
                dfs(depth + 1, next_pos, i);
            road[next_pos.x][next_pos.y] = 0;
            if (depth > 1 && d != i) cur_rotation--;
        }
    }
}

5-3：

问题描述：

网络设计问题：石油传输网络通常可表示为一个非循环带权的有向图G.G中有一个称为源的顶点s,石油从顶点输送到G中其他顶点,图G中每条边的权表示该边连接的2个顶点间的距离,网络中的油压随距离的增大而减小,为保证整个输油网络的正常工作,需要维持网络的最低油压Pmin,为此需要在网络的某处或全部顶点处设置增压器,在设置增压器的顶点处油压可以升至Pmax,油压从Pmax减到Pmin可使石油传输的距离至少为d,试设计一个算法,计算网络中增压器的最优设置方案,使得用最少增压器保证石油运输的畅通.

设计思路：

回溯法，每个节点单独作为树的一层，其中，左叉为1表示设置增压器，右叉为0表示不设置增压器。每当遍历到叶子节点时判断能否保证石油运输的畅通。

关键代码：

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
int num = 0;
int ss = 0;
int ans = n;
bool answer[100];
int n;
int mx;
vector<node> que[100];
bool set[100];
void dfs(int x, int k);
struct node
{
	int x; int y;
};
void traceback(int x)//运用二叉树结构，深度优先遍历
{
	if (x == n)//如果遍历到叶子结点
	{
		dfs(1, mx);
	}
	else
	{
		set[x] = 1;//给当前点设置增压器
		traceback(x + 1);
		if (x != 1)//第一个结点相当于固定有设置增压器的
		{
			set[x] = 0;//不设置增压器
			traceback(x + 1);
		}
	}
}
void dfs(int x, int k)//遍历所有路径，看是否通畅
{
	num++;
	if (num == n)//遍历了所有结点即表示通畅
	{
		if (ss < ans)//如果当前增压器数量比之前的少
		{
			ans = ss;
			for (int i = 1; i <= n; i++)//记录当前答案
			{
				answer[i] = set[i];
			}
		}
	}
	int m = que[x].size();
	for (int i = 0; i < m; i++)//遍历当前结点的所有子节点
	{
		if (set[x] == 1)//如果当前结点有增压器
		{
			ss++;//增压器计数
			if (mx - que[x][i].y >= 0)//如果可以到达下一个结点
				dfs(que[x][i].x, mx - que[x][i].y);
		}
		else//如果当前结点没有增压器
		{
			if (k - que[x][i].y >= 0)//如果可以到达下一个结点
				dfs(que[x][i].x, k - que[x][i].y);
		}
	}
}
int main()
{
	cin >> n >> k;
	for (int i = 1; i <= n; i++)
	{
		int m;
		cin >> m;
		for (int j = 1; j <= m; j++)
		{
			int a, b;
			cin >> a >> b;
			if (a > i)
			{
				que[i].push_back({ a,b });
			}
		}
	}
	cout << ans - 1 << endl;
	for (int i = 1; i <= n; i++)
	{
		cout << answer[i] << endl;
	}
}