a[i++]

今天才知道，a[i++]到底是什么意思；；

其实也很简单了，就是a[i]的值还是a[i]，然后i自增1；

把这篇博客当作平常各种错题博客吧，把各种从网上抄的代码不懂的地方写到这个地方算了

====================================================================

8.10

今天看到一个神奇的库叫做<queue>

没错这个库可以直接调用优先队列

优先队列可以优先调用一个参数，这个就比较人性化了

priority_queue<int>q1;
priority_queue<pair <int,int> >p2;//注意尖括号之间有间隔；
priority_queue<int,vector<int>,greater<int> >q3;//定义小的先出队列

上面这个就定义了三个q1,p2,q3

====================================================================

8.12

RMQ问题：区间最值问题，可以使用单调队列，以及线段树，顺便贴一下从网上找来的和RMQ 问题紧密联系的st算法：

/*网址http://blog.sina.com.cn/s/blog_6e63f59e0101598a.html

点击打开链接

ST算法的原理就是，nlogn预处理出Min[][]和Max[][]，查询的时候O(1)查询。

Max[j][i]或Min[j][i]代表，从j的位置开始，长度为2^i的子段中的最大值或最小值。

然后预处理的时候递推。

询问的时候先算出[l,r]的长度的2的对数，然后取出答案即可。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <cmath>
using namespace std;
#define mx 100010
int Min[mx][20],Max[mx][20],n,m,a[mx];

void makermq(){
   for (int i = 1;i <= n;i ++) Min[i][0] = Max[i][0] = i;

   for (int i = 1;(1 << i) <= n;i ++){
       for(int j = 1;j + (1 << i) - 1 <= n;j ++){
           int p = Min[j][i - 1],q = Min[j + (1 << i - 1)][i - 1];
           if (a[p] < a[q] || (a[p] == a[q] && p < q)) Min[j][i] = p;
           else Min[j][i] = q;
           p = Max[j][i - 1],q = Max[j + (1 << i - 1)][i - 1];
           if (a[p] > a[q] || (a[p] == a[q] && p < q)) Max[j][i] = p;
           else Max[j][i] = q;
       }
   }
}

int ask(int l,int r,int q){
   int tmp = int(log(r - l + 1) / log(2));
   int k1,k2;

   if (q == 0){
       k1 = Min[l][tmp],k2 = Min[r - (1 << tmp) + 1][tmp];
       if (a[k1] < a[k2] || (a[k1] == a[k2] && k1 < k2)) return k1;
       else return k2;
   }
   else{
       k1 = Max[l][tmp],k2 = Max[r - (1 << tmp) + 1][tmp];
       if (a[k1] > a[k2] || (a[k1] == a[k2] && k1 < k2)) return k1;
       else return k2;
   }
}

int main(){
   cin >> n >> m;
   for (int i = 1;i <= n;i ++) cin >> a[i];

   makermq();

   int l,r,q;
   for (int i = 1;i <= m;i ++){
       cin >> l >> r >> q;
       cout << ask(l,r,q) << endl;
   }
}

===============================================

上面这个纯属一时兴起，对于现在的我来说并无卵用（至少现在我是蒟蒻），还不如来点现实的填坑

今天主攻归并，发现一个网站有演示归并排序的一段动画，可以调节速度（唯一的槽点就是广告）

http://www.atool.org/sort.php

归并排序作为分治的基本应用，它比较神奇的地方就在于要把整个数据拆分成很多个小数据，小数据进行排序，小数据排序完以后，把他们放到稍大一点的数组中，再次进行排序，但明明感觉这样为何这么慢呢。。。

例题

jzabc除了对多米诺骨牌感兴趣外，对赛车也很感兴趣。上个周末他观看了一场赛车比赛。他总是能想出许多稀奇的问题。某一时刻，他看到有n辆车（总是匀速行驶）在同一直线上，并且处在一个无限长度的直道上，而且n辆车有严格的先后之分。他通过特殊的器材测出了每一辆车的速度。那么问题出现了，如果有两辆车A车和B车，A车在B车的后面，并且A车的速度比B车的快，那么经过一段时间后，A车一定会超过B车。我们称之为一次超车。那么他想请你帮忙计算超车总数。我们记车道起点的坐标为0。没有两辆车的坐标相同。

代码以及高能注释，有错希望各位大牛帮忙指正

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
const int N=300100;
int n,sum=0;
int c[N];
struct car
{
	int road;
	int v;
}cars[N];
bool cmp(car a,car b)
{
	return a.road>b.road;
}
void work(int zuo,int you)
{
	int zhong,x,i,j;//i,j为方便比较定义为局部变量，每层比较的时候i，j都表示车的坐标,
	//x用来临时存储←
	if(you > zuo +1)
	{
		zhong = (you + zuo) /2;
		work(zuo,zhong);//递归到最底层
		work(zhong+1,you);
		x=zuo;
		for(i=zuo,j=zhong+1;i<=zhong&&j<=you;)//注意这个归并过程i就是左，j就是右，i，j就是临时的左右，这里其实也是二分的一种表现
		{
			if(cars[i].v>cars[i].v)//出现逆序对
			{
				c[x]=cars[j].v;//c用来储存现在正在排序的集
				x++;j++;//更改指针
				sum+=zhong-i+1;//sum也就是超了几辆车！！！！
			}
			else
				c[x++]=cars[i++].v;//没出现逆序对就让缓冲区的上
		}
		if(j<=you)
			for(;j<=you;j++)
				c[x]=cars[j].v,x++;//缓冲区存的是已经排好序的，直接替换
		if(i<=zhong)
			for(;i<=zhong;i++)
				c[x]=cars[i].v,x++;
		for(i=zuo;i<=you;i++)
			cars[i].v=c[i];
	}
	else//如果右没有左边大
	{
		if(zuo+1==you&&cars[zuo].v>cars[you].v);
		{
			swap(cars[zuo].v,cars[you].v);
			sum++;
		}
	}
}

int main()
{
	cin>>n;
	for(int i=1;i<=n;i++)
	{
		cin>>cars[i].road>>cars[i].v;
	}
	sort(cars+1,cars+n+1,cmp);
	work(1,n);	//从一到n的排序
	cout<<sum<<endl;
	return 0;
}

==============================================================================================

8.14

今天新get√一个新技能叫做typedef

这个新技能主要在于使用超长的类型

比如说定义一个longlong就可以写成

typedef long long ll;

然后后面定义的就可以写成

ll cows[N];

我知道这种知识我现在才掌握有点台湾，他在码奇葩长的代码的时候还是挺使用的

好吧话不多说继续写题

PS：今天还是第一次晚上来机房呢