2017 4 18 每日总结（二）

 每日总结（二）

       Python 总结:

       正如昨天总结的可以使用insert和pop两个插入以及删除元素，还可以在不实用这两个的情况下比如x = [1, 1, 1]

       x[1:1] = [2, 2] => x = [1, 2, 2, 1, 1]

       同样 x[1: 2] = [ ]  => x = [1]

       所以我们可以直接这样操作就可以，不用使用insert和pop就可以，还是挺方便的，不过我才开始学不知道后面会不会有坑，这就不一定啦。

       今天学习了六个新的东西:(例子均为 x = [2, 1, 3]）

       append    在最后添加元素    x.append(4)  =>  x = [2, 1, 3, 4]

       count       输出查找量（可以是数字也可以是字符串）   x.count(1) => 1    x.count(4) =>  0

       extend     类似与拼接     y = [1, 1, 1]     x.extend(y)  =>   x = [2, 1, 3, 1, 1, 1]

       index       输出查找量的位置（和count一样，可以是数字也可以是字符串）    x.index(1)  =>  1

       sort          和c++中差不多还好，不过对于python中的cmp还不是很理解，用sort降序排序还有一点不同。

                       x.sort(reverse = True)    =>    x = [3, 2, 1]

       python 中还有字典，今天只学了皮毛，明天再深入理解一下。

                       d = {'bobo':87, 'nunu':99, 'haha':97}

                       d['bobo'] = 87  （感觉有点类似于c++中的map函数，也是两个数据的对应）

       另外很重要的是在c++中set容器是一个有序的集合，但是在python中它是无序的，没有顺序而言。

       今天也就看了一点这个而已。

       

       算法总结：

       今天接触的算法只有并查集，dancing links, spfa，但是解决的只有并查集而已，差不多都算是模板题，只有一点小小的处理，本来想趁势多写几道题，结果。。。GG，本以为简单的题，对思维还是有个很大的考察的，看了题解才勉勉强强搞定，不过也就算AC而已，还没有理解，怕是明天还得再来一道了。现在就得写一写昨天说的那道题的题解了。

       首先我好像还没总结过最短路。。。也就小小的讲了一下最小生成树的prim算法而已，今天趁势总结一波。

       说实话，最开始学这个的时候还好，因为dijkstra和prim算法贼像，所以跟着一起类比学习，就掌握的还算不错。prim算法中，在两个for循环中我们找当前所到未到点的最近距离，记录是哪个点，然后记录结果的一个变量加这个值就可以了，然后就更新dis数组中的值，即当前已经联通的点到没有联通的点的距离有没有比dis数组中的小的，然后再进行数据更新。最短路的dijkstra算法和这个类似。

       

A - Til the Cows Come Home

 POJ - 2387 

      以上面这道题为例：

      

#include <stdio.h>#include <string.h>#define MAX 0x3f3f3f3fint map[2005][2005];int main(){int n, m, i, j, k, a, b, len, max;int dis[2005], vis[2005];scanf("%d%d", &m, &n);memset(map, 0, sizeof(map));while (m--){scanf("%d%d%d", &a, &b, &len);if (!map[a][b]){map[a][b] = map[b][a] = len;}else if (map[a][b] > len){map[a][b] = map[b][a] = len;}}memset(vis, 0, sizeof(vis));for (i = 1; i <= n; i++){dis[i] = map[n][i];}vis[n] = 1;for (i = 1; i <= n; i++){max = MAX;for (j = 1; j <= n; j++){if (!vis[j] && dis[j] && dis[j] < max){max = dis[j];k = j;}}if (max == MAX){break;}vis[k] = 1;for (j = 1; j <= n; j++){if (!vis[j] && (dis[j] > map[k][j] + dis[k]||!dis[j]) && map[k][j] ){dis[j] = dis[k] + map[k][j];}}}printf("%d\n", dis[1]);return 0;}

       也就在将目标标记之后我们在对dis数组更新时有不同的处理方式罢了。

       具体怎么实现的推荐找一组数据代入看代码如何实现的，毕竟我也是这么来的，就算理解了算法怎么做的但还是敲不来的时候还是有的。

       spfa也是最短路的一种算法，不过spfa可以用于处理有负环的图。spfa要用到队列实现，就昨天说的那道题，那道题在处理上还有一个巧妙的地方。不说了，直接贴代码：

       

#include <stdio.h>#include <string.h>#include <queue>using namespace std;#define MAX 1000005#define INF 0x3f3f3f3fstruct node {int len, to, next;}point[2][MAX];int head[2][MAX];int vis[MAX];long long dis[MAX];void spfa(int dire){int i, j, k;memset(vis, 0, sizeof(vis));memset(dis, INF, sizeof(dis));dis[1] = 0;vis[1] = 1;queue<int>Q;Q.push(1);while (!Q.empty()){k = Q.front();Q.pop();vis[k] = 0;for (i = head[dire][k]; i != -1; i = point[dire][i].next){j = point[dire][i].to;if (dis[j] > dis[k] + point[dire][i].len){dis[j] = dis[k] + point[dire][i].len;if (!vis[j]){vis[j] = 1;Q.push(j);}}}}}int main(){int n, q, i, j, T, a, b, leng;scanf("%d", &T);while (T--){scanf("%d%d", &n, &q);for (i = 0; i <= n; i++){head[0][i] = head[1][i] = -1;}for (i = 0; i < q; i++){scanf("%d%d%d", &a, &b, &leng);point[0][i].len = leng;point[0][i].to = b;point[0][i].next = head[0][a];head[0][a] = i;point[1][i].len = leng;point[1][i].next = a;point[1][i].to = a;point[1][i].next = head[1][b];head[1][b] = i;}    long long ans = 0;spfa(0);for (i = 1; i <= n; i++){ans += dis[i];}spfa(1);for (i = 1; i <= n; i++){ans += dis[i];}printf("%lld\n", ans);}return 0;}

      我也是看了一下网上的题解的，这道题最主要的就是   

      point[0][i].next = head[0][a];

      head[0][a] = i;

      point[1][i].next = head[1][b];

      head[1][b] = i;

      这一步是最难理解的地方，这里我们可以分析，在结构体中len是该条路径的长度，to可以理解为目的地，也就是可以理解为到to表示的位置要经过len的长度。重要的就是这里的next表示啥呢？就是这里，也就是巧妙的地方，巧妙地存图，节省了空间。

       通过代入了几组数据发现了 next其实可以理解为链表所对应的下一个节点，而这里的head存的东西可以理解为头节点，因为每次存点都相当于给一个结构体标号为i，然后这里的head存下这个，主要是为了在应用spfa的时候我们可以找到通过这个点能够到达的其他点的一个关系，通过next找到一个类似标号的东西，这个位置的一个结构体就是我们要的东西，不是很理解代值，是最容易让自己理解的一种方法，可能会消耗时间，但也请下决心做。也可以在这里看到spfa的一个特点，进入了spfa中的点可以被再次利用，不像前一个算法，每个点最多出现一次，比较还是类似的。推荐找几个题加深理解。