2016年蓝桥个人赛赛前总复习 个人经验总结

20号就是蓝桥杯的省赛了，准备了半年，现在进入了最后的准备阶段，把几大经典算法和一些C++ 上必备的技巧做一个总结。

第一，dijkstra。为什么从dijkstra说起，因为这是最经典，最基础，使用率最广的图算法之一。

void dijkstra(){int path[v+1];int shortest[v+1]int shortestPoint;int shortestDist;int already;bool ifVisited[v+1];for(int i=1;i<=v;i++){path[i]=1;ifVisited[i]=false;shortest[i]=g[1][i];}shortestDist=0;shortestPoint=1;shortest[1]=0;ifVisited[1]=true;already=1;while(already<=v){shortestDist=inf;for(int i=1;i<=v;i++){if(ifVisited[i]==false&&shortest[i]<shortestDist){shortestPoint=i;shortestDist=shortest[i];}}ifVisited[shortestPoint]=true;already++;for(int i=1;i<=v;i++){if(ifVisited[i]==false&&g[shortestPoint][i]+shortest[shortestPoint]<shortest[i]){shortest[i]=g[shortestPoint][i]+shortest[shortestPoint];}}}return;}

基本数据结构如下：

path数组，记录这个点的前驱顶点是什么；

shortest数组，这个就是最终的结果，记录每个点的最短距离。

shortestPoint，当前回合择优选取的点。

shortestDist，当前回合选择最优点时，已经产生的最短距离。

ifVisited数组，记录哪些点已经达到了最短距离。

already，记录目前已经有几个点达到了最短距离。

第二，bellman-ford算法，这个算法用于dijkstra不能求的带负权的回路中。

代码如下：

void bellman-ford(){class line{public:int start,end,id,length;};line l[lineNumber+1];int leng[v+1];for(int i=1;i<=v;i++){leng[i]=inf;}leng[1]=0;for(int i=1;i<=v-1;i++){for(int i=1;i<=lineNumber;i++){if(leng[l[i].end]>leng[l[i].start]+l[i].length){leng[l[i].end]=leng[l[i].start]+l[i].length;}}} for(int i=1;i<=lineNumber;i++){if(leng[l[i].end]>leng[l[i].start]+l[i].length){cout<<"error";return;}}return;}

注意事项：bellman-ford是遍历边，遍历的循环次数是v-1次，v是点的数量，不是边的数量。

如果是无向图，则遍历边的时候，一条边遍历两次，相当于两条边，只是起点和重点的次序颠倒了。

第三：flyod算法。最直观的最短路算法，适用于要求任意两点间最短距离的情况，如果只需要求某一点到其他点最短路，则这个算法比较费时间，不推荐。

代码如下：

void flyod(){for(int i=1;i<=v;i++){for(int j=1;j<=v;j++){for(int k=1;k<=v;k++){if(g[j][k]>g[j][i]+g[i][k]){g[j][k]=g[j][i]+g[i][k];}}}}return;}

没有太多的注意事项。

第四：最小生成树 prim算法。

最简单的最小生成树算法。

代码如下：

void prim(){bool ifVisited[v+1];int minPoint,minDist;int minLength[v+1];int result=0;for(int i=1;i<=v;i++){ifVisited[i]=false;minLength[i]=inf;}ifVisited[1]=true;minPoint=1;minLength=0;for(int i=1;i<=v-1;i++){for(int j=1;j<=v;j++){if(ifVisited[j]==false&&g[minPoint][j]<minLength[j]){minLength[j]=g[minPoint][j];}}minDist=inf;for(int j=1;j<=v;j++){if(ifVisited[j]==false&&minLength[j]<minDist){minDist=g[minPoint][j];minPoint=j;}}result+=minDist;ifVisited[minPoint]=true;}return;} 

仔细看，prim和dijkstra真是很神似，他们的区别在于，prim在选择哪个点作为下一个点的时候，比较的是上一个选点和当前遍历点这跳线的长度哪个最短。而dijkstra是上个选点的最短路径+两点间距离。实际上这两个算法本质上是相同的。

第五：kruskal算法。

我们把最小生成树的算法放到一块来，一般来说，如果比赛中发现存储数据比较适合用边来的话，建议用kruskal，如果适合用一般的二维数组表示图，则使用prim比较方便写代码。

int father[e+1];class edge{public:int start,end,leng;};int cmp(const void *a,const void *b){return *(edge*)a.leng<*(edge*)b.leng;}int find(int a){return a==father[a]?a:find(father[a]);}bool join(int a,int b){a=find(a);b=find(b);if(a==b){return false;}else{father[a]=b;}return true;}void kruskal(){int result=0;edge ed[e+1];ed[1].leng=-inf;qsort(ed,e+1,sizeof(ed[0]),cmp);for(int i=1;i<=v;i++){if(join(ed[i].start,ed[i].end)==true){result+=ed[i].leng;}}return;}

第六：最小点覆盖，最大匹配数，匈牙利算法。

又一大比赛中常常出现的算法。最小点覆盖=最大匹配数。匈牙利算法基本代码如下：

bool ifVisited[y+1];int ancestor[y+1];bool dfs(int a){for(int i=1;i<=y;i++){if(ifVisited[i]==false&&g[a][i]==true){ifVisited[i]=true;if(ancestor[i]==0||dfs(ancestor[i])==true){return true;}}}return false;}void xiongyali(){for(int i=1;i<=y;i++){ancestor[i]=0;}for(int i=1;i<=x;i++){for(int j=1;j<=y;j++){ifVisited[j]=false;}if(dfs(i)==true){ans++;}}return;}

另外，两大公式：

最大匹配数=最小点覆盖；

最小路径覆盖=拆点前点数量-最大匹配数/2；

第七：0-1背包，最短两段子序列的动态规划。

拿0-1背包和子序列来说事，是因为这两个问题是动态规划的启蒙问题，具有非常高的代表性。

首先说一下0-1背包问题，典型解法：

for(int i=0;i<=itemNumber;i++){dp[0][i]=0;}for(int i=1;i<=itemNumber;i++){for(int j=1;j<=itemNumber;j++){dp[i][j]=dp[i-1][j]>dp[i-1][j-1]+weight[j]?dp[i-1][j]:dp[i-1][j-1]+weight[j];}}

初始化dp[0][n];然后从i开始遍历。

两段最短子序列问题，这个问题涉及三个数组，分别为前i个字符包括i组成的最大连续序列长度，后i个字符包括i组成的最大连续序列长度，前i个字符可以组成的最大序列，不包括i：

dp[0]=0;a[100];b[100];for(int i=1;i<=n;i++){dp[i]=dp[i-1]+value[i]>value[i]?dp[i-1]+value[i]:value[i];}a[0]=0;for(int i=1;i<=n;i++){if(a[i-1]>dp[i]){a[i]=a[i-1];}else{a[i]=dp[i];}}b[n]=0;for(int i=n-1;i>=0;i--){b[i]=value[i]>b[i+1]+value[i]?:value[i]:b[i+1]+value[i];}result=-inf;for(int i=0;i<n;i++){if(a[i]+b[i+1]>result){result=a[i]+b[i+1];}}return result;

第八：最大流算法，ek

最大流是用ek做，当然也可以km，ek比较直观，好上手，在比赛中比较合适。

int flow[v];int former[v];bool ifVisited[v];bool bfs(){queue<int> q;while(!q.empty()){q.pop();}for(int i=1;i<=v;i++){flow[i]=0;former[i]=0;ifVisited[i]=false;}former[1]=1;flow[1]=inf;ifVisited[1]=true;push(1);while(!q.empty()){int cur=q.front();q.pop();for(int i=1;i<=v;i++){if(ifVisited[i]==false&&g[cur][i]>0){ifVisited[i]=true;flow[i]=flow[cur]>g[cur][i]?g[cur][i]:flow[cur];push(i);}}}if(flow[v]==0){return false;}else{retur true;}}int ek(){bfs();int min=flow[v];while(min>0){int c=v;while(former[c]!=1){g[former[c]][c]-=flow[v];g[c][former[c]]+=flow[v];}result+=flow[v];bfs();min=flow[v];}return result;}

九，排序算法

直接插入排序，希尔排序，堆排序，冒泡排序，快速排序，归并排序