课后作业第五章

一。

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

解：

对于该问题的求解可以采用回溯法

该问题的搜索树类似排列树，即将n*n个形状或颜色不同的宝石在n*n个位置上排序。并且需要满足约束条件。求出可行解的数量。

#include<iostream>
using namespace std;
int n;
int ans = 0;
bool xcolor[100][100];//记录某一行是否有了某个颜色
bool ycolor[100][100];//记录某一列是否有了某个颜色
bool xshape[100][100];//记录某一行是否有了某个形状
bool yshape[100][100];//记录某一列是否有了某个形状
bool all[100][100];//记录某个宝石是否已经被选择,行代表颜色，列代表形状
void backtrack(int st)
{
	
	int y = st % n, x = st / n;
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < n; j++)//遍历所有宝石的选择状态
		{
			if (all[i][j] == 0)//如果该宝石还未被选择
			{
				
				if (xcolor[x][i] == 0 && ycolor[y][i] == 0 && xshape[x][j] == 0 && yshape[y][j] == 0)//如果与已选的宝石不冲突
				{
					all[i][j] = 1;//将该宝石置为已选
					xcolor[x][i] = 1, ycolor[y][i] = 1, xshape[x][j] = 1, yshape[y][j] = 1;
					if (st == n * n - 1)//已经选到了最后一个
					{
						ans++;
					}
					else
					{
						backtrack(st + 1);

					}
					all[i][j] = 0;//回溯，恢复状态
					xcolor[x][i] = 0, ycolor[y][i] = 0, xshape[x][j] = 0, yshape[y][j] = 0;
				}
			}
		}
	}
}
int main()
{
 cin >> n;
 backtrack(0);
 cout << ans << endl;
 return 0;
}

二。

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

解：

该问题的求解可运用回溯法。

该问题要求在到的重点前将所有的房间遍历一次。其搜索树结构类似与排列树。

即对所有可到达的格子进行排序（表示每个格子为第几次到达），然后判断结构是否满足约束条件：1，每个可到达的格子的周围格子必须有一个格子的数字是与其连续的 2，结束的格子与结尾的格子必须是指定的格子。

代码如下：

#include<iostream>
using namespace std;

int m, n, k;
int p, q, r, s;
int ans[1010][1010], a[1010][1010];
int dx[8] = { 0,1,1,1,0,-1,-1,-1 },
dy[8] = { 1,1,0,-1,-1,-1,0,1 };
int minas = 1e8 + 10, flag = 0, anslu = 0;
//最少转弯次数，判断是否有答案，最少转弯次数的数量 

void dfs(int x, int y, int num, int turn, int dir)
{
	if (x == r && y == s && turn <= minas && num == n * m - k)//到达终点且已经遍历所有的房间
	{
		if (turn < minas)//如果转弯次数更少
		{
			minas = turn;//修改最少转弯次数
			anslu = 1;//路数为1
			flag = 1;
			for (int i = 1; i <= m; i++)
			{
				for (int j = 1; j <= n; j++)
				{
					ans[i][j] = a[i][j];
				}
			}
		}
		else
		{
			anslu++;
		}
		return;
	}

	for (int i = 0; i < 8; i++)//依次遍历八个方向
	{
		int xx = x + dx[i], yy = y + dy[i];
		if (xx<1 || xx>m || yy<1 || yy>n) continue;//此时过界
		if (a[xx][yy] != 0) continue;//不能进入该房间或已经进入过该房间
		a[xx][yy] = num + 1;//能进入则进入该房间是第几个

		if (dir != i)//如果方向不一样
		{
			if (turn + 1 <= minas)
			{
				dfs(xx, yy, num + 1, turn + 1, i);
			}
		}
		else//相同方向 
		{
			dfs(xx, yy, num + 1, turn, i);
		}

		a[xx][yy] = 0;//回溯，状态恢复
	}
}

int main()
{
	cin >> m >> n >> k;
	for (int i = 1; i <= k; i++)
	{
		int x, y;
		cin >> x >> y;
		a[x][y] = -1;//不能进入的房间记为-1
	}
	cin >> p >> q >> r >> s;

	a[p][q] = 1;//最开始的房间即第一个进入的房间

	dfs(p, q, 1, -1, 8);

	if (flag == 1)
	{
		cout << minas << endl << anslu << endl;
		for (int i = 1; i <= m; i++)
		{
			for (int j = 1; j <= n; j++)
			{
				cout << ans[i][j] << " ";
			}
			cout << endl;
		}
	}
	else
	{
		cout << "没有路径\n";
	}
	return 0;
}

三。

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

解：

对于该问题的求解可用于回溯法，其搜索树结构类似于0-1二叉树，即每个节点单独作为树的一层，左叉为1表示设置增压器，右叉为0表示不设置增压器。每当遍历到叶子节点时判断能否保证石油运输的畅通。

#include<iostream>
#include<vector>
#include<queue>
using namespace std;
int n;
int mx;
struct node
{
	int x; int y;
};
vector<node> que[100];
bool set[100];
void dfs(int x, int k);
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);
		}
	}
}
int num = 0;
int ss = 0;
int ans = n;
bool answer[100];
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;
	}
}