九度oj 题目1495：关键点

题目描述：

在一个无权图中，两个节点间的最短距离可以看成从一个节点出发到达另一个节点至少需要经过的边的个数。
同时，任意两个节点间的最短路径可能有多条，使得从一个节点出发可以有多条最短路径可以选择，并且沿着这些路径到达目标节点所经过的边的个数都是一样的。
但是在图中有那么一些特殊的节点，如果去除这些点，那么从某个初始节点到某个终止节点的最短路径长度要么变长，要么这两个节点变得不连通。这些点被称为最短路径上的关键点。
现给定一个无权图，以及起始节点和终止节点，要求输出该图上，这对节点间最短路径上的关键点数目。

输入：

输入包含多组测试数据，每组测试数据第一行为4个整数n（1<=n<=10000），m(1<=m<=100000)，s(1<=s<=n)，t(1<=t<=n)。分别代表该图中的节点个数n，边数量m，起始节点s，终止节点t。
接下去m行描述边的信息，每行两个整数a，b（1<=a,b<=n 且 a != b）。表示节点a和节点b之间有一条边。

输出：

对于每组测试数据，输出给定的这对节点间最短路径上的关键点数目。注意：若给定两个节点间不连通，则我们认为其关键点数目是0。

样例输入：

5 5 1 5
1 2
1 3
2 4
3 4
4 5
4 4 1 4
1 2
2 4
3 4
1 3

样例输出：

1
0

开始看到这个题觉得有些懵，
一开始用深度优先搜索来做，找到最短的那条路径，并且对路径上走过的每一个点进行计数
最后计数值和终点的计数值一致的点就是关键点
代码如下

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <iostream>
 #define POINT_CNT 10020

 using namespace std;

 vector <int> adj[POINT_CNT];
 int flag[POINT_CNT];
 int cnt[POINT_CNT];
 int path[POINT_CNT];
 int tm[POINT_CNT];
 int n, m, s, t;
 int minStep;

 void dfs(int from, int step) {
     if (step > tm[from]) {
         return;
     }
     if (from != s && step == tm[from]) {
         if (cnt[from] != ) {
             for (int j = ; j <= minStep; j++) {
                 cnt[path[j]]++;
                 tm[path[j]] = j;
             }
         }
         return;
     }
     if (from == t) {
         if (step < minStep) {
             memset(cnt, , sizeof(cnt));
             for (int j = ; j <= step; j++) {
                 cnt[path[j]] = ;
                 tm[path[j]] = j;
             }
             minStep = step;
         }
         else if (step == minStep) {
             for (int j = ; j <= step; j++) {
                 cnt[path[j]]++;
                 tm[path[j]] = j;
             }
         }
         return;
     }
     int sz = adj[from].size();
     for (int i = ; i < sz; i++) {
         int p = adj[from][i];
         if (flag[p] == ) {
             flag[p] = ;
             path[step + ] = p;
             dfs(p,step+);
             flag[p] = ;
         }
     }
 }

 int main() {
     //freopen("input.txt", "r", stdin);
     //freopen("output.txt", "w", stdout);

     while (scanf("%d %d %d %d", &n, &m, &s, &t) != EOF) {
         for (int i = ; i < POINT_CNT; i++) {
             adj[i].clear();
         }
         while (m--) {
             int a, b;
             scanf("%d %d", &a, &b);
             adj[a].push_back(b);
             adj[b].push_back(a);
         }
         memset(flag, , sizeof(flag));
         memset(cnt, , sizeof(cnt));
         for (int i = ; i <= n; i++) {
             tm[i] = POINT_CNT;
         }
         minStep = POINT_CNT;

         flag[s] = ;
         path[] = s;
         tm[s] = ;
         dfs(s,);
         int way = cnt[t];
         int ans = ;
         if (way == ) {
             puts("");
             continue;
         }
         for (int i = ; i <= n; i++) {
             if (cnt[i] == way && i != t) {
                 ans++;
             }
         }
         printf("%d\n", ans);
     }
     return ;
 }

中间又做了一些剪枝的处理，但提交了好几次均超时。

无奈之下考虑广度优先搜索的思路

主要问题是如何找到关键点，此处我们需要遍历两次

第一次从源点s遍历到终点t,记录每一个经过点的层数

第二次从终点t遍历到起点s,只遍历那些层数比其小的。当队列为空时那个出队列的点就是关键点。

但一开始提交又是错误

代码如下

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <iostream>
 #include <queue>

 #define POINT_CNT 10020

 using namespace std;

 vector <int> edge[POINT_CNT];
 int flag[POINT_CNT];
 int level[POINT_CNT];
 int n, m, s, t;
 int minStep;
 queue <int> que;

 int main() {
     //freopen("input.txt", "r", stdin);
     //freopen("output.txt", "w", stdout);

     while (scanf("%d %d %d %d", &n, &m, &s, &t) != EOF) {
         for (int i = ; i < POINT_CNT; i++) {
             edge[i].clear();
         }
         while (m--) {
             int a, b;
             scanf("%d %d", &a, &b);
             edge[a].push_back(b);
             edge[b].push_back(a);
         }
         if (n == ) {
             puts("");
             continue;
         }
         memset(flag, , sizeof(flag));
         memset(level, , sizeof(level));
         while (!que.empty()) {
             que.pop();
         }
         que.push(s);
         flag[s] = ;
         while (!que.empty()) {
             int p = que.front(); que.pop();
             int ps = edge[p].size();
             int step = level[p];

             if (p == t) {
                 break;
             }
             for (int i = ; i < ps; i++) {
                 int to = edge[p][i];
                 if (flag[to] == ) {
                     que.push(to);
                     level[to] = step + ;
                     flag[to] = ;
                 }
             }
         }

         while (!que.empty()) {
             que.pop();
         }
         que.push(t);
         int ans = ;
         while (!que.empty()) {
             int p = que.front(); que.pop();
             int ps = edge[p].size();
             int step = level[p];
             if (p == s) {
                 break;
             }
             if (que.empty()) {
                 ans++;
             }
             for (int i = ; i < ps; i++) {
                 int to = edge[p][i];
                 if (level[to] < step) {
                     que.push(to);
                 }
             }
         }
         printf("%d\n", ans-);
     }
     return ;
 }

此时考虑特殊情况，如果只有一个点怎么办？如果有重边怎么办？

一是输出0，二是增加标记是否访问过

修改代码如下

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <iostream>
 #include <queue>

 #define POINT_CNT 10020

 using namespace std;

 vector <int> edge[POINT_CNT];
 int flag[POINT_CNT];
 int level[POINT_CNT];
 int n, m, s, t;
 int minStep;
 queue <int> que;

 int main() {
     //freopen("input.txt", "r", stdin);
     //freopen("output.txt", "w", stdout);

     while (scanf("%d %d %d %d", &n, &m, &s, &t) != EOF) {
         for (int i = ; i < POINT_CNT; i++) {
             edge[i].clear();
         }
         while (m--) {
             int a, b;
             scanf("%d %d", &a, &b);
             edge[a].push_back(b);
             edge[b].push_back(a);
         }
         if (n == ) {
             puts("");
             continue;
         }
         memset(flag, , sizeof(flag));
         memset(level, , sizeof(level));
         while (!que.empty()) {
             que.pop();
         }
         que.push(s);
         flag[s] = ;
         while (!que.empty()) {
             int p = que.front(); que.pop();
             int ps = edge[p].size();
             int step = level[p];

             if (p == t) {
                 break;
             }
             for (int i = ; i < ps; i++) {
                 int to = edge[p][i];
                 if (flag[to] == ) {
                     que.push(to);
                     level[to] = step + ;
                     flag[to] = ;
                 }
             }
         }

         while (!que.empty()) {
             que.pop();
         }
         que.push(t);
         int ans = ;
         memset(flag, , sizeof(flag));
         flag[t] = ;
         while (!que.empty()) {
             int p = que.front(); que.pop();
             int ps = edge[p].size();
             int step = level[p];
             if (p == s) {
                 break;
             }
             if (que.empty()) {
                 ans++;
             }
             for (int i = ; i < ps; i++) {
                 int to = edge[p][i];
                 if (level[to] < step && flag[to]==) {
                     que.push(to);
                     flag[to] = ;
                 }
             }
         }
         printf("%d\n", ans-);
     }
     return ;
 }

提交，还是错误。

。。。。。。。。。。

。。。。。。。。。。。。。。。。

。。。。。。。。。。。。。。。。。。

。。。。。。。。。。。。。。。。。。。。

。。。。。。。。。。。。。。。。。。。。。。

总是不过真是令人无奈

偶然发现自己初始化 level为0

那么有些和终点相连却并不和起点相连的点就会被访问，导致错误

比如

6就会被访问

再次修改如下

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #include <vector>
 #include <iostream>
 #include <queue>

 #define POINT_CNT 10020

 using namespace std;

 vector <int> edge[POINT_CNT];
 int flag[POINT_CNT];
 int level[POINT_CNT];
 int n, m, s, t;
 int minStep;
 queue <int> que;

 int main() {
     //freopen("input.txt", "r", stdin);
     //freopen("output.txt", "w", stdout);

     while (scanf("%d %d %d %d", &n, &m, &s, &t) != EOF) {
         for (int i = ; i < POINT_CNT; i++) {
             edge[i].clear();
         }
         while (m--) {
             int a, b;
             scanf("%d %d", &a, &b);
             edge[a].push_back(b);
             edge[b].push_back(a);
         }
         memset(flag, , sizeof(flag));
         fill(level, level + POINT_CNT, POINT_CNT);
         while (!que.empty()) {
             que.pop();
         }
         que.push(s);
         level[s] = ;
         flag[s] = ;
         while (!que.empty()) {
             int p = que.front(); que.pop();
             int ps = edge[p].size();
             int step = level[p];

             if (p == t) {
                 break;
             }
             for (int i = ; i < ps; i++) {
                 int to = edge[p][i];
                 if (flag[to] == ) {
                     que.push(to);
                     level[to] = step + ;
                     flag[to] = ;
                 }
             }
         }

         while (!que.empty()) {
             que.pop();
         }
         que.push(t);
         int ans = ;
         memset(flag, , sizeof(flag));
         flag[t] = ;
         while (!que.empty()) {
             int p = que.front(); que.pop();
             int ps = edge[p].size();
             int step = level[p];
             if (p == s) {
                 break;
             }
             if (que.empty()) {
                 ans++;
             }
             for (int i = ; i < ps; i++) {
                 int to = edge[p][i];
                 if (level[to] < step && flag[to]==) {
                     que.push(to);
                     flag[to] = ;
                 }
             }
         }
         printf("%d\n", max(ans-,));
     }
     return ;
 }

提交终于通过了，

汗！！！！！！！！！！！！！！！！！！