暑假集训总结——区间DP，堆的概念及应用，STL（vector、set、pair、map、priority_queue），hash表，树状数组，图论

序言：

经过长达十几天的集训，确实学了不少知识点。我想如果再不总结的话，6天之后又要忘完了。

所以发一篇具有总结回忆性的博客，供大家回忆。

目录会本人自己排列的时间的先后顺序来排列，可直接食用。

目录：

一 、 动态规划
    1.区间DP

二 、 STL
    1.vector
    2.pair
    3.set
    4.map
    5.priority_queue
三 、数据结构
    1.字符串hash
    2.hash表
    3.树状数组
    4.堆及其运用
四 、 图论
        最短路
        1.Floyd
        2.Dijkst
        3.SPFA
        4.Bellman-Ford
        及其优化
        优先队列 O（mlogn）
        fionacci堆O（nlogn + m）这个本人能力实在有限便不说了，想知道的可以去问问

---

动态规划

动态规划总共分为三个部分：
- 状态和状态变量

- 阶段和阶段变量

- 策略和最优策略

- 状态转移方程

什么是区间动态规划？

区间DP也是分为这三个部分，虽然它也是属于线性Dp的一种，但是它的阶段是以“区间长度”为单位。

区间DP的初始形态一般就由长度为$1$的“元区间”所构成的。它需要用左端点、右端点描述每个维度，在一些特殊的题中有可能会用到中点。

第一题 石子合并：

合并石子1

若最初的的第$l$堆石子和$r$堆石子被合并在一起，则说明$lr$之间的每堆石子也已经被合并，这样$l$和$r$才有可能相邻。

因此，在任何时刻，任意一堆石子均可以用一个闭区间[l,r]来描述，表示这一堆是由最初的第$lr$堆石子合并成的。

所以假设 如果有3堆石子，
则有2种合并方案，((1,2),3)和(1,(2,3))
如果有k堆石子呢？

不管怎么合并，总之最后总会归结为2堆，如果我们把最后两堆分开，左边和右边无论怎么合并，都必须满足最优合并方案，整个问题才能得到最优解。

AC代码:

#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;
int min(int x,int y){
   
	return x>y?y:x;
}
int dp[105][105];
int s[105];
int n,x,k;
int main(){
   
	scanf("%d",&n);
	memset(dp,0x3f3f3f3f,sizeof(dp));
	for(int i=1;i<=n;i++){
   
		scanf("%d",&x);
		s[i]=s[i-1]+x;
	}
	for(int i=1;i<=n;i++){
   
		dp[i][i]=0;
	}
	for(int len=2;len<=n;len++){
   
		for(int j=1;j<=n-len+1;j++){
   
			int r=j+len-1;
			for(int k=1;k<r;k++)
			dp[j][r]=min(dp[j][r],dp[j][k]+dp[k+1][r]);
			dp[j][r]+=(s[r]-s[j-1]);
		}
	}
	printf("%d",dp[1][n]);
	return 0;
}

---

第二题能量项链：

能量项链

这道题几乎只是与合并石子有点区别，此时它是一个环，序列的长度是合并石子的两倍。

只需要循环的长度变成两倍即可。

思路就是：

用 $dp[i][j]$ 表示合并区间 $i$ 到 $j$ 的最大能量，

第一重循环表示珠子分组的终点，第二重循环的表示从珠子分组的起点 ，第三重循环表示截断的点。

AC代码：

#include<iostream>
using namespace std;
int n,e[205],f[205][205]={
   0};
int main()
{
   
    int i,j,k,mx=0;
    cin>>n;
    for(i=1;i<=n;i++){
   
        cin>>e[i];
        e[n+i]=e[i];
    }
    for(j=2;j<=2*n-1;j++)
        for(i=j-1;i>0&&j-i<n;i--)
            for(k=i;k<j;k++)
                f[i][j]=max(f[i][k]+f[k+1][j]+e[i]*e[k+1]*e[j+1],f[i][j]);
    for(i=1;i<=n;i++)
       mx=max(mx,f[i][i+n-1]);
   cout<<mx; 
   return 0;
}

---

前面的都是版题以及版题的变式

现在来一点不是板子题的题。

第三题戳西瓜

戳西瓜

从题来看，我第一次是没看懂是说的一个什么意思。

不过有各位大佬，鼎力相助我才读懂这道题，并进而AC这道题

首先分析一下如果我戳破了第$i$个，那么会留下$i-1$和$i+1$，但是此时你的和却跟$i-1$,$i$,$i+1$都有关。

从这个条件不难看出它是一个(i-1,i+1)的开区间。

但是题目却要我们戳完所有的气球。怎么办呢？

这是我们就可以，设两个端点最左端点和最右端点分别为：

$a[0]$和$a[n+1]$且初值都赋值为$1$。

现在就不存在存在$i-1$和$i+1$是开区间的情况了。

设状态$dp[i][j]$,表示戳破第i个到第j个的西瓜。

目标为$dp[0][n+1]$。

气球 $i$ 和气球 $j$ 之间的所有气球都可能是最后被戳破的那一个，

假设最后戳破的为 $k$

因为最后戳的是$k$所以要先把$i$到$k$的全部戳破，答案为$dp[i][k]$

然后$k$到$j$肯定也要戳完,答案为$dp[k][j]$

现在在气球$i$到气球$j$之间就只剩下$i$,$k$,$j$了，

所以戳爆$k$的价值就是$nums[i]\ast nums[k]\ast nums[j]$

AC代码：

#include<cstdio>
#include<algorithm>
#include<cstring>

using namespace std;
int dp[505][505];
int a[505];
int main(){
   
	int n;
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
   
		scanf("%d",&a[i]);
	}
	n++;
	a[0]=1;
	a[n+1]=1;
	for (int i = n; i >= 0; i--){
   
		for (int j = i + 1; j < n + 2; j++){
   
			for (int k = i + 1; k < j; k++) {
   
				dp[i][j]=max(dp[i][j], dp[i][k] + dp[k][j] + a[i]*a[j]*a[k]);
			}
		}
	}
	printf("%d",dp[0][n+1]);
	return 0;
}

---

二·二叉堆

在这之前我们需要一滴滴的知识储备就是，树。

完全二叉树：

如果一棵深度为k的二叉树，1至k-1层都是满的，即每层结点数满足2i-1，只有最下面一层的结点数小于2i-1，并且最下面一层的结点都集中在该层最左边的若干位置，则此二叉树称为完全二叉树。

那么我们所学的二叉堆呢，总的来说就是一个数组。

它可以被看作一棵完全二叉树。树中每个结点与数组中存放该结

点中值的那个元素相对应。如图所示:：

设数组$A$的长度为$len$，二叉树的结点个数为$size$，

s$ize\le len$，则$A[i]$存储二叉树中编号为i的结点值

($1$≤$i$≤$size$)，而$A[size]$以后的元素并不属于相应的堆，

树的根为$A[1]$，并且利用完全二叉树的性质，

我们很容易求第$i$个结点的父结点$fa(i)$、左孩子$lch(i)$、

右孩子$rch(i)$的下标，分别是$i/2$、$2i$、$2i+1$。

除了这一性质之外，同时对除根以外的每个结点i，A[fa(i)]≥A[i]。

即除根结点以外，所有结点的值都不得超过其父结点的值，

这样就推出，堆中最大元素存放在根结点中，

且每一结点的子树中的结点值都小于等于该结点的值，

这种二叉堆又称为“大根堆”；反之，称为“小根堆”。

堆一般有两个重要的操作，$put$(往堆中加入一个元素)和

$get$(从堆中取出并删除一个元素),$put$操作(也可用于建堆，

首先创建一个小根堆为例)：

1、在堆尾加入一个元素，并把这个结点置为当前结点。

2、比较当前结点和它父结点的大小
如果当前结点小于父结点，则交换它们的值，并把父结点置为当前结点，
继续转2。
如果当前结点大于等于父结点，则转3。

3、结束。

以此循环$n$次，即可建立一个小根堆出来。

具体的操作请见其他各大博客，均有提及。

那么现在来看一下建小根堆的代码：

#include <cstdio>
#include <algorithm>

using namespace std;
const int maxn = 15;
int heap[maxn], n, heap_size[maxn];
void PUT(int k){
   
	int fa, now;
	heap[++heap_size] = k;//把现在需要插入的数放到堆尾 
	now  = heap_size;//把堆尾的这个数设为当前操作数 
	while(now > 1){
   //向上与父节点比较知道比完了各节点结束 
		fa = now >> 1;
		if(heap[now] >= heap[fa])//不小于父节点的值就结束 
			break;
		swap(heap[now], heap[fa]);//交换函数 
		now  = fa;//交换后又继续往上比较 
	}
}

int main(){
   
	scanf("%d", &n);
	for(int i = 1;i <= n;i++){
   //插入输入 
		scanf("%d",&a);
		PUT(a);
	}
	for(int i = 1;i <= n;i ++){
   //输出小根堆 
		printf("%d", heap[i]);
	}
	return 0;
}

从堆中去除并删除的$get$操作：
1、取出堆中根结点的值。

2、把堆的最后一个结点($hea{p}_{s}ize$)放到根的位置上，把根覆盖掉,堆长度减一。

3、把根结点置为当前父结点，即当前操作结点$now$。

4、如果$now$无儿子($now>hea{p}_{s}ize/2$)，则转6；否则，把$now$的两(或一)个儿子中值较小的那一个置为当前子结点$son$。

5、比较$now$与$son$的值，如果$now$的值小于等于$son$，转6；否则交换两个结点的值，把$now$指向$son$，转4。

6、结束。

由于技术问题，本人找不到这张流程图，在这里道歉。

那么就来看一下删除根节点操作的代码吧：

int Get(){
   
	int now, son ,res;
	res  = heap[1];