1.学习总结

1.1思维导图

 

1.2图结构学习体会

     

  • 深度遍历算法、广度遍历算法：容易理解，便于找寻，比较基础
  • 拓扑排序算法：这个拓扑排序不允许有回路，而且只能在有向图里。
  • Dijkstra算法：使用了广度优先搜索解决赋权有向图最短路径问题，以起始点为中心向外层层扩展，直到扩展到终点为止，最终得到一个最短路径

    2.PTA实验作业

    1.图着色问题

  •  

    1.1设计思路：

    当t=1时，对当前第t个顶点开始着色：若t>n，则已求得一个解，输出着色方案即可。否则，依次对顶点t着色1-m， 若t与所有其它相邻顶点无颜色冲突，则继续为下一顶点着色；否则，回溯，测试下一颜色

    1.2 代码截图

     

    1.3 提交列表

  •  

    2.1 题目2  

    7-5 畅通工程之最低成本建设问题

    2.2 设计思路

    这题就是你先把这个道路的邻接矩阵建立起来，然后用Prim算法算出他们最小权重的和，如果可以遍历到所有的城镇则输出需要的钱，如果没有则输出Impossible。

    2.3 代码截图

    2.4 PTA提交列表说明

  •  

    2.1 题目2：7-2 排座位

  • 2.3 代码截图

     

    2.4 PTA提交列表说明

  • 3.截图本周题目集的PTA最后排名（3分）

4. 阅读代码

天梯地图
本题要求你实现一个天梯赛专属在线地图，队员输入自己学校所在地和赛场地点后，该地图应该推荐两条路线：一条是最快到达路线；一条是最短距离的路线。题目保证对任意的查询请求，地图上都至少存在一条可达路线。

 分析：用两个Dijkstra + DFS。一个求最快路径（如果相同求路径的那条），一个求最短路径（如果相同求结点数最小的那条）~~~求最快路径可以直接在Dijkstra里面求前驱结点Timepre数组~~~求最短路径因为要求结点数最小的那条，所以要用dispre的二维数组存储所有结点的最短路径，然后用DFS求出满足条件的结点数最小的那条~~~~
注意：
1.一开始最后一个测试用例“答案错误”，后来发现是自己在求最短路径（第二个答案distance）的时候忘记了temppath每一次深搜结束后的pop_back();

2.如果直接使用DFS的话，会导致最后一个测试用例“运行超时”~~~

 
      1. #include <cstdio>  
      2. #include <algorithm>  
      3. #include <vector>  
      4. using namespace std;  
      5. const int inf = 999999999;  
      6. int dis[510], Time[510], e[510][510], w[510][510], Timepre[510], weight[510];  
      7. bool visit[510];  
      8. vector<int> Timepath, dispath, temppath, dispre[510];  
      9. int st, fin, minnode = inf;  
      10. void dfsTimepath(int v) {  
      11.     Timepath.push_back(v);  
      12.     if(v == st) {  
      13.         return ;  
      14.     }  
      15.     dfsTimepath(Timepre[v]);  
      16. }  
      17.   
      18. void dfsdispath(int v) {  
      19.     temppath.push_back(v);  
      20.     if(v == st) {  
      21.         if(temppath.size() < minnode) {  
      22.             minnode = temppath.size();  
      23.             dispath = temppath;  
      24.         }  
      25.         temppath.pop_back();  
      26.         return ;  
      27.     }  
      28.     for(int i = 0; i < dispre[v].size(); i++) {  
      29.         dfsdispath(dispre[v][i]);  
      30.     }  
      31.     temppath.pop_back();  
      32. }  
      33. int main() {  
      34.     fill(dis, dis + 510, inf);  
      35.     fill(Time, Time + 510, inf);  
      36.     fill(weight, weight + 510, inf);  
      37.     fill(e[0], e[0] + 510 * 510, inf);  
      38.     fill(w[0], w[0] + 510 * 510, inf);  
      39.     int n, m;  
      40.     scanf("%d %d", &n, &m);  
      41.     int a, b, flag, len, t;  
      42.     for(int i = 0; i < m; i++) {  
      43.         scanf("%d %d %d %d %d", &a, &b, &flag, &len, &t);  
      44.         e[a][b] = len;  
      45.         w[a][b] = t;  
      46.         if(flag != 1) {  
      47.             e[b][a] = len;  
      48.             w[b][a] = t;  
      49.         }  
      50.     }  
      51.     scanf("%d %d", &st, &fin);  
      52.   
      53.     Time[st] = 0;  
      54.     for(int i = 0; i < n; i++) {  
      55.         Timepre[i] = i;  
      56.     }  
      57.     for(int i = 0; i < n; i++) {  
      58.         int u = -1, minn = inf;  
      59.         for(int j = 0; j < n; j++) {  
      60.             if(visit[j] == false && Time[j] < minn) {  
      61.                 u = j;  
      62.                 minn = Time[j];  
      63.             }  
      64.         }  
      65.         if(u == -1) break;  
      66.         visit[u] = true;  
      67.         for(int v = 0; v < n; v++) {  
      68.             if(visit[v] == false && w[u][v] != inf) {  
      69.                 if(w[u][v] + Time[u] < Time[v]) {  
      70.                     Time[v] = w[u][v] + Time[u];  
      71.                     Timepre[v] = u;  
      72.                     weight[v] = weight[u] + e[u][v];  
      73.                 } else if(w[u][v] + Time[u] == Time[v] && weight[v] > weight[u] + e[u][v]) {  
      74.                     weight[v] = weight[u] + e[u][v];  
      75.                     Timepre[v] = u;  
      76.                 }  
      77.             }  
      78.         }  
      79.     }  
      80.     dfsTimepath(fin);  
      81.   
      82.     fill(visit, visit + 510, false);  
      83.     dis[st] = 0;  
      84.     for(int i = 0; i < n; i++) {  
      85.         int u = -1, minn = inf;  
      86.         for(int j = 0; j < n; j++) {  
      87.             if(visit[j] == false && minn > dis[j]) {  
      88.                 u = j;  
      89.                 minn = dis[j];  
      90.             }  
      91.         }  
      92.         if(u == -1) break;  
      93.         visit[u] = true;  
      94.         for(int v = 0; v < n; v++) {  
      95.             if(visit[v] == false && e[u][v] != inf) {  
      96.                 if(e[u][v] + dis[u] < dis[v]) {  
      97.                     dis[v] = e[u][v] + dis[u];  
      98.                     dispre[v].clear();  
      99.                     dispre[v].push_back(u);  
      100.                 } else if(e[u][v] + dis[u] == dis[v]) {  
      101.                     dispre[v].push_back(u);  
      102.                 }  
      103.             }  
      104.         }  
      105.     }  
      106.     dfsdispath(fin);  
      107.     printf("Time = %d", Time[fin]);  
      108.     if(dispath == Timepath) {  
      109.         printf("; Distance = %d: ", dis[fin]);  
      110.     } else {  
      111.         printf(": ");  
      112.         for(int i = Timepath.size() - 1; i >= 0; i--) {  
      113.             printf("%d", Timepath[i]);  
      114.             if(i != 0) printf(" => ");  
      115.         }  
      116.         printf("\n");  
      117.         printf("Distance = %d: ", dis[fin]);  
      118.     }  
      119.     for(int i = dispath.size() - 1; i >= 0; i--) {  
      120.         printf("%d", dispath[i]);  
      121.         if(i != 0) printf(" => ");  
      122.     }  
      123.     return 0;  
      124. }