广搜 深搜

最新推荐文章于 2022-03-12 19:59:50 发布
最新推荐文章于 2022-03-12 19:59:50 发布
阅读量401 收藏
点赞数
分类专栏： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq789045/article/details/52741514
版权




海贼王之伟大航路

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<map>
#include<queue>
using namespace std;

#define MAXN 20
#define INFINITE 1<<30

int N;

int graph[MAXN][MAXN];

typedef pair<int, int> Path_End;

map<Path_End, int> dp;
//queue<Path_End> q;

int bestTime;


void dfs(int path, int i, int sum)
{

	if (sum >= bestTime)
		return;

	if (i == N)
	{
		if (path != (1 << (N + 1)) - 1 - 1)
			return;
		bestTime = min(bestTime, sum);
		if (dp.count({ path,i }))
		{
			if (dp[{path, i}] <= sum)
				return;
			else
				dp[{path, i}] = sum;
		}
		else
		{
			dp.insert(pair<Path_End, int>({ path,i }, sum));
		}
		return;
	}

	if (dp.count({ path,i }))
	{
		if (dp[{path, i}] <= sum)
			return;
		else
			dp[{path, i}] = sum;
	}
	else
	{
		dp.insert(pair<Path_End, int>({ path,i }, sum));
	}

	for (int j = 1; j <= N; j++)
	{
		if (i != j)
		{
			if (!(path & (1 << j)))
			{
				int newPath = path;


				newPath = (newPath | (1 << j));
				dfs(newPath, j, sum + graph[i][j]);
			}


		}
	}
}


//void bfs()
//{
//	q.push({ 2,1 });
//
//	while (!q.empty())
//	{
//		Path_End pathend = q.front();
//		q.pop();
//
//		for (int j = 1; j <= N; j++)
//		{
//			if (j != pathend.second)
//			{
//				if (!(pathend.first & (1 << j)))
//				{
//					int newPath = pathend.first;
//
//
//
//					newPath = (newPath | (1 << j));
//					//dfs(newPath, j, sum + graph[i][j]);
//
//					if (dp.count({ newPath,j }))
//					{
//						if (dp[{newPath, j}] > dp[{pathend.first, pathend.second}] + graph[pathend.second][j])
//							dp[{newPath, j}] = dp[{pathend.first, pathend.second}] + graph[pathend.second][j];
//					}
//					else
//					{
//						dp.insert(pair<Path_End, int>({ newPath,j }, dp[{pathend.first, pathend.second}] + graph[pathend.second][j]));
//						q.push({ newPath,j });
//					}
//				}
//
//
//			}
//		}
//
//	}
//}



int main()
{



	{
		bestTime = INFINITE;
		scanf("%d", &N);
		dp.clear();
		for (int i = 1; i <= N; i++)
		{
			for (int j = 1; j <= N; j++)
			{
				scanf("%d", &graph[i][j]);
			}
		}

		dfs(2, 1, 0);

		//bfs();


		printf("%d\n", dp[{(1 << (N + 1)) - 1 - 1, N}]);
	}





}


蛋糕

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include <math.h>

using namespace std;

#define MAXN 30

int n, m;
int minArea = 1 << 30;
int area = 0;

int minV[MAXN];
int minA[MAXN];

int maxV(int level, int r, int h)
{
	int sum = 0;

	for (int i = level; i >= 1; i--)
	{
		sum += r*r*h;
		r--;
		h--;
	}
	return sum;
}


void dfs(int level, int r, int h, int v)
{
	if (level == 0)
	{
		if (v == 0)
			minArea = min(minArea, area);
		return;
	}


	if (v <= 0)
		return;

	if (v < minV[level])
		return;

	if (v>maxV(level, r, h))
		return;

	if (area >= minArea)
		return;

	if (area + minA[level] >= minArea)
		return;



	for (int rr = r; rr >= level; rr--)//当前层的半径
	{
		if (level == m)
			area = rr*rr;
		for (int hh = h; hh >= level; hh--)//当前层的高度
		{
			area += 2 * rr*hh;
			dfs(level - 1, rr - 1, hh - 1, v - rr*rr*hh);
			area -= 2 * rr*hh;
		}
	}
}

int main()
{
	scanf("%d%d", &n, &m);



	minV[0] = 0;
	minA[0] = 0;
	for (int i = 1; i <= m; i++)
	{
		minV[i] = minV[i - 1] + i*i*i;
		minA[i] = minA[i - 1] + 2 * i*i;
	}

	if (minV[m] > n)
	{
		printf("0\n");
		return 0;
	}


	int maxR = sqrt((double)(n - minV[m - 1]) / m) + 1;
	int maxH = (double)(n - minV[m - 1]) / (m*m) + 1;

	dfs(m, maxR, maxH, n);

	if (minArea == 1 << 30)
		printf("0\n");
	else
		printf("%d\n", minArea);
}


棋盘问题

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<map>
#include<queue>
using namespace std;

#define MAXN 12
#define INFINITE 1<<30

int n, k;

int c;


int chess[MAXN][MAXN];

int position[MAXN];

void search(int cur,int chessCnt)//cur表示行
{
	
	if (chessCnt==k)
	{
		c++;
		return;
	}
	if(cur>n)
		return;
	if(n-cur+1<k-chessCnt)
		return;
	
	for (int i = 1; i <= n; i++)//遍历列,选择在这行下棋子
	{
		if (chess[cur][i])
		{
			position[cur] = i;//cur行，i列
			int ok = 1;
			for (int j = 1; j<cur; j++)
			{
				if (position[j] == i )
				{
					ok = 0;
					break;
				}

			}
			if (ok)
			{
				search(cur + 1,chessCnt+1	);
			}
		}
	}
	
	position[cur] = 0;//选择不下棋子
	search(cur + 1,chessCnt);
}

int main()
{
	while (scanf("%d%d", &n, &k) == 2)
	{
		if (n == -1)
			return 0;

		c = 0;
		memset(chess, 0, sizeof(chess));
		memset(position, 0, sizeof(position));

		char str[MAXN];

		for (int i = 1; i <= n; i++)
		{
			scanf("%s", str);
			for (int j = 0; j<n; j++)
			{
				if (str[j] == '#')
				{
					chess[i][j + 1] = 1;
				}

			}
		}
		search(1,0);
		printf("%d\n", c);

	}

}


roads POJ1724

#include <iostream>
#include <vector>
#include <cstring>
#include<algorithm>
using namespace std;

#define MAXN 110
#define INFINITE 1<<30

struct Road
{
	int d, L, t;
};

vector<vector<Road> > cityMap(110); //邻接表。 cityMap[i]是从点i有路连到的城市集合
int minLen = 1 << 30; //当前找到的最优路径的长度
int totalLen; //正在走的路径的长度
int totalCost; //正在走的路径的花销
int visited[110]; //城市是否已经走过的标记
int minL[110][10100]; //minL[i][j]表示从1到i点的，花销为j的最短路的长度

int K, N, R;


void dfs(int s)
{
	if (s == N)
	{
		minLen = min(minLen, totalLen);
		return;
	}


	for (int i = 0; i < cityMap[s].size(); i++)
	{
		int d = cityMap[s][i].d;
		{
			if (!visited[d])
			{
				int cost = totalCost + cityMap[s][i].t;
				if (cost>K)
					continue;
				if (totalLen + cityMap[s][i].L >= minLen ||
					totalLen + cityMap[s][i].L >= minL[d][cost])
					continue;
				totalLen += cityMap[s][i].L;
				totalCost += cityMap[s][i].t;
				minL[d][cost] = totalLen;
				visited[d] = 1;

				dfs(d);

				visited[d] = 0;

				totalLen -= cityMap[s][i].L;
				totalCost -= cityMap[s][i].t;
			}
		}
	}
}

int main()
{
	

	cin >> K >> N >> R;

	

	for (int i = 1; i <= R; i++)
	{
		int s;
		Road r;
		cin >> s >> r.d >> r.L >> r.t;
		if (s != r.d)
		{
			cityMap[s].push_back(r);
		}

	}

	for (int i = 0; i<110; i++)
	{
		for (int j = 0; j<10100; j++)
			minL[i][j] = INFINITE;
	}


	memset(visited, 0, sizeof(visited));
	minLen = INFINITE;
	totalCost = totalLen = 0;
	visited[1] = 1;
	dfs(1);

	if (minLen < (1 << 30))
		cout << minLen << endl;
	else
		cout << "-1" << endl;
}


迷宫问题 (POJ3984)

#include<stdio.h>
#include<queue>
#include<string.h>
#include<stack>
using namespace std;



int graph[10][10];

int front;
int rear;

int visited[10][10];

struct Node
{
	int x;
	int y;
	int father;
	Node()
	{
	}
	Node(int _x, int _y, int _father) :x(_x), y(_y), father(_father)
	{
	}
};

Node q[2500];

int isPosLegal(int x, int y)
{
	return (x >= 1 && x <= 5 && y >= 1 && y <= 5);
}

int main()
{
	rear = 0;
	front = 1;
	memset(visited, 0, sizeof(visited));
	for (int i = 1; i <= 5; i++)
	{
		for (int j = 1; j <= 5; j++)
		{
			scanf("%d", &graph[i][j]);
		}
	}

	q[++rear] = Node(1, 1, 0);
	visited[1][1] = 1;
	int ok = 0;
	while (rear != front - 1)
	{

		Node n = q[front];
		int father = front;
		if (n.x == 5 && n.y == 5)
		{
			ok = 1;
			break;
		}
		front++;

		if (isPosLegal(n.x + 1, n.y) && visited[n.x + 1][n.y] == 0 && graph[n.x + 1][n.y]==0)
		{
			q[++rear] = Node(n.x + 1, n.y, father);
			visited[n.x + 1][n.y] = 1;
		}
		if (isPosLegal(n.x - 1, n.y) && visited[n.x - 1][n.y] == 0 && graph[n.x - 1][n.y] == 0)
		{
			q[++rear] = Node(n.x - 1, n.y, father);
			visited[n.x - 1][n.y] = 1;
		}
		if (isPosLegal(n.x, n.y + 1) && visited[n.x][n.y + 1] == 0 && graph[n.x ][n.y+1] == 0)
		{
			q[++rear] = Node(n.x, n.y + 1, father);
			visited[n.x ][n.y+1] = 1;
		}
		if (isPosLegal(n.x, n.y - 1) && visited[n.x][n.y - 1] == 0 && graph[n.x ][n.y-1] == 0)
		{
			q[++rear] = Node(n.x, n.y - 1, father);
			visited[n.x ][n.y-1] = 1;
		}

	}

	stack<int> s;
	if (ok)
	{
		while (front)
		{
			s.push(front);
			front = q[front].father;
		}
		int pos;
		while (!s.empty())
		{
			pos = s.top();
			s.pop();
			printf("(%d, %d)\n", q[pos].x-1, q[pos].y-1);
		}
	}

	

}


鸣人和佐助

#include<stdio.h>
#include<queue>
#include<string.h>
#include<stack>
using namespace std;


struct Node
{
	int x;
	int y;
	int chakela;
	int time;
	Node()
	{
	}
	Node(int _x, int _y, int _chakela, int _time) :x(_x), y(_y), chakela(_chakela), time(_time)
	{
	}
};

int M, N, T;
int record[210][210][15];
int graph[210][210];


int end_x, end_y;
int beg_x, beg_y;

int isFind = 0;

int isPosLegal(int x, int y)
{
	return (x >= 1 && x <= M && y >= 1 && y <= N);
}

int dx[] = { -1,1,0,0 };
int dy[] = { 0,0,-1,1 };

void bfs()
{
	queue<Node> q;

	q.push(Node(beg_x, beg_y, T, 0));

	while (!q.empty())
	{
		Node n = q.front();
		q.pop();

		if (n.x == end_x && n.y == end_y)
		{
			printf("%d\n", n.time);
			isFind = 1;
			return;
		}
		else
		{
			for (int i = 0; i<4; i++)
			{
				int r = n.x + dx[i];
				int c = n.y + dy[i];

				if (isPosLegal(r, c) )
				{
					if (graph[r][c] == 3 || graph[r][c] == 2)
					{
						if (record[r][c][n.chakela]>n.time + 1)
						{
							q.push(Node(r, c, n.chakela, n.time + 1));
							record[r][c][n.chakela] = n.time + 1;
						}
					}
					else if (graph[r][c] == 4 && n.chakela>0)
					{
						if (record[r][c][n.chakela - 1] > n.time + 1)
						{
							q.push(Node(r, c, n.chakela - 1, n.time + 1));
							record[r][c][n.chakela - 1] = n.time + 1;
						}

					}
				}

			}




		}
	}

}





int main()
{
	
	for (int i = 0; i < 210; i++)
		for (int j = 0; j < 210; j++)
			for (int k = 0; k < 15; k++)
				record[i][j][k] = 1 << 30;


	scanf("%d%d%d", &M, &N, &T);



	char str[210];
	for (int i = 1; i <= M; i++)
	{
		scanf("%s", str);
		for (int j = 1; j <= N; j++)
		{
			if (str[j - 1] == '@')
			{
				graph[i][j] = 1;
				beg_x = i;
				beg_y = j;
			}
			else if (str[j - 1] == '+')
			{
				graph[i][j] = 2;
				end_x = i;
				end_y = j;
			}
			else if (str[j - 1] == '*')
				graph[i][j] = 3;
			else if (str[j - 1] == '#')
				graph[i][j] = 4;
		}
	}


	
	bfs();
	if (!isFind)
		printf("%d\n", -1);

}


Flip Game 翻转棋盘

#include<stdio.h>
#include<queue>
#include<string.h>
#include<stack>
#include<bitset>
#include<map>
#include<set>
using namespace std;

int graph[6][6];//black 0,white 1

set<int> visited;

int isFinish(int bin)
{
	int flag = 0;

	for (int i = 1; i <= 16; i++)
	{
		if (bin & 1 << i)
		{
			if (flag == 0)
				flag = 1;
			else if (flag == 2)
				return 0;
		}
		else
		{
			if (flag == 0)
				flag = 2;
			else if (flag == 1)
				return 0;
		}
	}
	return 1;
}

int chessToInt(int(*gra)[6])
{
	int bin = 0;
	for (int i = 1; i <= 4; i++)
	{
		for (int j = 1; j <= 4; j++)
		{
			if (gra[i][j] == 1)
				bin = bin | (1 << ((i - 1) * 4 + j));
		}
	}
	return bin;
}

struct Node
{
	int bin;
	int time;

	Node()
	{
	}
	Node(int _bin, int _time) :bin(_bin), time(_time)
	{
	}
};

int dx[] = { -1,1,0,0 };
int dy[] = { 0,0,-1,1 };

int isPosLegal(int x, int y)
{
	return (x >= 1 && x <= 4 && y >= 1 && y <= 4);
}

int main()
{
	int isFind = 0;
	char str[100];

	for (int i = 1; i <= 4; i++)
	{
		scanf("%s", str);
		for (int j = 1; j <= 4; j++)
		{
			if (str[j - 1] == 'b')
			{
				graph[i][j] = 0;
			}
			else
				graph[i][j] = 1;
		}
	}
	queue<Node> q;

	int inputBin;
	inputBin = chessToInt(graph);
	q.push(Node(inputBin, 0));
	visited.insert(inputBin);


	while (!q.empty())
	{
		Node node = q.front();
		q.pop();

		if (isFinish(node.bin))
		{
			printf("%d\n", node.time);
			isFind = 1;
			break;
		}

		int newBin;

		for (int i = 1; i <= 4; i++)
		{
			for (int j = 1; j <= 4; j++)
			{
				newBin = node.bin;

				newBin = newBin ^ (1 << ((i - 1) * 4 + j));

				for (int k = 0; k < 4; k++)
				{
					int r, c;
					r = i + dx[k];
					c = j + dy[k];

					if (isPosLegal(r, c))
					{
						newBin = newBin ^ (1 << ((r - 1) * 4 + c));

					}
				}
				if (!visited.count(newBin))
				{
					visited.insert({ newBin,node.time + 1 });
					q.push(Node(newBin, node.time + 1));
				}
			}
		}
	}
	if (isFind == 0)
		printf("Impossible");
}


八数码POJ1077

#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<queue>
#include<stack>
using namespace std;

char visited[362880 / 8 + 30];

int chess[15];

int goalstutas;
int startstutas;

int isfind;


int dx[] = { -1,1,0,0 };
int dy[] = { 0,0,-1,1 };

char dir[] = "udlr";

struct Node
{
	int status;
	char from;

	int pos;

	int father;

	Node()
	{
	}
	Node(int _status, char _from, int _pos, int _father) :status(_status), from(_from), pos(_pos), father(_father)
	{
	}
};


Node record[100000000];

int head;
int tail;


int jiecheng(int n)
{
	int ans = 1;

	while (n)
	{
		ans *= n;
		n--;
	}
	return ans;
}

int chessToInt()
{
	int used[15];
	memset(used, 0, sizeof(used));
	int sum = 0;
	for (int i = 1; i <= 8; i++)
	{
		int cnt = 0;

		for (int j = 1; j < chess[i]; j++)
		{
			if (used[j] == 0)
				cnt++;
		}

		sum += (cnt*jiecheng(9 - i));
		used[chess[i]] = 1;
	}
	return sum;
}

void intToChess(int num)
{
	int used[15];
	memset(used, 0, sizeof(used));

	int sum = 0;


	for (int i = 1; i <= 9; i++)
	{
		int j = 1;
		while (j <= 9)
		{
			if (used[j])
			{
				j++;
				continue;
			}

			sum += jiecheng(9 - i);



			if (sum > num)
			{
				used[j] = 1;
				chess[i] = j;

				sum -= jiecheng(9 - i);
				break;
			}

			j++;
		}

	}


}


int isLegal(int r, int c)
{
	return r >= 1 && r <= 3 && c >= 1 && c <= 3;
}


void bfs()
{

	
	while (tail + 1 != head)
	{

		Node n = record[head];


		if (n.status == goalstutas)
		{
			
			stack<char> s;

			int cur = head;

			while (record[cur].father != 0)
			{
				s.push(record[cur].from);
				cur = record[cur].father;
			}
			while (!s.empty())
			{
				printf("%c", s.top());
				s.pop();
			}
			isfind=1;
			return;

		}


		intToChess(n.status);

		int r = (n.pos - 1) / 3 + 1;
		int c = (n.pos - 1) % 3 + 1;

		for (int i = 0; i < 4; i++)
		{
			int nx = r + dx[i];
			int ny = c + dy[i];

			if (!isLegal(nx, ny))
				continue;
			swap(chess[n.pos], chess[(nx - 1) * 3 + ny]);



			int status_temp = chessToInt();
			if (visited[status_temp / 8] & (1 << (status_temp % 8)))
			{
				swap(chess[n.pos], chess[(nx - 1) * 3 + ny]);
				continue;
			}
			record[++tail] = Node(status_temp, dir[i], (nx - 1) * 3 + ny, head);
			visited[status_temp / 8] = ((visited[status_temp / 8] | (1 << (status_temp % 8))));
			swap(chess[n.pos], chess[(nx - 1) * 3 + ny]);
		}
		head++;
	}
}



int main()
{






	for (int i = 1; i <= 8; i++)
		chess[i] = i + 1;
	chess[9] = 1;


	goalstutas = chessToInt();

	char c;
	int pos;
	for (int i = 1; i <= 9; i++)
	{

		while ((c = getchar()) == ' ')
			;

		if (c != 'x')
			chess[i] = (int)(c - '0') + 1;
		else
		{
			chess[i] = 1;
			pos = i;
		}
	}



	startstutas = chessToInt();


	head = 1;
	tail = 0;

	record[++tail] = Node(startstutas, '#', pos, 0);
	memset(visited, 0, sizeof(visited));
	isfind=0;
	bfs();
	if(!isfind)
		printf("unsolvable");


}


八数码 双向广搜

#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<string.h>
#include<queue>
#include<stack>
#include<bitset>
#include<map>
using namespace std;



int chess[15];

int goalstutas;
int startstutas;
int startPos;
int isfind;


int dx[] = { -1,1,0,0 };
int dy[] = { 0,0,-1,1 };

char dir[] = "udlr";

struct Node
{
	int status;
	char from;
	int pos;
	int fatherstatus;

	Node()
	{
	}
	Node(int _status, char _from, int _pos, int _fatherstatus) :status(_status), from(_from), pos(_pos), fatherstatus(_fatherstatus)
	{
	}
};


map<int, Node> record[2];
queue<Node> q[2];





int jiecheng(int n)
{
	int ans = 1;

	while (n)
	{
		ans *= n;
		n--;
	}
	return ans;
}

int chessToInt()
{
	int used[15];
	memset(used, 0, sizeof(used));
	int sum = 0;
	for (int i = 1; i <= 8; i++)
	{
		int cnt = 0;

		for (int j = 1; j < chess[i]; j++)
		{
			if (used[j] == 0)
				cnt++;
		}

		sum += (cnt*jiecheng(9 - i));
		used[chess[i]] = 1;
	}
	return sum;
}

void intToChess(int num)
{
	int used[15];
	memset(used, 0, sizeof(used));

	int sum = 0;


	for (int i = 1; i <= 9; i++)
	{
		int j = 1;
		while (j <= 9)
		{
			if (used[j])
			{
				j++;
				continue;
			}

			sum += jiecheng(9 - i);



			if (sum > num)
			{
				used[j] = 1;
				chess[i] = j;

				sum -= jiecheng(9 - i);
				break;
			}

			j++;
		}

	}


}


void show(int num)
{
	int used[15];
	memset(used, 0, sizeof(used));

	int sum = 0;
	int chess2[15];

	for (int i = 1; i <= 9; i++)
	{
		int j = 1;
		while (j <= 9)
		{
			if (used[j])
			{
				j++;
				continue;
			}

			sum += jiecheng(9 - i);



			if (sum > num)
			{
				used[j] = 1;
				chess2[i] = j;

				sum -= jiecheng(9 - i);
				break;
			}

			j++;
		}

	}

	for (int i = 1; i <= 3; i++)
	{
		for (int j = 1; j <= 3; j++)
		{
			printf("%d ", chess2[(i - 1) * 3 + j]);
		}
		printf("\n");
	}
	printf("\n");
}

int isLegal(int r, int c)
{
	return r >= 1 && r <= 3 && c >= 1 && c <= 3;
}


char reserveMove(char c)
{
	switch (c)
	{
	case 'l':return 'r';
	case 'u':return 'd';
	case 'r':return 'l';
	case 'd':return 'u';
	default:
		break;
	}
}

int expand(int which)
{
	int which2 = (which == 0) ? 1 : 0;

	Node n = q[which].front();
	q[which].pop();



	if (record[which2].count(n.status))
	{

		stack<char> s;
		Node temp = record[0][n.status];
		while (temp.fatherstatus != -1)
		{
			s.push(temp.from);
			temp = record[0][temp.fatherstatus];

		}

		while (!s.empty())
		{
			printf("%c", s.top());
			s.pop();
		}
		temp = record[1][n.status];

		while (temp.fatherstatus != -1)
		{
			printf("%c",reserveMove( temp.from));
			temp = record[1][temp.fatherstatus];

		}
		isfind = 1;
		return 1;
	}


	intToChess(n.status);

	int r = (n.pos - 1) / 3 + 1;
	int c = (n.pos - 1) % 3 + 1;

	for (int i = 0; i < 4; i++)
	{
		int nx = r + dx[i];
		int ny = c + dy[i];

		if (!isLegal(nx, ny))
			continue;
		swap(chess[n.pos], chess[(nx - 1) * 3 + ny]);
		int status_temp = chessToInt();

		if (record[which].count(status_temp))
		{
			swap(chess[n.pos], chess[(nx - 1) * 3 + ny]);
			continue;
		}

		Node newnode = Node(status_temp, dir[i], (nx - 1) * 3 + ny, n.status);
		q[which].push(newnode);
		record[which].insert({ newnode.status,newnode });

		swap(chess[n.pos], chess[(nx - 1) * 3 + ny]);
	}
	return 0;
}


void dbfs()
{
	q[0].push(Node(startstutas, '#', startPos, -1));
	q[1].push(Node(goalstutas, '#', 9, -1));

	record[0].insert({ startstutas,Node(startstutas, '#', startPos, -1) });
	record[1].insert({ goalstutas,Node(goalstutas, '#', 9, -1) });

	while (!q[0].empty() && !q[1].empty())
	{

		if (q[0].size() <= q[1].size())
		{
			if (expand(0))
				return;
		}
		else
		{
			if (expand(1))
				return;
		}
	}

	while (!q[0].empty())
	{
		if (expand(0))
			return;
	}

	while (!q[1].empty())
	{
		if (expand(1))
			return;
	}
}


int main()
{
	for (int i = 1; i <= 8; i++)
		chess[i] = i + 1;
	chess[9] = 1;

	goalstutas = chessToInt();

	char c;

	for (int i = 1; i <= 9; i++)
	{

		while ((c = getchar()) == ' ')
			;

		if (c != 'x')
			chess[i] = (int)(c - '0') + 1;
		else
		{
			chess[i] = 1;
			startPos = i;
		}
	}



	startstutas = chessToInt();


	isfind = 0;

	dbfs();

	if (!isfind)
		printf("unsolvable");


}


抓住那头牛(POJ3278)

#include<stdio.h>
#include<queue>
#include<string.h>
using namespace std;

#define MAXN 100010
int N, K;

struct Node
{
	int pos;
	int time;
	Node(int _pos, int _time) :pos(_pos), time(_time)
	{
	}
};

queue<Node> q;
int visited[MAXN];


int main()
{
	scanf("%d%d", &N, &K);
	memset(visited, 0, sizeof(visited));

	q.push(Node(N, 0));
	visited[N] = 1;

	while (!q.empty())
	{
		Node n = q.front();
		q.pop();
		int pos = n.pos;
		int time = n.time;

		if (pos == K)
		{
			printf("%d", time);
			return 0;
		}


		if (pos - 1 >= 0 && visited[pos - 1] == 0)
		{
			q.push(Node(pos - 1, time + 1));
			visited[pos - 1] = 1;
		}
		if (pos + 1 <= 100010 && visited[pos + 1] == 0)
		{
			q.push(Node(pos + 1, time + 1));
			visited[pos + 1] = 1;
		}
		if (pos * 2 <= 100010 && pos * 2 >= 0 && visited[pos * 2] == 0)
		{
			q.push(Node(pos * 2, time + 1));
			visited[pos * 2] = 1;
		}




	}

}


qq789045
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
广搜与深搜
雪雪
05-28 927
一、深搜 属于图算法的一种，英文缩写为DFS即Depth First Search.其过程简要来说是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次； 深度优先遍历图的思想是，从图中某顶点v出发： （1）访问顶点v； （2）依次从v的未被访问的邻接点出发，对图进行深度优先遍历；直至图中和v有路径相通的顶点都被访问； （3）若此时图中尚有顶点未被访问，则从一个未被访问的顶点出...
深搜和广搜
weixin_33963594的博客
09-28 395
一般来说，广搜常用于找单一的最短路线，或者是规模小的路径搜索，它的特点是"搜到就是最优解"， 而深搜用于找多个解或者是"步数已知（好比3步就必需达到前提）"的标题，它的空间效率高，然则找到的不必定是最优解，必需记实并完成全数搜索，故一般情况下，深搜需要很是高效的剪枝（优化）. 像搜索最短路径这些的很显著若是用广搜，因为广搜的特征就是一层一层往下搜的，保证当前搜到的都是最优解，当然，最短路径只是一...
广搜和深搜
weixin_30389003的博客
06-09 216
深度优先搜索： dfs，运用递归函数，通过栈的结构进行搜索。 模板： ·dfs(状态) –if 状态 是 目标状态then ·dosomething –else ·for 每个新状态 –if 新状态合法 »dfs(新状态) ·主程序： ·dfs(初始状态) 广度优先搜索： bfs，运用递归函数，通过队列的方式搜索。 dfs就是对于某一个搜索树，通过一定的顺序把每...
深搜与广搜
Godfryfry的博客
08-01 472
深搜 深度搜索的过程  深度优先搜索所遵循的搜索策略是尽可能“深”地搜索图。在深度优先搜索中，对于最新发现的节点，如果它还有以此为起点而未搜索的边，就沿此边继续搜索下去。当节点v的所有边都己被探寻过，搜索将回溯到发现节点v有那条边的始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被发现为止
C++的广搜深搜算法及入门级别动态规划.pdf
07-22
标题中提到了三种算法，分别是广度优先搜索（广搜）、深度优先搜索（深搜）和动态规划。这三个算法是计算机科学中用于图和树的搜索与优化问题的常用算法。下面将详细介绍这三种算法的相关知识点。 广度优先搜索...
搜索入门及深搜广搜演示
05-30
"搜索入门及深搜广搜演示" 搜索算法是一种常用的解决问题的方法，当我们面临着无法通过建立数学模型解决的问题时，搜索算法能够帮助我们找到解决方案。搜索算法可以分为两大类：深搜和广搜。深搜是一种基于回溯思想...
图的数据结构深搜/广搜
06-03
在计算机科学中，图是一种非常重要的数据结构，用于表示对象之间的关系或连接。在这个C++实现的项目中，我们关注的是图的深度优先搜索（DFS）和广度优先搜索（BFS）。这两种算法广泛应用于各种问题，如路径查找、...
图的实现及深搜和广搜
05-17
在计算机科学中，图是一种非常重要的数据结构，用于表示对象之间的关系或连接。在这个主题中，我们将深入探讨如何使用链式存储结构实现图，并详细解释深度优先搜索（DFS）和广度优先搜索（BFS）这两种图遍历算法。...
邻接表实现图的广搜和深搜(java模板）
04-14
在计算机科学中，图是一种非常重要的数据结构，用于表示对象之间的关系。邻接表是图的一种常见存储方式，尤其适用于稀疏图（边的数量远小于顶点数量的平方）。本篇将详细介绍如何使用Java实现基于邻接表的图的广度...
深搜和广搜的区别
Acettest's Blogs
04-08 460
深度优先搜索，堆栈实现； 广度优先搜索，队列实现 That heavily depends on the structure of the search tree and the number and location of solutions. If you know a solution is not far from the root of the tree, a breadth first...
HDU-1372 Knight Moves （BFS)
weixin_30815427的博客
08-24 68
Problem Description A friend of you is doing research on the Traveling Knight Problem (TKP) where you are to find the shortest closed tour of knight moves that visits each square of a given set ...
搜索2——广搜深搜
qq_36323837的博客
10-02 799
总共带了两双鞋都湿了，现在都开始穿拖鞋上课了。宿舍楼旁边那个湖，一直以为是人工湖，最近才发现原来是下水道。现在想想我当时为什么不报河南工程。。。烦气。都是老杨在那个牌上，把河南工程放下面了，再次诅咒老杨，蹲厕所没有手纸。 广度优先搜索和深度优先搜索主要是用于图的遍历。今天先不说图先把搜索总结完。 广度搜索：按层次来遍历。通常是用队列来写的。从某点出发（入队）判断当前点是否符合条件决定是否返回出队当...
搜索（深搜&广搜）
zjh_2017的博客
03-11 429
我记得在遥远的2017年，我会敲的搜索也只有暴力枚举了。那个时候的我深搜刚会一丢丢，所以也只配切切水题，然而经常死循环RE那是肯定的。如今的我因为在多次比赛中都死于搜索，那就必须得认真磕一下了。 其实是这样的：我眼里认为的暴力就真的只是暴力，暴力无非就两种：枚举打表和模拟。然而在这么多次比赛后，我总能听到那些dalao在那边说，这道题么暴力可以拿多少多少分。我听了一脸懵逼。我怎么就一分都拿不到。...
深搜广搜
u013804416的博客
09-28 362
一、定义： 1、深搜：深度优先搜索，会在一个方向一直搜下去，直到这条路走不通，才会考虑第二个方向 2、广搜：广度优先搜索，是先搜索每一个可行方向的第一步，然后再接着搜索每一个可行方向的第二步。以此类推。 二、广搜实现方法分析： 1、将搜索的初始化状态加到一个队列里面，然后每次从队列中取出一个状态，往可以前进的方向进一步，然后再将该状态放到队列。利用队列先进先出的特点，就可以实现广搜的效果。...
广搜（bfs）和 深搜（dfs）(新手）
qq_61465103的博客
03-12 3922
入门 广搜（dfs）和 深搜（bfs）
广搜与深搜的比较
qq_34600424的博客
01-23 973
2018-1-23 广搜，也就是我们所说的BFS，等同于树一层一层的遍历过程，我们需要将该节点对应的所有子节点的状态都加以保存，所以从这个方面来说，它的开销还是比较大的，但是它特别适用于求解最短路径的问题，因为我们所能找到的第一个满足条件的就已经是最优解了（因为我们已经是按照树的层数进行遍历的了），而对于深搜而言，我们必须把这一棵树遍历结束之后，我们才能求解出我们所要的解，但是它的内存占用相对比
c++ 图 深搜 广搜
最新发布
08-29
- *1* *2* *3* [【C++】数据结构之深搜+广搜 经典题型](https://blog.csdn.net/weixin_64967734/article/details/124994451)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值