uva208 - Firetruck

Firetruck

The Center City fire department collaborates with the transportation department to maintain maps of the city which reflects the current status of the city streets. On any given day, several streets are closed for repairs or construction. Firefighters need to be able to select routes from the firestations to fires that do not use closed streets.

Central City is divided into non-overlapping fire districts, each containing a single firestation. When a fire is reported, a central dispatcher alerts the firestation of the district where the fire is located and gives a list of possible routes from the firestation to the fire. You must write a program that the central dispatcher can use to generate routes from the district firestations to the fires.

Input

The city has a separate map for each fire district. Streetcorners of each map are identified by positive integers less than 21, with the firestation always on corner #1. The input file contains several test cases representing different fires in different districts.

• The first line of a test case consists of a single integer which is the number of the streetcorner closest to the fire.
• The next several lines consist of pairs of positive integers separated by blanks which are the adjacent streetcorners of open streets. (For example, if the pair 4 7 is on a line in the file, then the street between streetcorners 4 and 7 is open. There are no other streetcorners between 4 and 7 on that section of the street.)
• The final line of each test case consists of a pair of 0's.

Output

For each test case, your output must identify the case by number (CASE #1, CASE #2, etc). It must list each route on a separate line, with the streetcorners written in the order in which they appear on the route. And it must give the total number routes from firestation to the fire. Include only routes which do not pass through any streetcorner more than once. (For obvious reasons, the fire department doesn't want its trucks driving around in circles.)

Output from separate cases must appear on separate lines.

The following sample input and corresponding correct output represents two test cases.

Sample Input

6
1 2
1 3
3 4
3 5
4 6
5 6
2 3
2 4
0 0
4
2 3
3 4
5 1
1 6
7 8
8 9
2 5
5 7
3 1
1 8
4 6
6 9
0 0

Sample Output

CASE 1:
1 2 3 4 6
1 2 3 5 6
1 2 4 3 5 6
1 2 4 6
1 3 2 4 6
1 3 4 6
1 3 5 6
There are 7 routes from the firestation to streetcorner 6.
CASE 2:
1 3 2 5 7 8 9 6 4
1 3 4
1 5 2 3 4
1 5 7 8 9 6 4
1 6 4
1 6 9 8 7 5 2 3 4
1 8 7 5 2 3 4
1 8 9 6 4
There are 8 routes from the firestation to streetcorner 4.

 

// 题意：给一个无向图，输出从结点1到给定结点的所有路径，要求结点不能重复经过

// 算法：数据不难，直接回溯即可。但是需要注意两点：

// 1. 要事先判断路径是否存在，否则会超时

// 2. 必须按照字典序从小到大输出各路径。本程序的解决方法是给每个点的相邻点编号排序

预判dfs复杂度：

回溯dfs复杂度：O（b^n） b为分支数

算法耗时 9 ms

 

#include<cstdio>
#include<cstring>
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn=21+5;
int target, cnt;
int route[maxn], vis[maxn];
vector<int> G[maxn];

void dfs(int d, int v)
{
    if(v==target) {
        cnt++;
        for(int i=0;i<d-1;i++) printf("%d ", route[i]);
        printf("%d\n", route[d-1]);
        return;
    }
    for(int i=0;i<G[v].size();i++)
    {
        int u=G[v][i];
        if(!vis[u]) {
            route[d]=u;
            vis[u]=1; dfs(d+1, u); vis[u]=0;
        }
    }
}

bool can_reach_target(int u)
{
    if(u==target) return true;
    for(int i=0;i<G[u].size();i++)
    {
        int v=G[u][i];
        if(!vis[v]) {
            vis[v]=1;
            if(can_reach_target(v)) return true;
        }
    }
    return false;
}

int main()
{
    int kase=0;
    while(scanf("%d", &target)==1) {
        int u,v;
        for(int i=0;i<maxn;i++) G[i].clear();
        cnt=0;
        while(scanf("%d%d", &u, &v)==2&&(u||v)) {
            G[u].push_back(v);
            G[v].push_back(u);
        }
        for(int i=0;i<maxn;i++) sort(G[i].begin(), G[i].end());

        printf("CASE %d:\n", ++kase);
        memset(vis, 0, sizeof(vis));
        if(vis[1]=1, can_reach_target(1)) {
            memset(vis, 0, sizeof(vis));
            route[0]=1;vis[1]=1;
            dfs(1, 1);
        }
        printf("There are %d routes from the firestation to streetcorner %d.\n", cnt, target);
    }

    return 0;
}

 

解法二：双向搜索进行剪枝

从起点开始搜索之前，很有必要先确定一下有那些路是可以到达目标的。

如何确定那些路可以到目标呢？ 我们只需要先从目标点开始进行搜索，把所有搜索到得路径都进行标记。

然后，再从起点处进行搜索，在搜索之前，要先判断一下这个路径是否有被之前标记过，如果没有被标记，那么说明它是不可能

走到目标处的。这样的话，就不会盲目地去走了，也大大提高了效率。

 

下面代码加入一个mark数组，表示终点可以到达的点。mark_can_reach_target复杂度也是O（E）啦。 算法耗时 9 ms

 

#include<cstdio>
#include<cstring>
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
const int maxn=21+5;
int target, cnt;
int route[maxn], vis[maxn], mark[maxn];
vector<int> G[maxn];

void dfs(int d, int v)
{
        if(v==target) {
                cnt++;
                for(int i=0;i<d-1;i++) printf("%d ", route[i]);
                printf("%d\n", route[d-1]);
                return;
        }
        for(int i=0;i<G[v].size();i++)
        {
                int u=G[v][i];
                if(!vis[u] && mark[u]) {
                        route[d]=u;
                        vis[u]=1; dfs(d+1, u); vis[u]=0;
                }
        }
}

bool mark_can_reach_target(int u)
{
        bool reach_start=false;
        if(mark[u])
                return false;
        mark[u]=1;
        if(u==1)
                reach_start=true;
        for(int i=0;i<G[u].size();i++)
        {
                int v=G[u][i];
                if(mark_can_reach_target(v))
                        reach_start=true;
        }
        return reach_start;
}

int main()
{
        int kase=0;
        while(scanf("%d", &target)==1) {
                int u,v;
                for(int i=0;i<maxn;i++) G[i].clear();
                cnt=0;
                while(scanf("%d%d", &u, &v)==2&&(u||v)) {
                        G[u].push_back(v);
                        G[v].push_back(u);
                }
                for(int i=0;i<maxn;i++) sort(G[i].begin(), G[i].end());

                printf("CASE %d:\n", ++kase);
                memset(mark, 0, sizeof(mark));
                if(mark_can_reach_target(target)) {
                        memset(vis, 0, sizeof(vis));
                        route[0]=1;vis[1]=1;
                        dfs(1, 1);
                }
                printf("There are %d routes from the firestation to streetcorner %d.\n", cnt, target);
        }

    return 0;
}