soj 1015 Jill's Tour Paths 解题报告

题目描述：

1015. Jill's Tour Paths

Constraints

Time Limit: 1 secs, Memory Limit: 32 MB

Description

Every year, Jill takes a bicycle tour between two villages. There are different routes she can take between these villages, but she does have an upper limit on the distance that she wants to travel. Given a map of the region indicating the cities and the roads between them (and their distances), Jill would like to have a list of the various routes between the selected cities that will meet her distance requirements. Your task is to write a program that will produce a list of these routes, in increasing order of distance.

We make the following assumptions.

• At most one road connects any pair of villages, and this road is two-way and has a non-zero positive distance.
• There are no roads that lead directly from a village back to the same village.
• Jill is only concerned about a one-way trip. That is, she is not concerned about returning to the village from which she starts her tour.
• Jill will not visit any village more than once during the tour.

The farthest Jill will ever travel is 9999 units

Input

The input will contain several possible cases, each including a route map, identification of the start and destination villages, and the maximum distance Jill is willing to travel.

Each case appears in the input as a set of integers separated by blanks and/or ends of lines. The order and interpretation of these integers in each case is as follows:

• NV – the number of villages in the route map. This number will be no larger than 20.
• NR – the number of roads that appear in the route map. Each road connects a distinct pair of villages.
• NR triples, one for each road, containing C1, C2, and DIST – C1 and C2 identify two villages connected by a road, and DIST gives the distance between these villages on that road.
• SV, DV – the numbers associated with the start and destination villages; the villages are numbered 1 to NV.
• MAXDIST – the maximum distance Jill is willing to travel (one way).

The data for the last case will be followed by a single integer with the value –1.

Output

For each case, display the case number (1, 2, …) on the first line of output. Then, each on a separate additional line, list the routes that Jill might take preceded by the length of the route. Order the routes first by length, from shortest to longest. Within routes having the same length, order them in increasing lexicographic order. The sample input and output provide suitable examples, and the formatting shown there should be followed closely (each village number should be separated by a single space). Separate the output for consecutive cases by a single blank line. If there is no route, print out " NO ACCEPTABLE TOURS"(notice there is one space at the front).

Sample Input

4 5

1 2 2

1 3 3

1 4 1

2 3 2

3 4 4

1 3

4

4 5

1 2 2

1 3 3

1 4 1

2 3 2

3 4 4

1 4

10

5 7

1 2 2

1 4 5

2 3 1

2 4 2

2 5 3

3 4 3

3 5 2

1 3

8

5 7

1 2 2

1 4 5

2 3 1

2 4 2

2 5 3

3 4 3

3 5 2

1 3

1

-1

Sample Output

Case 1:

 3: 1 3

 4: 1 2 3

Case 2:

 1: 1 4

 7: 1 3 4

 8: 1 2 3 4

Case 3:

 3: 1 2 3

 7: 1 2 4 3

 7: 1 2 5 3

 8: 1 4 2 3

 8: 1 4 3

Case 4:

 NO ACCEPTABLE TOURS

题目分析：

比较简单的一道题，要求求出两点之间小于最大长度的所有路径，用深搜和广搜都可以解决，要注意深搜时在回溯的时候一定要记得将数据恢复到上一次搜索前的状态。以下是深搜的实现。

代码实现：

#include <iostream>
#include <algorithm>
#include <vector>
#include <string.h>
using namespace std;

struct sol {
    sol(){}
    int route[];
    int size;
    int dista;
};
vector<sol> sols;
bool visited[];
int adj[][];
int path[][];
int adjs[];
int r[];
int j, src, dist, len, maxr; // init

void calP() {
    int i;
    sol one;
    one.size = j;
    one.dista = len;
    for (i = ; i < one.size; i++) {
        one.route[i] = r[i];
    }
    sols.push_back(one);
}
void dfs(int now) {
    if (now == dist) {
        calP();
        return;
    }
    int i, l;
    l = adjs[now];
    for (i = ; i < l; i++) {
        if (!visited[adj[now][i]]) {
            r[j++] = adj[now][i];
            visited[adj[now][i]] = true;
            len += path[now][adj[now][i]];
            if (len <= maxr) {
                dfs(adj[now][i]);
            }
            len -= path[now][adj[now][i]];
            visited[adj[now][i]] = false;
            j--;
        }
    }
}
bool cmp(const sol& a, const sol& b) {
    if (a.dista > b.dista) {
        return false;
    }
    if (a.dista == b.dista) {
        int minl = a.size;
        int i;
        if (minl > b.size) {
            minl = b.size;
        }
        for (i = ; i < minl; i++) {
            if (a.route[i] > b.route[i])
                return false;
            if (a.route[i] < b.route[i])
                return true;

        }
        return a.size < b.size;
    }
    return true;
}
int main() {
    int nv, nr, i, f, t, d, ncase = , k;
    while (cin >> nv && nv != -) {
        cin >> nr;
        sols.clear();
        memset(path, , sizeof(path));
        memset(adj, , sizeof(adj));
        memset(adjs, , sizeof(adjs));
        memset(visited, , sizeof(visited));
        for (i = ; i < nr; i++) {
            cin >> f >> t >> d;
            adj[t][adjs[t]++] = f;
            adj[f][adjs[f]++] = t;
            path[t][f] = path[f][t] = d;
        }
        cin >> src >> dist;
        cin >> maxr;
        j = len = ;
        visited[src] = true;
        r[j++] = src;
        dfs(src);
        sort(sols.begin(), sols.end(), cmp);
        if (ncase != ) {
            cout << endl;
        }
        cout << "Case " << ++ncase << ":\n";
        for (i = ; i < sols.size(); i++) {
            cout << " " << sols[i].dista << ":";
            for (k = ; k < sols[i].size; k++) {
                cout << " " << sols[i].route[k];
            }
            cout << endl;
        }
        if (sols.size() == ) {
            cout << " NO ACCEPTABLE TOURS" << endl;
        }
    }
}

复杂度：

图的节点数为V，边数为E, 解个数为n。

时间：初始化(E) + 深搜(E*V) + 排序(n*lg(n))

空间：V^2

标签：

深搜