Uva 208 Firetruck

大致思路：其实用dfs就可以解决，但是只用dfs的话，会导致超时。在进行dfs前，应该判断一下从1点能否到达目的地，这样就不会超时了，估计是测试数据中有很多是从1点无法到达目的地的。

　　　　判断能否到达可以用bfs判断，在这道题里，效率还算不错。

C++代码：

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

using namespace std;

const int MAXN = 20 + 5;
vector <int> link[MAXN];
int path[MAXN], vis[MAXN];
int N, counter;

void Init() {
    for(int i=0; i<MAXN; ++i) {
        link[i].clear();
    }
}

void Read() {
    int x, y;
    while(true) {
        scanf("%d%d", &x, &y);
        if(!x && !y) {
            break;
        }
        link[x].push_back(y);
        link[y].push_back(x);
    }
    for(int i=0; i<MAXN; i++) {
        if(link[i].size()) {
            sort(link[i].begin(), link[i].end());
        }
    }
}

void Print(int cur) {
    for(int i = 1; i < cur; ++ i) {
        printf("%d ", path[i]);
    }
    printf("%d\n", path[cur]);
}

void Dfs(int value, int cur) {
    if(value == N) {
        ++ counter;
        Print(cur);
        return ;
    }
    for(size_t i = 0; i < link[value].size(); ++ i) {
        int node = link[value][i];
        if(!vis[node]) {
            vis[node] = 1;
            path[cur+1] = node;
            Dfs(node, cur + 1);
            vis[node] = 0;
        }

    }
}

bool IsConnect() {
    queue<int> q;
    q.push(1);
    bool is[MAXN] = {false};
    is[1] = true;
    while(!q.empty()) {
        int t = q.front();
        q.pop();
        if(t == N) {
            return true;
        }
        for(size_t i = 0; i < link[t].size(); ++ i) {
            if(!is[link[t][i]]) {
                is[link[t][i]] = true;
                q.push(link[t][i]);
            }
        }
    }
    return false;
}

int main() {
    int Case = 0;
    while(scanf("%d", &N)!=EOF) {
        Init();
        Read();
        counter = 0;
        printf("CASE %d:\n", ++Case);
        if(IsConnect()) {
            memset(vis, 0, sizeof(vis));
            vis[1] = 1;
            path[1] = 1;
            Dfs(1, 1);
        }
        printf("There are %d routes from the firestation to streetcorner %d.\n", counter, N);
    }
    return 0;
}

 

 

试着用java写了一下

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

/**
 * Created by emerald on 8/8/15.
 * uva208
 */
public class Main {
    public static void main(String []args) {
        Scanner in = new Scanner(System.in);
        int Case = 0;
        while (in.hasNext()) {
            N = in.nextInt();
            init();
            read(in);
            System.out.println("CASE " + (++Case) +":");
            counter = 0;
            if(isConnect()) {
                boolean vis[] = new boolean[MAXN];
                int path[] = new int[MAXN];
                for(int i=0; i<vis.length; ++ i) {
                    vis[i] = false;
                }
                vis[1] = true;
                path[1] = 1;
                dfs(1, 2, vis, path);
            }
            System.out.println("There are "+ counter +" routes from the firestation to streetcorner " + N +".");
        }
    }

    public static int MAXN = 20 + 5;
    public static int N, counter;
    public static ArrayList<Integer> link[] = new ArrayList[MAXN];

    public static void init() {
        for(int i=0; i<link.length; ++ i) {
            link[i] = new ArrayList<>();
        }
    }
    public static void read(Scanner in) {
        int x, y;
        while (in.hasNext()) {
            x = in.nextInt();
            y = in.nextInt();
            if(x == 0 && y == 0) {
                break;
            }
            link[x].add(y);
            link[y].add(x);
        }
        for(int i=0; i<link.length; ++ i) {
            if(link[i].size() > 0) {
                Collections.sort(link[i]);
            }
        }
    }

    public static boolean isConnect() {
        int q[] = new int[MAXN * MAXN];
        int front = 0, rear = 1;
        boolean vis[] = new boolean[MAXN];
        for(int i=0; i<vis.length; ++ i) {
            vis[i] = false;
        }
        q[front] = 1;
        vis[1] = true;
        while (front < rear) {
            int t = q[front];
            if(t == N) {
                return true;
            }
            for(int i=0; i<link[t].size(); ++ i) {
                int value = link[t].get(i);
                if(!vis[value]) {
                    vis[value] = true;
                    q[rear ++] = value;
                }
            }
            ++ front;
        }
        return false;
    }

    public static void dfs(int value, int cur, boolean vis[], int path[]) {
        if(value == N) {
            ++ counter;
            print(path, cur);
            return;
        }
        for(int each:link[value]) {
            if(!vis[each]) {
                vis[each] = true;
                path[cur] = each;
                dfs(each, cur+1, vis, path);
                vis[each] = false;
            }
        }
    }

    public static void print(int path[], int cur) {
        for(int i=1; i<cur-1; i++) {
            System.out.print(path[i] + " ");
        }
        System.out.println(path[cur-1]);
    }
}