Sicily 1031. Campus（shortest path）

最新推荐文章于 2018-01-03 23:52:00 发布
原创 最新推荐文章于 2018-01-03 23:52:00 发布 · 1.6k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#sicily #dijkstra #优化 #算法

本文介绍了一种解决校园内两点间最短路径问题的方法，包括Floyd-Warshall算法和Dijkstra算法的不同实现方式，并提供了详细的代码示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1031. Campus

Constraints

Time Limit: 1 secs, Memory Limit: 32 MB

Description

At present, Zhongshan University has 4 campuses with a total area of 6.17 square kilometers sitting respectively on both sides of the Pearl River or facing the South China Sea. The Guangzhou South Campus covers an area of 1.17 square kilometers, the North Campus covers an area of 0.39 square kilometers, the Guangzhou East Campus has an area of 1.13 square kilometers and the Zhuhai Campus covers an area of 3.48 square kilometers. All campuses have exuberance of green trees, abundance of lawns and beautiful sceneries, and are ideal for molding the temperaments, studying and doing research.

 

 

       Sometime, the professors and students have to go from one place to another place in one campus or between campuses. They want to find the shortest path between their source place S and target place T. Can you help them?

 

 

Input

The first line of the input is a positive integer C. C is the number of test cases followed. In each test case, the first line is a positive integer N (0<N<=100) that represents the number of roads. After that, N lines follow. The i-th(1<=i<=N) line contains two strings Si, Ti and one integer Di (0<=Di<=100). It means that there is a road whose length is Di between Si and Ti. Finally, there are two strings S and T, you have to find the shortest path between S and T. S, T, Si(1<=i<=N) and Ti(1<=i<=N) are all given in the following format: str_Campus.str_Place. str_Campus represents the name of the campus, and str_Place represents the place in str_Campus. str_Campus is "North", "South", "East" or "Zhuhai". str_Place is a string which has less than one hundred lowercase characters from "a-z". You can assume that there is at most one road directly between any two places.

Output

The output of the program should consist of C lines, one line for each test case. For each test case, the output is a single line containing one integer. If there is a path between S and T, output the length of the shortest path between them. Otherwise just output "-1" (without quotation mark). No redundant spaces are needed.

Sample Input

de style="color: rgb(51, 51, 51); font-size: 18.01801872253418px; line-height: 27.027027130126953px;" > 
1
2
South.xiaolitang South.xiongdelong 2
South.xiongdelong Zhuhai.liyuan 100
South.xiongdelong South.xiaolitang
de>

Sample Output

de style="color: rgb(51, 51, 51); font-size: 18.01801872253418px; line-height: 27.027027130126953px;" > 
2
de>

Problem Source

ZSUACM Team Member

极度坑爹的一题，不过也学到了很多，顺便以这道来研究最短路径问题好了，注意地点相同的特殊情况（坑），还有一个要记住的地方就是丫的给你100条路最多可以有200个地方啊- -


首先是没有用map的Floyd-Warshall算法：


#include <stdio.h>
#include <string.h>
#define INF 99999999
#define MAX 115 * 2

int total_num_of_name, map[MAX][MAX];
char num_of_name[MAX][MAX];

int min(int a, int b) {
    return a > b ? b : a;
}

void make_map(char f[], char t[], int dis) {
    int i, t_num, f_num;
    
    for (i = 0; i < total_num_of_name; i++) {
        if (strcmp(f, num_of_name[i]) == 0) {
            f_num = i;
            break;
        }
    }
    if (i >= total_num_of_name) {
        f_num = total_num_of_name;
        strcpy(num_of_name[total_num_of_name++], f);
    }
    
    for (i = 0; i < total_num_of_name; i++) {
        if (strcmp(t, num_of_name[i]) == 0) {
            t_num = i;
            break;
        }
    }
    if (i >= total_num_of_name) {
        t_num = total_num_of_name;
        strcpy(num_of_name[total_num_of_name++], t);
    }
    
    map[f_num][t_num] = dis < map[f_num][t_num] ? dis : map[f_num][t_num];
    map[t_num][f_num] = dis < map[t_num][f_num] ? dis : map[t_num][f_num];
}

int find_num(char a[]) {
    for (int i = 0; i < total_num_of_name; i++) {
        if (strcmp(a, num_of_name[i]) == 0)
            return i;
    }
    return -1;
}

void Floyd_Warshall() {
    int i, j, k;
    for (i = 0; i < MAX; i++) {
        map[i][i] = 0;
    }
    for (k = 0; k < total_num_of_name; k++) {
        for (i = 0; i < total_num_of_name; i++) {
            for (j = 0; j < total_num_of_name; j++) {
                map[i][j] = min(map[i][j], map[i][k] + map[k][j]);
            }
        }
    }
}

int main() {
    int case_num, n, dis, f_num, t_num;
    char temp_f[MAX], temp_t[MAX];
    scanf("%d", &case_num);
    while (case_num--) {
        scanf("%d", &n);
        for (int i = 0; i < MAX; i++) {
            for (int j = 0; j < MAX; j++) {
                map[i][j] = INF;
            }
        }
        memset(num_of_name, '\0', sizeof(num_of_name));
        total_num_of_name = 0;
        while (n--) {
            memset(temp_f, '\0', sizeof(temp_f));
            memset(temp_t, '\0', sizeof(temp_t));
            scanf("%s %s %d", temp_f, temp_t, &dis);
            make_map(temp_f, temp_t, dis);
        }
        scanf("%s%s", &temp_f, &temp_t);
        if (strcmp(temp_f, temp_t) == 0) {
            printf("0\n");
            continue;
        }
        f_num = find_num(temp_f);
        t_num = find_num(temp_t);
        if (f_num == -1 || t_num == -1) {
            printf("-1\n");
            continue;
        }
        Floyd_Warshall();
        printf("%d\n", map[f_num][t_num] >= INF ? -1 : map[f_num][t_num]);

    }
    return 0;
}
然后试试用map： 


#include <stdio.h>
#include <string.h>
#include <iostream>
#include <map>
#include <string>
using namespace std;
#define INF 99999999
#define MAX 115 * 2

int total_num_of_name, mapp[MAX][MAX];
char num_of_name[MAX][MAX];

int min(int a, int b) {
    return a > b ? b : a;
}

void Floyd_Warshall() {
    int i, j, k;
    for (i = 0; i < MAX; i++) {
        mapp[i][i] = 0;
    }
    for (k = 0; k < total_num_of_name; k++) {
        for (i = 0; i < total_num_of_name; i++) {
            for (j = 0; j < total_num_of_name; j++) {
                mapp[i][j] = min(mapp[i][j], mapp[i][k] + mapp[k][j]);
            }
        }
    }
}

int main() {
    
    std::ios::sync_with_stdio(false);
    
    int case_num, n, dis;
    string temp_f, temp_t;
    cin >> case_num;
    
    while (case_num--) {
        cin >> n;
        
        for (int i = 0; i < MAX; i++) {
            for (int j = 0; j < MAX; j++) {
                mapp[i][j] = INF;
            }
        }
        total_num_of_name = 0;
        map<string, int> m;
        
        while (n--) {
            cin >> temp_f >> temp_t >> dis;
            if (m.find(temp_f) == m.end()) {
                m[temp_f] = total_num_of_name++;
            }
            if (m.find(temp_t) == m.end()) {
                m[temp_t] = total_num_of_name++;
            }
            mapp[m[temp_f]][m[temp_t]] = dis < mapp[m[temp_f]][m[temp_t]] ? dis : mapp[m[temp_f]][m[temp_t]];
            mapp[m[temp_t]][m[temp_f]] = dis < mapp[m[temp_t]][m[temp_f]] ? dis : mapp[m[temp_t]][m[temp_f]];
        }
        
        cin >> temp_f >> temp_t;
        if (temp_f == temp_t) {
            cout << 0 << endl;
            continue;
        }
        
        if (m.find(temp_f) == m.end() || m.find(temp_t) == m.end()) {
            cout << -1 << endl;
            continue;
        }
        
        Floyd_Warshall();
        
        cout << (mapp[m[temp_f]][m[temp_t]] >= INF ? -1 : mapp[m[temp_f]][m[temp_t]]) << endl;

    }
    return 0;
}
有map的Dijkstra： 


#include <stdio.h>
#include <string.h>
#include <iostream>
#include <map>
#include <string>
using namespace std;
#define INF 99999999
#define MAX 115 * 2

int total_num_of_name, mapp[MAX][MAX];
char num_of_name[MAX][MAX];

int min(int a, int b) {
    return a > b ? b : a;
}

///////////////////////////////////////Dijkstra///////////////////////////////////////
int Dijkstra(int start_point, int end_point) {
    
    int dis_from_sp[MAX];  //各个点到起点的最短距离
    fill(dis_from_sp, dis_from_sp + total_num_of_name, INF);  //一开始为INF
    
    bool used_point[MAX];  //各个点是否用过来扩展更新最短路径，这里的点是dis_from_sp中的点
    fill(used_point, used_point + total_num_of_name, false);
    
    dis_from_sp[start_point] = 0;  //起点特殊
    
    while (1) {
        int v = -1;
        for (int i = 0; i < total_num_of_name; i++) {  //从dis_from_sp中找出一个没有用过的而且到起点距离最小的点来更新起点到各个点的最短路径
            if (!used_point[i] && (v == -1 || dis_from_sp[i] < dis_from_sp[v]))
                v = i;
        }
        
        if (v == -1)  //如果还是-1说明dis_from_sp中的点都已经用完了
            break;
        
        used_point[v] = true;
        for (int i = 0; i < total_num_of_name; i++) {  //通过中间点（当前到起点的最短点）来更新最短路径
            dis_from_sp[i] = min(dis_from_sp[i], dis_from_sp[v] + mapp[v][i]);
        }
    }
    return dis_from_sp[end_point];  //最后只需要返回终点到起点的最短路径就可以了
}
///////////////////////////////////////Dijkstra///////////////////////////////////////

int main() {
    
    std::ios::sync_with_stdio(false);
    
    int case_num, n, dis;
    string temp_f, temp_t;
    cin >> case_num;
    
    while (case_num--) {
        cin >> n;
        
        for (int i = 0; i < MAX; i++) {
            for (int j = 0; j < MAX; j++) {
                mapp[i][j] = INF;
            }
        }
        total_num_of_name = 0;
        map<string, int> m;
        
        while (n--) {
            cin >> temp_f >> temp_t >> dis;
            if (m.find(temp_f) == m.end()) {
                m[temp_f] = total_num_of_name++;
            }
            if (m.find(temp_t) == m.end()) {
                m[temp_t] = total_num_of_name++;
            }
            mapp[m[temp_f]][m[temp_t]] = dis < mapp[m[temp_f]][m[temp_t]] ? dis : mapp[m[temp_f]][m[temp_t]];
            mapp[m[temp_t]][m[temp_f]] = dis < mapp[m[temp_t]][m[temp_f]] ? dis : mapp[m[temp_t]][m[temp_f]];
        }
        
        cin >> temp_f >> temp_t;
        if (temp_f == temp_t) {
            cout << 0 << endl;
            continue;
        }
        
        if (m.find(temp_f) == m.end() || m.find(temp_t) == m.end()) {
            cout << -1 << endl;
            continue;
        }
        
        for (int i = 0; i < total_num_of_name; i++) {
            mapp[i][i] = 0;
        }
        
        int ans = Dijkstra(m[temp_f], m[temp_t]);
        
        cout << (ans < INF ? ans : -1) << endl;
    }
    return 0;
}
优化的Dijkstra算法： 


#include <stdio.h>
#include <string.h>
#include <iostream>
#include <map>
#include <string>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
#define INF 99999999
#define MAX 115 * 2

//这次也是Dijkstra算法，但是在数值的插入和取最小值方面进行了优化，使用了优先队列，这样经过自动排序后，每次可以直接从队首取得距离起点最小值


int total_num_of_name;//点的总数

struct edges {//用结构体作为二维动态数组的元素存图
    int to;//到达的点
    int diss;//距离
    edges(int new_to, int new_diss): to(new_to), diss(new_diss){}//结构体的初始化函数
};

vector<edges> e[MAX];//用结构体作为二维动态数组的元素存图

typedef pair<int, int> p;//优先队列里的元素，first是到起点距离，second是点号

int Dijkstra(int start_point, int end_point) {
    
    int dis_from_sp[MAX];//到起点的距离
    fill(dis_from_sp, dis_from_sp + total_num_of_name, INF);//初始化
    dis_from_sp[start_point] = 0;//起点的特殊处理
    
    priority_queue<p, vector<p>, greater<p> > q;//优先队列，greater参数让其从小到大排序
    q.push(p(0, start_point));//起点进入
    
    while (!q.empty()) {
        p temp_p = q.top();//获得队首元素，也即是距离起点的最小值
        q.pop();
        int pos = temp_p.second;
        
        if (dis_from_sp[pos] < temp_p.first)//这说明有可能这个点通过其他的中间点获得了比它记录的到起点的更短距离，这时候以它来更新最短距离没有意义（本来就不是最短的）
            continue;
        
        for (int i = 0; i < (int)e[pos].size(); i++) {//在pos能到达的点之间更新
            edges new_edge = e[pos][i];
            
            if (dis_from_sp[new_edge.to] > dis_from_sp[pos] + new_edge.diss) {//如果某个点距离起点的距离比通过中间点的连接的距离大，则要更新
                
                dis_from_sp[new_edge.to] = dis_from_sp[pos] + new_edge.diss;
                
                q.push(p(dis_from_sp[new_edge.to], new_edge.to));//这就相当于没有优化的Dijkstra算法中的dis_from_sp的更新
            }
        }
    }
    
    return dis_from_sp[end_point];
}

int main() {
    
    std::ios::sync_with_stdio(false);
    
    int case_num, n, dis;
    string temp_f, temp_t;
    cin >> case_num;
    
    while (case_num--) {
        
        cin >> n;
        total_num_of_name = 0;
        map<string, int> m;
        for (int i = 0; i < MAX; i++) {//丫的没有初始化WA了n次
            e[i].clear();
        }
         
        while (n--) {
            cin >> temp_f >> temp_t >> dis;
            if (m.find(temp_f) == m.end()) {
                m[temp_f] = total_num_of_name++;
            }
            if (m.find(temp_t) == m.end()) {
                m[temp_t] = total_num_of_name++;
            }
            e[m[temp_f]].push_back(edges(m[temp_t], dis));
            e[m[temp_t]].push_back(edges(m[temp_f], dis));
        }
        
        for (int i = 0; i < total_num_of_name; i++) {//这里是对起点终点相同的点的调整，感觉不要也行吧。。。
            int j;
            for (j = 0; j < (int)e[i].size(); j++) {
                if (e[i][j].to == i) {
                    e[i][j] = edges(i, 0);
                    break;
                }
            }
            if (j >= (int)e[i].size())
                e[i].push_back(edges(i, 0));
        }
        
        
        cin >> temp_f >> temp_t;
        if (temp_f == temp_t) {
            cout << 0 << endl;
            continue;
        }
        
        if (m.find(temp_f) == m.end() || m.find(temp_t) == m.end()) {
            cout << -1 << endl;
            continue;
        }
        
        int ans = Dijkstra(m[temp_f], m[temp_t]);
        
        cout << (ans < INF ? ans : -1) << endl;
    }
    return 0;
}
下面是自己的玩玩：如何还原最短路径呢？ 

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <map>
#include <string>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;
#define INF 99999999
#define MAX 115 * 2

//这次也是Dijkstra算法，但是在数值的插入和取最小值方面进行了优化，使用了优先队列，这样经过自动排序后，每次可以直接从队首取得距离起点最小值


int total_num_of_name;//点的总数

struct edges {//用结构体作为二维动态数组的元素存图
    int to;//到达的点
    int diss;//距离
    edges(int new_to, int new_diss): to(new_to), diss(new_diss){}//结构体的初始化函数
};

vector<edges> e[MAX];//用结构体作为二维动态数组的元素存图

typedef pair<int, int> p;//优先队列里的元素，first是到起点距离，second是点号

int pre[MAX];

int Dijkstra(int start_point, int end_point) {
    
    int dis_from_sp[MAX];//到起点的距离
    fill(dis_from_sp, dis_from_sp + total_num_of_name, INF);//初始化
    dis_from_sp[start_point] = 0;//起点的特殊处理
    
    priority_queue<p, vector<p>, greater<p> > q;//优先队列，greater参数让其从小到大排序
    q.push(p(0, start_point));//起点进入
    
    fill(pre, pre + total_num_of_name, -1);
    
    while (!q.empty()) {
        p temp_p = q.top();//获得队首元素，也即是距离起点的最小值
        q.pop();
        int pos = temp_p.second;
        
        if (dis_from_sp[pos] < temp_p.first)//这说明有可能这个点通过其他的中间点获得了比它记录的到起点的更短距离，这时候以它来更新最短距离没有意义（本来就不是最短的）
            continue;
        
        for (int i = 0; i < (int)e[pos].size(); i++) {//在pos能到达的点之间更新
            edges new_edge = e[pos][i];
            
            if (dis_from_sp[new_edge.to] > dis_from_sp[pos] + new_edge.diss) {//如果某个点距离起点的距离比通过中间点的连接的距离大，则要更新
                
                dis_from_sp[new_edge.to] = dis_from_sp[pos] + new_edge.diss;
                
                q.push(p(dis_from_sp[new_edge.to], new_edge.to));//这就相当于没有优化的Dijkstra算法中的dis_from_sp的更新
                
                pre[new_edge.to] = pos;//这里表示，直接到达new_edge.to的最短路径上的点
            }
        }
    }
    
    return dis_from_sp[end_point];
}

string name[MAX];//用来存点的字符名字

void find_shortest_path(int p) {
    
    vector<int> path;
    for (; p != -1; p = pre[p])
        path.push_back(p);//从终点不断地往回找
    reverse(path.begin(), path.end());//倒过来就是从起点到终点了
    
    vector<int> :: iterator pathh;
    for (pathh = path.begin(); pathh != path.end(); pathh++) {
        if (pathh != path.begin())
            cout << " ---> ";
        cout << name[*pathh];
    }
    cout << endl;
}

int main() {
    
    std::ios::sync_with_stdio(false);
    
    int case_num, n, dis;
    string temp_f, temp_t;
    cin >> case_num;
    
    while (case_num--) {
        
        cin >> n;
        total_num_of_name = 0;
        map<string, int> m;
        for (int i = 0; i < MAX; i++) {//丫的没有初始化WA了n次
            e[i].clear();
            name[i].clear();
        }
        
        while (n--) {
            cin >> temp_f >> temp_t >> dis;
            if (m.find(temp_f) == m.end()) {
                m[temp_f] = total_num_of_name++;
                name[total_num_of_name - 1] = temp_f;
            }
            if (m.find(temp_t) == m.end()) {
                m[temp_t] = total_num_of_name++;
                name[total_num_of_name - 1] = temp_t;
            }
            e[m[temp_f]].push_back(edges(m[temp_t], dis));
            e[m[temp_t]].push_back(edges(m[temp_f], dis));
        }
        
        for (int i = 0; i < total_num_of_name; i++) {//这里是对起点终点相同的点的调整，感觉不要也行吧。。。
            int j;
            for (j = 0; j < (int)e[i].size(); j++) {
                if (e[i][j].to == i) {
                    e[i][j] = edges(i, 0);
                    break;
                }
            }
            if (j >= (int)e[i].size())
                e[i].push_back(edges(i, 0));
        }
        
        
        cin >> temp_f >> temp_t;
        if (temp_f == temp_t) {
            cout << 0 << endl;
            continue;
        }
        
        if (m.find(temp_f) == m.end() || m.find(temp_t) == m.end()) {
            cout << -1 << endl;
            continue;
        }
        
        int ans = Dijkstra(m[temp_f], m[temp_t]);
        
        cout << (ans < INF ? ans : -1) << endl;
        
        find_shortest_path(m[temp_t]);
    }
    return 0;
}

sicily 1562.LVM
01-18
sicily 1562_LVM.cpp参考代码
CPP-for-sicily.zip_sicily
09-21
"CPP-for-sicily.zip_sicily"这个压缩包，显然是为了解决与"Sicily"相关的编程问题而准备的资源，它包含了一份名为"C++ for sicily.doc"的文档，这很可能是针对Sicily地区或某个特定的Sicily项目的一份C++解题模板...
1031. Campus
ACM 【程式=演算法+資料結構】@蜡笔小轩V
07-14 1537
TAG  最短路 kruskal经典题目，直接用kruskal就行，只是注意要把字符串映射成编号，我用STL的map容器做的。还有节点数最多是200/* source code of submission 424628, Zhongshan University Online Judge System */ #include #include #include #include using namespace std; char s1[110],s2[110]; int g[200]
Sicily---1031. Campus（最短路径）
鲜橙的思维空间
12-12 695
题目如下：Description At present, Zhongshan University has 4 campuses with a total area of 6.17 square kilometers sitting respectively on both sides of the Pearl River or facing the South China Sea. The Gu
Sicily 1031 Campus
记录下自己的点滴奋斗
02-07 377
大意就是求出两个地点的最短路。 简单的单源最短路问题，我用的是优先队列实现的dijkstra算法，离散数学教的~注意题目的陷阱，输入数据的坑就好啦。 #include #include #include #include #define MAXN 205 #define INF 100000000 using namespace std; int d[MAXN];
Sicily Shortest path in unweighted graph
whj95的专栏
12-19 837
Source:http://soj.sysu.edu.cn/show_problem.php?pid=1003&cid=2104Description输入一个无向图，指定一个顶点s开始bfs遍历，求出s到图中每个点的最短距离。 如果不存在s到t的路径，则记s到t的距离为-1。Sample Input输入的第一行包含两个整数n和m，n是图的顶点数，m是边数。1<=n<=1000，0<=m<=1000
sicily1294.rar_1294_sicily
09-14
【标题】"sicily1294.rar_1294_sicily" 提供的信息表明，这可能是一个与中山大学ACM竞赛相关的代码压缩包，其中包含了对问题1294 "Sicily"的解决方案。在ACM（国际大学生程序设计竞赛，International Collegiate ...
Sicily_Queue.rar_sicily
09-23
"Sicily_Queue.rar_sicily"这个压缩包文件显然包含了与在Sicily平台上实现高效队列操作相关的代码或文档。 首先，我们需要理解队列的基本概念。队列就像一个等待服务的队伍，新进来的元素（入队）会排在队伍的末尾...
sicily-1274.rar_sicily
09-24
【标题】"sicily-1274.rar_sicily" 指向的是一个名为 "sicily-1274" 的RAR压缩文件，它包含的可能是一个关于 "sicily" 项目的源代码。RAR是一种流行的压缩格式，用于打包多个文件或文件夹到一个单一的、易于管理的...
No1031.Campus
qiaosen20的博客
06-01 294
一、题目描述 Description At present, Zhongshan University has 4 campuses with a total area of 6.17 square kilometers sitting respectively on both sides of the Pearl River or facing the South China S
sicily1031Campus之最短路径解题报告
langzi989的专栏
10-13 1022
sicily1031Campus之最短路径解题报告题目陷阱昨天讲了人工智能中的搜索算法，贪婪算法，A*算法，爬山算法，模拟退火算法和遗传算法，听着好屌的样子，其实也没什么，回来之后打算练习一个A*算法的实例，刚想做A*算法，发现前几天讲的最短路径还没有做，然后就在sicily上找到了这道题1031，本想着这道题木很容易，很快能做完然后再继续A*算法，没想到这题WA了我一晚上，看到其他人的结题报告才过
Sicily 1031. Campus
Jason__sz的博客
01-03 318
题解：即求多源最短路径问题，使用Floyd算法求解。参考思路：弗洛伊德算法一些细节：1、字符串处理方法：用一个string数组来存储所有地名，其结点编号为数组中相应下标 2、要考虑输入地名不存在和无解的情况代码如下：// Problem#: 1031 // Submission#: 5233116 // The source code is licensed under Creative Commo
1031.Campus 求两个地点的最短路径
xiehaoyun2012的专栏
01-09 477
/*1031.Campus 求两个地点的最短路径 给出一系列的路径，求出给定两个点的路径（这里要特别注意：坑爹的测试数据有 给出两个相同的存在地点应该要输出0） 思路：用map把地点string和id对应起来。然后之后就用id来遍历了 建立vector数组，id是对应地点的id，vector里面装的是一条条边Edge 然后从其实地点开始放进优先队列，入
xtu Shortest Path
weixin_30887919的博客
08-11 303
Acceteped : 23 Submit : 61 Time Limit : 5000 MS Memory Limit : 65536 KB Description 题目描述 N(3≤N≤1,000)个城市（编号从1~N），M(N-1≤M≤10,000)条公路连接这些城市，每条公路都是双...
sicily 1031.Campus
因为特别的二，所以二的特别。
12-29 435
djstra单源最短路径. #include #include #include #include #include #include using namespace std; const int MAXN = 1000005; int road[202][202]; bool used[202]; int minlength[202]; int number; int djst
Sicily题目分类与解题策略
"Sicily题目分类包含了各种类型的算法题目，包括贪心、递推、分治、数据结构、搜索、回溯、马周游、队列、排序、高精度计算、模拟、背包问题等。这些题目按照难度进行规范，有的需要解决大规模数据，有的涉及特定的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值