刷版子·总结（待补全......）
强势安利black学长板子
http://blog.csdn.net/loi_black/article/details/53161216#t18
最短路：
spfa
//期望的时间复杂度为o(ke)，k为所有顶点的进队次数，k一般<=2
#include+SLF优化
#includespfa判负环
bfs
//maxn<=200001时(具体多少没有测试过)就TLE --->洛谷P3385 判负环
#include
#include
#include
#include
#include
#define maxn 200001
using namespace std;
int n,m,t=0,tot=0,num[maxn];
int dis[maxn],first[maxn],nxt[maxn];
bool vis[maxn];
struct node{
int f,t,d;
}e[maxn*2];
deque <int> q;
void add(int f,int t,int d)
{
e[++tot]=(node){f,t,d};
nxt[tot]=first[f];
first[f]=tot;
}
bool spfa(int x)
{
for(int i=1;i<=n;i++) dis[i]=0x3f3f3f;
memset(vis,false,sizeof(vis));
while(!q.empty()) q.pop_front();
q.push_front(x);
vis[x]=true;
dis[x]=0;
while(!q.empty())
{
int u=q.front();
q.pop_front();
vis[u]=false;
for(int i=first[u];i!=-1;i=nxt[i])
{
int v=e[i].t;
if(dis[v]>dis[u]+e[i].d)
{
dis[v]=dis[u]+e[i].d;
if(!vis[v])
{
if(++num[v]>n) return false;
if(q.empty()) q.push_front(v);
else
{
if(dis[v]>dis[q.front()]) q.push_back(v);
else q.push_front(v);
}
}
}
}
}
return true;
}
int main()
{
freopen("fuhuan.in","r",stdin);
freopen("fuhuan.out","w",stdout);
int a,b,w;
scanf("%d",&t);
while(t--)
{
memset(first,-1,sizeof(first));
memset(num,0,sizeof(num));
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++)
{
scanf("%d%d%d",&a,&b,&w);
if(w < 0) add(a,b,w);
else { add(a,b,w); add(b,a,w); }
}
if(!spfa(1)) printf("YE5\n");
else printf("N0\n");
}
return 0;
}
dfs
//比bfs快
//负圈又称负环,就是说一个全部由负权的边组成的环,这样的话不存在最短路,因为每在环中转一圈路径总长就会变小
#includedijkstra
#include1;
//找与当前点相连的，并且离起点最近的点
//--->不一定与当前点相连，因为只要是离起点最近，除非都是maxn，不然一定是
//一定能保证从它到起点这段路上所有距离都是更新为最小值的，而且我们从起点开始更新，
//一层一层拓展出去，一定是先更新离起点近的某一个点或是几个点，再更新后面的
// “一个点或是几个点”：因为每次找离起点最近的，有可能间接到起点比直接到近，间接与间接之间，
//直接与直接之间也有远近之分，但是我们每次找的只是那个最短的
for(j=1;j<=n;++j)
{
if(!visit[j]&&min>dis[j])
{
min=dis[j];
k=j;
}
}
visit[k]=1;
//用新找到的这个最近的点来更新与它相邻的点：最近的点有更大的可能以最小的距离更新完所有的点
//或者是一部分点
//只有相邻 map[k][j] 才不可能为初始值Max，dis[j]才能>dis[k]+map[k][j]，才可以被更新
for(j=1;j<=n;++j)
{
if(!visit[j]&&dis[j]>dis[k]+map[k][j])
dis[j]=dis[k]+map[k][j];
}
}
printf("%d\n",dis[n]);
}
int main()
{
int t,n,i,j,from,to,cost;
while(scanf("%d%d",&t,&n)!=EOF)
{
for(i=1;i<=n;++i)
{
map[i][i]=0;
for(j=1;jmap [i][j]=map[j][i]=Max;
}
for(i=1;i<=t;++i)
{
scanf("%d%d%d",&from,&to,&cost);
if(cost<map[from][to]) //--->不写也行，直接赋值，覆盖掉原来的初始值Max
map[from][to]=map[to][from]=cost;
}
for(i=1;i<=n;++i)
dis[i]=map[1][i];//dis初始化为起点到i点的距离，与起点不直接相邻（相连），保持初始化map时的极大值Max
dijkstra(n);
}
return 0;
}
归并排序求逆序对
有注释版：
#include//还没有分到最简单的状态（l=r），没有分到底，也就是剩一个元素的时候
{//如果包含l=r的话，会无限循环，且l=r是最简单的状态，是停止递归的条件 ，此时开始从最后一个递归调用返回 --->from baike
msort(l,mid);
msort(mid+1,r); //这两个递归可以当做是处理 寻找范围 的一种方法 ，按顺序计算出下一步要求哪一个区间的逆序对
}
//每一部分都会被分成两部分考虑到，不用担心逆序对个数的遗漏 如：
//3 2 1 4 6 5被分为 3 2 1 和 4 6 5 两部分，同样的，3 2 1 和 4 6 5 也会各自被分为3 、2 1 和 4 、6 5两部分，
//数组以1开头的话，则是被分为 3 2 、1 和 4 6 、5两部分
//以此类推 ，3 2 1 和 4 6 5这两部分内部的逆序对也会被找出，不会产生遗漏
ll i=l,k=l,j=mid+1;//分成两部分
while(i<=mid&&j<=r)
{
if(a[i]<=a[j]) b[k++]=a[i++];//a中的当前区间处理出的顺序（每次存小的那个+下面的while循环中处理的）依然存在b的相应区间
//（保证未被操作（未被更新）的数不受影响）
//b中存的是两部分中较小的那个，a[i]小，存入b，i++，a[j]与上一部分的下一个(i+1)比较
else
{
total+=mid-i+1;//i后面的（i~mid）+i自己（i本身） //后面一部分的元素小，找到一个“前面大于后面的”，逆序对个数增加
b[k++]=a[j++];//记录较小的
}
}
while(i<=mid) b[k++]=a[i++]; //j这边的已经放完了，i那边的还有，说明i这边的比较大，把剩下的放进去就好 ①
while(j<=r) b[k++]=a[j++]; //i这边的已经放完了，j那边的还有，说明j这边的比较大，把剩下的放进去就好 ②
for(ll i=l;i<=r;i++) a[i]=b[i]; //把排好序（可能是部分排好序）的b中的值再赋回a中 （//只更新改的这一部分 ）
//把排好序（可能是部分排好序--->通过while把逆序对中小的存到大的之前，
//以前找到的逆序对消失，不会产生重复查找的事情（一个逆序对被多次找出并记录的情况不会发生。））的b中的值再赋回a中，再对a
//进行查找，重复上述操作
//另外，①与②只会出现一个（只会有一个满足/成立）
}
int main()
{
scanf("%d",&n);
for(ll i=1;i<=n;i++)
{
scanf("%d",&a[i]);
}
msort(1,n);
printf("%lld\n",total);
return 0;
}
/*
重点注意：why total+=mid-i+1
以4 5 1 6 2 3为例
我们先分析递归调用的过程，每次一分为二：
4 5 1①--->4 5②,1--->到了4,5,1递归就停止了...
6 2 3③--->6 2,④1--->到了6,2,1递归就停止了...
递归停止后， 开始从最后一个递归调用返回④--->③--->②--->① 所以是先处理有半部分区间，再处理左半部分区间，也就是说，在处理 4 5 1 6 2 3
这个大区间时，左右两个子区间都是有序的，而且是从小到大排序的，所以如果找到一个逆序对（一定是整个区间的逆序对，所有子区间的逆序对
已经处理完了，并且小的在前，大的在后，也就是上面提到的“消失了”，最后才处理最大的原来的那个区间）因为大区间是最后处理的，
而且处理前小区间的逆序对已找出，不会有遗漏，而且两个小区间还有序，所以上面提到的 “一定是整个区间的逆序对”的意思就是说，如果有逆序对，
也就是前一个>后一个，那么这个“前一个”一定在左区间，也就是前面的那个区间，这个“后一个”一定在右区间，也就是后面那个区间
那便可以解释 total+=mid-i+1的含义：
在大区间未处理之前，我们的原序列现在为：1 4 5 | 2 3 6，我们可以搜到4和2构成了一对逆序对，又因为每个区间都是递增的，那么，4所在的
那个区间中，在4之后的数（这里只有5），与2肯定也能形成一堆逆序对，毕竟都比4大了，肯定比2大，所以total所加的值，也就是新找到的
逆序对的个数是包括4在内（+1）的4后面所有数的个数的总和（mid-i（i为4的坐标，mid是左区间的右边界）），所以就能得出mid-i+1来了，所以：
total+=mid-i+1
另外，各个小区间的处理方法与大区间相同，只不过是早处理一点，所以说，total+=mid-i+1也同样适用于各个小区间
*/
无注释版：
（好吧，有一丢丢注释♪(^∇^*)）
#include1,r);
}
ll i=l,j=mid+1,k=l;
while(i<=mid&&j<=r)//"<="是因为有可能i/j的最后一个也<对方的最后一个或者是某个数，但是最后一定有一方至少剩下一个，最大的那些个没有一个更大的使其被存进b数组中，那肯定就留下了呗，然后再用下面的while循环来存储他们
{
if(a[i]<=a[j])
{
b[k++]=a[i++];
}
else
{
b[k++]=a[j++]; ans+=mid-i+1;
}
}
while(i<=mid) b[k++]=a[i++];//"<="是因为有可能最后一个剩着（当前的区间中相比之下最大的那个数）
while(j<=r) b[k++]=a[j++];
for(int i=l;i<=r;i++) a[i]=b[i];
}
int main()
{
scanf("%lld",&n);
for(ll i=1;i<=n;i++) scanf("%d",&a[i]);
gbpx(1,n);
printf("%lld\n",ans);
return 0;
}
//归并排序的话就把输出tot改为输出a数组即可，而且tot也不用记了 ^3^