走迷宫项目

这个项目主要就是基于easyx图形库来用的

先是把图片加载上去，但是我搞的时候忘记使用双缓冲绘图就会导致这个图片一直闪，而且物体移动会导致图片上面留下痕迹

 

 于是就把双缓冲加上然后把图片也放入循环当中

就不会出现之前的情况；

我的物体移动由于走迷宫是一格一格走嘛，那我们的移动就要多少多少像素的移动，也就是我们的变量要加一个具体的数字

char key=_getch();
		if (y <= 0 || x <= 0 || x >= 500 || y >= 500) {//防止跑出边界
			if (x <= 0) {
				x = 20;
			}
			else if (x >= 500) {
				x = 20;
			}
			else if (y <= 0) {
				y = 20;
			}
			else if (y >= 500) {
				y = 20;
			}
			continue;
		}
		else
		{
		switch (key)
		{
		case 72:
			y-=20;
			printf("上键\n");
			break;
		case 80:
			y+=20;
			printf("下键\n");
			break;
		case 75:
			x-=20;
			printf("左键\n");
			break;
		case 77:
			x+=20;
			printf("右键\n");
			break;
		}
		}

 然后我的想法是让一个二维数组来记录这个地图，通过dfs算法来找到路，用bfs或者f什么什么算法来找出最短路径，就ok

下面是我写的一个线段树的题目

# 【模板】线段树 1

## 题目描述

如题，已知一个数列，你需要进行下面两种操作：

1. 将某区间每一个数加上 $k$。
2. 求出某区间每一个数的和。

## 输入格式

第一行包含两个整数 $n, m$，分别表示该数列数字的个数和操作的总个数。

第二行包含 $n$ 个用空格分隔的整数，其中第 $i$ 个数字表示数列第 $i$ 项的初始值。

接下来 $m$ 行每行包含 $3$ 或 $4$ 个整数，表示一个操作，具体如下：

1. `1 x y k`：将区间 $[x, y]$ 内每个数加上 $k$。
2. `2 x y`：输出区间 $[x, y]$ 内每个数的和。

## 输出格式

输出包含若干行整数，即为所有操作 2 的结果。

## 样例 #1

### 样例输入 #1

```
5 5
1 5 4 2 3
2 2 4
1 2 3 2
2 3 4
1 1 5 1
2 1 4
```

### 样例输出 #1

```
11
8
20
```

## 提示

对于 $30\%$ 的数据：$n \le 8$，$m \le 10$。  
对于 $70\%$ 的数据：$n \le {10}^3$，$m \le {10}^4$。  
对于 $100\%$ 的数据：$1 \le n, m \le {10}^5$。

保证任意时刻数列中所有元素的绝对值之和 $\le {10}^{18}$。

**【样例解释】**


就是很简单的一个线段树的模板题（水）

#include 
struct node
{
	int l, r;
	long long val;
	int lazy;
}tree[10000000];
int a[1000000];
void bulid_tree(int node, int start, int end)
{
	tree[node].l = start;
	tree[node].r = end;
	if (start == end)
	{
		tree[node].val = a[start];
		return;
	}
	else
	{
		int mid = (start + end) / 2;
		int left = node * 2;
		int right = node * 2 + 1;
		bulid_tree(left, start, mid);
		bulid_tree(right, mid + 1, end);
		tree[node].val = tree[left].val + tree[right].val;
	}
}
void lazy(int node)
{
	if (tree[node].lazy)
	{
		tree[node * 2].lazy += tree[node].lazy;
		tree[node * 2].val += tree[node].lazy * (tree[node * 2].r - tree[node * 2].l + 1);
		tree[node * 2+1].lazy += tree[node].lazy;
		tree[node * 2+1].val += tree[node].lazy * (tree[node * 2+1].r - tree[node * 2+1].l + 1);
		tree[node].lazy = 0;
	}
}
long long qureytree(int L, int R, int node)
{
	if (tree[node].l > R || tree[node].r < L)
	{
		return 0;
	}
	else if (tree[node].l >= L && tree[node].r <= R)
	{
		return tree[node].val;
	}
	lazy(node);
	return qureytree(L, R, 2 * node) + qureytree(L, R, 2 * node + 1);
}
void updata(int L, int R, int v, int node)//v表示增加的值
{
	if (tree[node].l > R || tree[node].r < L)
	{
		return;
	}
	else if (tree[node].l >= L && tree[node].r <= R)
	{
		tree[node].lazy += v;
		tree[node].val += v * (tree[node].r - tree[node].l + 1);;
		return;
	}
	lazy(node);
	updata(L, R,v, 2 * node);
	updata(L, R,v,2 * node+1);
	int left = node * 2;
	int right = node * 2 + 1;
	tree[node].val = tree[left].val + tree[right].val;
}
int main()
{
	int n, m, l, r, v, teap;
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= n; i++)
	{
		scanf("%d", &a[i]);
	}
	bulid_tree(1, 1, n);
	while (m--)
	{
		//printf("888");
		scanf("%d", &teap);
		if (teap == 1)
		{
			scanf("%d%d%d", &l, &r, &v);
			updata(l, r, v, 1);
		}
		else
		{
			scanf("%d%d", &l, &r);
			printf("%lld\n", qureytree(l, r, 1));
		}
	}
}

下班下班