SZU:D89 The Settlers of Catan

Judge Info

• Memory Limit: 65536KB
• Case Time Limit: 3000MS
• Time Limit: 3000MS
• Judger: Number Only Judger

Description

Within Settlers of Catan, the 1995 German game of the year, players attempt to dominate an island by building roads, settlements and cities across its uncharted wilderness.

You are employed by a software company that just has decided to develop a computer version of this game, and you are chosen to implement one of the game's special rules:

When the game ends, the player who built the longest road gains two extra victory points.

The problem here is that the players usually build complex road networks and not just one linear path. Therefore, determining the longest road is not trivial (although human players usually see it immediately).

Compared to the original game, we will solve a simplified problem here: You are given a set of nodes (cities) and a set of edges (road segments) of length 1 connecting the nodes. The longest road is defined as the longest path within the network that doesn't use an edge twice. Nodes may be visited more than once, though.

Example: The following network contains a road of length 12.

o        o -- o        o
 \      /      \      /
  o -- o        o -- o
 /      \      /      \
o        o -- o        o -- o
               \      /
                o -- o

Input

The input file will contain one or more test cases. The first line of each test case contains two integers: the number of nodes n (2<=n<=25) and the number of edges m (1<=m<=25). The next m lines describe the m edges. Each edge is given by the numbers of the two nodes connected by it. Nodes are numbered from 0 to n-1. Edges are undirected. Nodes have degrees of three or less. The network is not neccessarily connected.

Input will be terminated by two values of 0 for n and m.

Output

For each test case, print the length of the longest road on a single line.

Sample Input

3 2
0 1
1 2
15 16
0 2
1 2
2 3
3 4
3 5
4 6
5 7
6 8
7 8
7 9
8 10
9 11
10 12
11 12
10 13
12 14
0 0

Sample Output

2
12

建模：

　　已知n 个点，m 条边，输入两个点来构成一条边，构成一副无向图，两点之间可以有多条边，从任意一个点搜索，要求每条边只能经过一次，找到最长的路径。

思路：

　　1.输入点的个数n, 边的个数m，并且初始化存整个无向图的二维数组w
　　2.存边进入二维数组W
　　3.对所有点进行dfs搜索，如果路径最长则更新max
　　4.dfs找出所有存在的边，并且记录路径的长度

我的代码：

 #include <stdio.h>
 #include <string.h>

 #define MAXN 30

 int n,m;
 int G[MAXN][MAXN];
 int vis[MAXN][MAXN];
 int maxNum;
 int k;

 void dfs(int u, int num){
   int flag;
     for(int v=; v<n; ++v){
         if(G[u][v] && !vis[u][v]){

             if(G[u][v] != ){
                 flag = ;
                 vis[u][v] = ;
                 vis[u][v] = ;
                 G[u][v] --;
                 G[v][u] --;
             }
             else {
                 vis[u][v] = ;
                 vis[v][u] = ;

             }

             dfs(v, num+);
             if(flag == ){
                 G[u][v]++;
                 G[v][u]++;
             }
             flag = ;
             vis[u][v] = vis[v][u] = ;
         }
     }

     if(num > maxNum) maxNum = num;
 }

 int main(){

     int a,b;

     while(~scanf("%d %d", &n, &m)){

         if(!n && !m) break;
         memset(G, , sizeof(G));
         for(int i=; i<m; ++i){
             scanf("%d %d", &a, &b);
             ++G[a][b];
         ++G[b][a];
         }

         maxNum = -;

         for(int i=; i<n; ++i){
             memset(vis, , sizeof(vis));
             dfs(i, );
         }
         printf("%d\n",maxNum);
     }
     return ;
 }

朋友的代码：

 #include <stdio.h>
 #include <string.h>
 #define N 26

 int w[N][N],max,n;  //w[N][N] 存入整个图，w[i][j]=x 代表i到j有x条边

 void dfs(int,int);

 int main()
 {
     int m,sum;
     int a,b,i;
     while()
     {
         scanf("%d%d",&n,&m);
         if(!m && !n)
             break;

         memset(w,,sizeof(w)); //初始化

         for(i=;i<m;i++)
         {
             scanf("%d%d",&a,&b);
             w[a][b]++;  //无向图
             w[b][a]++;
         }

         max=;
         for(i=;i<n;i++)
         {
             sum=;   //把每个点作为出发点，对每一个点进行搜索
             dfs(i,sum);
         }
         printf("%d\n",max);
     }
     return ;
 }

 void dfs(int a,int sum)  // a 为当前探索到哪一个节点，sum为当前探索到的路径长度
 {
     int i;
     if(sum>max)  //更新当前搜索到的最长路径
         max=sum;
     for(i=;i<n;i++)
     {
         if(w[a][i])
         {
             w[a][i]--;  w[i][a]--; //用去一条边
             dfs(i,sum+);  // 进行下一层递归
             w[a][i]++;  w[i][a]++; //回溯到上一层
         }
     }
     return;
 }