Interview street, 王國連通問題

Interviewstreet Challenge

Kingdom Connectivity

Input Description

Output Description:

解題思路

思路一

思路2 (建議看這個)

Kingdom Connectivity

It has been a prosperous year for King Charles and he is rapidly expanding his kingdom. a beautiful new kingdom has been recently constructed and in this kingdom there are many cities connected by a number of one-way roads. Two cities may be directly connected by more than one roads, this is to ensure high connectivity.

對於 Charles 國王來說，這是成功的一年，他迅速的擴展了他的王國。一個美麗的王國最近建立了，在這個王國中有許多城市通過許多單行道連通起來。兩個城市可以直接通過多於一條路來連通，這是爲了確保更高的連通性。

In this new kingdom King Charles has made one of the cities at his financial capital and one as warfare capital and he wants high connectivity between these two capitals. The connectivity of a pair of cities say city A and city B is defined as the number of different paths from city A to city B. A path may use a road more than once if possible. Two path are considered different if they do not use exactly the same sequece of roads.

在這個新的王國，國王 Charles 使一個城市作爲他的金融中心，另一個作爲戰爭中心，他想讓這兩個城市之間有更高的連通性。比方說城市A和城市B這一對城市的連通性由從城市A到城市B不同 路徑 的數目定義。如果可能的話，一個 路徑 可以多次使用一個道路。如果他們不精確地使用同一個道路序列，兩個路徑就是不同的。

There are N cities numbered 1 to N in the new kindom and M one-way roads. City 1 is the monetary captial and city N is the warare capital.

王國中有編號從1到N的N個城市和M條單行道。城市1是金融中心，城市N是戰爭中心。

You being one of he best programmers in new kindom need to answer the connectivity of financial capital and warfare capital, i.e number of different path from city 1 to city N.

你是王國中最好的計劃員之一，需要回答金融中心和戰爭中心的連通性，例如，從城市1到城市N之間不同路徑的數目。

Input Description

First line contains two integers N and M.

第一行包含兩個整數N和M。

Then follow M lines, each having two integers asy x and y, 1<=x,y<=N, indicating there is a road from city x to city y.

接到來的M行，每一行有兩個整數，例如x和y，1<=x,y<=N, 代表有一條從城市x到城市y的道路。

Output Description:

Print the number of different path from city 1 to city N modulo 1,000,000,000 (10^9). If there are infinitely many different paths print "INFINITE PATHS" (quotes are for clarity).

打印從城市1到城市N不同 路徑 的數目 (不知道對誰求模)。如果有無窮多條不同 路徑 打印 "INFINITE PATHS" (引號是爲了清楚的說明)。

Sample Input:

5 5
1 2
2 4
2 3
3 4
4 5

Sample Output:

2

Sample Input:

5 5
1 2
4 2
2 3
3 4
4 5

Sample Output:

INFINITE PATHS

Constraints:

2<=N<=10,000(10^4)

1<=M<=1,00,000(10^5)

解題思路

好吧，我承認這道題我現在還沒有解決。

思路一

現在說說我的思路，初看題目我就感覺應該會用到圖論上的知識，但是我又沒怎麼學過離散數學，與於我就想，先不去看圖論方面的知識，只憑自己的直覺試試先。

我的 main 函數大概做了以下幾件事：

1. 獲取數據
2. 使用遞歸的方式獲取路徑數量 (path_num)

獲取數據就不用說了，我使用了一個結構體來保存，如下：

struct road {
    int from;
    int to;
    int times;
};

下面來說一說遞歸函數都做了點什麼。

遞歸函數 get_path_num()

這個函數邏輯是這樣的，從 目標城市N 開始，倒着查找 起始城市1 ，最終返回從 1 到 N 的不同路徑的數量。內部實現如下：

• 找出 N 可由哪些城市到達，將可到達N的城市存爲一個列表，名爲from_list。
• 檢查from_list中的每一個元素：比如城市 M,如果爲城市1，path_num加1，否則遞歸調用本身，返回從城市M開始倒着找到城市1的不同路徑的數量。

是不是沒看懂，這是因爲我說得也不清楚。如果真想清楚，只有看代碼了。下面的代碼是我第一次的實驗品，總共有10個test case，但只過了3個。我的建議是，不要看下面的代碼了，這段代碼邏輯不是十分清楚，並且還有bug。直接看我看過圖論知識後寫的第二段代碼吧。

/**
 * @file kingdom_connectivity.c
 * @brief
 * @author Airead Fan <[email protected]>
 * @date 2012  3月 02 15:51:52 CST
 */

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

//#define _DEBUG_

#ifdef _DEBUG_
#define DBG(fmt, args...) printf(fmt, ##args)
#else
#define DBG(fmt, args...)
#endif

struct road {
    int from;
    int to;
    int times;
};

int city_num, road_num;

/**
 * @brief get road list from stdin
 * @param road_num : the number of road
 * @return on error returns NULL, otherwise returns struct #road *
 */
struct road *get_road_list(int road_num)
{
    int i;
    int size;
    struct road *road_list;

    size = sizeof(struct road) * (road_num + 1);
    road_list = (struct road *)malloc(size);
    if (road_list == NULL) {
        printf("malloc failed\n");
        return NULL;
    }
    memset(road_list, 0, size);

    for (i = 0; i < road_num; i++) {
        scanf("%d %d", &road_list[i].from, &road_list[i].to);
    }

    return road_list;
}

/**
 * @brief get the list of city which can go to city
 * @param city : should go to city
 * @param road_list : all road in it
 * @return on error returns NULL, otherwise returns city_from_list
 */
int *get_city_from_list(int city, struct road *road_list)
{
    int count, *city_from_list, *tmp_list;
    int size;
    struct road *road;

    /* get from city list number to malloc */
    count = 0;
    road = road_list;
    while (road->to != 0) {
        if (road->to == city) {
            count++;
        }
        road++;
    }

    size = sizeof(int) * (count + 1);
    city_from_list = (int *)malloc(size);
    if (city_from_list == NULL) {
        printf("malloc city_from failed\n");
        return NULL;
    }
    memset(city_from_list, 0, size);

    /* set city_from_list */
    road = road_list;
    tmp_list = city_from_list;
    while (road->to != 0) {
        if (road->to == city) {
            *tmp_list++ = road->from;
            road->times++;
            DBG("\n%d --> %d: times: %d\n", road->from, road->to, road->times);
        }
        road++;
    }

    return city_from_list;
}

/**
 * @brief get the number of path from city_from to city_to
 * @param city_start : start point of city
 * @param city_to :
 * @param road_list :
 * @param road_num : the number of road
 * @return on infinite returns -1, otherwise returns the number of path
 */
int get_path_number(int city_start, int city_to, struct road *road_list, int road_num)
{
    int num, *city_from_list, tmp_num;
    int *pcity;
    struct road *road;
    static int target_from;            /*
                                        * if target city call
                                        * get_city_from_list, target_from set 1,
                                        * and don't call again
                                        */

    DBG("->%d", city_to);

    num = 0;

    if (city_to == city_num) {
        if (target_from == 0) {
            target_from = 1;
        } else {
            return 0;
        }
    }

    city_from_list = get_city_from_list(city_to, road_list);
    if (city_from_list == NULL) {
        return 0;
    }

    /* check infinite*/
    road = road_list;
    while (road->to != 0) {
        if (road->times >= road_num) {
            DBG("%d --> %d: times: %d\n", road->from, road->to, road->times);
            return -1;
        }
        road++;
    }

    pcity = city_from_list;
    while (*pcity != 0) {
        if (*pcity == city_start) {
            DBG("->%d", *pcity);
            num++;
        } else {
            tmp_num = get_path_number(city_start, *pcity, road_list, road_num);
            if (tmp_num < 0) {
                return -1;
            }
            num += tmp_num;
        }
        pcity++;
    }

    return num;
}

int main(int argc, char *argv[])
{
    int i, path_num;
    struct road *road_list;

    scanf("%d %d", &city_num, &road_num);
    DBG("city_num = %d, road_num = %d\n", city_num, road_num);

    road_list = get_road_list(road_num);

    for (i = 0; i < road_num; i++) {
        DBG("road[%d]: %3d   --> %3d\n", i + 1, road_list[i].from, road_list[i].to);
    }

    path_num = get_path_number(1, city_num, road_list, road_num);
    if (path_num < 0) {
        printf("INFINITE PATHS");
    }else {
        printf("%d", path_num);
    }

    free(road_list);
    return 0;
}

思路2 (建議看這個)

這次我看了圖論相關的知識了。

先對題目進行分析，查看 output sample 可知，結果分成兩大類：一個是求出具體有幾條不同路徑，另一個是說明路徑是無限的。如果這個有向圖有圈的，就可以輸出無限了。否則的話，就要求出共有幾條不同的路徑。

判斷是否有無限路徑

定理： 設S爲有限的有向無圈圖，則圖S存在一個拓撲排序。

根據這個定理，我們可不可以認爲，一個不存在拓撲排序的的有向圖就是有圈的呢，我不是十分確定，但是我的代碼就是這樣判斷的。

拓撲排序的算法：

Step 1, 求S的每個頂點N的入度INDEG(N)
Step 2, 在隊列中插入所有的零度頂點
Step 3, 重複 Step 4 和 Step 5，直到隊列空
Step 4, 移去並檢查隊列的前面頂點N
Step 5, 對頂點N的每個鄰點M重複
        (a) 置INDEG(M) = INDEG(M) - 1
            [刪除從N到M的邊]
        (b) 若INDEG(M) = 0，則添加M到隊列
            [結束循環]
        [結束 Step 3 循環]
Step 6, 退出

求出有多少不同路徑

我的基本想法是：從城市1開始，檢查它所有的可達城市，如果爲目標城市則計數加1，否則檢查該城市的每一個可達城市，重複直到沒有可達城市爲止。比較類似於圖的深度優先算法吧。

這樣，我就可以走完從城市1所有能走的路徑，那麼當前的計數是否就應該爲 從城市1到城市N不同路徑的數量 呢？我覺得應該是的，但是結果是: 10個test case只過了2個，還沒有我上一個版本過的多，鬱悶死啦-_-。感興趣的同學可以討論一下這道題的解法。

題目來自：Interview street Kingdom Connectivity。不知道沒註冊能不能看。

第二個版本代碼如下:

/**
 * @file kingdom_connectivity.c
 * @brief
 * @author Airead Fan <[email protected]>
 * @date 2012  3月 05 15:35:53 CST
 */

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

#define _DEBUG_

#ifdef _DEBUG_
#define DBG(fmt, args...) printf(fmt, ##args)
#else
#define DBG(fmt, args...)
#endif

struct point {
    int indeg;
    int outdeg;
    int status;
    struct edge *edge;
};

struct edge {
    int begin;
    int end;
    struct edge *next;
};

/**
 * @brief insert edge to point_list
 * @param point_list
 * @param begin
 * @param end
 * @return on success returns 0, otherwise returns -1
 */
int point_list_insert_edge(struct point *point_list, int begin, int end)
{
    struct edge *tmpedge;

    if ((tmpedge = malloc(sizeof(struct edge))) == NULL) {
        return -1;
    }

    tmpedge->begin = begin;
    tmpedge->end = end;
    tmpedge->next = point_list[begin - 1].edge;
    point_list[begin - 1].edge = tmpedge;

    point_list[begin - 1].outdeg++;
    point_list[end - 1].indeg++;

    return 0;
}

/**
 * @brief get point list from stdin
 * @param city_num
 * @return on error returns NULL, otherwise returns point_list
 */
struct point *get_point_list(int city_num)
{
    struct point *point_list;
    int size;

    point_list = NULL;

    size = sizeof(struct point) * city_num;
    if ((point_list = malloc(size)) == NULL) {
        fprintf(stderr, "create point failed\n");
        return NULL;
    }
    memset(point_list, 0, size);

    return point_list;
}

/**
 * @brief get edge list from stdin
 * @param edge_num
 * @return on error returns NULL, otherwise returns edge_list
 */
struct edge *get_edge_list(int edge_num)
{
    struct edge *edge_list;
    int begin, end;
    int i, size;

    edge_list = NULL;

    size = sizeof(struct edge) * edge_num;
    if ((edge_list = malloc(size)) == NULL) {
        fprintf(stderr, "create edge failed\n");
        return NULL;
    }
    memset(edge_list, 0, size);

    for (i = 0; i < edge_num; i++) {
        scanf("%d %d", &begin, &end);
        edge_list[i].begin = begin;
        edge_list[i].end = end;
    }

    return edge_list;
}

/**
 * @brief find the point whose indeg is indeg
 * @param indeg
 * @param point_list
 * @param city
 * @return not found returns NULL, otherwise returns struct *point
 */
struct point *find_point_from_indeg(int indeg, struct point *point_list, int city_num)
{
    int i;
    struct point *p;

    for (i = 0; i < city_num; i++) {
        if (point_list[i].indeg == indeg && point_list[i].status == 0) {
            p = &point_list[i];
            break;
        }
    }

    if (i == city_num) {
        p = NULL;
    }

    return p;
}

/**
 * @brief check cyclic
 * @param point_list
 * @param city_num
 * @return not cyclic returns 0, otherwise returns 1;
 */
int is_cyclic(struct point *point_list, int city_num)
{
    int i;
    struct point *p;

    for (i = 0; i < city_num; i++) {
        point_list[i].status = 0;
    }

    i = 0;
    while ((p = find_point_from_indeg(0, point_list, city_num)) != NULL) {
        p->status = 1;
        while (p->edge != NULL) {
            point_list[p->edge->end - 1].indeg--;
            p->edge = p->edge->next;
        }
        i++;
    }

    if (i < city_num) {
        return 1;
    }

    return 0;
}

/**
 * @brief target is destination, path_num++
 * @param point_list
 * @param city_num
 * @param path_num
 * @return on success returns 0, otherwise returns -1
 *
 * check the second parameter point
 */
int check_target(struct point *point_list, int city, int city_num, int *path_num, char *trace)
{
    struct edge *tmpedge;
    char buf[32];

    snprintf(buf, 32, "%d->", city);
    strcat(trace, buf);

    if (city == city_num) {
        DBG("%s\n", trace);
        (*path_num)++;
        trace[strlen(trace) - 3] = '\0';
        return 0;
    }

    tmpedge = point_list[city - 1].edge;
    while (tmpedge != NULL) {
        check_target(point_list, tmpedge->end, city_num, path_num, trace);
        tmpedge = tmpedge->next;
    }

    trace[strlen(trace) - 3] = '\0';

    return 0;
}

/**
 * @brief get the number of different paths
 * @param point_list
 * @param city_num
 * @param edge_num
 * @return on error returns -1, otherwise returns number;
 */
int get_path_number(struct point *point_list, int city_num, int edge_num)
{
    int path_num;
    char trace[1024];

    memset(trace, 0, sizeof(trace));
    path_num = 0;
    check_target(point_list, 1, city_num, &path_num, trace);

    return path_num;
}

int debug_point_list(struct point *point_list, int city_num)
{
    int i;
    struct edge *edge;

    fprintf(stderr, "point | indeg | outdeg | target \n");

    for (i = 0; i < city_num; i++) {
        fprintf(stdout, "%3d   | %3d   | %4d   | ", i + 1, point_list[i].indeg, point_list[i].outdeg);
        edge = point_list[i].edge;
        while (edge != NULL) {
            fprintf(stdout, "%d, ", edge->end);
            edge = edge->next;
        }
        fprintf(stdout, "\n");
    }

    return 0;
}

/**
 * @brief reset point list with edge list
 * @param point_list
 * @param edge_list
 * @param edge_num
 * @return on success returns 0, otherwise returns -1
 */
int point_list_reset(struct point *point_list, struct edge *edge_list, int city_num, int edge_num)
{
    int i;

    for (i = 0; i < edge_num; i++) {
        if (edge_list[i].begin == city_num) {
            DBG("ignore %d --> %d\n", edge_list[i].begin, edge_list[i].end);
            continue;
        }
        if (point_list_insert_edge(point_list, edge_list[i].begin, edge_list[i].end) < 0) {
            fprintf(stderr, "inset edge failed\n");
            return -1;
        }
    }

    return 0;
}

int main(int argc, char *argv[])
{
    int city_num, edge_num;
    struct point *point_list;
    struct edge *edge_list;
    int path_num;

    scanf("%d %d", &city_num, &edge_num);
    DBG("city num: %d, edge num: %d\n", city_num, edge_num);

    if ((point_list = get_point_list(city_num)) == NULL) {
        fprintf(stderr, "get point_list failed\n");
        exit(1);
    }

    if ((edge_list = get_edge_list(edge_num)) == NULL) {
        fprintf(stderr, "get edge_list failed\n");
        exit(1);
    }

    if (point_list_reset(point_list, edge_list, city_num, edge_num) < 0) {
        fprintf(stderr, "point list reset failed\n");
        exit(1);
    }

    debug_point_list(point_list, city_num);

    if (is_cyclic(point_list, city_num) != 0) {
        fprintf(stdout, "INFINITE PATHS");
        return 0;
    }

    if (point_list_reset(point_list, edge_list, city_num, edge_num) < 0) {
        fprintf(stderr, "point list reset failed\n");
        exit(1);
    }

    path_num = get_path_number(point_list, city_num, edge_num);

    fprintf(stdout, "%d", path_num);
    DBG("\n");

    return 0;
}