算法课作业——回溯法

返回主目录

7-1 图k-着色问题 (20分)

题目：

图k-着色问题是一个著名的NP完全问题。给定无向图G=(V,E)和正整数k，问可否用k种颜色为V中的每个结点分配一种颜色，使得不会有两个相邻结点具有同一种颜色？ 该问题的一个具体实例可能会有多个解（一个解就是一种合法的着色方案），要求计算全部解的数目。

输入格式:
输入的第一行包含三个整数N(1≤N≤20)、M(0≤M≤N(N−1)/2)和K(1≤K≤N)，分别是无向图的结点数、边数和可用颜色数。 结点从1到N编号，颜色从1到K编号。随后M行，每行给出一条边的两个端点的编号。题目保证给定的无向图是简单图（即不存在自环和多重边）。

输出格式:
输出一行表示全部解的数目（无解时输出0即可）。

输入样例:
5 7 3
1 2
2 3
3 4
4 5
5 1
1 3
1 4
输出样例:
6

解决代码：

#include<bits/stdc++.h>
using namespace std;
int N, M, K;
int ans = 0;//number of results
vector<vector<int> > table;
vector<int> colorOfPoint;

bool isLegal(int point) {
	//本函数用于检查某个点的涂色是否合法
	for (int i = 1; i <= N; i++) {
		if (table[point][i] == 1) {
			if (colorOfPoint[i] == colorOfPoint[point])
				return false;
		}
	}
	return true;
}

void Kcolor(int point) {
	//采用回溯法
	//回溯法常用树来描绘整个过程，但在本程序的实现中并不会采用树数据结构，而是数组
	//本函数用来给输入变量point从1到K种颜色涂，如果合法则涂下一个点。	
	if (point == N+1) {
		ans++;
		return;
	}
	for (int color = 1; color <= K; color++) {
		colorOfPoint[point] = color;
		if (isLegal(point)) {
			Kcolor(point+1);
		}
		colorOfPoint[point] = 0;	//无论进入下一个点还是非合法涂色，都应在这里清零
	}
}

int main() {
	cin >> N >> M >> K;
	table.resize(N + 1, vector<int>(N + 1));
	colorOfPoint.resize(N + 1);
	for (int i = 1; i <= N; i++) {	//初始化table
		for (int j = 1; j <= N; j++) {
			table[i][j] = 0;
		}
	}
	for (int i = 1; i <= N; i++) {	//初始化colorOfPoint
		colorOfPoint[i] = 0;
	}
	int tmpS, tmpE;
	for (int i = 0; i < M; i++) {
		cin >> tmpS >> tmpE;
		table[tmpS][tmpE] = table[tmpE][tmpS] = 1;	//0表示无通路，1表示有通路
	}
	Kcolor(1);	//从第一个点开始
	cout << ans;
	return 0;
}

7-2 子集和问题 (20分)

题目：

子集和问题是一个典型的NP难度问题。给定一个正整数集合A={a1,a​2,…,an}(元素互不相同)和一个正整数y，问是否存在一个子集Y⊆A，它的元素之和为y？ 该问题的一个具体实例可能会有多个解（一个解就是一个元素之和为y的子集Y⊆A），要求计算并输出某个特定的解。

输入格式:
输入的第一行包含两个整数n(1≤n≤20)和y(>0)，分别是集合A的元素个数和子集和的目标值，A的元素从1到n编号。 接下来的一行有n个数，表示集合A的n个元素。最后一个行是一个正整数t，表示待计算并输出的第t个解。注意，如果将集合中元素由小到大排序，则问题的所有解有字典序。这里要求输出按字典序的第t个解。题目保证集合A的元素互不相同且按照递增次序输入。

输出格式:
输出占一行, 表示按字典序的第t个解，解中各个数递增且两数之间用一空格隔开。若第t个解不存在，则输出"No Solution!"。

输入样例:
6 60
10 20 30 50 60 80
2
输出样例:
10 50
（这里所有的解按照字典序依次为{10,20,30}、{10,50}、{60}，第2个解为{10,50}）

解决代码：

#include<bits/stdc++.h>
using namespace std;
int n, y, t;
vector<int> num;
vector<bool> boolVec;
vector<vector<bool> > ans;
//本程序的思想是通过用布尔向量标注符合y的数字，比如10，20，30的向量就是{1，1，1，0，0，0}
//num存储输入数字，boolVec用来标注当前的布尔向量情况，ans用于存储符合要求的布尔向量

void getAllBoolVec(int index,int sum) {
	//本函数用于得到符合要求的布尔向量
	//为了符合字典序，因此左子树是1，右子树是0
	if (index == n)	//因为索引以0开头
		return;
	sum += num[index];	
	boolVec[index] = 1;
	if (sum < y) {
		getAllBoolVec(index + 1, sum);
	}
	else if (sum == y) {
		ans.push_back(boolVec);
	}
	/*else {		//这里不可以根据sum>y就返回，因为要做下面的处理
		return;	
	}*/
	boolVec[index] = 0;	//将之前操作取消，进入右子树，相当于回溯
	sum -= num[index];
	getAllBoolVec(index + 1, sum);	//与前面呼应从而形成左右子树（实际上还是数组数据结构）
}

void output(vector<bool> boolVector) {
	//本函数是将指定的布尔向量对应的数字序列输出
	bool first = true;
	for (int i = 0; i < n; i++) {
		if (boolVector[i] == 1) {
			if (first) {
				cout << num[i];
				first = false;
			}
			else {
				cout << ' ' << num[i];
			}
		}
	}
}

int main() {
	cin >> n >> y;
	num.resize(n);
	boolVec.resize(n);
	//不小心省略了初始化步骤，为了稳妥最好还是加上
	for (int i = 0; i < n; i++) {
		cin >> num[i];
	}
	cin >> t;
	getAllBoolVec(0,0);
	if (t > ans.size()) {
		cout << "No Solution!";
	}
	else {
		output(ans[t - 1]);
	}
	return 0;
}

如果在n较大t较大的测试点过不了，我提供一个sample

输入：
10 10
1 2 3 4 5 6 7 8 9 10
10
输出：
10

7-3 马周游问题 (60分)

任给大小为n×n(8≤n≤1000)的棋盘， 在棋盘上任意设定马的初始位置，试快速找出一种马能跳到每个棋格恰好一次的棋步（要求最后回到初始位置）。注意，棋盘上马按照跳“日”的规则移动。例如，在8×8的棋盘， 当马位于第3行第4列的方格时，下一步可以跳到箭头所指的八个方格之一。

输入格式:
在一行中给出三个正整数n,a,b，其中n(8≤n≤1000)为棋盘的行列大小, a和b(1≤a,b≤n)分别是马的初始位置所在方格的行号和列号。

输出格式:
输出占n行，每行含有n个正整数，组成一个n× n方阵。该方阵的n
​2
​​ 个元素由正整数1,2,…,n
​2
​​ 组成，其中马走第i步前所处方格其内对应的数为i(i=1,2,…,n
​2
​​ ) (马在初始位置所处方格内数为1）。

输入样例:
8 3 4
输出样例:
54 57 44 25 64 59 42 9
45 2 55 58 43 8 63 60
56 53 24 1 26 61 10 41
3 46 19 28 21 12 7 62
52 29 4 23 6 27 40 11
47 18 49 20 13 22 37 34
30 51 16 5 32 35 14 39
17 48 31 50 15 38 33 36

描述

这道题我用自己的方法老是超时失败，我在网上找到了一个通过的，但是该代码风格实在一言难尽。。所以这里就贴一下吧。注释掉的就是能通过的。。网上也有写成项目形式的解题方法。
更新：目前找到了一种思路，待有时间实现看看。
更新：请参考这篇博文，下面先给出他的代码。

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <queue>
using namespace std;

typedef struct {
    int x;
    int y;
} Step;

Step step[8] = { {-2, -1}, {-1, -2}, { 1, -2}, { 2, -1}, { 2, 1}, { 1, 2}, {-1, 2}, {-2,1} };

struct NextPos {
    int nextPosSteps; //表示下一位置有多少种走法；走法少的优先考虑
    int nextPosDirection; //下一位置相对于当前位置的方位
    int nextPosToMidLength; //表示当前位置距中间点距离；距离中间点远的优先考虑
    bool operator < (const NextPos &a) const {
        return nextPosSteps > a.nextPosSteps && nextPosToMidLength < a.nextPosToMidLength;
    }
    
};

int board[100][100];
int M,N; //棋盘大小
//检测这个位置是否可以走
bool check(int x, int y) {
    if (x >= 0 && x < M && y >= 0 && y < N && board[x][y] == 0)
        return true;
    return false;
}
//下一位置有多少种走法
int nextPosHasSteps(int x, int y) {
    int steps = 0;
    for (int i = 0; i < 8; ++i) {
        if (check(x + step[i].x, y + step[i].y))
            steps++;
    }
    return steps;
}
//判断是否回到起点
bool returnStart(int x, int y) {
    //校验最后是否可以回到起点，也就是棋盘的中间位置
    int midx,midy;
    midx = M / 2 - 1;
    midy = N / 2 - 1;
    for (int i = 0; i < 8; ++i)
        if (x + step[i].x == midx && y + step[i].y == midy)
            return true;
    return false;
}

//输出结果
void outputResult(int xstart,int ystart) {
    int num = M * N;
    int k = num - board[xstart][ystart];
    for (int i = 0; i < M; ++i) {
        cout<<endl<<endl;
        for (int j = 0; j < N; ++j) {
            board[i][j] = (board[i][j] + k) % num + 1;
            cout<<setw(5)<<board[i][j];
        }
    }
    cout<<endl<<endl;
}

//某一位置距离棋盘中心的距离
int posToMidLength(int x,int y) {
    int midx = M / 2 - 1;
    int midy = N / 2 - 1;
    return (abs(x - midx) + abs(y - midy));
}

void BackTrace(int t, int x, int y,int xstart,int ystart) {
    //找到结果
    if (t == M * N && returnStart(x,y)) {//遍历了棋盘的所以位置，并且最后可以回到起点，形成回路
        outputResult(xstart,ystart);
        exit(1);
    }
    else {
        priority_queue<NextPos> nextPosQueue;
        for (int i = 0; i < 8; ++i) {
            if (check(x + step[i].x, y + step[i].y)) {
                NextPos aNextPos;
                aNextPos.nextPosSteps = nextPosHasSteps(x + step[i].x, y + step[i].y);
                aNextPos.nextPosDirection = i;
                aNextPos.nextPosToMidLength = posToMidLength(x + step[i].x,y + step[i].y);
                nextPosQueue.push(aNextPos);
            }
        }
        
        while(nextPosQueue.size()) {
            int d = nextPosQueue.top().nextPosDirection;
            nextPosQueue.pop();
            x += step[d].x;
            y += step[d].y;
            board[x][y] = t + 1;
            BackTrace(t + 1, x, y,xstart,ystart);
            //回溯
            board[x][y] = 0;
            x -= step[d].x;
            y -= step[d].y;
        }
    }
}

void horseRun(int xstart,int ystart) {
    //初始化棋盘
    for (int i = 0; i < M; i++)
        for (int j = 0; j < N; j++)
            board[i][j] = 0;
    int midx = M / 2 -1;
    int midy = N / 2 -1;
    board[midx][midy] = 1; //从棋盘的中间的位置开始马周游
    BackTrace(1, midx, midy,xstart,ystart);
}

int main() {
    //马周游起始位置
    int x, y;
    cout<<"请输入棋盘大小m*n 要求：|m-n|<=2 且 m和n都为偶数 且 m,n < 20 :";
    cin>>M>>N;
    cout<<"请输入马周游起始位置--横纵坐标0 <= x < "<<M<<"和0 <= y < "<<N<<" :";
    cin>>x>>y;
    horseRun(x,y); //执行马周游
    return 0;
}