#include

#define MAXV            100
#define MAXDEGREE       100

typedef struct {
        unsigned int edges[MAXV+1][MAXV+1];
        unsigned int nverticies;
        unsigned int nedges;
} graph;

graph g;

typedef struct {
        unsigned int x;
        unsigned int y;
        unsigned int value;
} minSt;

minSt minList[10000];
unsigned int minCnt;

int map[100];
int cnt;

void init_graph()
{
        memset(&g, 0, sizeof(graph));
}

void set_edges(int i)
{
        g.nedges = i;
}

void set_verticies(int i)
{
        g.nverticies = i;
}

void set_edge(int x, int y,int weight)
{
        g.edges[x][y] = weight;
        g.edges[y][x] = weight;

        minList[minCnt].x = x;
        minList[minCnt].y = y;
        minList[minCnt++].value = weight;
}

void sort_min()
{
        minSt tmp;
        int i,j;

        for ( i = 0 ; i < minCnt ; i++ ) {
                for ( j = i ; j < minCnt ; j++ ) {
                        if ( minList[i].value > minList[j].value ) {
                                tmp = minList[i];
                                minList[i] = minList[j];
                                minList[j] = tmp;
                        }
                }
        }
#if 0
        for ( i = 0 ; i < minCnt ; i++ ) {
                printf("x(%d) y(%d) weight(%d)\n",minList[i].x, minList[i].y, minList[i].value);
        }
#endif
}

void print_graph()
{
        int i,j;
        printf("==========================\n");
        for ( i = 1 ; i <= g.nverticies ; i++ ) {
                for ( j = 1 ; j <= g.nverticies ; j++ ) {
                        printf("%3d ",g.edges[i][j]);
                }
                printf("\n");
        }
}

unsigned int ConnMap[101][101];

int isConnected2()
{
        int i,j,k;

        memcpy(ConnMap, g.edges, sizeof(ConnMap));

        for ( i = 1 ; i <= g.nverticies ; i++ ) {
                for ( j = 1 ; j <= g.nverticies ; j++ ) {
                        if ( i == j )
                                continue;
                        for ( k = 1 ; k <= g.nverticies ; k++ ) {
                                if ( j == k )
                                        continue;
                                if ( i == k )
                                        continue;
                                if ( ConnMap[i][j] > 0 && ConnMap[j][k] > 0 ) {
                                        ConnMap[i][j] = 1;
                                        ConnMap[j][i] = 1;

                                        ConnMap[j][k] = 1;
                                        ConnMap[k][j] = 1;

                                        ConnMap[i][k] = 1;
                                        ConnMap[k][i] = 1;
                                }
                        }
                }
        }

#if 0
        printf("==========================\n");
        for ( i = 1 ; i <= g.nverticies ; i++ ) {
                for ( j = 1 ; j <= g.nverticies ; j++ ) {
                        printf("%3d ",ConnMap[i][j]);
                }
                printf("\n");
        }
        exit(0);
#endif

}

int isConnected(int start,int end)
{
        register unsigned int i,j;
        register unsigned int check=0;

        if ( start == end )
                return 1;

#if 1
        if ( g.edges[start][end] > 0 ) {
                return 1;
        }
#endif

        for ( i = 1 ; i <= g.nverticies ; i++ ) {
                if ( i == start )
                        continue;

                check = 0;
                for ( j = 0 ; j < cnt ; j++ ) {
                        if ( map[j] == i ) {
                                check=1;
                                break;
                        }
                }
                if ( check == 1 )
                        continue;

                if ( g.edges[start][i] > 0) {
                        map[cnt]=start;
                        cnt++;
                        if (isConnected(i,end) == 1 ) {
                                return 1;
                        }
                }
        }
        return 0;
}


void del_edge(int x,int y)
{
        g.edges[x][y] = 0;
        g.edges[y][x] = 0;
}

int main()
{
        int edge;
        int vert;
        int x,y;
        int i,weight;
        int start, end, people;
        int min;
        int scenario=1;

        while(1) {
                init_graph();
                scanf("%d %d",&vert,&edge);
                if ( vert == 0 )
                        break;
                if ( vert < 1 || vert > 100 )
                        continue;

                set_verticies(vert);
                set_edges(edge);

                for ( i = 0 ; i < edge ; i++ ) {
                        scanf("%d %d %d",&x,&y,&weight);
                        set_edge(x,y,weight);
                }
                scanf("%d %d %d",&start,&end,&people);

                sort_min();

                cnt = 0;
                i = 0;

                while ( isConnected(start,end)) {
#if 0
                while ( 1 ) {
                        isConnected2();
                        if ( ConnMap[start][end] == 0 )
                                break;
#endif

                        cnt = 0;
                        min = minList[i].value;
                        del_edge(minList[i].x,minList[i].y);
                        i++;
                }

                if ( people % (min-1 ) == 0 )
                        min = people/(min-1);
                else
                        min = people/(min-1) + 1;

                printf("Scenario #%d\n",scenario++);
                printf("Minimum Number of Trips = %d\n\n",min);

                minCnt = 0;

                fflush(stdin);
        }

        return 0;
}


#if 0
int find_min(int *x, int *y)
{
        int i,j;
        int min=99999;
        int a;

        for ( i = 1 ; i <= g.nverticies ; i++ ) {
                for ( j = 1 ; j <= g.nverticies ; j++ ) {
                        if ( g.edges[i][j] > 0 && g.edges[i][j] < min ){
                                min = g.edges[i][j];
                                *x = i;
                                *y = j;
                        }
                }
        }
        return min;
}
#endif

#include <stdio.h>
 
#define MAX_CITY                101
#define DISCONNECTED        0
#define PASSED                        1
#define NOTPASSED                0
 
typedef struct TourInfo{
        int roadNum;                                                // road Number (input)
        int cityNum;                                                // city Number (input)
        int roadInfo[MAX_CITY][MAX_CITY];        // road info (max passenger info)
        int cityIsPassed[MAX_CITY];                 // passed or not passed
        int cityMinNum[MAX_CITY];                         // min Passenger Number 
        int startCity;                                                // start (input)
        int destCity;                                                // destination (input)
        int totalPassengerNum;                                // total passenger Number (input)
        int minPassengerNum;                                // result
}TourInfo;
 
void initTourInfo();
int findMinNumberOfTrips(int left);
 
TourInfo tour;
 
int main(void)
{
        int firstCity, secondCity, maxPassengerNum;
        int scenarioCount=0, result, i;
        while(1){
                
                scanf("%d %d", &tour.cityNum, &tour.roadNum);
                if(tour.cityNum==0  && tour.roadNum==0) break;
 
                result = 0;
                initTourInfo();
 
                for(i=0; i<tour.roadNum; i++){
                        scanf("%d %d %d", &firstCity, &secondCity, &maxPassengerNum);
                        tour.roadInfo[firstCity][secondCity] = maxPassengerNum;
                        tour.roadInfo[secondCity][firstCity] = maxPassengerNum;
                }
                scanf("%d %d %d", &tour.startCity, &tour.destCity, &tour.totalPassengerNum);
                if(tour.totalPassengerNum < 1) break;
 
                findMinNumberOfTrips(tour.startCity);
 
                scenarioCount++;
                result = tour.totalPassengerNum / (tour.minPassengerNum-1);   
                if(tour.totalPassengerNum % (tour.minPassengerNum-1))
                        result++;
 
                printf("Scenario #%d\n", scenarioCount);
                printf("Minimum Number of Trips = %d\n\n", result);
        } 
        return 0;
}
 
int findMinNumberOfTrips(int left)
{
        int i, right, minPass;
 
        tour.cityIsPassed[left]=PASSED; 
 
        // Last City
        if(left==tour.destCity){
                                
                if(!tour.minPassengerNum) {
                        tour.minPassengerNum = tour.cityMinNum[left];
                }
                else {
                        if(tour.minPassengerNum < tour.cityMinNum[left]) {
                                tour.minPassengerNum = tour.cityMinNum[left];
                        }
                }
                tour.cityMinNum[left]=NOTPASSED;
                tour.cityIsPassed[left]=NOTPASSED;
                return 1;
        }
 
        for(right=1; right<=tour.cityNum; right++)
        {
                if(tour.cityIsPassed[right]==PASSED) continue; // already passed city
 
                if(tour.roadInfo[left][right]!=0) // CONNECTED
                {
                        if(!tour.cityMinNum[left]){ // first path
                                tour.cityMinNum[right] = tour.roadInfo[left][right];
                        }
                        else{
                                if(tour.cityMinNum[left] > tour.roadInfo[left][right]){
                                        tour.cityMinNum[right] = tour.roadInfo[left][right];
                                }
                                else{
                                        tour.cityMinNum[right] = tour.cityMinNum[left];
                                }
                        }
 
                        if(tour.minPassengerNum >= tour.cityMinNum[right])
                                continue;
 
                        findMinNumberOfTrips(right);
                }
        }
        // init and return
        tour.cityMinNum[left]=NOTPASSED;
        tour.cityIsPassed[left]=NOTPASSED;
        return 1;
}
 
 
void initTourInfo()
{
        int i,j;
        for(i=0; i<MAX_CITY; i++) {
                for(j=0; j<MAX_CITY; j++) {
                        tour.roadInfo[i][j] = DISCONNECTED;
                }
                tour.cityIsPassed[i] = NOTPASSED;
                tour.cityMinNum[i] = NOTPASSED;
        }
        tour.minPassengerNum = 0;
}

I got accept from Judge Server

----------------------------------------------------------------------------------------------

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define MAX_NUM 1000000
int getCycleLength(unsigned int input);
 
typedef struct Number{
 int num1;
 int num2;
 unsigned int cycleLength;
}Number;
 
char *number;
 
int main(void)
{
 char line[100];
 int  numCount=0, tmp;
 int  i, cycleLength, check=0;
 Number  num;
 
 while(scanf("%d %d", &num.num1, &num.num2) == 2){
  
  if(num.num1>1000000 ||  num.num2>1000000 || num.num1<1 || num.num2<1){
   continue;
  }
 
  check = 0;
  if(num.num1 > num.num2){
   tmp       = num.num2;
   num.num2 = num.num1;
   num.num1 = tmp;
   check  = 1;
  }
 
  number = (char*)malloc(MAX_NUM);
  memset(number, '1', MAX_NUM);
 
  num.cycleLength = 0;
  for(i=num.num2; i>=num.num1; i--)
  {
   if(number[i-1]=='0')
    continue;
 
   cycleLength = getCycleLength(i);
   if(!cycleLength)
    return 0;
 
   if(cycleLength > num.cycleLength ){
    num.cycleLength = cycleLength;
   }
  }
  if(check){
   printf("%d %d %d\n", num.num2, num.num1, num.cycleLength);
  }
  else
  {
   printf("%d %d %d\n", num.num1, num.num2, num.cycleLength);
  }
  free(number);
 }
 return 0;
}
 
int getCycleLength(unsigned int input)
{
 unsigned int cycleLength=1;
 while(input != 1)
 {
  if(input-1<MAX_NUM && input>0){
   number[input-1] = '0';
  // printf("%d = %c\n", input, number[input-1]);
  }
  //printf("%d ", input);
  if(input%2 == 1){
   input = (input*3) +1;
   cycleLength++;
  }
  else {
   input = (input/2);
   cycleLength++;
  }
 }
 //printf("%d\n", input);
 return cycleLength;
}