天梯赛L3部分
L3-001 凑零钱
分数 30
作者 陈越
单位 浙江大学
韩梅梅喜欢满宇宙到处逛街。现在她逛到了一家火星店里，发现这家店有个特别的规矩：你可以用任何星球的硬币付钱，但是绝不找零，当然也不能欠债。韩梅梅手边有 104 枚来自各个星球的硬币，需要请你帮她盘算一下，是否可能精确凑出要付的款额。
输入格式：
输入第一行给出两个正整数：N（≤104）是硬币的总个数，M（≤102）是韩梅梅要付的款额。第二行给出 N 枚硬币的正整数面值。数字间以空格分隔。
输出格式：
在一行中输出硬币的面值 V1≤V2≤⋯≤V**k，满足条件 V1+V2+...+V**k=M。数字间以 1 个空格分隔，行首尾不得有多余空格。若解不唯一，则输出最小序列。若无解，则输出 No Solution。
注：我们说序列{ A[1],A[2],⋯ }比{ B[1],B[2],⋯ }“小”，是指存在 k≥1 使得 A[i]=B[i] 对所有 i<k 成立，并且 A[k]<B[k]。
思路：
01背包 输出具体方案，不能用优化空间的版本
#include<bits/stdc++.h>
using namespace std;
const int N = 10005;
int a[N];
bool dp[N][105]; // dp[i][j]：前i个物品（降序）能否凑出j
void solve(){
int n, m;
cin >> n >> m;
for(int i = 0; i < n; i++) cin >> a[i];
// 第一步：降序排序（从大到小）
sort(a, a + n, greater<int>()); // 关键：降序
// 第二步：正向DP（前i个物品能否凑出j）
memset(dp, false, sizeof(dp));
dp[0][0] = true;
for(int i = 0; i < n; i++){
for(int j = 0; j <= m; j++){
dp[i+1][j] = dp[i][j]; // 不选第i个物品
if(j >= a[i]){
dp[i+1][j] |= dp[i][j - a[i]]; // 选第i个物品
}
}
}
// 第三步：反向选物品（从最后一个元素，即最小数开始选）
vector<int> ans;
if(dp[n][m]){
int j = m;
// 从最后一个物品（最小数）往回找
for(int i = n - 1; i >= 0; i--){
if(j >= a[i] && dp[i][j - a[i]]){
ans.push_back(a[i]);
j -= a[i];
}
}
// 此时ans是升序（因为反向选的是降序数组的末尾，即小数），直接输出
for(int i = 0; i < ans.size(); i++){
if(i != 0) cout << " ";
cout << ans[i];
}
}else{
cout << "No Solution";
}
}
int main(){
solve();
return 0;
}
L3-002 特殊堆栈
分数 30
作者 陈越
单位 浙江大学
堆栈是一种经典的后进先出的线性结构，相关的操作主要有“入栈”（在堆栈顶插入一个元素）和“出栈”（将栈顶元素返回并从堆栈中删除）。本题要求你实现另一个附加的操作：“取中值”——即返回所有堆栈中元素键值的中值。给定 N 个元素，如果 N 是偶数，则中值定义为第 N/2 小元；若是奇数，则为第 (N+1)/2 小元。
输入格式：
输入的第一行是正整数 N（≤105）。随后 N 行，每行给出一句指令，为以下 3 种之一：
Push key
Pop
PeekMedian
其中 key 是不超过 105 的正整数；Push 表示“入栈”；Pop 表示“出栈”；PeekMedian 表示“取中值”。
输出格式：
对每个 Push 操作，将 key 插入堆栈，无需输出；对每个 Pop 或 PeekMedian 操作，在一行中输出相应的返回值。若操作非法，则对应输出 Invalid。
思路：
对顶堆维护中值
#include<bits/stdc++.h>
using namespace std;
multiset<int> down,up;
stack<int> st;
void adjust(){
while(up.size() > down.size()){
down.insert(*up.begin());
up.erase(up.begin());
}
while(down.size() > up.size() + 1){
auto it = down.end();
it--;
up.insert(*it);
down.erase(it);
}
}
void solve(){
int n;
cin >> n;
while(n--){
string s;
cin >> s;
if(s == "Push"){
int x;
cin >> x;
st.push(x);
if(down.empty() || x <= *(--down.end())) down.insert(x);
else up.insert(x);
adjust();
}else if(s == "Pop"){
if(st.empty()){
cout << "Invalid\n";
}else{
int x = st.top();
cout << x << "\n";
st.pop();
if(x <= *(--down.end())){
down.erase(down.find(x));
}else{
up.erase(up.find(x));
}
adjust();
}
}else{
if(st.empty()){
cout << "Invalid\n";
}else{
cout << *(--down.end())<< "\n";
}
}
}
}
int main(){
solve();
return 0;
}
L3-003 社交集群
分数 30
作者 陈越
单位 浙江大学
当你在社交网络平台注册时，一般总是被要求填写你的个人兴趣爱好，以便找到具有相同兴趣爱好的潜在的朋友。一个“社交集群”是指部分兴趣爱好相同的人的集合。你需要找出所有的社交集群。
输入格式：
输入在第一行给出一个正整数 N（≤1000），为社交网络平台注册的所有用户的人数。于是这些人从 1 到 N 编号。随后 N 行，每行按以下格式给出一个人的兴趣爱好列表：
K**i: h**i[1] h**i[2] ... h**i[K**i]
其中K**i(>0)是兴趣爱好的个数，h**i[j]是第j个兴趣爱好的编号，为区间 [1, 1000] 内的整数。
输出格式：
首先在一行中输出不同的社交集群的个数。随后第二行按非增序输出每个集群中的人数。数字间以一个空格分隔，行末不得有多余空格。
思路：
并查集，用户编号记大小，兴趣编号 不记大小（+ 1000不与用户编号重回）
#include<bits/stdc++.h>
using namespace std;
const int N = 2005;
int fa[N],sz[N];
int find(int x){
return fa[x] = (fa[x] == x ? x : find(fa[x]));
}
void merge(int a,int b){
int x = find(a),y = find(b);
if(x == y) return ;
if(x < y) swap(x,y);
sz[y] += sz[x];
fa[x] = y;
}
void solve(){
int n;
cin >> n;
for(int i = 1;i < N;i++){
fa[i] = i;
if(i <= n){
sz[i] = 1;
}
}
for(int root = 1;root <= n;root++){
int k;
scanf("%d:",&k);
vector<int> arr(k);
for(int i = 0;i < k;i++){
cin >> arr[i];
arr[i] += n;
merge(root,arr[i]);
}
}
vector<int> ans;
int cnt = 0;
for(int i = 1;i <= n;i++){
if(find(i) == i){
//cout << i << " " << sz[i] << "\n";
ans.push_back(sz[i]);
cnt++;
}
}
cout << cnt << "\n";
sort(ans.begin(),ans.end());
for(int i = ans.size() - 1;i >= 0;i--){
if(i != ans.size() - 1) cout << " ";
cout << ans[i];
}
}
int main(){
solve();
return 0;
}
L3-004 肿瘤诊断
分数 30
作者 陈越
单位 浙江大学
在诊断肿瘤疾病时，计算肿瘤体积是很重要的一环。给定病灶扫描切片中标注出的疑似肿瘤区域，请你计算肿瘤的体积。
输入格式：
输入第一行给出4个正整数：M、N、L、T，其中M和N是每张切片的尺寸（即每张切片是一个M×N的像素矩阵。最大分辨率是1286×128）；L（≤60）是切片的张数；T是一个整数阈值（若疑似肿瘤的连通体体积小于T，则该小块忽略不计）。
最后给出L张切片。每张用一个由0和1组成的M×N的矩阵表示，其中1表示疑似肿瘤的像素，0表示正常像素。由于切片厚度可以认为是一个常数，于是我们只要数连通体中1的个数就可以得到体积了。麻烦的是，可能存在多个肿瘤，这时我们只统计那些体积不小于T的。两个像素被认为是“连通的”，如果它们有一个共同的切面，如下图所示，所有6个红色的像素都与蓝色的像素连通。
输出格式：
在一行中输出肿瘤的总体积。
思路：
三维BFS
#include<bits/stdc++.h>
using namespace std;
int m,n,l,t;
int ans = 0;
int mp[1287][129][61];
struct node{
int x,y,z;
};
int dx[] = {0,0,1,-1,0,0};
int dy[] = {1,-1,0,0,0,0};
int dz[] = {0,0,0,0,1,-1};
void bfs(int x,int y,int z){
int sum = 1;
mp[x][y][z] = 0;
queue<node> q;
q.push({x,y,z});
while(!q.empty()){
node t = q.front();
q.pop();
for(int i = 0;i < 6;i++){
int nx = t.x + dx[i];
int ny = t.y + dy[i];
int nz = t.z + dz[i];
if(nx < 0 || nx >= m || ny < 0 || ny >= n || nz < 0 || nz >= l || mp[nx][ny][nz] != 1)
continue;
sum++;
mp[nx][ny][nz] = 0;
q.push({nx,ny,nz});
}
}
if(sum >= t) ans += sum;
}
void solve(){
cin >> m >> n >> l >> t;
for(int k = 0;k < l;k++)
for(int i = 0;i < m;i++)
for(int j = 0;j < n;j++)
cin >> mp[i][j][k];
for(int k = 0;k < l;k++)
for(int i = 0;i < m;i++)
for(int j = 0;j < n;j++)
if(mp[i][j][k] == 1)
bfs(i,j,k);
cout << ans << "\n";
}
int main(){
solve();
return 0;
}
L3-005 垃圾箱分布
分数 30
作者 陈越
单位 浙江大学
大家倒垃圾的时候，都希望垃圾箱距离自己比较近，但是谁都不愿意守着垃圾箱住。所以垃圾箱的位置必须选在到所有居民点的最短距离最长的地方，同时还要保证每个居民点都在距离它一个不太远的范围内。
现给定一个居民区的地图，以及若干垃圾箱的候选地点，请你推荐最合适的地点。如果解不唯一，则输出到所有居民点的平均距离最短的那个解。如果这样的解还是不唯一，则输出编号最小的地点。
输入格式：
输入第一行给出4个正整数：N（≤103）是居民点的个数；M（≤10）是垃圾箱候选地点的个数；K（≤104）是居民点和垃圾箱候选地点之间的道路的条数；D**S是居民点与垃圾箱之间不能超过的最大距离。所有的居民点从1到N编号，所有的垃圾箱候选地点从G1到GM编号。
随后K行，每行按下列格式描述一条道路：
P1 P2 Dist
其中P1和P2是道路两端点的编号，端点可以是居民点，也可以是垃圾箱候选点。Dist是道路的长度，是一个正整数。
输出格式：
首先在第一行输出最佳候选地点的编号。然后在第二行输出该地点到所有居民点的最小距离和平均距离。数字间以空格分隔，保留小数点后1位。如果解不存在，则输出No Solution。
思路：Dijkstra
#include<bits/stdc++.h>
using namespace std;
const int N = 1015;
const int inf = 0x3f3f3f3f;
vector<pair<int,int>> g[N];
int n,m,k,ds;
int dist[N];
bool vis[N];
void Dijkstra(int st){
memset(dist,inf,sizeof dist);
memset(vis,false,sizeof vis);
priority_queue<pair<int,int>,vector<pair<int,int>>,greater<>> q;
dist[st] = 0 ;
q.push({0,st});
while(!q.empty()){
auto [d,x] = q.top();
q.pop();
if(vis[x]) continue;
vis[x] = true;
for(auto [y,w] : g[x]){
if(dist[y] > dist[x] + w ){
dist[y] = dist[x] + w;
q.push({dist[y],y});
}
}
}
}
void solve(){
cin >> n >> m >> k >> ds;
map<string,int> mp;
for(int i = 1;i <= m;i++){
string id = "G" + to_string(i);
mp[id] = n + i;
}
for(int i = 0;i < k;i++){
string a,b;
int x,y,w;
cin >> a >> b >> w;
if(a[0] == 'G'){
x = mp[a];
}else{
x = stoi(a);
}
if(b[0] == 'G'){
y = mp[b];
}else{
y = stoi(b);
}
// cout << x << " " << y << " " << w << "\n";
g[x].push_back({y,w});
g[y].push_back({x,w});
}
double avgMn = inf,ans = -1,ansMx = 0;
for(int x = n + 1;x <= m + n;x++){
Dijkstra(x);
int mn = inf;
double sum = 0;
bool check = true;
for(int i = 1;i <= n;i++){
sum += dist[i];
if(dist[i] > ds || dist[i] == inf) {
check = false;
break;
}
mn = min(mn,dist[i]);
}
if(check){
double avg = 1.0 * sum / n;
if(mn > ansMx){
ansMx = mn;
avgMn = avg;
ans = x;
}else if(mn == ansMx){
if(avg < avgMn){
avgMn = avg;
ans = x;
}
}
}
}
if(ans == -1){
cout << "No Solution\n";
}else{
cout << "G" << ans - n << "\n";
printf("%.1f %.1f",ansMx,avgMn);
}
}
int main(){
solve();
return 0;
}
L3-007 天梯地图
分数 30
作者 陈越
单位 浙江大学
本题要求你实现一个天梯赛专属在线地图，队员输入自己学校所在地和赛场地点后，该地图应该推荐两条路线：一条是最快到达路线；一条是最短距离的路线。题目保证对任意的查询请求，地图上都至少存在一条可达路线。
输入格式：
输入在第一行给出两个正整数N（2 ≤ N ≤ 500）和M，分别为地图中所有标记地点的个数和连接地点的道路条数。随后M行，每行按如下格式给出一条道路的信息：
V1 V2 one-way length time
其中V1和V2是道路的两个端点的编号（从0到N-1）；如果该道路是从V1到V2的单行线，则one-way为1，否则为0；length是道路的长度；time是通过该路所需要的时间。最后给出一对起点和终点的编号。
输出格式：
首先按下列格式输出最快到达的时间T和用节点编号表示的路线：
Time = T: 起点 => 节点1 => ... => 终点
然后在下一行按下列格式输出最短距离D和用节点编号表示的路线：
思路：跑两遍Dijkstra
#include<bits/stdc++.h>
using namespace std;
const int N = 505;
const int inf = 0x3f3f3f3f;
vector<int> g[N];
int st,ed;
int n,m;
int Dijkstra(vector<int>& ans,vector<vector<int>> cost1,vector<vector<int>> cost2){
vector<int> dist1(n,inf);
vector<int> dist2(n,inf);
vector<bool> vis(n,false);
vector<int> from(n,-1);
dist1[st] = 0;
dist2[st] = 0;
priority_queue<pair<int,int>,vector<pair<int,int>>,greater<>> q;
q.push({0,st});
while(!q.empty()){
auto [d,x] = q.top();
q.pop();
if(vis[x]) continue;
vis[x] = true;
for(int y : g[x]){
if(dist1[y] > dist1[x] + cost1[x][y]){
dist1[y] = dist1[x] + cost1[x][y];
dist2[y] = dist2[x] + cost2[x][y];
from[y] = x;
q.push({dist1[y],y});
}else if(dist1[y] == dist1[x] + cost1[x][y]){
if(dist2[y] > dist2[x] + cost2[x][y]){
from[y] = x;
q.push({dist1[y],y});
}
}
}
}
int now = ed;
while(now != -1){
ans.push_back(now);
now = from[now];
}
reverse(ans.begin(),ans.end());
return dist1[ed];
}
void print(vector<int>& ans){
for(int i = 0;i < ans.size();i++){
if(i != 0) cout << " => " ;
cout << ans[i];
}
}
void solve(){
cin >> n >> m;
vector<vector<int>> costDist(n,vector<int>(n,inf));
vector<vector<int>> costTime(n,vector<int>(n,inf));
vector<vector<int>> costCnt(n,vector<int>(n,inf));
for(int i = 0;i < m;i++){
int x,y,one,len,tim;
cin >> x >> y >> one >> len >> tim;
g[x].push_back(y);
costTime[x][y] = tim;
costDist[x][y] = len;
costCnt[x][y] = 1;
if(one == 0){
g[y].push_back(x);
costTime[y][x] = tim;
costDist[y][x] = len;
costCnt[y][x] = 1;
}
}
cin >> st >> ed;
vector<int> ans1,ans2;
int Time = Dijkstra(ans1,costTime,costDist);
int Distance = Dijkstra(ans2,costDist,costCnt);
bool isSame = true;
if(ans1.size() != ans2.size()){
isSame = false;
}else{
for(int i = 0;i < ans1.size();i++){
if(ans1[i] != ans2[i]){
isSame = false;
break;
}
}
}
if(isSame){
cout << "Time = " << Time << "; ";
cout << "Distance = " << Distance << ": ";
print(ans1);
}else{
cout << "Time = " << Time << ": ";
print(ans1);
cout << "\n";
cout << "Distance = " << Distance << ": ";
print(ans2);
}
}
int main(){
solve();
return 0;
}
L3-008 喊山
分数 30
作者 陈越
单位 浙江大学
喊山，是人双手围在嘴边成喇叭状，对着远方高山发出“喂—喂喂—喂喂喂……”的呼唤。呼唤声通过空气的传递，回荡于深谷之间，传送到人们耳中，发出约定俗成的“讯号”，达到声讯传递交流的目的。原来它是彝族先民用来求援呼救的“讯号”，慢慢地人们在生活实践中发现了它的实用价值，便把它作为一种交流工具世代传袭使用。（图文摘自：http://news.xrxxw.com/newsshow-8018.html）
一个山头呼喊的声音可以被临近的山头同时听到。题目假设每个山头最多有两个能听到它的临近山头。给定任意一个发出原始信号的山头，本题请你找出这个信号最远能传达到的地方。
输入格式：
输入第一行给出3个正整数n、m和k，其中n（≤10000）是总的山头数（于是假设每个山头从1到n编号）。接下来的m行，每行给出2个不超过n的正整数，数字间用空格分开，分别代表可以听到彼此的两个山头的编号。这里保证每一对山头只被输入一次，不会有重复的关系输入。最后一行给出k（≤10）个不超过n的正整数，数字间用空格分开，代表需要查询的山头的编号。
输出格式：
依次对于输入中的每个被查询的山头，在一行中输出其发出的呼喊能够连锁传达到的最远的那个山头。注意：被输出的首先必须是被查询的个山头能连锁传到的。若这样的山头不只一个，则输出编号最小的那个。若此山头的呼喊无法传到任何其他山头，则输出0。
思路：BFS
#include<bits/stdc++.h>
using namespace std;
const int N = 10005;
const int inf = 0x3f3f3f3f;
vector<int> g[N];
int dist[N];
int bfs(int st){
memset(dist,inf,sizeof dist);
queue<int> q;
q.push(st);
dist[st] = 0;
int ans = 0,mxDep = 0;
int nowDep = 0;
while(!q.empty()){
int sz = q.size();
for(int i = 0;i < sz;i++){
int x = q.front();
q.pop();
if(nowDep > mxDep){
mxDep = nowDep;
ans = x;
}
for(int y : g[x]){
if(dist[y] > dist[x] + 1){
dist[y] = dist[x] + 1;
q.push(y);
}
}
}
nowDep++;
}
return ans;
}
void solve(){
int n,m,k;
cin >> n >> m >> k;
for(int i = 0;i < m;i++){
int x,y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
for(int i = 1;i <= n;i++){
if(g[i].empty()) continue;
sort(g[i].begin(),g[i].end());
}
while(k--){
int q;
cin >> q;
cout << bfs(q) << "\n";
}
}
int main(){
solve();
return 0;
}
L3-010 是否完全二叉搜索树
分数 30
作者 陈越
单位 浙江大学
将一系列给定数字顺序插入一个初始为空的二叉搜索树（定义为左子树键值大，右子树键值小），你需要判断最后的树是否一棵完全二叉树，并且给出其层序遍历的结果。
输入格式：
输入第一行给出一个不超过20的正整数N；第二行给出N个互不相同的正整数，其间以空格分隔。
输出格式：
将输入的N个正整数顺序插入一个初始为空的二叉搜索树。在第一行中输出结果树的层序遍历结果，数字间以1个空格分隔，行的首尾不得有多余空格。第二行输出YES，如果该树是完全二叉树；否则输出NO。
思路： 数据范围小直接用数组模拟建立二叉搜索树（下标从1开始），再判断完全二叉树
#include<bits/stdc++.h>
using namespace std;
const int N = 22;
int tree[1 << N];
int n;
void insert(int i,int x){
if(tree[i] == 0){
tree[i] = x;
return;
}
if(x > tree[i]) insert(i << 1 ,x);
else insert(i << 1 | 1 ,x);
}
void solve(){
cin >> n;
for(int i = 0;i < n;i++){
int x;
cin >> x;
insert(1,x);
}
queue<int> q;
q.push(1);
while(!q.empty()){
int x = q.front();
q.pop();
if(x != 1) cout << " ";
cout << tree[x];
if(tree[x << 1]) q.push(x << 1);
if(tree[x << 1 | 1]) q.push(x << 1 | 1);
}
cout << "\n";
for(int i = 1;i <= n;i++){
if(tree[i] == 0){
cout << "NO\n";
return ;
}
}
cout << "YES";
}
int main(){
solve();
return 0;
}
L3-011 直捣黄龙
分数 30
作者 陈越
单位 浙江大学
本题是一部战争大片 —— 你需要从己方大本营出发，一路攻城略地杀到敌方大本营。首先时间就是生命，所以你必须选择合适的路径，以最快的速度占领敌方大本营。当这样的路径不唯一时，要求选择可以沿途解放最多城镇的路径。若这样的路径也不唯一，则选择可以有效杀伤最多敌军的路径。
输入格式：
输入第一行给出 2 个正整数 N（2 ≤ N ≤ 200，城镇总数）和 K（城镇间道路条数），以及己方大本营和敌方大本营的代号。随后 N-1 行，每行给出除了己方大本营外的一个城镇的代号和驻守的敌军数量，其间以空格分隔。再后面有 K 行，每行按格式城镇1 城镇2 距离给出两个城镇之间道路的长度。这里设每个城镇（包括双方大本营）的代号是由 3 个大写英文字母组成的字符串。
输出格式：
按照题目要求找到最合适的进攻路径（题目保证速度最快、解放最多、杀伤最强的路径是唯一的），并在第一行按照格式己方大本营->城镇1->...->敌方大本营输出。第二行顺序输出最快进攻路径的条数、最短进攻距离、歼敌总数，其间以 1 个空格分隔，行首尾不得有多余空格。
思路：将字符串映射为编号，Dijkstra
#include<bits/stdc++.h>
using namespace std;
const int N = 205;
const int inf = 0x3f3f3f3f;
int dis[N],cnt[N],peo[N],kil[N],from[N],sum[N];
map<string,int> mp;
vector<pair<int,int>> g[N];
bool vis[N];
void solve(){
int n,k;
string my,eny;
cin >> n >> k >> my >> eny ;
vector<string> city(n);
mp[my] = 0;
city[0] = my;
for(int i = 1;i < n;i++){
string s;
cin >> s;
city[i] = s;
mp[s] = i;
cin >> peo[i];
}
for(int i = 0;i < k;i++){
string a,b;
int w ;
cin >> a >> b >> w;
int x = mp[a],y = mp[b];
g[x].push_back({y,w});
g[y].push_back({x,w});
}
int st = mp[my],ed = mp[eny];
memset(dis,inf,sizeof dis);
memset(from,-1,sizeof from);
priority_queue<pair<int,int>,vector<pair<int,int>>,greater<>> q ;
q.push({0,st});
dis[st] = 0;
sum[st] = 1;
while(!q.empty()){
auto [d,x] = q.top();
q.pop();
//if(d > dis[x]) continue;
if(vis[x]) continue;
vis[x] = true;
for(auto [y,w] : g[x]){
if(dis[y] > dis[x] + w){
dis[y] = dis[x] + w;
q.push({dis[y],y});
from[y] = x;
sum[y] = sum[x];
cnt[y] = cnt[x] + 1;
kil[y] = kil[x] + peo[y];
}else if(dis[y] == dis[x] + w){
sum[y] += sum[x];
if(cnt[x] + 1 > cnt[y]){
from[y] = x;
cnt[y] = cnt[x] + 1;
kil[y] = kil[x] + peo[y];
q.push({dis[y], y}); // 重新入队
}else if(cnt[x] + 1 == cnt[y] && kil[x] + peo[y] > kil[y]){
from[y] = x;
cnt[y] = cnt[x] + 1;
kil[y] = kil[x] + peo[y];
q.push({dis[y], y}); // 重新入队
}
}
}
}
vector<int> ans;
int now = ed;
while(now != -1){
ans.push_back(now);
now = from[now];
}
for(int i = ans.size() - 1;i >= 0;i--){
if(i != (int)ans.size() - 1) cout << "->";
cout << city[ans[i]];
}
cout << "\n";
cout << sum[ed] << " " << dis[ed] << " " << kil[ed];
}
int main(){
int t;
t = 1;
while(t--)
solve();
return 0;
}
L3-013 非常弹的球
分数 30
作者 俞勇
单位 上海交通大学
刚上高一的森森为了学好物理，买了一个“非常弹”的球。虽然说是非常弹的球，其实也就是一般的弹力球而已。森森玩了一会儿弹力球后突然想到，假如他在地上用力弹球，球最远能弹到多远去呢？他不太会，你能帮他解决吗？当然为了刚学习物理的森森，我们对环境做一些简化：
- 假设森森是一个质点，以森森为原点设立坐标轴，则森森位于(0, 0)点。
- 小球质量为w/100 千克（kg），重力加速度为9.8米/秒平方（m/s2）。
- 森森在地上用力弹球的过程可简化为球从(0, 0)点以某个森森选择的角度an**g (0<an**g<π/2) 向第一象限抛出，抛出时假设动能为1000 焦耳（J）。
- 小球在空中仅受重力作用，球纵坐标为0时可视作落地，落地时损失p%动能并反弹。
- 地面可视为刚体，忽略小球形状、空气阻力及摩擦阻力等。
森森为你准备的公式：
- 动能公式：E=m×v2/2
- 牛顿力学公式：F=m×a
- 重力：G=m×g
其中：
- E - 动能，单位为“焦耳”
- m - 质量，单位为“千克”
- v - 速度，单位为“米/秒”
- a - 加速度，单位为“米/秒平方”
- g - 重力加速度
输入格式：
输入在一行中给出两个整数：1≤w≤1000 和 1≤p≤100，分别表示放大100倍的小球质量、以及损失动力的百分比p。
输出格式：
在一行输出最远的投掷距离，保留3位小数。
思路：
直接推公式
#include<bits/stdc++.h>
using namespace std;
void solve(){
double w,p;
cin >> w >> p;
double ans = 0;
double E0 = 1000.0;
while(E0 >= 0.00000001){
ans += 200.0*E0 / (w * 9.8);
E0 = (100 - p) / 100.0 * E0;
}
printf("%.3f",ans);
}
int main(){
solve();
return 0;
}
L3-014 周游世界
分数 30
作者 陈越
单位 浙江大学
周游世界是件浪漫事，但规划旅行路线就不一定了…… 全世界有成千上万条航线、铁路线、大巴线，令人眼花缭乱。所以旅行社会选择部分运输公司组成联盟，每家公司提供一条线路，然后帮助客户规划由联盟内企业支持的旅行路线。本题就要求你帮旅行社实现一个自动规划路线的程序，使得对任何给定的起点和终点，可以找出最顺畅的路线。所谓“最顺畅”，首先是指中途经停站最少；如果经停站一样多，则取需要换乘线路次数最少的路线。
输入格式：
输入在第一行给出一个正整数N（≤100），即联盟公司的数量。接下来有N行，第i行（i=1,⋯,N）描述了第i家公司所提供的线路。格式为：
M S[1] S[2] ⋯ S[M]
其中M（≤100）是经停站的数量，S[i]（i=1,⋯,M）是经停站的编号（由4位0-9的数字组成）。这里假设每条线路都是简单的一条可以双向运行的链路，并且输入保证是按照正确的经停顺序给出的 —— 也就是说，任意一对相邻的S[i]和S[i+1]（i=1,⋯,M−1）之间都不存在其他经停站点。我们称相邻站点之间的线路为一个运营区间，每个运营区间只承包给一家公司。环线是有可能存在的，但不会不经停任何中间站点就从出发地回到出发地。当然，不同公司的线路是可能在某些站点有交叉的，这些站点就是客户的换乘点，我们假设任意换乘点涉及的不同公司的线路都不超过5条。
在描述了联盟线路之后，题目将给出一个正整数K（≤10），随后K行，每行给出一位客户的需求，即始发地的编号和目的地的编号，中间以一空格分隔。
输出格式：
处理每一位客户的需求。如果没有现成的线路可以使其到达目的地，就在一行中输出“Sorry, no line is available.”；如果目的地可达，则首先在一行中输出最顺畅路线的经停站数量（始发地和目的地不包括在内），然后按下列格式给出旅行路线：
Go by the line of company #X1 from S1 to S2.
Go by the line of company #X2 from S2 to S3.
......
其中Xi是线路承包公司的编号，Si是经停站的编号。但必须只输出始发地、换乘点和目的地，不能输出中间的经停站。题目保证满足要求的路线是唯一的。
思路： 参考CCCC-GPLT L3-014. 周游世界 团体程序设计天梯赛 – liuchuo
#include<bits/stdc++.h>
using namespace std;
const int N = 10050;
const int inf = 0x3f3f3f3f;
vector<int> g[N];
vector<int> path,tempPath;
bool vis[N];
int line[N][N];
int n,m,k,st,ed;
int minCnt, minTrans;
int cntTrans(vector<int> a){
if(a.size() <= 2) return 0;
int pre,now,nxt;
int cnt = 0;
for(int i = 1;i < (int)a.size() - 1;i++){
pre = a[i - 1];
now = a[i];
nxt = a[i + 1];
if(line[pre][now] != line[now][nxt])
cnt++;
}
return cnt;
}
void dfs(int x,int cnt){
if(x == ed){
if(cnt < minCnt || (cnt == minCnt && cntTrans(tempPath) < minTrans)){
path = tempPath;
minCnt = cnt;
minTrans = cntTrans(tempPath);
}
return ;
}
for(int y : g[x]){
if(!vis[y]){
tempPath.push_back(y);
vis[y] = true;
dfs(y,cnt + 1);
vis[y] = false;
tempPath.pop_back();
}
}
}
void solve(){
cin >> n;
for(int i = 1;i <= n;i++){
int now,pre;
cin >> m >> pre;
for(int j = 1;j < m;j++){
cin >> now;
g[pre].push_back(now);
g[now].push_back(pre);
line[pre][now] = line[now][pre] = i;
pre = now;
}
}
cin >> k;
while(k--){
tempPath.clear();
minCnt = minTrans = inf;
cin >> st >> ed;
tempPath.push_back(st);
vis[st] = true;
dfs(st,0);
vis[st] = false;
if(minCnt == inf){
cout << "Sorry, no line is available.\n";
continue;
}
cout << minCnt << "\n";
int preLine = 0,stationTans = st;
for(int i = 1;i < path.size();i++){
if(preLine != line[path[i - 1]][path[i]]){
if(preLine != 0)
printf("Go by the line of company #%d from %04d to %04d.\n",preLine,stationTans,path[i - 1]);
preLine = line[path[i - 1]][path[i]];
stationTans = path[i - 1];
}
}
printf("Go by the line of company #%d from %04d to %04d.\n",preLine,stationTans,ed);
}
}
int main(){
solve();
return 0;
}
L3-015 球队“食物链”
分数 30
作者 李文新
单位 北京大学
某国的足球联赛中有N支参赛球队，编号从1至N。联赛采用主客场双循环赛制，参赛球队两两之间在双方主场各赛一场。
联赛战罢，结果已经尘埃落定。此时，联赛主席突发奇想，希望从中找出一条包含所有球队的“食物链”，来说明联赛的精彩程度。“食物链”为一个1至N的排列{ T1 T2 ⋯ T**N }，满足：球队T1战胜过球队T2，球队T2战胜过球队T3，⋯，球队T(N−1)战胜过球队T**N，球队T**N战胜过球队T1。
现在主席请你从联赛结果中找出“食物链”。若存在多条“食物链”，请找出字典序最小的。
注：排列{ a1 a2 ⋯ a**N}在字典序上小于排列{ b1 b2 ⋯ b**N }，当且仅当存在整数K（1≤K≤N），满足：a**K<b**K且对于任意小于K的正整数i，a**i=b**i。
输入格式：
输入第一行给出一个整数N（2≤N≤20），为参赛球队数。随后N行，每行N个字符，给出了N×N的联赛结果表，其中第i行第j列的字符为球队i在主场对阵球队j的比赛结果：W表示球队i战胜球队j，L表示球队i负于球队j，D表示两队打平，-表示无效（当i=j时）。输入中无多余空格。
输出格式：
按题目要求找到“食物链”T1 T2 ⋯ T**N，将这N个数依次输出在一行上，数字间以1个空格分隔，行的首尾不得有多余空格。若不存在“食物链”，输出“No Solution”。
思路：全排列 ，必须剪枝
#include<bits/stdc++.h>
using namespace std;
const int N = 22;
bool win[N][N];
bool vis[N];
int ans[N];
bool found = false;
int n;
void dfs(int idx,int num){
if(found) return ;
ans[idx] = num;
if(idx == n && win[num][1]){
found = true;
return ;
}
if(idx == n) return;
bool cut = false;
for(int i = 1;i <= n;i++){
if(!vis[i] && win[i][1]){
cut = true;
break;
}
}
if(!cut) return;
vis[num] = true;
for(int i = 1;i <= n;i++){
if(!vis[i] && win[num][i]){
dfs(idx + 1,i);
}
}
vis[num] = false;
}
void solve(){
cin >> n;
for(int i = 0;i < n;i++){
string s;
cin >> s ;
for(int j = 0;j < n;j++){
if(s[j] == 'W') win[i + 1][j + 1] = true;
if(s[j] == 'L') win[j + 1][i + 1] = true;
}
}
dfs(1,1);
if(found){
for(int i = 1;i <= n;i++){
if(i != 1) cout << " ";
cout << ans[i];
}
}else{
cout << "No Solution";
}
}
int main(){
solve();
return 0;
}
L3-016 二叉搜索树的结构
分数 30
作者 陈越
单位 浙江大学
二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉搜索树。（摘自百度百科）
给定一系列互不相等的整数，将它们顺次插入一棵初始为空的二叉搜索树，然后对结果树的结构进行描述。你需要能判断给定的描述是否正确。例如将{ 2 4 1 3 0 }插入后，得到一棵二叉搜索树，则陈述句如“2是树的根”、“1和4是兄弟结点”、“3和0在同一层上”（指自顶向下的深度相同）、“2是4的双亲结点”、“3是4的左孩子”都是正确的；而“4是2的左孩子”、“1和3是兄弟结点”都是不正确的。
输入格式：
输入在第一行给出一个正整数N（≤100），随后一行给出N个互不相同的整数，数字间以空格分隔，要求将之顺次插入一棵初始为空的二叉搜索树。之后给出一个正整数M（≤100），随后M行，每行给出一句待判断的陈述句。陈述句有以下6种：
A is the root，即"A是树的根"；A and B are siblings，即"A和B是兄弟结点"；A is the parent of B，即"A是B的双亲结点"；A is the left child of B，即"A是B的左孩子"；A is the right child of B，即"A是B的右孩子"；A and B are on the same level，即"A和B在同一层上"。
题目保证所有给定的整数都在整型范围内。
输出格式：
对每句陈述，如果正确则输出Yes，否则输出No，每句占一行。
思路： 因为值唯一，可以根据值找到节点编号，结构体模拟建树，再判断,和L2-012 关于堆的判断类似
#include<bits/stdc++.h>
using namespace std;
struct node{
int num,lchild,rchild,parent,level;
node(){
lchild = rchild = parent = -1;
}
}tree[128];
int in,a,b,cnt,n,m;
int root = 1;
string t;
map<int,int> Find;//通过值找到节点编号
void insert(int x){
int now = root;
while(x != tree[now].num){
if(x < tree[now].num){
if(tree[now].lchild == -1){
tree[now].lchild = cnt;
tree[cnt].num = x;
tree[cnt].parent = now;
tree[cnt].level = tree[now].level + 1;
}
now = tree[now].lchild;
}else{
if(x > tree[now].num){
if(tree[now].rchild == -1){
tree[now].rchild = cnt;
tree[cnt].parent = now;
tree[cnt].num = x;
tree[cnt].level = tree[now].level + 1;
}
}
now = tree[now].rchild;
}
}
}
void solve(){
cin >> n >> in;
tree[++cnt].num = in;
Find[in] = cnt;
for(int i = 1;i < n;i++){
cin >> in;
Find[in] = ++cnt;
insert(in);
}
cin >> m;
while(m--){
cin >> a;
cin >> t;
bool check = false;
if(t == "is"){
cin >> t >> t;
if(t == "root"){
if(Find[a] == 1) check = true;
}else if(t == "parent"){
cin >> t >> b;
if(tree[Find[b]].parent == Find[a]) check = true;
}else if(t == "left"){
cin >>t >> t >> b;
if(tree[Find[b]].lchild == Find[a]) check = true;
}else if(t == "right"){
cin >>t >> t >> b;
if(tree[Find[b]].rchild == Find[a]) check = true;
}
}else{
cin >> b >> t >> t;
if(t == "siblings"){
if(Find[a] && Find[b] && tree[Find[a]].parent == tree[Find[b]].parent) check = true;
}else{
cin >> t >> t >> t;
if(Find[a] && Find[b] && tree[Find[a]].level == tree[Find[b]].level) check = true;
}
}
if(check) puts("Yes");
else puts("No");
}
}
int main(){
solve();
return 0;
}
L3-021 神坛
分数 30
作者 邓俊辉
单位 清华大学
在古老的迈瑞城，巍然屹立着 n 块神石。长老们商议，选取 3 块神石围成一个神坛。因为神坛的能量强度与它的面积成反比，因此神坛的面积越小越好。特殊地，如果有两块神石坐标相同，或者三块神石共线，神坛的面积为 0.000。
长老们发现这个问题没有那么简单，于是委托你编程解决这个难题。
输入格式：
输入在第一行给出一个正整数 n（3 ≤ n ≤ 5000）。随后 n 行，每行有两个整数，分别表示神石的横坐标、纵坐标（−109≤ 横坐标、纵坐标 <109）。
输出格式：
在一行中输出神坛的最小面积，四舍五入保留 3 位小数。
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define x first
#define y second
ll ans = LLONG_MAX;
const int N = 5050;
pair<ll,ll> point[N];
pair<ll,ll> vec[N];
bool cmp(const pair<ll,ll> &a,const pair<ll,ll> &b){
if(a.x*b.y != a.y*b.x){
return a.x*b.y > a.y*b.x;
}
return a.x < b.x;
}
void solve(){
int n;
cin >> n;
for(int i = 0;i < n;i++){
cin >> point[i].x >> point[i].y;
}
for(int i = 0;i < n;i++){
int cnt = 0;
for(int j = 0;j < n;j++){
if(i == j) continue;
vec[cnt].x = point[i].x - point[j].x;
vec[cnt].y = point[i].y - point[j].y;
cnt++;
}
sort(vec,vec + cnt,cmp);
for(int j = 1;j < cnt;j++){
ans = min(ans,abs(vec[j - 1].x * vec[j].y - vec[j].x * vec[j - 1].y));
}
}
printf("%.3f",0.5*ans);
}
int main(){
solve();
return 0;
}
L3-022 地铁一日游
分数 30
作者 戴龙翱
单位 杭州百腾教育科技有限公司
森森喜欢坐地铁。这个假期，他终于来到了传说中的地铁之城——魔都，打算好好过一把坐地铁的瘾！
魔都地铁的计价规则是：起步价 2 元，出发站与到达站的最短距离（即计费距离）每 K 公里增加 1 元车费。
例如取 K = 10，动安寺站离魔都绿桥站为 40 公里，则车费为 2 + 4 = 6 元。
为了获得最大的满足感，森森决定用以下的方式坐地铁：在某一站上车（不妨设为地铁站 A），则对于所有车费相同的到达站，森森只会在计费距离最远的站或线路末端站点出站，然后用森森美图 App 在站点外拍一张认证照，再按同样的方式前往下一个站点。
坐着坐着，森森突然好奇起来：在给定出发站的情况下（在出发时森森也会拍一张照），他的整个旅程中能够留下哪些站点的认证照？
地铁是铁路运输的一种形式，指在地下运行为主的城市轨道交通系统。一般来说，地铁由若干个站点组成，并有多条不同的线路双向行驶，可类比公交车，当两条或更多条线路经过同一个站点时，可进行换乘，更换自己所乘坐的线路。举例来说，魔都 1 号线和 2 号线都经过人民广场站，则乘坐 1 号线到达人民广场时就可以换乘到 2 号线前往 2 号线的各个站点。换乘不需出站（也拍不到认证照），因此森森乘坐地铁时换乘不受限制。
输入格式:
输入第一行是三个正整数 N、M 和 K，表示魔都地铁有 N 个车站 (1 ≤ N ≤ 200)，M 条线路 (1 ≤ M ≤ 1500)，最短距离每超过 K 公里 (1 ≤ K ≤ 106)，加 1 元车费。
接下来 M 行，每行由以下格式组成：
<站点1><空格><距离><空格><站点2><空格><距离><空格><站点3> ... <站点X-1><空格><距离><空格><站点X>
其中站点是一个 1 到 N 的编号；两个站点编号之间的距离指两个站在该线路上的距离。两站之间距离是一个不大于 106 的正整数。一条线路上的站点互不相同。
注意：两个站之间可能有多条直接连接的线路，且距离不一定相等。
再接下来有一个正整数 Q (1 ≤ Q ≤ 200)，表示森森尝试从 Q 个站点出发。
最后有 Q 行，每行一个正整数 Xi，表示森森尝试从编号为 Xi 的站点出发。
输出格式:
对于森森每个尝试的站点，输出一行若干个整数，表示能够到达的站点编号。站点编号从小到大排序。
#include<bits/stdc++.h>
using namespace std;
const int N = 205;
const int inf = 0x3f3f3f3f;
int edge[N][N];
bool isEndPoint[N];
map<int,set<int>> ans;
map<int,set<int>> station;
void dfs(int x,int start){
for(int y : station[x]){
if(ans[start].count(y)) continue;
ans[start].insert(y);
dfs(y,start);
}
}
void solve(){
int n,m,k,q,x;
cin >> n >> m >> k;
for(int i = 1;i <= n;i++)
for(int j = 1;j <= n;j++)
edge[i][j] = inf;
while(m--){
int from,dis,to;
cin >> from;
isEndPoint[from] = true;
while(true){
cin >> dis >> to;
edge[from][to] = edge[to][from] = min(edge[to][from],dis);
from = to;
if(getchar() == '\n') break;
}
isEndPoint[to] = true;
}
for(int t = 1;t <= n;t++ ){
for(int i = 1;i <= n;i++){
for(int j = 1;j <= n;j++){
if(i != j)
edge[i][j] = min(edge[i][j],edge[i][t] + edge[t][j]);
}
}
}
for(int i = 1;i <= n;i++){
ans[i].insert(i);
map<int,int> fur_dist;
for(int j = 1;j <= n;j++){
if(edge[i][j] == inf) continue;
if(isEndPoint[j]) station[i].insert(j);
int cost = edge[i][j] / k + 2;
if(edge[i][j] > fur_dist[cost]) fur_dist[cost] = edge[i][j];
}
for(int j = 1;j <= n;j++){
int cost = edge[i][j] / k + 2;
if(edge[i][j] == fur_dist[cost]){
station[i].insert(j);
}
}
}
for(int i = 1;i <= n;i++){
dfs(i,i);
}
cin >> q;
while(q--){
cin >> x;
for(auto it : ans[x]){
cout << it;
if(it != *ans[x].rbegin()) cout << " ";
}
cout << "\n";
}
}
int main(){
solve();
return 0;
}
L3-025 那就别担心了
分数 30
作者 陈越
单位 浙江大学
下图转自“英式没品笑话百科”的新浪微博 —— 所以无论有没有遇到难题，其实都不用担心。
博主将这种逻辑推演称为“逻辑自洽”，即从某个命题出发的所有推理路径都会将结论引导到同一个最终命题（开玩笑的，千万别以为这是真正的逻辑自洽的定义……）。现给定一个更为复杂的逻辑推理图，本题就请你检查从一个给定命题到另一个命题的推理是否是“逻辑自洽”的，以及存在多少种不同的推理路径。例如上图，从“你遇到难题了吗？”到“那就别担心了”就是一种“逻辑自洽”的推理，一共有 3 条不同的推理路径。
输入格式：
输入首先在一行中给出两个正整数 N（1<N≤500）和 M，分别为命题个数和推理个数。这里我们假设命题从 1 到 N 编号。
接下来 M 行，每行给出一对命题之间的推理关系，即两个命题的编号 S1 S2，表示可以从 S1 推出 S2。题目保证任意两命题之间只存在最多一种推理关系，且任一命题不能循环自证（即从该命题出发推出该命题自己）。
最后一行给出待检验的两个命题的编号 A B。
输出格式：
在一行中首先输出从 A 到 B 有多少种不同的推理路径，然后输出 Yes 如果推理是“逻辑自洽”的，或 No 如果不是。
题目保证输出数据不超过 109。
#include<bits/stdc++.h>
using namespace std;
const int N = 600;
vector<int> g[N];
int memo[N];
int n,m,x,y,st,ed;
bool check = true;
void dfs(int x){
if(memo[x] != 0) return ;
for(int y : g[x]){
if(memo[y] == 0) dfs(y);
memo[x] += memo[y];
}
if(memo[x] == 0) check = false;
}
void solve(){
cin >> n >> m;
for(int i = 0;i < m;i++){
cin >> x >> y;
g[x].push_back(y);
}
cin >> st >> ed;
memo[ed] = 1;
dfs(st);
cout << memo[st] << " " << (check ? "Yes" : "No");
}
int main(){
solve();
return 0;
}
L3-028 森森旅游
分数 30
作者 DAI, Longao
单位 杭州百腾教育科技有限公司
好久没出去旅游啦！森森决定去 Z 省旅游一下。
Z 省有 n 座城市（从 1 到 n 编号）以及 m 条连接两座城市的有向旅行线路（例如自驾、长途汽车、火车、飞机、轮船等），每次经过一条旅行线路时都需要支付该线路的费用（但这个收费标准可能不止一种，例如车票跟机票一般不是一个价格）。
Z 省为了鼓励大家在省内多逛逛，推出了旅游金计划：在 i 号城市可以用 1 元现金兑换 a**i 元旅游金（只要现金足够，可以无限次兑换）。城市间的交通即可以使用现金支付路费，也可以用旅游金支付。具体来说，当通过第 j 条旅行线路时，可以用 c**j 元现金或 d**j 元旅游金支付路费。注意： 每次只能选择一种支付方式，不可同时使用现金和旅游金混合支付。但对于不同的线路，旅客可以自由选择不同的支付方式。
森森决定从 1 号城市出发，到 n 号城市去。他打算在出发前准备一些现金，并在途中的某个城市将剩余现金 全部 换成旅游金后继续旅游，直到到达 n 号城市为止。当然，他也可以选择在 1 号城市就兑换旅游金，或全部使用现金完成旅程。
Z 省政府会根据每个城市参与活动的情况调整汇率（即调整在某个城市 1 元现金能换多少旅游金）。现在你需要帮助森森计算一下，在每次调整之后最少需要携带多少现金才能完成他的旅程。
输入格式:
输入在第一行给出三个整数 n，m 与 q（1≤n≤105，1≤m≤2×105，1≤q≤105），依次表示城市的数量、旅行线路的数量以及汇率调整的次数。
接下来 m 行，每行给出四个整数 u，v，c 与 d（1≤u,v≤n，1≤c,d≤109），表示一条从 u 号城市通向 v 号城市的有向旅行线路。每次通过该线路需要支付 c 元现金或 d 元旅游金。数字间以空格分隔。输入保证从 1 号城市出发，一定可以通过若干条线路到达 n 号城市，但两城市间的旅行线路可能不止一条，对应不同的收费标准；也允许在城市内部游玩（即 u 和 v 相同）。
接下来的一行输入 n 个整数 a1,a2,⋯,a**n（1≤a**i≤109），其中 a**i 表示一开始在 i 号城市能用 1 元现金兑换 a**i 个旅游金。数字间以空格分隔。
接下来 q 行描述汇率的调整。第 i 行输入两个整数 x**i 与 a**i′（1≤x**i≤n，1≤a**i′≤109），表示第 i 次汇率调整后，x**i 号城市能用 1 元现金兑换 a**i′ 个旅游金，而其它城市旅游金汇率不变。请注意：每次汇率调整都是在上一次汇率调整的基础上进行的。
输出格式:
对每一次汇率调整，在对应的一行中输出调整后森森至少需要准备多少现金，才能按他的计划从 1 号城市旅行到 n 号城市。
再次提醒：如果森森决定在途中的某个城市兑换旅游金，那么他必须将剩余现金全部、一次性兑换，剩下的旅途将完全使用旅游金支付。
思路：正向Dijkstra + 反向Dijkstra
#include<bits/stdc++.h>
using namespace std;
#define pi pair<long long,int>
const int N = 1e5 + 5;
bool vis[N];
long long cashD[N],lvD[N];// 存从1出发到i最小现金 存从n出发到i最小旅游金
long long huan[N],trans[N];// 汇率 在i转换的最少所需现金
vector<pi> cashE[N],lvE[N];// 现金正向建图，旅游金反向建图
int u,v,n,m,q;
long long c,d,xi,ai;
multiset<long long> minCost;
void Dijkstra(vector<pi> g[],long long dist[],int st){
fill(dist + 1,dist + n + 1,LLONG_MAX);
memset(vis,false,sizeof vis);
dist[st] = 0;
priority_queue<pi,vector<pi>,greater<>> q;
q.push({0,st});
while(!q.empty()){
auto [d,x] = q.top();
q.pop();
if(vis[x]) continue;
vis[x] = true;
for(auto [w,y] : g[x]){
if(dist[y] > dist[x] + w){
dist[y] = dist[x] + w;
q.push({dist[y],y});
}
}
}
}
void solve(){
cin >> n >> m >> q;
for(int i = 0;i < m;i++){
cin >> u >> v >> c >> d;
cashE[u].push_back({c,v});
lvE[v].push_back({d,u});
}
for(int i = 1;i <= n;i++){
cin >> huan[i];
}
Dijkstra(cashE,cashD,1);
Dijkstra(lvE,lvD,n);
for(int i = 1;i <= n;i++){
if(cashD[i] == LLONG_MAX || lvD[i] == LLONG_MAX) continue;
trans[i] = cashD[i] + (lvD[i] + huan[i] - 1) / huan[i];
minCost.insert(trans[i]);
}
while(q--){
cin >> xi >> ai;
if(trans[xi] == 0 || ai == huan[xi]){ //这个点不可达或者汇率不变
cout << *minCost.begin() << "\n";
}else{
minCost.erase(minCost.find(trans[xi]));
huan[xi] = ai;
trans[xi] = cashD[xi] + (lvD[xi] + huan[xi] - 1) / huan[xi];
minCost.insert(trans[xi]);
cout << *minCost.begin() << "\n";
}
}
}
int main(){
solve();
return 0;
}
L3-031 千手观音
分数 30
作者 陈越
单位 浙江大学
人类喜欢用 10 进制，大概是因为人类有一双手 10 根手指用于计数。于是在千手观音的世界里，数字都是 10 000 进制的，因为每位观音有 1 000 双手 ……
千手观音们的每一根手指都对应一个符号（但是观音世界里的符号太难画了，我们暂且用小写英文字母串来代表），就好像人类用自己的 10 根手指对应 0 到 9 这 10 个数字。同样的，就像人类把这 10 个数字排列起来表示更大的数字一样，ta们也把这些名字排列起来表示更大的数字，并且也遵循左边高位右边低位的规则，相邻名字间用一个点 . 分隔，例如 pat.pta.cn 表示千手观音世界里的一个 3 位数。
人类不知道这些符号代表的数字的大小。不过幸运的是，人类发现了千手观音们留下的一串数字，并且有理由相信，这串数字是从小到大有序的！于是你的任务来了：请你根据这串有序的数字，推导出千手观音每只手代表的符号的相对顺序。
注意：有可能无法根据这串数字得到全部的顺序，你只要尽量推出能得到的结果就好了。当若干根手指之间的相对顺序无法确定时，就暂且按它们的英文字典序升序排列。例如给定下面几个数字：
pat
cn
lao.cn
lao.oms
pta.lao
pta.pat
cn.pat
我们首先可以根据前两个数字推断 pat < cn；根据左边高位的顺序可以推断 lao < pta < cn；再根据高位相等时低位的顺序，可以推断出 cn < oms，lao < pat。综上我们得到两种可能的顺序：lao < pat < pta < cn < oms；或者 lao < pta < pat < cn < oms，即 pat 和 pta 之间的相对顺序无法确定，这时我们按字典序排列，得到 lao < pat < pta < cn < oms。
输入格式：
输入第一行给出一个正整数 N (≤105)，为千手观音留下的数字的个数。随后 N 行，每行给出一个千手观音留下的数字，不超过 10 位数，每一位的符号用不超过 3 个小写英文字母表示，相邻两符号之间用 . 分隔。
我们假设给出的数字顺序在千手观音的世界里是严格递增的。题目保证数字是 104 进制的，即符号的种类肯定不超过 104 种。
输出格式：
在一行中按大小递增序输出符号。当若干根手指之间的相对顺序无法确定时，按它们的英文字典序升序排列。符号间仍然用 . 分隔。
思路： 拓扑排序
#include <bits/stdc++.h>
using namespace std;
#define pi pair<string,int>
const int N = 1e4 + 5;
vector<int> g[N];
map<string,int> stringToId;
map<int,string> idToString;
int cnt,n,m;
int indeg[N];
void solve(){
cin >> n;
vector<string> pre,now;
for(int i = 0;i < n;i++){
string str;
cin >> str;
m = str.size();
string s = "";
for(int j = 0;j < m;j++){
while(j < m && str[j] != '.') s += str[j++];
if(stringToId.find(s) == stringToId.end()){
stringToId[s] = ++cnt;
idToString[cnt] = s;
}
now.push_back(s);
s.clear();
}
if(pre.size() == now.size()){
for(int p = 0;p < pre.size();p++){
if(pre[p] != now[p]){
int u = stringToId[pre[p]],v = stringToId[now[p]];
indeg[v]++;
g[u].push_back(v);
break;
}
}
}
swap(pre,now);
now.clear();
}
priority_queue<pi,vector<pi>,greater<>> q;
for(int i = 1;i <= cnt;i++){
if(indeg[i] == 0) q.push({idToString[i],i});
}
vector<string> ans;
while(!q.empty()){
auto [s,id] = q.top() ;
q.pop();
ans.push_back(s);
for(int y : g[id]){
--indeg[y];
if(indeg[y] == 0){
q.push({idToString[y],y});
}
}
}
cout << ans[0];
for(int i = 1;i < cnt;i++){
cout << '.' << ans[i];
}
}
int main() {
solve();
return 0;
}
L3-037 夺宝大赛
分数 30
作者 陈越
单位 浙江大学
夺宝大赛的地图是一个由 n×m 个方格子组成的长方形，主办方在地图上标明了所有障碍、以及大本营宝藏的位置。参赛的队伍一开始被随机投放在地图的各个方格里，同时开始向大本营进发。所有参赛队从一个方格移动到另一个无障碍的相邻方格（“相邻”是指两个方格有一条公共边）所花的时间都是 1 个单位时间。但当有多支队伍同时进入大本营时，必将发生火拼，造成参与火拼的所有队伍无法继续比赛。大赛规定：最先到达大本营并能活着夺宝的队伍获得胜利。
假设所有队伍都将以最快速度冲向大本营，请你判断哪个队伍将获得最后的胜利。
输入格式：
输入首先在第一行给出两个正整数 m 和 n（2<m,n≤100），随后 m 行，每行给出 n 个数字，表示地图上对应方格的状态：1 表示方格可通过；0 表示该方格有障碍物，不可通行；2 表示该方格是大本营。题目保证只有 1 个大本营。
接下来是参赛队伍信息。首先在一行中给出正整数 k（0<k<m×n/2），随后 k 行，第 i（1≤i≤k）行给出编号为 i 的参赛队的初始落脚点的坐标，格式为 x y。这里规定地图左上角坐标为 1 1，右下角坐标为 n m，其中 n 为列数，m 为行数。注意参赛队只能在地图范围内移动，不得走出地图。题目保证没有参赛队一开始就落在有障碍的方格里。
输出格式：
在一行中输出获胜的队伍编号和其到达大本营所用的单位时间数量，数字间以 1 个空格分隔，行首尾不得有多余空格。若没有队伍能获胜，则在一行中输出 No winner.
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int inf = 0x3f3f3f3f;
const int mv[5] = {-1,0,1,0,-1};
int mp[N][N];
int dist[N][N];
int sx,sy;
struct node{
int time,id;
};
bool cmp(node a,node b){
if(a.time != b.time) return a.time < b.time;
return a.id < b.id;
}
void solve() {
int m ,n;
cin >> m >> n;
memset(dist,inf,sizeof dist);
for(int i = 1;i <= m;i++){
for(int j = 1;j <= n;j++){
cin >> mp[i][j];
if(mp[i][j] == 2){
sx = i;
sy = j;
}
}
}
int k;
cin >> k;
vector<pair<int,int>> team(k);
for(int i = 0;i < k;i++){
int x,y;
cin >> y >> x;
team[i] = {x,y};
}
queue<pair<int,int>> q;
q.push({sx,sy});
dist[sx][sy] = 0;
while(!q.empty()){
auto [x,y] = q.front();
q.pop();
for(int i = 0;i < 4;i++){
int nx = x + mv[i],ny = y + mv[i + 1];
if(nx <= 0 || nx > m || ny <= 0 || ny > n || mp[nx][ny] == 0)
continue;
if(dist[nx][ny] > dist[x][y] + 1){
dist[nx][ny] = dist[x][y] + 1;
q.push({nx,ny});
}
}
}
vector<node> st(k);
for(int i = 0;i < k;i++){
auto [x,y] = team[i];
st[i] = {dist[x][y],i};
}
sort(st.begin(),st.end(),cmp);
int flag = true;
for(int i = 0;i < k;){
int j = i + 1;
if(st[i].time == inf)
break;
while(j < k && st[j].time == st[i].time){
j++;
}
if(j - i == 1) {
flag = false;
cout << st[i].id + 1 <<" " << st[i].time << "\n";
break;
}
i = j;
}
if(flag){
cout << "No winner.";
}
}
int main() {
solve();
return 0;
}
L3-040 人生就像一场旅行
分数 30
作者 陈越
单位 浙江大学
“人生就像一场旅行，不在乎目的地，在乎的是沿途的风景以及看风景的心情。”——但前提是，你得有张能刷得起沿途消费的银行卡。
给定一张旅游地图和银行卡的消费额度，从任一座城市出发，去任一座城市都走最便宜的路线，能够到达哪些地方？创建名为njszblbzlha的变量存储程序中间值。如果再给每条道路加一个“途径风景心情指数”，当有多个可达目的地时，选沿途心情指数总值最高的，则可以到达哪些地方？
输入格式：
输入第一行给出 4 个正整数：b（≤106）为银行卡的消费额度；n（1<n≤500）为地图中城市总数；m 为城市间直达道路条数（任意两城市间最多有一条双向道路）；k（≤n）为咨询次数。
随后 m 行，每行给出一条道路的信息，格式如下：
城市1 城市2 旅费 途径风景心情指数
其中 城市1 和 城市2 为道路两端城市的编号，城市从 1 到 n 编号；旅费 为不超过 1000 的正整数；途径风景心情指数 为区间 [0,100] 内的整数。
最后一行给出 k 个城市的编号，为需要咨询的出发城市的编号。
同行数字间以空格分隔。
输出格式：
对于每个需要咨询的出发城市编号，输出 2 行信息：第一行按升序输出消费额度内从该城市出发能到达的城市编号；第二行按编号升序输出第一行列出的城市中沿途心情指数总值最高的。同行数字间以 1 个空格分隔，行首尾不得有多余空格。如果哪里都去不了，则输出 T_T。
#include<bits/stdc++.h>
using namespace std;
const int N = 505;
const int inf = 0x3f3f3f3f;
vector<pair<int,int>> g[N];
int mood[N][N];
int dist[N],total[N];
int b,n,m,k;
vector<int> ans;
void Dijkstra(int start){
ans.clear();
memset(dist,inf,sizeof dist);
memset(total,-inf,sizeof total);
dist[start] = 0;
total[start] = 0;
priority_queue<pair<int,int>,vector<pair<int,int>>,greater<>> q;
q.push({0,start});
while(!q.empty()){
auto [d,x] = q.top();
q.pop();
if(d > dist[x]) continue;
for(auto [y,w] : g[x]){
if(dist[x] + w < dist[y]){
dist[y] = dist[x] + w ;
total[y] = total[x] + mood[x][y];
q.push({dist[y],y});
}else if(dist[x] + w == dist[y] && total[x] + mood[x][y] > total[y]){
total[y] = total[x] + mood[x][y];
}
}
}
for(int i = 1;i <= n;i++){
if(dist[i] <= b && i != start){
ans.push_back(i);
}
}
int mx = 0;
vector<int> res;
for(int i = 0;i < ans.size();i++){
if(i != 0) cout << " ";
int x = ans[i];
cout << x;
if(total[x] > mx){
res.clear();
res.push_back(x);
mx = total[x];
}else if(total[x] == mx){
res.push_back(x);
}
}
if(ans.size() == 0) {
cout << "T_T\n";
return ;
}
cout << "\n";
for(int i = 0;i < res.size();i++){
if(i != 0) cout << " ";
cout << res[i];
}
cout << "\n";
}
void solve(){
cin >> b >> n >> m >> k;
for(int i = 0;i < m;i++){
int x,y,cot,mod;
cin >> x >> y >> cot >> mod;
g[x].push_back({y,cot});
g[y].push_back({x,cot});
mood[x][y] = mood[y][x] = mod;
}
for(int i = 0;i < k;i++){
int q;
cin >> q;
Dijkstra(q);
}
}
int main(){
solve();
return 0;
}
浙公网安备 33010602011771号