3.21总结

最新推荐文章于 2024-11-07 23:24:07 发布

人都呼吸

最新推荐文章于 2024-11-07 23:24:07 发布

阅读量646

点赞数 23

文章标签：算法

本文链接：https://blog.csdn.net/2301_80882402/article/details/136921156

版权

D - Shuffle'm Up

分析：

建立题目需执行操作的函数，不断调用函数重复执行操作，直到s12达到要求，便结束函数，如果不能组成要求的字符串，因为组成的字符串是有限的，所以当新组成的字符串之前组成过，，便结束函数输出-1

#include <set>

用于使用`std::set`容器。`std::set`是C++标准库提供的关联容器，它内部自动排序存储元素，并且保证元素的唯一性，即相同元素不会重复存储。在这段代码中，`std::set`被用来存储字符串集合，确保集合中不会有重复的字符串。通过使用`std::set`，可以方便地进行元素的插入、查找和去重操作，适用于需要维护一组唯一元素的场景。

str.push_back(s2[i]);

是在C++中用于向字符串`str`的末尾添加字符的操作。具体来说，`push_back`是std::string`类的成员函数，用于将一个字符添加到字符串的末尾。在这里，`s2[i]`表示字符串`s2`中索引为`i`的字符，`push_back`将该字符添加到字符串`str`的末尾。通过这样的操作，可以逐个将`s2`中的字符添加到`str`中，用于生成新的字符串。

ss.insert(str)、ss.count(str)

在C++中，`std::set`是一个关联容器，它提供了`insert`和`count`等方法来操作集合中的元素。

1. `ss.insert(str)`：这个操作用于向`std::set`容器 `ss` 中插入元素 `str`。如果 `str` 在插入之前不存在于 `ss` 中，那么 `insert` 操作会将 `str` 插入到 `ss` 中；如果 `str` 已经存在于 `ss` 中，则 `insert` 操作不会有任何效果。这样可以确保 `set` 中的元素是唯一的，不会重复。

2. `ss.count(str)`：这个操作用于统计 `std::set` 容器 `ss` 中等于 `str` 的元素的个数。由于 `set` 中的元素是唯一的，因此 `count` 方法的返回值要么是 0（表示 `str` 不在 `ss` 中），要么是 1（表示 `str` 在 `ss` 中）。

代码：

#include <iostream>
#include <set>
using namespace std;
set <string> ss;
string s12;
int len, ans;

void dfs(string s1, string s2, int n) 
{
    string str;
    for (int i = 0; i < len; i++) {
        str.push_back(s2[i]);
        str.push_back(s1[i]);
    }
    if (ss.count(str))
        return;
    ss.insert(str);
    if (str == s12) 
    {
        ans = n;
        return;
    }
    else {
        s1.clear();
        s2.clear();
        for (int i = 0; i < len; i++) 
        {
            s1.push_back(str[i]);
        }
        for (int i = len; i < len * 2; i++) 
        {
            s2.push_back(str[i]);
        }
        dfs(s1, s2, n + 1);
    }
}

int main() 
{
    string s1, s2;
    int t;
    cin >> t;
    for (int i = 1; i <= t; i++) 
    {
        ss.clear();
        cin >> len;
        cin >> s1 >> s2 >> s12;
        ans = -1;
        dfs(s1, s2, 0);
        if (ans > 0) 
            ans++;
        cout << i << " " << ans << endl;
    }
    return 0;
}

E - Pots

分析：

BFS
可以知道总共有6种操作方式，使用switch执行操作以及对操作的输出，g[tail].f用于储存所执行的方法，使用BFS搜索，直到其中一个罐子的水为C升，输出步数并对点进行回溯，查找达成要求所经历的步骤

代码：

#include<stdio.h>
int A, B, C, book[101][101],d[10000]={0};
struct nb
{
	int a;
	int b;
	int step;
	int ans;
	int f;
}g[10000000];
//FILL(1)  FILL(2) DROP(1)  DROP(2)  POUR(1, 2)  POUR(2, 1)
int main()
{
	int n=0;
	scanf("%d%d%d", &A, &B, &C);
	int tail, head, k;
	int x, y;
	head = tail = 1;
	g[tail].a = 0;
	g[tail].b = 0;
	g[tail].step = 0;
	g[tail].ans = 0;
	g[tail].f = 0;
	tail++;
	while (head < tail)
	{
		for (int i = 1; i <= 6; i++)
		{
			switch (i)    //6种操作
			{
			case 1:
				x = A;
				y=g[head].b;
				break;
			case 2:
				y = B;
				x=g[head].a;
				break;
			case 3:
				x = 0;
				y=g[head].b;
				break;
			case 4:
				y = 0;
				x=g[head].a;
				break;
			case 5:
				if (g[head].a + g[head].b > B)
				{
					x =g[head].a-( B - g[head].b);
					y = B;
				}
				else
				{
					y = g[head].a + g[head].b;
					x = 0;
				}
				break;
			case 6:
				if (g[head].a + g[head].b > A)
				{
					y =g[head].b-( A - g[head].a);
					x = A;
				}
				else
				{
					x = g[head].b + g[head].a;
					y = 0;
				}
				break;
			}
			if (book[x][y] == 1)
				continue;
			book[x][y] = 1;
			g[tail].a = x;
			g[tail].b = y;
			g[tail].f = head;
			g[tail].ans = i;   //储存到达当前情况所使用的步骤
			g[tail].step = g[head].step + 1;
			tail++;
			if (x == C || y == C)
			{
				printf("%d\n", g[tail-1].step);
				k = tail - 1;
				while (k)    //回溯，将达成目标的步骤找出来并存入新数组
				{
					d[n++]=g[k].ans;
					k = g[k].f;
				}
				for(int j=n-1;j>=0;j--)
				{
					switch (d[j])
					{
					case 1:
						printf("FILL(1)\n");
						break;
					case 2:
						printf("FILL(2)\n");
						break;
					case 3:
						printf("DROP(1)\n");
						break;
					case 4:
						printf("DROP(2)\n");
						break;
					case 5:
						printf("POUR(1,2)\n");
						break;
					case 6:
						printf("POUR(2,1)\n");
						break;
					}
				}
				return 0;
			}
		}
		head++;
	}
	printf("impossible\n");
	return 0;
}

M - A计划

分析：

BFS，需要注意的是如果传送门传送到的楼层的点是‘#’或‘*’，这个点就不走

代码：

#include<stdio.h>
#include<string.h>
int nx[] = { 0,1,0,-1 };
int ny[] = { 1,0,-1,0 };
int c, n, m, t, book[3][11][11];
char a[3][11][11];
struct nb
{
	int x;
	int y;
	int z;
	int t;
}g[300000];

int main()
{
	scanf("%d", &c);
	while (c--)
	{
		int k = 0;
		memset(book, 0, sizeof(book));
		scanf("%d%d%d", &n, &m, &t);
		for (int i = 0; i < 2; i++)
			for (int j = 0; j < n; j++)
			{
				scanf("%s", a[i][j]);
				getchar();
			}

		int tx, ty, tz, head, tail;
		head = tail = 1;
		g[head].z = 0;
		g[head].x = 0;
		g[head].y = 0;
		g[head].t = 0;
		book[0][0][0] = 1;
		tail++;
		while (head < tail)
		{
			for (int i = 0; i < 4; i++)
			{

				tx = g[head].x + nx[i];
				ty = g[head].y + ny[i];
				if (a[g[head].z][tx][ty] == '#')
				{
					if (g[head].z == 0)
						tz = 1;
					else
						tz = 0;
				}
				else
					tz = g[head].z;
				if (tz < 0 || tz >= 2 || tx < 0 || tx >= n || ty < 0 || ty >= m || book[tz][tx][ty] == 1 || a[tz][tx][ty] == '*'|| a[tz][tx][ty] == '#')
					continue;
				g[tail].z = tz;
				g[tail].x = tx;
				g[tail].y = ty;
				g[tail].t = g[head].t + 1;
				book[tz][tx][ty] = 1;
				if (a[tz][tx][ty] == 'P')
				{
					if (g[tail].t <= t)
						printf("YES\n");
					else
						printf("NO\n");
					k = 1;
					break;
				}
				tail++;
			}
			head++;
		}
		if (k == 0)
			printf("NO\n");
	}
	return 0;
}